Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

[ 7, 12, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 0, 13, 18, 13, 13, 0, 13, 2, 13, 2, 13, 4, 18, 13, 13, 13, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 2, 17, 13, 17, 0, 13, 18, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 18, 13, 13, 13, 0, 18, 13, 2, 13, 17, 18, 13, 13, 14, 2, 17, 18, 13, 13, 0, 18, 13, 2, 13, 17, 18, 13, 13, 14, 2, 18, 13, 13, 17, 0, 18, 13, 2, 13, 17, 18, 13, 13, 0, 18, 13, 2, 13, 17, 18, 13, 13, 0, 13, 2, 18, 13, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 7, 15 ], [ 18, 17 ], [ 15, 27 ], [ 36, 35 ], [ 17, 40 ], [ 43, 42 ], [ 48, 47 ], [ 6, 49 ], [ 15, 51 ], [ 35, 56 ], [ 17, 56 ], [ 59, 58 ], [ 6, 65 ], [ 47, 70 ], [ 74, 73 ], [ 81, 78 ], [ 58, 79 ], [ 84, 83 ], [ 6, 88 ], [ 95, 90 ], [ 58, 91 ], [ 83, 93 ], [ 58, 96 ], [ 83, 97 ], [ 35, 102 ], [ 17, 102 ], [ 83, 103 ], [ 110, 105 ], [ 58, 106 ], [ 83, 108 ], [ 58, 111 ], [ 83, 112 ], [ 35, 116 ], [ 17, 116 ], [ 83, 117 ], [ 125, 120 ], [ 58, 121 ], [ 83, 123 ], [ 58, 126 ], [ 83, 127 ], [ 134, 129 ], [ 58, 130 ], [ 83, 132 ], [ 58, 135 ], [ 83, 136 ], [ 139, 138 ], [ 58, 141 ], [ 6, 142 ], [ 138, 146 ], [ 155, 152 ] ]

[ "def abc044_c():\n import numpy as np\n n, a = map(int, input().split())\n x = list(map(lambda x: int(x) - a, input().split())) # 平均ターゲット値を引いておく\n x = np.array(x, dtype=np.int64)\n\n vrange = n * (a + np.max(x)) # 取りうる値の幅(片側), 広めにとってもかまわない\n dp = np.zeros((n+1, 2*vrange+1), dtype=np.int64) # DPテーブル\n dp[0, vrange] = 1 # 0枚時点で何も選ばずに総和0(平均ターゲット)になる場合を初期値にセット\n\n for i in np.arange(n):\n # 1つ前のターンを引き継ぐ\n dp[i+1, :] += dp[i, :]\n if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ans = dp[n, vrange] - 1 # 初期値(何も選ばない)の1通りを除く\n print(ans)\n\nif __name__ == '__main__':\n abc044_c()", "def abc044_c():\n import numpy as np\n n, a = map(int, input().split())\n x = list(map(lambda x: int(x) - a, input().split())) # 平均ターゲット値を引いておく\n x = np.array(x, dtype=np.int64)\n\n vrange = n * (a + np.max(x)) # 取りうる値の幅(片側), 広めにとってもかまわない\n dp = np.zeros((n+1, 2*vrange+1), dtype=np.int64) # DPテーブル\n dp[0, vrange] = 1 # 0枚時点で何も選ばずに総和0(平均ターゲット)になる場合を初期値にセット\n\n for i in np.arange(n):\n # 1つ前のターンを引き継ぐ\n dp[i+1, :] += dp[i, :]\n if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ans = dp[n, vrange] - 1 # 初期値(何も選ばない)の1通りを除く\n print(ans)", "abc044_c", "import numpy as np", "numpy", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(lambda x: int(x) - a, input().split()))", "x", "list(map(lambda x: int(x) - a, input().split()))", "list", "map(lambda x: int(x) - a, input().split())", "map", "lambda x: int(x) - a", "int(x) - a", "int(x)", "int", "x", "a", "x", "input().split()", "().split", "()", "input", "split", "x = np.array(x, dtype=np.int64)", "x", "np.array(x, dtype=np.int64)", "np.array", "np", "array", "x", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "vrange = n * (a + np.max(x))", "vrange", "n * (a + np.max(x))", "n", "a + np.max(x)", "a", "np.max(x)", "np.max", "np", "max", "x", "dp = np.zeros((n+1, 2*vrange+1), dtype=np.int64)", "dp", "np.zeros((n+1, 2*vrange+1), dtype=np.int64)", "np.zeros", "np", "zeros", "(n+1, 2*vrange+1)", "n+1", "n", "1", "2*vrange+1", "2*vrange", "2", "vrange", "1", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "dp[0, vrange] = 1", "dp[0, vrange]", "dp", "0", "1", "for i in np.arange(n):\n # 1つ前のターンを引き継ぐ\n dp[i+1, :] += dp[i, :]\n if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ", "i", "np.arange(n)", "np.arange", "np", "arange", "n", "dp[i+1, :] += dp[i, :]", "dp[i+1, :]", "dp", "i+1", "i", "1", "dp[i, :]", "dp", "i", "if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ", "0 < x[i]", "0", "x[i]", "x", "i", "dp[i+1, x[i]:] += dp[i, :-x[i]]", "dp[i+1, x[i]:]", "dp", "i+1", "i", "1", "dp[i, :-x[i]]", "dp", "i", "elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n ", "x[i] < 0", "x[i]", "x", "i", "0", "dp[i+1, :x[i]] += dp[i, -x[i]:]", "dp[i+1, :x[i]]", "dp", "i+1", "i", "1", "dp[i, -x[i]:]", "dp", "i", "dp[i+1, :] += dp[i, :]", "dp[i+1, :]", "dp", "i+1", "i", "1", "dp[i, :]", "dp", "i", "ans = dp[n, vrange] - 1", "ans", "dp[n, vrange] - 1", "dp[n, vrange]", "dp", "n", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n abc044_c()", "__name__ == '__main__'", "__name__", "'__main__'", "abc044_c()", "abc044_c", "def abc044_c():\n import numpy as np\n n, a = map(int, input().split())\n x = list(map(lambda x: int(x) - a, input().split())) # 平均ターゲット値を引いておく\n x = np.array(x, dtype=np.int64)\n\n vrange = n * (a + np.max(x)) # 取りうる値の幅(片側), 広めにとってもかまわない\n dp = np.zeros((n+1, 2*vrange+1), dtype=np.int64) # DPテーブル\n dp[0, vrange] = 1 # 0枚時点で何も選ばずに総和0(平均ターゲット)になる場合を初期値にセット\n\n for i in np.arange(n):\n # 1つ前のターンを引き継ぐ\n dp[i+1, :] += dp[i, :]\n if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ans = dp[n, vrange] - 1 # 初期値(何も選ばない)の1通りを除く\n print(ans)", "def abc044_c():\n import numpy as np\n n, a = map(int, input().split())\n x = list(map(lambda x: int(x) - a, input().split())) # 平均ターゲット値を引いておく\n x = np.array(x, dtype=np.int64)\n\n vrange = n * (a + np.max(x)) # 取りうる値の幅(片側), 広めにとってもかまわない\n dp = np.zeros((n+1, 2*vrange+1), dtype=np.int64) # DPテーブル\n dp[0, vrange] = 1 # 0枚時点で何も選ばずに総和0(平均ターゲット)になる場合を初期値にセット\n\n for i in np.arange(n):\n # 1つ前のターンを引き継ぐ\n dp[i+1, :] += dp[i, :]\n if 0 < x[i]:\n # x[i]が正の値、1つ前のx[i]個ぶん左側をスライドして持ってくる\n dp[i+1, x[i]:] += dp[i, :-x[i]]\n elif x[i] < 0:\n # x[i]が負の値、1つ前のx[i]個ぶん右側をスライドして持ってくる\n dp[i+1, :x[i]] += dp[i, -x[i]:]\n else:\n # x[i]がゼロ\n dp[i+1, :] += dp[i, :]\n\n ans = dp[n, vrange] - 1 # 初期値(何も選ばない)の1通りを除く\n print(ans)", "abc044_c" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 0, 13, 2, 39, 17, 2, 2, 2, 17, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 39, 28, 13, 4, 13, 2, 40, 2, 13, 17, 17, 2, 2, 2, 13, 17, 17, 17, 0, 18, 13, 13, 18, 13, 2, 13, 18, 13, 13, 0, 13, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 18, 13 ]

[ [ 106, 2 ], [ 106, 11 ], [ 100, 13 ], [ 26, 25 ], [ 104, 28 ], [ 33, 30 ], [ 101, 31 ], [ 25, 32 ], [ 107, 33 ], [ 109, 35 ], [ 104, 43 ], [ 50, 47 ], [ 110, 48 ], [ 53, 52 ], [ 104, 55 ], [ 115, 57 ], [ 110, 59 ], [ 113, 59 ], [ 63, 62 ], [ 104, 68 ], [ 104, 74 ], [ 82, 79 ], [ 116, 80 ], [ 62, 81 ], [ 110, 83 ], [ 113, 83 ], [ 62, 85 ], [ 30, 86 ], [ 101, 87 ], [ 52, 88 ], [ 112, 90 ], [ 116, 91 ], [ 113, 96 ], [ 110, 96 ], [ 100, 101 ], [ 106, 104 ], [ 106, 107 ], [ 109, 110 ], [ 116, 112 ], [ 112, 113 ], [ 115, 116 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\nfor i in range(n):\n x[i] -= a\n\ndp = [0] * (2 * n * 50 + 2)\ndp[0] = 1\n\nfor i in range(n):\n h = dp[:]\n for j in range(-(n - 1) * 50, (n - 1) * 50 + 1):\n h[j] += dp[j - x[i]]\n dp = h\n\nprint(dp[0] - 1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n x[i] -= a", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "dp = [0] * (2 * n * 50 + 2)", "dp", "[0] * (2 * n * 50 + 2)", "[0]", "0", "2 * n * 50 + 2", "2 * n * 50", "2 * n", "2", "n", "50", "2", "dp[0] = 1", "dp[0]", "dp", "0", "1", "for i in range(n):\n h = dp[:]\n for j in range(-(n - 1) * 50, (n - 1) * 50 + 1):\n h[j] += dp[j - x[i]]\n dp = h", "i", "range(n)", "range", "n", "h = dp[:]", "h", "dp[:]", "dp", ":", "for j in range(-(n - 1) * 50, (n - 1) * 50 + 1):\n h[j] += dp[j - x[i]]\n ", "j", "range(-(n - 1) * 50, (n - 1) * 50 + 1)", "range", "-(n - 1) * 50", "-(n - 1)", "n - 1", "n", "1", "50", "(n - 1) * 50 + 1", "(n - 1) * 50", "n - 1", "n", "1", "50", "1", "h[j] += dp[j - x[i]]", "h[j]", "h", "j", "dp[j - x[i]]", "dp", "j - x[i]", "j", "x[i]", "x", "i", "dp = h", "dp", "h", "print(dp[0] - 1)", "print", "dp[0] - 1", "dp[0]", "dp", "0", "1", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "dp = [0] * (2 * n * 50 + 2)", "[0] * (2 * n * 50 + 2)", "dp", "dp = h", "h", "dp", "h = dp[:]", "dp[:]", "h" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 13, 0, 13, 39, 28, 13, 13, 4, 18, 13, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 2, 17, 13, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 4, 13, 18, 13, 13, 14, 2, 2, 13, 17, 2, 13, 2, 13, 13, 0, 18, 18, 13, 13, 13, 17, 14, 2, 2, 13, 17, 2, 2, 2, 13, 18, 13, 2, 13, 17, 17, 2, 2, 13, 18, 13, 2, 13, 17, 2, 2, 17, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 14, 2, 2, 13, 17, 40, 40, 17, 2, 13, 18, 13, 2, 13, 17, 2, 2, 17, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 4, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 222, 2 ], [ 222, 11 ], [ 207, 13 ], [ 213, 25 ], [ 208, 30 ], [ 211, 31 ], [ 216, 33 ], [ 37, 36 ], [ 208, 36 ], [ 217, 40 ], [ 36, 43 ], [ 211, 44 ], [ 48, 47 ], [ 223, 51 ], [ 223, 61 ], [ 214, 62 ], [ 219, 65 ], [ 69, 68 ], [ 223, 72 ], [ 76, 75 ], [ 220, 81 ], [ 68, 82 ], [ 68, 86 ], [ 75, 89 ], [ 223, 91 ], [ 214, 92 ], [ 99, 94 ], [ 220, 96 ], [ 68, 97 ], [ 75, 98 ], [ 68, 103 ], [ 75, 108 ], [ 217, 110 ], [ 68, 112 ], [ 75, 117 ], [ 217, 119 ], [ 68, 121 ], [ 223, 126 ], [ 214, 127 ], [ 134, 129 ], [ 220, 131 ], [ 68, 132 ], [ 75, 133 ], [ 220, 136 ], [ 68, 138 ], [ 75, 140 ], [ 68, 144 ], [ 75, 150 ], [ 217, 152 ], [ 68, 154 ], [ 223, 159 ], [ 214, 160 ], [ 167, 162 ], [ 220, 164 ], [ 68, 165 ], [ 75, 166 ], [ 220, 170 ], [ 68, 172 ], [ 75, 174 ], [ 220, 177 ], [ 68, 179 ], [ 75, 182 ], [ 217, 184 ], [ 68, 186 ], [ 194, 189 ], [ 220, 191 ], [ 68, 192 ], [ 75, 193 ], [ 220, 200 ], [ 223, 201 ], [ 223, 203 ], [ 214, 204 ], [ 207, 208 ], [ 222, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 222, 223 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nX = max(max(x),a)\ny = []\nfor i in x:\n y.append(i-a)\ndp = [[0]*(2*n*X+1) for _ in range(n+1)]\n\nfor i in range(n+1):\n for j in range(len(dp[i])):\n if i == 0 and j == n * X:\n dp[i][j] = 1\n elif i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X):\n dp[i][j] = dp[i-1][j]\n elif i > 0 and 0 <= j - y[i-1] <= 2 * n * X:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n else:\n dp[i][j] = 0\n\nprint(dp[n][n*X]-1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X = max(max(x),a)", "X", "max(max(x),a)", "max", "max(x)", "max", "x", "a", "y = []", "y", "[]", "for i in x:\n y.append(i-a)", "i", "x", "y.append(i-a)", "y.append", "y", "append", "i-a", "i", "a", "[0]*(2*n*X+1) for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0]*(2*n*X+1)", "[0]", "0", "2*n*X+1", "2*n*X", "2*n", "2", "n", "X", "1", "dp = [[0]*(2*n*X+1) for _ in range(n+1)]", "dp", "[[0]*(2*n*X+1) for _ in range(n+1)]", "for i in range(n+1):\n for j in range(len(dp[i])):\n if i == 0 and j == n * X:\n dp[i][j] = 1\n elif i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X):\n dp[i][j] = dp[i-1][j]\n elif i > 0 and 0 <= j - y[i-1] <= 2 * n * X:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n else:\n dp[i][j] = 0", "i", "range(n+1)", "range", "n+1", "n", "1", "for j in range(len(dp[i])):\n if i == 0 and j == n * X:\n dp[i][j] = 1\n elif i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X):\n dp[i][j] = dp[i-1][j]\n elif i > 0 and 0 <= j - y[i-1] <= 2 * n * X:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n else:\n dp[i][j] = 0", "j", "range(len(dp[i]))", "range", "len(dp[i])", "len", "dp[i]", "dp", "i", "if i == 0 and j == n * X:\n dp[i][j] = 1\n elif i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X):\n dp[i][j] = dp[i-1][j]\n elif i > 0 and 0 <= j - y[i-1] <= 2 * n * X:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n else:\n dp[i][j] = 0", "i == 0 and j == n * X", "i == 0", "i", "0", "j == n * X", "j", "n * X", "n", "X", "dp[i][j] = 1", "dp[i][j]", "[i]", "dp", "i", "j", "1", "elif i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X):\n dp[i][j] = dp[i-1][j]\n ", "i > 0 and (j - y[i-1] < 0 or j - y[i-1] > 2 * n * X)", "i > 0", "i", "0", "j - y[i-1] < 0 or j - y[i-1] > 2 * n * X", "j - y[i-1] < 0", "j - y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "0", "j - y[i-1] > 2 * n * X", "j - y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "2 * n * X", "2 * n", "2", "n", "X", "dp[i][j] = dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "elif i > 0 and 0 <= j - y[i-1] <= 2 * n * X:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n ", "i > 0 and 0 <= j - y[i-1] <= 2 * n * X", "i > 0", "i", "0", "0 <= j - y[i-1] <= 2 * n * X", "0 <= j - y[i-1]", "0", "j - y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "2 * n * X", "2 * n", "2", "n", "X", "dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j] + dp[i-1][j-y[i-1]]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][j-y[i-1]]", "[i-1]", "dp", "i-1", "i", "1", "j-y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "dp[i][j] = 0", "dp[i][j]", "[i]", "dp", "i", "j", "0", "print(dp[n][n*X]-1)", "print", "dp[n][n*X]-1", "dp[n][n*X]", "[n]", "dp", "n", "n*X", "n", "X", "1", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "X = max(max(x),a)", "max(max(x),a)", "X", "y = []", "[]", "y", "dp = [[0]*(2*n*X+1) for _ in range(n+1)]", "[[0]*(2*n*X+1) for _ in range(n+1)]", "dp", "n, a = map(int, input().split())", "map(int, input().split())", "n" ]

[ 7, 15, 13, 13, 13, 13, 13, 13, 13, 0, 13, 12, 4, 18, 4, 18, 4, 18, 18, 18, 13, 13, 13, 13, 13, 13, 17, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 17, 0, 13, 17, 0, 13, 17, 12, 13, 0, 13, 2, 39, 17, 17, 0, 18, 13, 17, 17, 0, 13, 4, 13, 13, 28, 13, 13, 28, 13, 4, 13, 17, 17, 17, 14, 2, 2, 13, 13, 17, 0, 18, 13, 13, 18, 13, 2, 13, 13, 29, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 39, 13, 39, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 13, 0, 13, 13, 14, 2, 13, 17, 4, 18, 13, 13, 40, 13, 14, 2, 13, 17, 0, 13, 17, 4, 18, 13, 13, 13, 0, 13, 2, 17, 13, 4, 18, 13, 13, 4, 18, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 13, 28, 13, 4, 13, 17, 4, 13, 13, 0, 13, 2, 2, 18, 13, 13, 18, 13, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 39, 13, 10, 4, 13, 10, 39, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 199, 10 ], [ 202, 35 ], [ 220, 40 ], [ 220, 43 ], [ 49, 48 ], [ 57, 54 ], [ 48, 55 ], [ 60, 59 ], [ 91, 62 ], [ 65, 64 ], [ 91, 64 ], [ 68, 67 ], [ 67, 76 ], [ 64, 77 ], [ 83, 80 ], [ 48, 81 ], [ 67, 82 ], [ 48, 84 ], [ 67, 86 ], [ 64, 87 ], [ 48, 89 ], [ 91, 91 ], [ 244, 93 ], [ 200, 100 ], [ 244, 102 ], [ 232, 104 ], [ 226, 106 ], [ 247, 109 ], [ 200, 118 ], [ 122, 121 ], [ 248, 121 ], [ 238, 124 ], [ 245, 125 ], [ 239, 128 ], [ 121, 128 ], [ 227, 132 ], [ 239, 135 ], [ 121, 135 ], [ 239, 138 ], [ 121, 138 ], [ 211, 141 ], [ 233, 145 ], [ 239, 147 ], [ 121, 147 ], [ 241, 149 ], [ 212, 152 ], [ 221, 152 ], [ 233, 155 ], [ 227, 159 ], [ 205, 162 ], [ 224, 164 ], [ 233, 165 ], [ 229, 167 ], [ 224, 169 ], [ 227, 170 ], [ 173, 172 ], [ 206, 178 ], [ 233, 178 ], [ 235, 180 ], [ 206, 184 ], [ 233, 184 ], [ 172, 185 ], [ 230, 187 ], [ 227, 187 ], [ 172, 188 ], [ 242, 189 ], [ 212, 189 ], [ 221, 189 ], [ 214, 191 ], [ 242, 193 ], [ 212, 193 ], [ 221, 193 ], [ 215, 197 ], [ 236, 197 ], [ 218, 197 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ], [ 244, 209 ], [ 211, 212 ], [ 214, 215 ], [ 220, 218 ], [ 220, 221 ], [ 226, 227 ], [ 229, 230 ], [ 232, 233 ], [ 235, 236 ], [ 245, 238 ], [ 238, 239 ], [ 241, 242 ], [ 244, 245 ], [ 247, 248 ] ]

[ "#!/usr/bin/env python3\nimport sys, math, itertools, heapq, collections, bisect, fractions\ninput = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')\nsys.setrecursionlimit(10**8)\ninf = float('inf')\nans = count = 0\n\ndef counting(A):\n memo=[0]*2501\n memo[0]=1\n n=len(A)\n for ai in A:\n for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n return memo\n\n\n \n\nn,X=map(int,input().split())\nA,B=[],[]\nlis=list(map(int,input().split()))\nfor li in lis:\n li-=X\n if li<0:\n B.append(-li)\n elif li==0:\n count+=1\n else:\n A.append(li)\ncount=2**count\nA.sort();B.sort()\nA=counting(A)\nB=counting(B)\nfor i in range(1,len(A)):\n ans+=A[i]*B[i]*count\nans+=count-1\n\nprint(ans)", "import sys, math, itertools, heapq, collections, bisect, fractions", "sys", "math", "itertools", "heapq", "collections", "bisect", "fractions", "input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')", "input", "lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')", "sys.stdin.buffer.readline().rstrip().decode('utf-8')", "sys.stdin.buffer.readline().rstrip().decode", "sys.stdin.buffer.readline().rstrip()", "sys.stdin.buffer.readline().rstrip", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "rstrip", "decode", "'utf-8'", "sys.setrecursionlimit(10**8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**8", "10", "8", "inf = float('inf')", "inf", "float('inf')", "float", "'inf'", "ans = count = 0", "ans", "0", "= count = 0", "count", "0", "def counting(A):\n memo=[0]*2501\n memo[0]=1\n n=len(A)\n for ai in A:\n for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n return memo\n\n\n ", "counting", "memo=[0]*2501", "memo", "[0]*2501", "[0]", "0", "2501", "memo[0]=1", "memo[0]", "memo", "0", "1", "n=len(A)", "n", "len(A)", "len", "A", "for ai in A:\n for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n ", "ai", "A", "for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n ", "i", "range(2500,0,-1)", "range", "2500", "0", "-1", "if i-ai<0:continue\n ", "i-ai<0", "i-ai", "i", "ai", "0", "memo[i]+=memo[i-ai]", "memo[i]", "memo", "i", "memo[i-ai]", "memo", "i-ai", "i", "ai", "return memo", "memo", "A", "A", "n,X=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X", "A,B=[],[]", "A", "[]", "B", "[]", "lis=list(map(int,input().split()))", "lis", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for li in lis:\n li-=X\n if li<0:\n B.append(-li)\n elif li==0:\n count+=1\n else:\n A.append(li)", "li", "lis", "li-=X", "li", "X", "if li<0:\n B.append(-li)\n elif li==0:\n count+=1\n else:\n A.append(li)", "li<0", "li", "0", "B.append(-li)", "B.append", "B", "append", "-li", "li", "elif li==0:\n count+=1\n ", "li==0", "li", "0", "count+=1", "count", "1", "A.append(li)", "A.append", "A", "append", "li", "count=2**count", "count", "2**count", "2", "count", "A.sort()", "A.sort", "A", "sort", "B.sort()", "B.sort", "B", "sort", "A=counting(A)", "A", "counting(A)", "counting", "A", "B=counting(B)", "B", "counting(B)", "counting", "B", "for i in range(1,len(A)):\n ans+=A[i]*B[i]*count", "i", "range(1,len(A))", "range", "1", "len(A)", "len", "A", "ans+=A[i]*B[i]*count", "ans", "A[i]*B[i]*count", "A[i]*B[i]", "A[i]", "A", "i", "B[i]", "B", "i", "count", "ans+=count-1", "ans", "count-1", "count", "1", "print(ans)", "print", "ans", "input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')", "lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')", "input", "inf = float('inf')", "float('inf')", "inf", "A=counting(A)", "counting(A)", "A", "n,X=map(int,input().split())", "map(int,input().split())", "n", "count+=1", "1", "count", "ans+=count-1", "count-1", "ans", "ans = count = 0", "0", "ans", "count = 0", "0", "count", "def counting(A):\n memo=[0]*2501\n memo[0]=1\n n=len(A)\n for ai in A:\n for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n return memo\n\n\n ", "def counting(A):\n memo=[0]*2501\n memo[0]=1\n n=len(A)\n for ai in A:\n for i in range(2500,0,-1):\n if i-ai<0:continue\n memo[i]+=memo[i-ai]\n return memo\n\n\n ", "counting", "B=[],[]", "[]", "B", "B=counting(B)", "counting(B)", "B", "A,B=[],[]", "[]", "A", "ans+=A[i]*B[i]*count", "A[i]*B[i]*count", "ans", "li-=X", "X", "li", "count=2**count", "2**count", "count", "X=map(int,input().split())", "map(int,input().split())", "X", "lis=list(map(int,input().split()))", "list(map(int,input().split()))", "lis" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 18, 18, 18, 13, 13, 13, 13, 17, 9, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 18, 13 ]

[ [ 148, 2 ], [ 148, 11 ], [ 142, 13 ], [ 27, 26 ], [ 146, 30 ], [ 151, 35 ], [ 45, 38 ], [ 152, 41 ], [ 48, 47 ], [ 146, 50 ], [ 53, 52 ], [ 146, 55 ], [ 58, 57 ], [ 146, 62 ], [ 149, 63 ], [ 152, 70 ], [ 47, 71 ], [ 52, 72 ], [ 57, 73 ], [ 86, 77 ], [ 152, 80 ], [ 47, 82 ], [ 52, 84 ], [ 57, 85 ], [ 152, 89 ], [ 47, 90 ], [ 52, 91 ], [ 57, 92 ], [ 109, 94 ], [ 152, 97 ], [ 47, 99 ], [ 52, 102 ], [ 57, 105 ], [ 143, 107 ], [ 47, 108 ], [ 152, 112 ], [ 47, 113 ], [ 52, 114 ], [ 57, 115 ], [ 154, 117 ], [ 121, 120 ], [ 146, 125 ], [ 157, 128 ], [ 152, 132 ], [ 146, 133 ], [ 120, 134 ], [ 120, 136 ], [ 149, 137 ], [ 158, 140 ], [ 155, 140 ], [ 142, 143 ], [ 148, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ] ]

[ "n, a = map(int, input().split())\nX = tuple(map(int, input().split()))\ndp = [[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]\ndp[0][0][0] = 1\nfor i in range(n):\n # i枚目までで\n for j in range(n):\n # j枚のカードを選んで\n for s in range(n*a+1):\n # 合計がsになるパターン\n if dp[i][j][s] == 0:\n continue\n # i枚目のカードが選ばれない場合\n dp[i+1][j][s] += dp[i][j][s]\n # i枚目のカードが選ばれる場合\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]\nans = 0\nfor k in range(1, n+1):\n ans += dp[n][k][k*a]\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X = tuple(map(int, input().split()))", "X", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[[0] * (2550) for _ in range(n+1)]", "dp = [[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]", "dp", "[[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n # i枚目までで\n for j in range(n):\n # j枚のカードを選んで\n for s in range(n*a+1):\n # 合計がsになるパターン\n if dp[i][j][s] == 0:\n continue\n # i枚目のカードが選ばれない場合\n dp[i+1][j][s] += dp[i][j][s]\n # i枚目のカードが選ばれる場合\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]", "i", "range(n)", "range", "n", "for j in range(n):\n # j枚のカードを選んで\n for s in range(n*a+1):\n # 合計がsになるパターン\n if dp[i][j][s] == 0:\n continue\n # i枚目のカードが選ばれない場合\n dp[i+1][j][s] += dp[i][j][s]\n # i枚目のカードが選ばれる場合\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]", "j", "range(n)", "range", "n", "for s in range(n*a+1):\n # 合計がsになるパターン\n if dp[i][j][s] == 0:\n continue\n # i枚目のカードが選ばれない場合\n dp[i+1][j][s] += dp[i][j][s]\n # i枚目のカードが選ばれる場合\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]", "s", "range(n*a+1)", "range", "n*a+1", "n*a", "n", "a", "1", "if dp[i][j][s] == 0:\n continue\n # i枚目のカードが選ばれない場合\n ", "dp[i][j][s] == 0", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "0", "continue", "dp[i+1][j][s] += dp[i][j][s]", "dp[i+1][j][s]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "s", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "dp[i+1][j+1][s+X[i]] += dp[i][j][s]", "dp[i+1][j+1][s+X[i]]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "s+X[i]", "s", "X[i]", "X", "i", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "ans = 0", "ans", "0", "for k in range(1, n+1):\n ans += dp[n][k][k*a]", "k", "range(1, n+1)", "range", "1", "n+1", "n", "1", "ans += dp[n][k][k*a]", "ans", "dp[n][k][k*a]", "[k]", "[n]", "dp", "n", "k", "k*a", "k", "a", "print(ans)", "print", "ans", "X = tuple(map(int, input().split()))", "tuple(map(int, input().split()))", "X", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "dp = [[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]", "[[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]", "dp", "ans = 0", "0", "ans", "ans += dp[n][k][k*a]", "dp[n][k][k*a]", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 13, 18, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 13, 18, 18, 18, 13, 13, 13, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 159, 2 ], [ 159, 11 ], [ 156, 13 ], [ 150, 25 ], [ 157, 28 ], [ 171, 30 ], [ 151, 33 ], [ 154, 35 ], [ 160, 36 ], [ 40, 39 ], [ 154, 43 ], [ 165, 48 ], [ 58, 51 ], [ 166, 54 ], [ 61, 60 ], [ 154, 63 ], [ 66, 65 ], [ 154, 68 ], [ 71, 70 ], [ 172, 74 ], [ 151, 74 ], [ 70, 79 ], [ 157, 81 ], [ 60, 82 ], [ 96, 85 ], [ 166, 88 ], [ 60, 90 ], [ 65, 93 ], [ 70, 95 ], [ 166, 99 ], [ 60, 100 ], [ 65, 101 ], [ 70, 103 ], [ 157, 105 ], [ 60, 106 ], [ 117, 108 ], [ 166, 111 ], [ 60, 113 ], [ 65, 115 ], [ 70, 116 ], [ 166, 120 ], [ 60, 121 ], [ 65, 122 ], [ 70, 123 ], [ 168, 125 ], [ 129, 128 ], [ 154, 133 ], [ 162, 136 ], [ 166, 140 ], [ 154, 141 ], [ 128, 142 ], [ 128, 144 ], [ 160, 145 ], [ 163, 148 ], [ 169, 148 ], [ 150, 151 ], [ 159, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 168, 169 ], [ 171, 172 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nsum_x = sum(x)\nsum_x = max(sum_x, n*a)\n\ndp = [[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)]\n#dp[i][j][k]はi番目までのカードの中からj枚選んで、合計がkになるときの選び方の総数\ndp[0][0][0] = 1\n\nfor i in range(n):\n for j in range(n):\n for k in range(sum_x+1):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-x[i]]\n dp[i+1][j][k] += dp[i][j][k]\n\nans = 0\nfor i in range(1, n+1):\n ans += dp[n][i][i*a]\n #print(dp[n][i][i*a])\nprint(ans)\n", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "sum_x = sum(x)", "sum_x", "sum(x)", "sum", "x", "sum_x = max(sum_x, n*a)", "sum_x", "max(sum_x, n*a)", "max", "sum_x", "n*a", "n", "a", "[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[[0]*(sum_x+1) for _ in range(n+1)]", "dp = [[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)]", "dp", "[[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n for j in range(n):\n for k in range(sum_x+1):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-x[i]]\n dp[i+1][j][k] += dp[i][j][k]", "i", "range(n)", "range", "n", "for j in range(n):\n for k in range(sum_x+1):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-x[i]]\n dp[i+1][j][k] += dp[i][j][k]", "j", "range(n)", "range", "n", "for k in range(sum_x+1):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-x[i]]\n dp[i+1][j][k] += dp[i][j][k]", "k", "range(sum_x+1)", "range", "sum_x+1", "sum_x", "1", "if k-x[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-x[i]]\n ", "k-x[i] >= 0", "k-x[i]", "k", "x[i]", "x", "i", "0", "dp[i+1][j+1][k] += dp[i][j][k-x[i]]", "dp[i+1][j+1][k]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k", "dp[i][j][k-x[i]]", "[j]", "[i]", "dp", "i", "j", "k-x[i]", "k", "x[i]", "x", "i", "dp[i+1][j][k] += dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans = 0", "ans", "0", "for i in range(1, n+1):\n ans += dp[n][i][i*a]\n #print(dp[n][i][i*a])", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "ans += dp[n][i][i*a]", "ans", "dp[n][i][i*a]", "[i]", "[n]", "dp", "n", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "sum_x = sum(x)", "sum(x)", "sum_x", "n, a = map(int, input().split())", "map(int, input().split())", "n", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "ans += dp[n][i][i*a]", "dp[n][i][i*a]", "ans", "dp = [[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)]", "[[[0]*(sum_x+1) for _ in range(n+1)] for _ in range(n+1)]", "dp", "ans = 0", "0", "ans", "sum_x = max(sum_x, n*a)", "max(sum_x, n*a)", "sum_x" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 18, 13, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 13, 4, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 2, 2, 17, 13, 13, 17, 0, 13, 4, 18, 13, 13, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 2, 17, 13, 13, 17, 14, 2, 2, 13, 18, 13, 13, 2, 18, 13, 13, 2, 13, 2, 2, 17, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 18, 13, 13, 4, 13, 4, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 178, 4 ], [ 178, 13 ], [ 181, 15 ], [ 175, 31 ], [ 182, 33 ], [ 179, 38 ], [ 169, 40 ], [ 179, 43 ], [ 182, 46 ], [ 163, 48 ], [ 167, 55 ], [ 167, 61 ], [ 170, 62 ], [ 172, 65 ], [ 164, 68 ], [ 78, 71 ], [ 173, 73 ], [ 164, 73 ], [ 167, 76 ], [ 170, 77 ], [ 81, 80 ], [ 167, 83 ], [ 86, 85 ], [ 167, 92 ], [ 170, 93 ], [ 85, 98 ], [ 176, 100 ], [ 80, 101 ], [ 176, 104 ], [ 80, 105 ], [ 85, 107 ], [ 167, 111 ], [ 170, 112 ], [ 121, 114 ], [ 173, 116 ], [ 164, 116 ], [ 80, 118 ], [ 85, 120 ], [ 173, 123 ], [ 164, 123 ], [ 80, 124 ], [ 85, 125 ], [ 134, 127 ], [ 173, 129 ], [ 164, 129 ], [ 80, 131 ], [ 85, 133 ], [ 173, 137 ], [ 164, 137 ], [ 80, 138 ], [ 85, 139 ], [ 173, 142 ], [ 164, 142 ], [ 80, 143 ], [ 85, 145 ], [ 176, 147 ], [ 80, 148 ], [ 173, 156 ], [ 164, 156 ], [ 167, 157 ], [ 167, 159 ], [ 170, 160 ], [ 163, 164 ], [ 178, 167 ], [ 169, 170 ], [ 172, 173 ], [ 175, 176 ], [ 178, 179 ], [ 181, 182 ] ]

[ "# 全DP C - 高橋君とカード / Tak and Cards\n\nimport numpy as np\n\nN, A = map(int, input().split())\nx = np.array(list(map(int, input().split())))\n\nx_diff = x - np.array(A)\nX = max(A, max(x))\n\ndp = np.zeros((N+2, 2*N*X+2)) #dp[i+1][j]はx_diff[i]までの数からいくつか選んで合計j-N*Xにするような選び方のパターン\ndp = dp.tolist()\ndp[0][N*X] = 1\n\nfor i in range(N):\n for j in range(2*N*X+1):\n if j < x_diff[i] or x_diff[i] < j - 2*N*X: # x_diff[i]を足しても絶対にj-N*Xにならないとき\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x_diff[i]]\n \nprint(int(dp[N][N*X] - 1))", "import numpy as np", "numpy", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "x = np.array(list(map(int, input().split())))", "x", "np.array(list(map(int, input().split())))", "np.array", "np", "array", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x_diff = x - np.array(A)", "x_diff", "x - np.array(A)", "x", "np.array(A)", "np.array", "np", "array", "A", "X = max(A, max(x))", "X", "max(A, max(x))", "max", "A", "max(x)", "max", "x", "dp = np.zeros((N+2, 2*N*X+2))", "dp", "np.zeros((N+2, 2*N*X+2))", "np.zeros", "np", "zeros", "(N+2, 2*N*X+2)", "N+2", "N", "2", "2*N*X+2", "2*N*X", "2*N", "2", "N", "X", "2", "dp = dp.tolist()", "dp", "dp.tolist()", "dp.tolist", "dp", "tolist", "dp[0][N*X] = 1", "dp[0][N*X]", "[0]", "dp", "0", "N*X", "N", "X", "1", "for i in range(N):\n for j in range(2*N*X+1):\n if j < x_diff[i] or x_diff[i] < j - 2*N*X: # x_diff[i]を足しても絶対にj-N*Xにならないとき\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x_diff[i]]\n ", "i", "range(N)", "range", "N", "for j in range(2*N*X+1):\n if j < x_diff[i] or x_diff[i] < j - 2*N*X: # x_diff[i]を足しても絶対にj-N*Xにならないとき\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x_diff[i]]\n ", "j", "range(2*N*X+1)", "range", "2*N*X+1", "2*N*X", "2*N", "2", "N", "X", "1", "if j < x_diff[i] or x_diff[i] < j - 2*N*X: # x_diff[i]を足しても絶対にj-N*Xにならないとき\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x_diff[i]]\n ", "j < x_diff[i] or x_diff[i] < j - 2*N*X", "j < x_diff[i]", "j", "x_diff[i]", "x_diff", "i", "x_diff[i] < j - 2*N*X", "x_diff[i]", "x_diff", "i", "j - 2*N*X", "j", "2*N*X", "2*N", "2", "N", "X", "dp[i+1][j] = dp[i][j]", "dp[i+1][j]", "[i+1]", "dp", "i+1", "i", "1", "j", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i+1][j] = dp[i][j] + dp[i][j-x_diff[i]]", "dp[i+1][j]", "[i+1]", "dp", "i+1", "i", "1", "j", "dp[i][j] + dp[i][j-x_diff[i]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i][j-x_diff[i]]", "[i]", "dp", "i", "j-x_diff[i]", "j", "x_diff[i]", "x_diff", "i", "print(int(dp[N][N*X] - 1))", "print", "int(dp[N][N*X] - 1)", "int", "dp[N][N*X] - 1", "dp[N][N*X]", "[N]", "dp", "N", "N*X", "N", "X", "1", "dp = np.zeros((N+2, 2*N*X+2))", "np.zeros((N+2, 2*N*X+2))", "dp", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = max(A, max(x))", "max(A, max(x))", "X", "dp = dp.tolist()", "dp.tolist()", "dp", "x_diff = x - np.array(A)", "x - np.array(A)", "x_diff", "A = map(int, input().split())", "map(int, input().split())", "A", "x = np.array(list(map(int, input().split())))", "np.array(list(map(int, input().split())))", "x" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 18, 4, 18, 13, 13, 39, 2, 13, 17, 2, 13, 17, 17, 13, 18, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 2, 13, 17, 18, 13, 13, 0, 18, 13, 2, 13, 17, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13 ]

[ [ 120, 4 ], [ 120, 13 ], [ 117, 15 ], [ 108, 27 ], [ 112, 36 ], [ 112, 39 ], [ 54, 47 ], [ 109, 50 ], [ 57, 56 ], [ 112, 59 ], [ 123, 61 ], [ 118, 63 ], [ 56, 64 ], [ 67, 66 ], [ 112, 69 ], [ 76, 71 ], [ 109, 72 ], [ 56, 74 ], [ 109, 77 ], [ 56, 78 ], [ 85, 80 ], [ 109, 81 ], [ 56, 83 ], [ 109, 86 ], [ 56, 87 ], [ 126, 89 ], [ 93, 92 ], [ 112, 97 ], [ 114, 100 ], [ 109, 102 ], [ 112, 103 ], [ 115, 106 ], [ 127, 106 ], [ 108, 109 ], [ 120, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ] ]

[ "import numpy as np\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\n\n# dp[i][j][k]：　i枚目までのカードをj枚使用して合計kを作れる組み合わせ\ndp = np.zeros((n+1, n+1, 3001)).astype(np.int64)\ndp[0][0][0] = 1\n\nfor i in range(n):\n _x = x[i]\n for j in range(n):\n dp[i+1, j+1, _x:] += dp[i, j, :-_x]\n dp[i+1, j, :] += dp[i, j, :]\n\nans = 0\nfor j in range(1, n+1):\n ans += dp[n, j, j*a]\nprint(ans)", "import numpy as np", "numpy", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "dp = np.zeros((n+1, n+1, 3001)).astype(np.int64)", "dp", "np.zeros((n+1, n+1, 3001)).astype(np.int64)", "np.zeros((n+1, n+1, 3001)).astype", "np.zeros((n+1, n+1, 3001))", "np.zeros", "np", "zeros", "(n+1, n+1, 3001)", "n+1", "n", "1", "n+1", "n", "1", "3001", "astype", "np.int64", "np", "int64", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n _x = x[i]\n for j in range(n):\n dp[i+1, j+1, _x:] += dp[i, j, :-_x]\n dp[i+1, j, :] += dp[i, j, :]", "i", "range(n)", "range", "n", "_x = x[i]", "_x", "x[i]", "x", "i", "for j in range(n):\n dp[i+1, j+1, _x:] += dp[i, j, :-_x]\n dp[i+1, j, :] += dp[i, j, :]", "j", "range(n)", "range", "n", "dp[i+1, j+1, _x:] += dp[i, j, :-_x]", "dp[i+1, j+1, _x:]", "dp", "i+1", "i", "1", "dp[i, j, :-_x]", "dp", "i", "dp[i+1, j, :] += dp[i, j, :]", "dp[i+1, j, :]", "dp", "i+1", "i", "1", "dp[i, j, :]", "dp", "i", "ans = 0", "ans", "0", "for j in range(1, n+1):\n ans += dp[n, j, j*a]", "j", "range(1, n+1)", "range", "1", "n+1", "n", "1", "ans += dp[n, j, j*a]", "ans", "dp[n, j, j*a]", "dp", "n", "print(ans)", "print", "ans", "dp = np.zeros((n+1, n+1, 3001)).astype(np.int64)", "np.zeros((n+1, n+1, 3001)).astype(np.int64)", "dp", "n, a = map(int, input().split())", "map(int, input().split())", "n", "ans += dp[n, j, j*a]", "dp[n, j, j*a]", "ans", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "_x = x[i]", "x[i]", "_x", "ans = 0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 4, 18, 13, 13, 14, 2, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 4, 13, 17, 4, 13, 0, 13, 4, 18, 13, 13, 17, 14, 2, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 4, 13, 2, 4, 13, 17, 13, 17, 4, 13, 41, 28, 13, 13, 2, 13, 17, 4, 13, 0, 13, 13, 41, 28, 13, 13, 2, 13, 17, 4, 40, 13, 0, 13, 13, 0, 13, 2, 4, 13, 13, 17, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 2, 13, 13, 0, 18, 13, 2, 13, 13, 18, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 18, 13, 13, 28, 13, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 13, 0, 18, 13, 2, 13, 13, 18, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 18, 13, 13, 4, 13, 2, 2, 18, 13, 17, 4, 13, 17, 13, 17, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 231, 2 ], [ 231, 11 ], [ 225, 13 ], [ 26, 25 ], [ 232, 28 ], [ 33, 30 ], [ 226, 31 ], [ 25, 32 ], [ 217, 33 ], [ 226, 36 ], [ 226, 42 ], [ 226, 47 ], [ 219, 56 ], [ 226, 59 ], [ 226, 66 ], [ 226, 71 ], [ 220, 80 ], [ 87, 86 ], [ 226, 86 ], [ 86, 89 ], [ 86, 92 ], [ 222, 94 ], [ 99, 98 ], [ 226, 98 ], [ 98, 101 ], [ 98, 105 ], [ 228, 107 ], [ 234, 110 ], [ 223, 114 ], [ 240, 117 ], [ 235, 121 ], [ 126, 123 ], [ 241, 124 ], [ 129, 128 ], [ 223, 128 ], [ 237, 131 ], [ 235, 135 ], [ 138, 137 ], [ 235, 141 ], [ 128, 142 ], [ 149, 144 ], [ 238, 145 ], [ 128, 147 ], [ 137, 148 ], [ 158, 149 ], [ 241, 150 ], [ 137, 151 ], [ 154, 153 ], [ 235, 156 ], [ 161, 158 ], [ 241, 159 ], [ 153, 160 ], [ 238, 162 ], [ 153, 163 ], [ 166, 165 ], [ 229, 165 ], [ 213, 168 ], [ 235, 172 ], [ 175, 174 ], [ 165, 177 ], [ 235, 178 ], [ 185, 180 ], [ 214, 181 ], [ 238, 181 ], [ 174, 183 ], [ 165, 184 ], [ 158, 185 ], [ 194, 185 ], [ 241, 186 ], [ 174, 187 ], [ 190, 189 ], [ 235, 192 ], [ 197, 194 ], [ 241, 195 ], [ 189, 196 ], [ 214, 198 ], [ 238, 198 ], [ 189, 199 ], [ 241, 205 ], [ 220, 210 ], [ 213, 214 ], [ 231, 217 ], [ 219, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ], [ 237, 238 ], [ 240, 241 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\nfor i in range(n):\n x[i] -= a\n\nx.sort()\n\nif x[0] > 0 or x[-1] < 0:\n print(0)\n exit()\n\nnum_zero = x.count(0)\n\nif x[0] == 0 or x[-1] == 0:\n print(pow(2, num_zero) - 1)\n exit()\n\nxp = [i for i in x if i > 0]\nxm = [-i for i in x if i < 0]\n\nsum_xp = sum(xp) + 1\ndp = [0] * sum_xp\ndp[0] = 1\nfor i in xp:\n new_dp = [0] * sum_xp\n for j in range(sum_xp - i):\n new_dp[i + j] += dp[j]\n for j in range(sum_xp):\n dp[j] += new_dp[j]\n\nfor i in xm:\n new_dp = [0] * sum_xp\n for j in range(i, sum_xp):\n new_dp[j - i] += dp[j]\n for j in range(sum_xp):\n dp[j] += new_dp[j]\n\nprint(dp[0] * pow(2, num_zero) - 1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n x[i] -= a", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "x.sort()", "x.sort", "x", "sort", "if x[0] > 0 or x[-1] < 0:\n print(0)\n exit()", "x[0] > 0 or x[-1] < 0", "x[0] > 0", "x[0]", "x", "0", "0", "x[-1] < 0", "x[-1]", "x", "-1", "0", "print(0)", "print", "0", "exit()", "exit", "num_zero = x.count(0)", "num_zero", "x.count(0)", "x.count", "x", "count", "0", "if x[0] == 0 or x[-1] == 0:\n print(pow(2, num_zero) - 1)\n exit()", "x[0] == 0 or x[-1] == 0", "x[0] == 0", "x[0]", "x", "0", "0", "x[-1] == 0", "x[-1]", "x", "-1", "0", "print(pow(2, num_zero) - 1)", "print", "pow(2, num_zero) - 1", "pow(2, num_zero)", "pow", "2", "num_zero", "1", "exit()", "exit", "i for i in x if i > 0", "for i in x if i > 0", "i", "x", "i > 0", "i", "0", "if i > 0", "i", "xp = [i for i in x if i > 0]", "xp", "[i for i in x if i > 0]", "-i for i in x if i < 0", "for i in x if i < 0", "i", "x", "i < 0", "i", "0", "if i < 0", "-i", "i", "xm = [-i for i in x if i < 0]", "xm", "[-i for i in x if i < 0]", "sum_xp = sum(xp) + 1", "sum_xp", "sum(xp) + 1", "sum(xp)", "sum", "xp", "1", "dp = [0] * sum_xp", "dp", "[0] * sum_xp", "[0]", "0", "sum_xp", "dp[0] = 1", "dp[0]", "dp", "0", "1", "for i in xp:\n new_dp = [0] * sum_xp\n for j in range(sum_xp - i):\n new_dp[i + j] += dp[j]\n for j in range(sum_xp):\n dp[j] += new_dp[j]", "i", "xp", "new_dp = [0] * sum_xp", "new_dp", "[0] * sum_xp", "[0]", "0", "sum_xp", "for j in range(sum_xp - i):\n new_dp[i + j] += dp[j]\n ", "j", "range(sum_xp - i)", "range", "sum_xp - i", "sum_xp", "i", "new_dp[i + j] += dp[j]", "new_dp[i + j]", "new_dp", "i + j", "i", "j", "dp[j]", "dp", "j", "for j in range(sum_xp):\n dp[j] += new_dp[j]", "j", "range(sum_xp)", "range", "sum_xp", "dp[j] += new_dp[j]", "dp[j]", "dp", "j", "new_dp[j]", "new_dp", "j", "for i in xm:\n new_dp = [0] * sum_xp\n for j in range(i, sum_xp):\n new_dp[j - i] += dp[j]\n for j in range(sum_xp):\n dp[j] += new_dp[j]", "i", "xm", "new_dp = [0] * sum_xp", "new_dp", "[0] * sum_xp", "[0]", "0", "sum_xp", "for j in range(i, sum_xp):\n new_dp[j - i] += dp[j]\n ", "j", "range(i, sum_xp)", "range", "i", "sum_xp", "new_dp[j - i] += dp[j]", "new_dp[j - i]", "new_dp", "j - i", "j", "i", "dp[j]", "dp", "j", "for j in range(sum_xp):\n dp[j] += new_dp[j]", "j", "range(sum_xp)", "range", "sum_xp", "dp[j] += new_dp[j]", "dp[j]", "dp", "j", "new_dp[j]", "new_dp", "j", "print(dp[0] * pow(2, num_zero) - 1)", "print", "dp[0] * pow(2, num_zero) - 1", "dp[0] * pow(2, num_zero)", "dp[0]", "dp", "0", "pow(2, num_zero)", "pow", "2", "num_zero", "1", "new_dp = [0] * sum_xp", "[0] * sum_xp", "new_dp", "a = map(int, input().split())", "map(int, input().split())", "a", "num_zero = x.count(0)", "x.count(0)", "num_zero", "xp = [i for i in x if i > 0]", "[i for i in x if i > 0]", "xp", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "xm = [-i for i in x if i < 0]", "[-i for i in x if i < 0]", "xm", "n, a = map(int, input().split())", "map(int, input().split())", "n", "sum_xp = sum(xp) + 1", "sum(xp) + 1", "sum_xp", "new_dp = [0] * sum_xp", "[0] * sum_xp", "new_dp", "dp = [0] * sum_xp", "[0] * sum_xp", "dp" ]

[ 7, 15, 13, 15, 13, 13, 15, 15, 15, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 13, 17, 17, 28, 13, 4, 13, 2, 13, 13, 17, 17, 14, 40, 2, 13, 18, 13, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 10, 17, 13, 10, 18, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 146, 11 ], [ 146, 20 ], [ 143, 22 ], [ 36, 35 ], [ 147, 39 ], [ 147, 47 ], [ 138, 48 ], [ 140, 51 ], [ 59, 54 ], [ 141, 56 ], [ 62, 61 ], [ 147, 65 ], [ 68, 67 ], [ 147, 70 ], [ 75, 74 ], [ 147, 78 ], [ 138, 79 ], [ 74, 85 ], [ 144, 87 ], [ 61, 88 ], [ 96, 91 ], [ 141, 93 ], [ 67, 94 ], [ 74, 95 ], [ 141, 98 ], [ 67, 100 ], [ 74, 103 ], [ 144, 105 ], [ 61, 106 ], [ 131, 108 ], [ 112, 111 ], [ 147, 116 ], [ 134, 119 ], [ 141, 122 ], [ 111, 123 ], [ 111, 125 ], [ 138, 126 ], [ 135, 129 ], [ 132, 129 ], [ 131, 132 ], [ 134, 135 ], [ 146, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ] ]

[ "import sys\nimport heapq, math\nfrom itertools import zip_longest, permutations, combinations, combinations_with_replacement\nfrom itertools import accumulate, dropwhile, takewhile, groupby\nfrom functools import lru_cache\nfrom copy import deepcopy\n\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\n\ndp = [[0] * (N * A + 1) for _ in range(N + 1)]\n\ndp[0][0] = 1\n\nfor i in range(0, N):\n for cnt in range(N, 0, -1):\n for val in range(N * A, -1, -1):\n if val - X[i] >= 0:\n dp[cnt][val] += dp[cnt - 1][val - X[i]]\n\nans = 0\nfor i in range(1, N + 1):\n ans += dp[i][i * A]\n\nprint(ans)", "import sys", "sys", "import heapq, math", "heapq", "math", "from itertools import zip_longest, permutations, combinations, combinations_with_replacement", "from itertools import accumulate, dropwhile, takewhile, groupby", "from functools import lru_cache", "from copy import deepcopy", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[0] * (N * A + 1) for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[0] * (N * A + 1)", "[0]", "0", "N * A + 1", "N * A", "N", "A", "1", "dp = [[0] * (N * A + 1) for _ in range(N + 1)]", "dp", "[[0] * (N * A + 1) for _ in range(N + 1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(0, N):\n for cnt in range(N, 0, -1):\n for val in range(N * A, -1, -1):\n if val - X[i] >= 0:\n dp[cnt][val] += dp[cnt - 1][val - X[i]]", "i", "range(0, N)", "range", "0", "N", "for cnt in range(N, 0, -1):\n for val in range(N * A, -1, -1):\n if val - X[i] >= 0:\n dp[cnt][val] += dp[cnt - 1][val - X[i]]", "cnt", "range(N, 0, -1)", "range", "N", "0", "-1", "for val in range(N * A, -1, -1):\n if val - X[i] >= 0:\n dp[cnt][val] += dp[cnt - 1][val - X[i]]", "val", "range(N * A, -1, -1)", "range", "N * A", "N", "A", "-1", "-1", "if val - X[i] >= 0:\n dp[cnt][val] += dp[cnt - 1][val - X[i]]", "val - X[i] >= 0", "val - X[i]", "val", "X[i]", "X", "i", "0", "dp[cnt][val] += dp[cnt - 1][val - X[i]]", "dp[cnt][val]", "[cnt]", "dp", "cnt", "val", "dp[cnt - 1][val - X[i]]", "[cnt - 1]", "dp", "cnt - 1", "cnt", "1", "val - X[i]", "val", "X[i]", "X", "i", "ans = 0", "ans", "0", "for i in range(1, N + 1):\n ans += dp[i][i * A]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "ans += dp[i][i * A]", "ans", "dp[i][i * A]", "[i]", "dp", "i", "i * A", "i", "A", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "ans += dp[i][i * A]", "dp[i][i * A]", "ans", "A = map(int, input().split())", "map(int, input().split())", "A", "dp = [[0] * (N * A + 1) for _ in range(N + 1)]", "[[0] * (N * A + 1) for _ in range(N + 1)]", "dp", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "N, A = map(int, input().split())", "map(int, input().split())", "N" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 14, 2, 2, 13, 18, 13, 13, 13, 9, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 2, 13, 17, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 2, 13, 2, 13, 17, 13, 3, 0, 13, 18, 18, 18, 13, 13, 2, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 168, 2 ], [ 168, 11 ], [ 15, 14 ], [ 14, 23 ], [ 171, 25 ], [ 174, 28 ], [ 172, 31 ], [ 35, 34 ], [ 169, 38 ], [ 156, 43 ], [ 53, 46 ], [ 157, 49 ], [ 56, 55 ], [ 169, 58 ], [ 61, 60 ], [ 169, 63 ], [ 66, 65 ], [ 175, 69 ], [ 81, 72 ], [ 157, 75 ], [ 55, 77 ], [ 65, 79 ], [ 60, 80 ], [ 157, 84 ], [ 55, 85 ], [ 65, 86 ], [ 60, 87 ], [ 65, 91 ], [ 172, 93 ], [ 55, 94 ], [ 175, 95 ], [ 113, 98 ], [ 157, 101 ], [ 55, 103 ], [ 65, 106 ], [ 172, 108 ], [ 55, 109 ], [ 60, 111 ], [ 157, 116 ], [ 55, 117 ], [ 65, 118 ], [ 60, 119 ], [ 159, 121 ], [ 125, 124 ], [ 169, 127 ], [ 163, 131 ], [ 124, 133 ], [ 175, 135 ], [ 165, 138 ], [ 157, 142 ], [ 169, 143 ], [ 163, 145 ], [ 124, 147 ], [ 124, 150 ], [ 166, 154 ], [ 160, 154 ], [ 156, 157 ], [ 159, 160 ], [ 168, 163 ], [ 165, 166 ], [ 168, 169 ], [ 171, 172 ], [ 174, 175 ] ]

[ "n,a = map(int,input().split())\nx = [int(i) for i in input().split()]\n\nsum_x = sum(x)\n\ndp = [[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)]\n\ndp[0][0][0] = 1\n\nfor i in range(n):\n for j in range(n):\n for k in range(sum_x+1):\n dp[i+1][k][j] += dp[i][k][j]\n if k + x[i] > sum_x:\n continue\n dp[i+1][k+x[i]][j+1] += dp[i][k][j]\n \nans = 0\n\nfor i in range(n):\n if a*(i+1) > sum_x:\n break\n ans += dp[n][a*(i+1)][i+1]\n\nprint(ans)", "n,a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "x = [int(i) for i in input().split()]", "x", "[int(i) for i in input().split()]", "sum_x = sum(x)", "sum_x", "sum(x)", "sum", "x", "[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)", "for k in range(n+1)", "k", "range(n+1)", "range", "n+1", "n", "1", "for k in range(n+1)", "[[0 for i in range(n+1)]for j in range(sum_x+1)]", "dp = [[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)]", "dp", "[[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n for j in range(n):\n for k in range(sum_x+1):\n dp[i+1][k][j] += dp[i][k][j]\n if k + x[i] > sum_x:\n continue\n dp[i+1][k+x[i]][j+1] += dp[i][k][j]\n ", "i", "range(n)", "range", "n", "for j in range(n):\n for k in range(sum_x+1):\n dp[i+1][k][j] += dp[i][k][j]\n if k + x[i] > sum_x:\n continue\n dp[i+1][k+x[i]][j+1] += dp[i][k][j]\n ", "j", "range(n)", "range", "n", "for k in range(sum_x+1):\n dp[i+1][k][j] += dp[i][k][j]\n if k + x[i] > sum_x:\n continue\n dp[i+1][k+x[i]][j+1] += dp[i][k][j]\n ", "k", "range(sum_x+1)", "range", "sum_x+1", "sum_x", "1", "dp[i+1][k][j] += dp[i][k][j]", "dp[i+1][k][j]", "[k]", "[i+1]", "dp", "i+1", "i", "1", "k", "j", "dp[i][k][j]", "[k]", "[i]", "dp", "i", "k", "j", "if k + x[i] > sum_x:\n continue\n ", "k + x[i] > sum_x", "k + x[i]", "k", "x[i]", "x", "i", "sum_x", "continue", "dp[i+1][k+x[i]][j+1] += dp[i][k][j]", "dp[i+1][k+x[i]][j+1]", "[k+x[i]]", "[i+1]", "dp", "i+1", "i", "1", "k+x[i]", "k", "x[i]", "x", "i", "j+1", "j", "1", "dp[i][k][j]", "[k]", "[i]", "dp", "i", "k", "j", "ans = 0", "ans", "0", "for i in range(n):\n if a*(i+1) > sum_x:\n break\n ans += dp[n][a*(i+1)][i+1]", "i", "range(n)", "range", "n", "if a*(i+1) > sum_x:\n break\n ", "a*(i+1) > sum_x", "a*(i+1)", "a", "i+1", "i", "1", "sum_x", "break", "ans += dp[n][a*(i+1)][i+1]", "ans", "dp[n][a*(i+1)][i+1]", "[a*(i+1)]", "[n]", "dp", "n", "a*(i+1)", "a", "i+1", "i", "1", "i+1", "i", "1", "print(ans)", "print", "ans", "dp = [[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)]", "[[[0 for i in range(n+1)]for j in range(sum_x+1)]for k in range(n+1)]", "dp", "ans = 0", "0", "ans", "a = map(int,input().split())", "map(int,input().split())", "a", "ans += dp[n][a*(i+1)][i+1]", "dp[n][a*(i+1)][i+1]", "ans", "n,a = map(int,input().split())", "map(int,input().split())", "n", "x = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "x", "sum_x = sum(x)", "sum(x)", "sum_x" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 18, 13, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 13, 0, 13, 18, 13, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 0, 13, 4, 13, 18, 13, 2, 13, 17, 0, 13, 4, 18, 13, 13, 17, 0, 13, 18, 13, 13, 0, 18, 13, 17, 17, 28, 13, 13, 0, 18, 13, 39, 13, 2, 18, 13, 39, 40, 13, 18, 13, 39, 13, 28, 13, 13, 0, 18, 13, 39, 40, 13, 2, 18, 13, 39, 40, 13, 18, 13, 39, 13, 0, 13, 2, 2, 17, 4, 13, 13, 18, 13, 17, 4, 13, 2, 13, 17, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 18, 13, 10, 18, 13 ]

[ [ 133, 4 ], [ 133, 13 ], [ 145, 15 ], [ 142, 31 ], [ 128, 32 ], [ 148, 34 ], [ 143, 36 ], [ 146, 36 ], [ 143, 38 ], [ 146, 38 ], [ 151, 41 ], [ 143, 43 ], [ 146, 43 ], [ 143, 45 ], [ 146, 45 ], [ 136, 48 ], [ 143, 52 ], [ 146, 52 ], [ 143, 54 ], [ 146, 54 ], [ 139, 57 ], [ 65, 64 ], [ 72, 69 ], [ 140, 70 ], [ 75, 74 ], [ 149, 74 ], [ 81, 77 ], [ 140, 78 ], [ 140, 83 ], [ 74, 86 ], [ 140, 88 ], [ 93, 92 ], [ 137, 92 ], [ 100, 95 ], [ 140, 96 ], [ 92, 99 ], [ 140, 102 ], [ 92, 105 ], [ 140, 107 ], [ 130, 111 ], [ 152, 117 ], [ 140, 119 ], [ 131, 124 ], [ 133, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ], [ 139, 140 ], [ 128, 142 ], [ 142, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ] ]

[ "import numpy as np\n\n\nn, a = map(int, input().split())\nX = np.array(list(map(int, input().split())))\nX -= a\n\nplus = X[X > 0]\nzero = X[X == 0]\nminus = abs(X[X < 0])\n\nnum_count = np.zeros(2551, dtype=np.int64)\nnum_count[0] = 1\n\nfor num in plus:\n num_count[num:] = num_count[:-num] + num_count[num:]\n\nfor num in minus:\n num_count[:-num] = num_count[:-num] + num_count[num:]\n\nans = 2 ** len(zero) * (num_count[0])\n\nprint(ans-1)", "import numpy as np", "numpy", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X = np.array(list(map(int, input().split())))", "X", "np.array(list(map(int, input().split())))", "np.array", "np", "array", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X -= a", "X", "a", "plus = X[X > 0]", "plus", "X[X > 0]", "X", "X > 0", "X", "0", "zero = X[X == 0]", "zero", "X[X == 0]", "X", "X == 0", "X", "0", "minus = abs(X[X < 0])", "minus", "abs(X[X < 0])", "abs", "X[X < 0]", "X", "X < 0", "X", "0", "num_count = np.zeros(2551, dtype=np.int64)", "num_count", "np.zeros(2551, dtype=np.int64)", "np.zeros", "np", "zeros", "2551", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "num_count[0] = 1", "num_count[0]", "num_count", "0", "1", "for num in plus:\n num_count[num:] = num_count[:-num] + num_count[num:]", "num", "plus", "num_count[num:] = num_count[:-num] + num_count[num:]", "num_count[num:]", "num_count", "num:", "num", "num_count[:-num] + num_count[num:]", "num_count[:-num]", "num_count", ":-num", "-num", "num", "num_count[num:]", "num_count", "num:", "num", "for num in minus:\n num_count[:-num] = num_count[:-num] + num_count[num:]", "num", "minus", "num_count[:-num] = num_count[:-num] + num_count[num:]", "num_count[:-num]", "num_count", ":-num", "-num", "num", "num_count[:-num] + num_count[num:]", "num_count[:-num]", "num_count", ":-num", "-num", "num", "num_count[num:]", "num_count", "num:", "num", "ans = 2 ** len(zero) * (num_count[0])", "ans", "2 ** len(zero) * (num_count[0])", "2 ** len(zero)", "2", "len(zero)", "len", "zero", "num_count[0]", "num_count", "0", "print(ans-1)", "print", "ans-1", "ans", "1", "a = map(int, input().split())", "map(int, input().split())", "a", "ans = 2 ** len(zero) * (num_count[0])", "2 ** len(zero) * (num_count[0])", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "minus = abs(X[X < 0])", "abs(X[X < 0])", "minus", "num_count = np.zeros(2551, dtype=np.int64)", "np.zeros(2551, dtype=np.int64)", "num_count", "X -= a", "a", "X", "X = np.array(list(map(int, input().split())))", "np.array(list(map(int, input().split())))", "X", "plus = X[X > 0]", "X[X > 0]", "plus", "zero = X[X == 0]", "X[X == 0]", "zero" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 31, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 17, 17, 28, 13, 4, 13, 18, 13, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 4, 13, 13, 2, 13, 13, 17, 0, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 29, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 2, 13, 10, 17, 13, 10, 18, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 168, 4 ], [ 159, 11 ], [ 171, 18 ], [ 162, 32 ], [ 165, 37 ], [ 43, 42 ], [ 169, 49 ], [ 43, 51 ], [ 43, 52 ], [ 56, 55 ], [ 62, 61 ], [ 42, 65 ], [ 55, 72 ], [ 76, 75 ], [ 83, 78 ], [ 75, 80 ], [ 86, 85 ], [ 42, 88 ], [ 91, 90 ], [ 42, 93 ], [ 98, 97 ], [ 85, 102 ], [ 55, 104 ], [ 112, 107 ], [ 75, 109 ], [ 90, 110 ], [ 97, 111 ], [ 75, 114 ], [ 90, 116 ], [ 97, 119 ], [ 85, 122 ], [ 125, 124 ], [ 128, 127 ], [ 42, 134 ], [ 55, 136 ], [ 51, 137 ], [ 141, 140 ], [ 75, 143 ], [ 127, 144 ], [ 51, 146 ], [ 127, 147 ], [ 140, 150 ], [ 124, 150 ], [ 175, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 168, 169 ], [ 171, 172 ] ]

[ "import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\nsys.setrecursionlimit(10 ** 9)\nINF = 1 << 60\nMOD = 1000000007\n\n\ndef main():\n N, A, *X = map(int, read().split())\n\n M = sum(X)\n dp = [[0] * (M + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, min(N, M // A) + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "MOD = 1000000007", "MOD", "1000000007", "def main():\n N, A, *X = map(int, read().split())\n\n M = sum(X)\n dp = [[0] * (M + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, min(N, M // A) + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return", "main", "N, A, *X = map(int, read().split())", "N", "map(int, read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "A", "*X", "X", "M = sum(X)", "M", "sum(X)", "sum", "X", "[0] * (M + 1) for j in range(N + 1)", "for j in range(N + 1)", "j", "range(N + 1)", "range", "N + 1", "N", "1", "for j in range(N + 1)", "[0] * (M + 1)", "[0]", "0", "M + 1", "M", "1", "dp = [[0] * (M + 1) for j in range(N + 1)]", "dp", "[[0] * (M + 1) for j in range(N + 1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(N):\n for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ", "i", "range(N)", "range", "N", "for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ", "j", "range(N, 0, -1)", "range", "N", "0", "-1", "for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ", "k", "range(X[i], M + 1)", "range", "X[i]", "X", "i", "M + 1", "M", "1", "dp[j][k] += dp[j - 1][k - X[i]]", "dp[j][k]", "[j]", "dp", "j", "k", "dp[j - 1][k - X[i]]", "[j - 1]", "dp", "j - 1", "j", "1", "k - X[i]", "k", "X[i]", "X", "i", "ans = 0", "ans", "0", "for j in range(1, min(N, M // A) + 1):\n ans += dp[j][A * j]\n\n ", "j", "range(1, min(N, M // A) + 1)", "range", "1", "min(N, M // A) + 1", "min(N, M // A)", "min", "N", "M // A", "M", "A", "1", "ans += dp[j][A * j]", "ans", "dp[j][A * j]", "[j]", "dp", "j", "A * j", "A", "j", "print(ans)", "print", "ans", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "INF = 1 << 60", "1 << 60", "INF", "MOD = 1000000007", "1000000007", "MOD", "read = sys.stdin.read", "sys.stdin.read", "read", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "def main():\n N, A, *X = map(int, read().split())\n\n M = sum(X)\n dp = [[0] * (M + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, min(N, M // A) + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return", "def main():\n N, A, *X = map(int, read().split())\n\n M = sum(X)\n dp = [[0] * (M + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, 0, -1):\n for k in range(X[i], M + 1):\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, min(N, M // A) + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return", "main" ]

[ 7, 0, 13, 12, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 4, 2, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 13, 17, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 17, 4, 13, 18, 13, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 125, 2 ], [ 122, 13 ], [ 126, 15 ], [ 122, 16 ], [ 20, 19 ], [ 126, 21 ], [ 19, 24 ], [ 123, 25 ], [ 116, 27 ], [ 32, 31 ], [ 110, 41 ], [ 119, 44 ], [ 52, 47 ], [ 111, 49 ], [ 120, 51 ], [ 55, 54 ], [ 114, 57 ], [ 60, 59 ], [ 117, 67 ], [ 54, 68 ], [ 78, 71 ], [ 111, 73 ], [ 54, 75 ], [ 59, 77 ], [ 111, 80 ], [ 54, 81 ], [ 59, 82 ], [ 95, 84 ], [ 111, 86 ], [ 54, 88 ], [ 59, 91 ], [ 117, 93 ], [ 54, 94 ], [ 111, 97 ], [ 54, 98 ], [ 59, 99 ], [ 111, 105 ], [ 114, 106 ], [ 120, 107 ], [ 110, 111 ], [ 122, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "f=lambda:map(int,input().split())\nn,a=f()\nl=[i-a for i in f()]\ndp=[[0]*5000 for _ in range(51)]\nZ=2500\ndp[0][Z]=1\nfor i in range(n):\n for s in range(5000-max(l[i],0)):\n dp[i+1][s]+=dp[i][s]\n dp[i+1][s+l[i]]+=dp[i][s]\nprint(dp[n][Z]-1)", "f=lambda:map(int,input().split())", "f", "lambda:map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "n,a=f()", "n", "f()", "f", "a", "i-a for i in f()", "for i in f()", "i", "f()", "f", "for i in f()", "i-a", "i", "a", "l=[i-a for i in f()]", "l", "[i-a for i in f()]", "[0]*5000 for _ in range(51)", "for _ in range(51)", "_", "range(51)", "range", "51", "for _ in range(51)", "[0]*5000", "[0]", "0", "5000", "dp=[[0]*5000 for _ in range(51)]", "dp", "[[0]*5000 for _ in range(51)]", "Z=2500", "Z", "2500", "dp[0][Z]=1", "dp[0][Z]", "[0]", "dp", "0", "Z", "1", "for i in range(n):\n for s in range(5000-max(l[i],0)):\n dp[i+1][s]+=dp[i][s]\n dp[i+1][s+l[i]]+=dp[i][s]", "i", "range(n)", "range", "n", "for s in range(5000-max(l[i],0)):\n dp[i+1][s]+=dp[i][s]\n dp[i+1][s+l[i]]+=dp[i][s]", "s", "range(5000-max(l[i],0))", "range", "5000-max(l[i],0)", "5000", "max(l[i],0)", "max", "l[i]", "l", "i", "0", "dp[i+1][s]+=dp[i][s]", "dp[i+1][s]", "[i+1]", "dp", "i+1", "i", "1", "s", "dp[i][s]", "[i]", "dp", "i", "s", "dp[i+1][s+l[i]]+=dp[i][s]", "dp[i+1][s+l[i]]", "[i+1]", "dp", "i+1", "i", "1", "s+l[i]", "s", "l[i]", "l", "i", "dp[i][s]", "[i]", "dp", "i", "s", "print(dp[n][Z]-1)", "print", "dp[n][Z]-1", "dp[n][Z]", "[n]", "dp", "n", "Z", "1", "dp=[[0]*5000 for _ in range(51)]", "[[0]*5000 for _ in range(51)]", "dp", "n,a=f()", "f()", "n", "l=[i-a for i in f()]", "[i-a for i in f()]", "l", "Z=2500", "2500", "Z", "a=f()", "f()", "a", "f=lambda:map(int,input().split())", "lambda:map(int,input().split())", "f" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 15, 41, 28, 13, 4, 18, 4, 13, 13, 4, 2, 4, 13, 13, 13, 0, 13, 13, 0, 13, 4, 13, 39, 17, 28, 13, 13, 0, 13, 4, 13, 28, 13, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 13, 0, 13, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 74, 2 ], [ 74, 11 ], [ 16, 15 ], [ 15, 25 ], [ 75, 26 ], [ 77, 28 ], [ 68, 31 ], [ 38, 37 ], [ 78, 37 ], [ 80, 40 ], [ 69, 48 ], [ 84, 48 ], [ 56, 51 ], [ 81, 52 ], [ 37, 54 ], [ 83, 58 ], [ 81, 59 ], [ 84, 64 ], [ 69, 64 ], [ 68, 69 ], [ 74, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 81, 83 ], [ 83, 84 ] ]

[ "n,a=map(int,input().split())\nfrom collections import Counter\nX = [int(x) - a for x in input().split()]\nd=Counter([0])\nfor i in X:\n tmp=Counter()\n for j,k in d.items():\n tmp[i+j]+=k\n d+=tmp\nprint(d[0]-1)", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "from collections import Counter", "int(x) - a for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x) - a", "int(x)", "int", "x", "a", "X = [int(x) - a for x in input().split()]", "X", "[int(x) - a for x in input().split()]", "d=Counter([0])", "d", "Counter([0])", "Counter", "[0]", "0", "for i in X:\n tmp=Counter()\n for j,k in d.items():\n tmp[i+j]+=k\n d+=tmp", "i", "X", "tmp=Counter()", "tmp", "Counter()", "Counter", "for j,k in d.items():\n tmp[i+j]+=k\n ", "j", "k", "d.items()", "d.items", "d", "items", "tmp[i+j]+=k", "tmp[i+j]", "tmp", "i+j", "i", "j", "k", "d+=tmp", "d", "tmp", "print(d[0]-1)", "print", "d[0]-1", "d[0]", "d", "0", "1", "d=Counter([0])", "Counter([0])", "d", "n,a=map(int,input().split())", "map(int,input().split())", "n", "a=map(int,input().split())", "map(int,input().split())", "a", "X = [int(x) - a for x in input().split()]", "[int(x) - a for x in input().split()]", "X", "tmp=Counter()", "Counter()", "tmp", "d+=tmp", "tmp", "d" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 4, 13, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 2, 4, 13, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 4, 13, 13, 17, 14, 40, 2, 13, 13, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 2, 13, 17, 10, 17, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 202, 2 ], [ 202, 11 ], [ 205, 13 ], [ 187, 25 ], [ 206, 28 ], [ 32, 31 ], [ 206, 37 ], [ 193, 42 ], [ 52, 45 ], [ 194, 48 ], [ 61, 54 ], [ 194, 57 ], [ 64, 63 ], [ 197, 68 ], [ 199, 71 ], [ 206, 73 ], [ 63, 75 ], [ 79, 78 ], [ 206, 84 ], [ 88, 87 ], [ 188, 91 ], [ 87, 96 ], [ 200, 97 ], [ 107, 100 ], [ 194, 103 ], [ 63, 104 ], [ 78, 105 ], [ 87, 106 ], [ 194, 110 ], [ 63, 112 ], [ 78, 114 ], [ 87, 115 ], [ 124, 117 ], [ 194, 120 ], [ 63, 121 ], [ 78, 122 ], [ 87, 123 ], [ 194, 128 ], [ 63, 130 ], [ 78, 132 ], [ 87, 133 ], [ 194, 137 ], [ 63, 139 ], [ 78, 142 ], [ 87, 145 ], [ 200, 146 ], [ 184, 148 ], [ 152, 151 ], [ 206, 157 ], [ 151, 162 ], [ 203, 163 ], [ 188, 165 ], [ 190, 168 ], [ 194, 172 ], [ 151, 174 ], [ 151, 176 ], [ 203, 177 ], [ 191, 181 ], [ 185, 181 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ], [ 193, 194 ], [ 202, 197 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n#dp[i][j] := iの数字まで考えたとき、jの数字になる個数\nmax_s = sum(x)\ndp = [[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)]\n#init\ndp[0][0][0] = 1\ndp[1][0][0] = 1\nfor i in range(1,n+1):\n num = x[i-1]\n for j in range(len(x)+1):\n for k in range(max_s + 1):\n if k - num < 0:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]\nans = 0\nfor i in range(len(x)+1):\n if i * a <= max_s+1:\n ans += dp[-1][i][i*a]\nprint(ans-1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_s = sum(x)", "max_s", "sum(x)", "sum", "x", "[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)", "for k in range(len(x) + 1)", "k", "range(len(x) + 1)", "range", "len(x) + 1", "len(x)", "len", "x", "1", "for k in range(len(x) + 1)", "[[0 for i in range(max_s + 1)] for j in range(n+1)]", "dp = [[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)]", "dp", "[[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "dp[1][0][0] = 1", "dp[1][0][0]", "[0]", "[1]", "dp", "1", "0", "0", "1", "for i in range(1,n+1):\n num = x[i-1]\n for j in range(len(x)+1):\n for k in range(max_s + 1):\n if k - num < 0:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "num = x[i-1]", "num", "x[i-1]", "x", "i-1", "i", "1", "for j in range(len(x)+1):\n for k in range(max_s + 1):\n if k - num < 0:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]", "j", "range(len(x)+1)", "range", "len(x)+1", "len(x)", "len", "x", "1", "for k in range(max_s + 1):\n if k - num < 0:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]", "k", "range(max_s + 1)", "range", "max_s + 1", "max_s", "1", "if k - num < 0:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]", "k - num < 0", "k - num", "k", "num", "0", "dp[i][j][k] = dp[i-1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-num]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k] + dp[i-1][j-1][k-num]", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "dp[i-1][j-1][k-num]", "[j-1]", "[i-1]", "dp", "i-1", "i", "1", "j-1", "j", "1", "k-num", "k", "num", "ans = 0", "ans", "0", "for i in range(len(x)+1):\n if i * a <= max_s+1:\n ans += dp[-1][i][i*a]", "i", "range(len(x)+1)", "range", "len(x)+1", "len(x)", "len", "x", "1", "if i * a <= max_s+1:\n ans += dp[-1][i][i*a]", "i * a <= max_s+1", "i * a", "i", "a", "max_s+1", "max_s", "1", "ans += dp[-1][i][i*a]", "ans", "dp[-1][i][i*a]", "[i]", "[-1]", "dp", "-1", "i", "i*a", "i", "a", "print(ans-1)", "print", "ans-1", "ans", "1", "ans = 0", "0", "ans", "max_s = sum(x)", "sum(x)", "max_s", "ans += dp[-1][i][i*a]", "dp[-1][i][i*a]", "ans", "dp = [[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)]", "[[[0 for i in range(max_s + 1)] for j in range(n+1)] for k in range(len(x) + 1)]", "dp", "n, a = map(int, input().split())", "map(int, input().split())", "n", "num = x[i-1]", "x[i-1]", "num", "a = map(int, input().split())", "map(int, input().split())", "a", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 28, 13, 4, 13, 13, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 13, 3, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 177, 2 ], [ 177, 11 ], [ 186, 13 ], [ 180, 25 ], [ 187, 28 ], [ 32, 31 ], [ 178, 35 ], [ 171, 40 ], [ 50, 43 ], [ 172, 46 ], [ 53, 52 ], [ 178, 57 ], [ 183, 60 ], [ 187, 62 ], [ 52, 64 ], [ 68, 67 ], [ 181, 71 ], [ 75, 74 ], [ 52, 77 ], [ 86, 79 ], [ 172, 82 ], [ 52, 83 ], [ 74, 84 ], [ 67, 85 ], [ 172, 89 ], [ 52, 91 ], [ 74, 93 ], [ 67, 94 ], [ 97, 96 ], [ 184, 99 ], [ 181, 101 ], [ 105, 104 ], [ 52, 109 ], [ 119, 112 ], [ 172, 115 ], [ 52, 116 ], [ 104, 117 ], [ 96, 118 ], [ 172, 122 ], [ 52, 124 ], [ 104, 127 ], [ 96, 130 ], [ 184, 131 ], [ 168, 133 ], [ 137, 136 ], [ 178, 141 ], [ 136, 146 ], [ 166, 147 ], [ 181, 148 ], [ 174, 151 ], [ 172, 155 ], [ 178, 156 ], [ 136, 157 ], [ 136, 159 ], [ 166, 160 ], [ 175, 163 ], [ 169, 163 ], [ 177, 166 ], [ 168, 169 ], [ 171, 172 ], [ 174, 175 ], [ 177, 178 ], [ 180, 181 ], [ 183, 184 ], [ 186, 187 ] ]

[ "#!/usr/bin/env python3\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\ns = sum(x)\ndp = [[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]\ndp[0][0][0] = 1\nfor i in range(1, n+1):\n xi = x[i-1]\n for j in range(s+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n for j in range(xi, s+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]\n\nans = 0\nfor i in range(1, n+1):\n if i*a > s:\n break\n ans += dp[n][i][i*a]\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "s = sum(x)", "s", "sum(x)", "sum", "x", "[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[[0] * (s+1) for _ in range(n+1)]", "dp = [[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]", "dp", "[[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(1, n+1):\n xi = x[i-1]\n for j in range(s+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n for j in range(xi, s+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "xi = x[i-1]", "xi", "x[i-1]", "x", "i-1", "i", "1", "for j in range(s+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n ", "j", "range(s+1)", "range", "s+1", "s", "1", "for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n ", "k", "range(i)", "range", "i", "dp[i][k][j] = dp[i-1][k][j]", "dp[i][k][j]", "[k]", "[i]", "dp", "i", "k", "j", "dp[i-1][k][j]", "[k]", "[i-1]", "dp", "i-1", "i", "1", "k", "j", "for j in range(xi, s+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]", "j", "range(xi, s+1)", "range", "xi", "s+1", "s", "1", "for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]", "k", "range(1, i+1)", "range", "1", "i+1", "i", "1", "dp[i][k][j] += dp[i-1][k-1][j-xi]", "dp[i][k][j]", "[k]", "[i]", "dp", "i", "k", "j", "dp[i-1][k-1][j-xi]", "[k-1]", "[i-1]", "dp", "i-1", "i", "1", "k-1", "k", "1", "j-xi", "j", "xi", "ans = 0", "ans", "0", "for i in range(1, n+1):\n if i*a > s:\n break\n ans += dp[n][i][i*a]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "if i*a > s:\n break\n ", "i*a > s", "i*a", "i", "a", "s", "break", "ans += dp[n][i][i*a]", "ans", "dp[n][i][i*a]", "[i]", "[n]", "dp", "n", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "a = map(int, input().split())", "map(int, input().split())", "a", "ans = 0", "0", "ans", "dp = [[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]", "[[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]", "dp", "ans += dp[n][i][i*a]", "dp[n][i][i*a]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "s = sum(x)", "sum(x)", "s", "xi = x[i-1]", "x[i-1]", "xi", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x" ]

[ 7, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 17, 13, 0, 13, 4, 18, 13, 13, 0, 13, 39, 2, 13, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 17, 4, 13, 13, 28, 13, 4, 13, 4, 13, 18, 13, 13, 0, 13, 18, 13, 2, 13, 17, 0, 13, 2, 13, 13, 14, 40, 40, 17, 2, 13, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 29, 2, 18, 18, 13, 13, 13, 17, 23, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 13, 4, 13, 13, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 132, 9 ], [ 134, 12 ], [ 15, 14 ], [ 6, 16 ], [ 130, 17 ], [ 20, 19 ], [ 14, 22 ], [ 25, 24 ], [ 31, 30 ], [ 130, 33 ], [ 19, 36 ], [ 40, 39 ], [ 47, 42 ], [ 24, 44 ], [ 14, 46 ], [ 50, 49 ], [ 24, 55 ], [ 58, 57 ], [ 24, 63 ], [ 49, 64 ], [ 67, 66 ], [ 134, 68 ], [ 49, 70 ], [ 74, 73 ], [ 66, 75 ], [ 132, 76 ], [ 57, 82 ], [ 73, 83 ], [ 19, 84 ], [ 91, 86 ], [ 24, 88 ], [ 49, 89 ], [ 57, 90 ], [ 24, 94 ], [ 49, 96 ], [ 57, 98 ], [ 24, 101 ], [ 49, 103 ], [ 57, 106 ], [ 73, 107 ], [ 114, 109 ], [ 24, 111 ], [ 49, 112 ], [ 57, 113 ], [ 24, 116 ], [ 49, 118 ], [ 57, 120 ], [ 24, 125 ], [ 130, 126 ], [ 14, 127 ], [ 130, 130 ], [ 132, 132 ], [ 134, 134 ], [ 176, 140 ], [ 176, 149 ], [ 173, 151 ], [ 180, 165 ], [ 177, 166 ], [ 171, 167 ], [ 174, 168 ], [ 176, 171 ], [ 173, 174 ], [ 176, 177 ] ]

[ "import numpy as np\n\n\ndef main(n, a, x):\n X = max(a, max(x))\n NX = X * n\n NX2 = 2 * NX\n dp = np.zeros(shape=(n + 1, NX2 + 1), dtype=int)\n dp[0][NX] = 1\n for j in range(1, len(dp)):\n for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n return dp[n][NX] - 1\n\n\nif __name__ == '__main__':\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n print(main(N, A, X))", "import numpy as np", "numpy", "def main(n, a, x):\n X = max(a, max(x))\n NX = X * n\n NX2 = 2 * NX\n dp = np.zeros(shape=(n + 1, NX2 + 1), dtype=int)\n dp[0][NX] = 1\n for j in range(1, len(dp)):\n for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n return dp[n][NX] - 1", "main", "X = max(a, max(x))", "X", "max(a, max(x))", "max", "a", "max(x)", "max", "x", "NX = X * n", "NX", "X * n", "X", "n", "NX2 = 2 * NX", "NX2", "2 * NX", "2", "NX", "dp = np.zeros(shape=(n + 1, NX2 + 1), dtype=int)", "dp", "np.zeros(shape=(n + 1, NX2 + 1), dtype=int)", "np.zeros", "np", "zeros", "shape=(n + 1, NX2 + 1)", "shape", "(n + 1, NX2 + 1)", "n + 1", "n", "1", "NX2 + 1", "NX2", "1", "dtype=int", "dtype", "int", "dp[0][NX] = 1", "dp[0][NX]", "[0]", "dp", "0", "NX", "1", "for j in range(1, len(dp)):\n for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n ", "j", "range(1, len(dp))", "range", "1", "len(dp)", "len", "dp", "for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n ", "t", "range(len(dp[j]))", "range", "len(dp[j])", "len", "dp[j]", "dp", "j", "xj = x[j - 1]", "xj", "x[j - 1]", "x", "j - 1", "j", "1", "yj = xj - a", "yj", "xj - a", "xj", "a", "if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n ", "0 <= t - yj <= NX2", "0 <= t - yj", "0", "t - yj", "t", "yj", "NX2", "dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j - 1][t] + dp[j - 1][t - yj]", "dp[j - 1][t]", "[j - 1]", "dp", "j - 1", "j", "1", "t", "dp[j - 1][t - yj]", "[j - 1]", "dp", "j - 1", "j", "1", "t - yj", "t", "yj", "dp[j][t] = dp[j - 1][t]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j - 1][t]", "[j - 1]", "dp", "j - 1", "j", "1", "t", "return dp[n][NX] - 1", "dp[n][NX] - 1", "dp[n][NX]", "[n]", "dp", "n", "NX", "1", "n", "n", "a", "a", "x", "x", "if __name__ == '__main__':\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n print(main(N, A, X))", "__name__ == '__main__'", "__name__", "'__main__'", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "print(main(N, A, X))", "print", "main(N, A, X)", "main", "N", "A", "X", "A = map(int, input().split())", "map(int, input().split())", "A", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "N, A = map(int, input().split())", "map(int, input().split())", "N", "def main(n, a, x):\n X = max(a, max(x))\n NX = X * n\n NX2 = 2 * NX\n dp = np.zeros(shape=(n + 1, NX2 + 1), dtype=int)\n dp[0][NX] = 1\n for j in range(1, len(dp)):\n for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n return dp[n][NX] - 1", "def main(n, a, x):\n X = max(a, max(x))\n NX = X * n\n NX2 = 2 * NX\n dp = np.zeros(shape=(n + 1, NX2 + 1), dtype=int)\n dp[0][NX] = 1\n for j in range(1, len(dp)):\n for t in range(len(dp[j])):\n xj = x[j - 1]\n yj = xj - a\n if 0 <= t - yj <= NX2:\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - yj]\n else:\n dp[j][t] = dp[j - 1][t]\n return dp[n][NX] - 1", "main" ]

[ 7, 41, 28, 13, 13, 4, 2, 18, 13, 17, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 31, 13, 0, 13, 13, 0, 13, 2, 13, 4, 13, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 40, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 4, 3 ], [ 3, 10 ], [ 75, 12 ], [ 75, 25 ], [ 78, 28 ], [ 81, 31 ], [ 76, 33 ], [ 72, 38 ], [ 46, 41 ], [ 73, 43 ], [ 49, 48 ], [ 76, 53 ], [ 57, 56 ], [ 82, 60 ], [ 82, 61 ], [ 73, 67 ], [ 76, 68 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ] ]

[ "n,*x=map(int,open(0).read().split());y=[x[0]-i for i in x];m=n*max(x);d=[[0]*m*2 for _ in[0]*-~n];d[0][0]=1\nfor i in range(1,n+1):\n\tfor s in range(-m,m):d[i][s]=d[i-1][s]+d[i-1][s-y[i]]\nprint(d[n][0]-1)", "x[0]-i for i in x", "for i in x", "i", "x", "for i in x", "x[0]-i", "x[0]", "x", "0", "i", "n,*x=map(int,open(0).read().split())", "n", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "*x", "x", "y=[x[0]-i for i in x]", "y", "[x[0]-i for i in x]", "m=n*max(x)", "m", "n*max(x)", "n", "max(x)", "max", "x", "d=[[0]*m*2 for _ in[0]*-~n]", "d", "[[0]*m*2 for _ in[0]*-~n]", "d[0][0]=1", "d[0][0]", "[0]", "d", "0", "0", "1", "for i in range(1,n+1):\n\tfor s in range(-m,m):d[i][s]=d[i-1][s]+d[i-1][s-y[i]]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "for s in range(-m,m):d[i][s]=d[i-1][s]+d[i-1][s-y[i]", "s", "range(-m,m)", "range", "-m", "m", "m", "print(d[n][0]-1)", "print", "d[n][0]-1", "d[n][0]", "[n]", "d", "n", "0", "1", "d=[[0]*m*2 for _ in[0]*-~n]", "[[0]*m*2 for _ in[0]*-~n]", "d", "n,*x=map(int,open(0).read().split())", "map(int,open(0).read().split())", "n", "y=[x[0]-i for i in x]", "[x[0]-i for i in x]", "y", "m=n*max(x)", "n*max(x)", "m" ]

[ 7, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 0, 13, 4, 13, 0, 18, 13, 17, 17, 28, 13, 13, 28, 13, 13, 4, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 2, 13, 4, 18, 13, 13, 2, 13, 13, 17, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 85, 3 ], [ 85, 12 ], [ 79, 14 ], [ 86, 24 ], [ 82, 32 ], [ 39, 36 ], [ 83, 37 ], [ 42, 41 ], [ 80, 41 ], [ 83, 50 ], [ 58, 53 ], [ 83, 54 ], [ 41, 56 ], [ 83, 62 ], [ 41, 65 ], [ 83, 72 ], [ 85, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "\"\"\"\nkari1 = '4 8'\nkari2 = '7 9 8 9' #5\n#kari1 = '3 8'\n#kari2 = '6 6 9' #0\n#kari1 = '8 5'\n#kari2 = '3 6 2 8 7 6 5 9' #19\n#kari1 = '33 3'\n#kari2 = '3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3' #8589934591\nn, a = map(int, kari1.split())\nx_a = list(map(lambda x: int(x) - a, kari2.split()))\n\"\"\"\nn, a = map(int, input().split())\nx_a = list(map(lambda x: int(x) - a, input().split()))\ndic = dict()\ndic[0] = 1\n\nfor x in x_a:\n for key, value in list(dic.items()):\n dic[x + key] = value + dic.get(x + key, 0)\n\nprint(dic[0] - 1)", "\"\"\"\nkari1 = '4 8'\nkari2 = '7 9 8 9' #5\n#kari1 = '3 8'\n#kari2 = '6 6 9' #0\n#kari1 = '8 5'\n#kari2 = '3 6 2 8 7 6 5 9' #19\n#kari1 = '33 3'\n#kari2 = '3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3' #8589934591\nn, a = map(int, kari1.split())\nx_a = list(map(lambda x: int(x) - a, kari2.split()))\n\"\"\"", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x_a = list(map(lambda x: int(x) - a, input().split()))", "x_a", "list(map(lambda x: int(x) - a, input().split()))", "list", "map(lambda x: int(x) - a, input().split())", "map", "lambda x: int(x) - a", "int(x) - a", "int(x)", "int", "x", "a", "x", "input().split()", "().split", "()", "input", "split", "dic = dict()", "dic", "dict()", "dict", "dic[0] = 1", "dic[0]", "dic", "0", "1", "for x in x_a:\n for key, value in list(dic.items()):\n dic[x + key] = value + dic.get(x + key, 0)", "x", "x_a", "for key, value in list(dic.items()):\n dic[x + key] = value + dic.get(x + key, 0)", "key", "value", "list(dic.items())", "list", "dic.items()", "dic.items", "dic", "items", "dic[x + key] = value + dic.get(x + key, 0)", "dic[x + key]", "dic", "x + key", "x", "key", "value + dic.get(x + key, 0)", "value", "dic.get(x + key, 0)", "dic.get", "dic", "get", "x + key", "x", "key", "0", "print(dic[0] - 1)", "print", "dic[0] - 1", "dic[0]", "dic", "0", "1", "n, a = map(int, input().split())", "map(int, input().split())", "n", "x_a = list(map(lambda x: int(x) - a, input().split()))", "list(map(lambda x: int(x) - a, input().split()))", "x_a", "dic = dict()", "dict()", "dic", "a = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 2, 39, 17, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 0, 13, 2, 13, 18, 13, 13, 14, 2, 40, 13, 17, 2, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 139, 2 ], [ 139, 11 ], [ 145, 13 ], [ 27, 26 ], [ 146, 26 ], [ 26, 30 ], [ 137, 31 ], [ 133, 33 ], [ 148, 36 ], [ 137, 38 ], [ 140, 39 ], [ 43, 42 ], [ 140, 46 ], [ 149, 53 ], [ 142, 56 ], [ 64, 59 ], [ 143, 61 ], [ 149, 63 ], [ 67, 66 ], [ 140, 69 ], [ 72, 71 ], [ 149, 75 ], [ 85, 78 ], [ 143, 80 ], [ 66, 82 ], [ 71, 84 ], [ 143, 87 ], [ 66, 88 ], [ 71, 89 ], [ 130, 91 ], [ 71, 93 ], [ 134, 95 ], [ 146, 95 ], [ 66, 96 ], [ 131, 100 ], [ 131, 103 ], [ 149, 105 ], [ 115, 108 ], [ 143, 110 ], [ 66, 112 ], [ 131, 114 ], [ 143, 117 ], [ 66, 118 ], [ 71, 119 ], [ 143, 125 ], [ 140, 126 ], [ 149, 127 ], [ 130, 131 ], [ 133, 134 ], [ 139, 137 ], [ 139, 140 ], [ 142, 143 ], [ 145, 146 ], [ 148, 149 ] ]

[ "n,A = map(int,input().split())\na = list(map(int,input().split()))\na = [x-A for x in a]\nB = A*n\ndp = [[0]*B*2 for i in range(n+1)]\ndp[0][B] = 1\nfor i in range(n):\n for j in range(B*2):\n dp[i+1][j] += dp[i][j]\n k = j+a[i]\n if k >=0 and k<B*2:\n dp[i+1][k] += dp[i][j]\nprint(dp[n][B]-1)", "n,A = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x-A for x in a", "for x in a", "x", "a", "for x in a", "x-A", "x", "A", "a = [x-A for x in a]", "a", "[x-A for x in a]", "B = A*n", "B", "A*n", "A", "n", "[0]*B*2 for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "[0]*B*2", "[0]*B", "[0]", "0", "B", "2", "dp = [[0]*B*2 for i in range(n+1)]", "dp", "[[0]*B*2 for i in range(n+1)]", "dp[0][B] = 1", "dp[0][B]", "[0]", "dp", "0", "B", "1", "for i in range(n):\n for j in range(B*2):\n dp[i+1][j] += dp[i][j]\n k = j+a[i]\n if k >=0 and k<B*2:\n dp[i+1][k] += dp[i][j]", "i", "range(n)", "range", "n", "for j in range(B*2):\n dp[i+1][j] += dp[i][j]\n k = j+a[i]\n if k >=0 and k<B*2:\n dp[i+1][k] += dp[i][j]", "j", "range(B*2)", "range", "B*2", "B", "2", "dp[i+1][j] += dp[i][j]", "dp[i+1][j]", "[i+1]", "dp", "i+1", "i", "1", "j", "dp[i][j]", "[i]", "dp", "i", "j", "k = j+a[i]", "k", "j+a[i]", "j", "a[i]", "a", "i", "if k >=0 and k<B*2:\n dp[i+1][k] += dp[i][j]", "k >=0 and k<B*2", "k >=0", "k", "0", "k<B*2", "k", "B*2", "B", "2", "dp[i+1][k] += dp[i][j]", "dp[i+1][k]", "[i+1]", "dp", "i+1", "i", "1", "k", "dp[i][j]", "[i]", "dp", "i", "j", "print(dp[n][B]-1)", "print", "dp[n][B]-1", "dp[n][B]", "[n]", "dp", "n", "B", "1", "k = j+a[i]", "j+a[i]", "k", "a = [x-A for x in a]", "[x-A for x in a]", "a", "A = map(int,input().split())", "map(int,input().split())", "A", "n,A = map(int,input().split())", "map(int,input().split())", "n", "dp = [[0]*B*2 for i in range(n+1)]", "[[0]*B*2 for i in range(n+1)]", "dp", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "B = A*n", "A*n", "B" ]

[ 7, 15, 13, 12, 13, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 13, 2, 39, 17, 17, 0, 18, 13, 13, 17, 0, 18, 13, 2, 18, 13, 17, 13, 17, 28, 13, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 2, 39, 17, 17, 28, 13, 4, 13, 17, 14, 2, 2, 13, 13, 40, 2, 13, 13, 17, 0, 18, 13, 13, 18, 13, 13, 0, 18, 13, 13, 2, 18, 13, 13, 18, 13, 2, 13, 13, 0, 13, 13, 4, 13, 2, 18, 13, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 132, 6 ], [ 12, 11 ], [ 130, 18 ], [ 12, 20 ], [ 23, 22 ], [ 130, 31 ], [ 35, 34 ], [ 11, 37 ], [ 40, 39 ], [ 48, 45 ], [ 39, 46 ], [ 133, 47 ], [ 57, 50 ], [ 39, 51 ], [ 22, 54 ], [ 133, 56 ], [ 22, 63 ], [ 70, 69 ], [ 76, 75 ], [ 75, 82 ], [ 75, 86 ], [ 93, 90 ], [ 69, 91 ], [ 75, 92 ], [ 39, 94 ], [ 110, 94 ], [ 75, 95 ], [ 100, 97 ], [ 69, 98 ], [ 75, 99 ], [ 39, 102 ], [ 110, 102 ], [ 75, 103 ], [ 39, 105 ], [ 110, 105 ], [ 75, 107 ], [ 111, 110 ], [ 69, 111 ], [ 45, 115 ], [ 110, 116 ], [ 39, 116 ], [ 133, 117 ], [ 127, 124 ], [ 132, 133 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\noffset = 2500\n\ndef main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n for i in range(N): X[i] -= A\n dp = [0] * 5010\n dp[offset] += 1\n dp[X[0] + offset] += 1\n for i, x in enumerate(X):\n if i == 0: continue\n dp2 = [0] * 5010\n for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n dp = dp2\n #print(dp[offset - 3: offset + 4])\n print(dp[offset] - 1)\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "offset = 2500", "offset", "2500", "def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n for i in range(N): X[i] -= A\n dp = [0] * 5010\n dp[offset] += 1\n dp[X[0] + offset] += 1\n for i, x in enumerate(X):\n if i == 0: continue\n dp2 = [0] * 5010\n for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n dp = dp2\n #print(dp[offset - 3: offset + 4])\n print(dp[offset] - 1)", "main", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(N): X[i] -= A\n ", "i", "range(N)", "range", "N", "dp = [0] * 5010", "dp", "[0] * 5010", "[0]", "0", "5010", "dp[offset] += 1", "dp[offset]", "dp", "offset", "1", "dp[X[0] + offset] += 1", "dp[X[0] + offset]", "dp", "X[0] + offset", "X[0]", "X", "0", "offset", "1", "for i, x in enumerate(X):\n if i == 0: continue\n dp2 = [0] * 5010\n for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n dp = dp2\n #print(dp[offset - 3: offset + 4])\n ", "i", "x", "enumerate(X)", "enumerate", "X", "if i == 0: continue\n ", "i == 0", "i", "0", "dp2 = [0] * 5010", "dp2", "[0] * 5010", "[0]", "0", "5010", "for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n ", "j", "range(5010)", "range", "5010", "if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n ", "j < x or j - x >= 5010", "j < x", "j", "x", "j - x >= 5010", "j - x", "j", "x", "5010", "dp2[j] = dp[j]", "dp2[j]", "dp2", "j", "dp[j]", "dp", "j", "dp2[j] = dp[j] + dp[j - x]", "dp2[j]", "dp2", "j", "dp[j] + dp[j - x]", "dp[j]", "dp", "j", "dp[j - x]", "dp", "j - x", "j", "x", "dp = dp2", "dp", "dp2", "print(dp[offset] - 1)", "print", "dp[offset] - 1", "dp[offset]", "dp", "offset", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n for i in range(N): X[i] -= A\n dp = [0] * 5010\n dp[offset] += 1\n dp[X[0] + offset] += 1\n for i, x in enumerate(X):\n if i == 0: continue\n dp2 = [0] * 5010\n for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n dp = dp2\n #print(dp[offset - 3: offset + 4])\n print(dp[offset] - 1)", "def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n for i in range(N): X[i] -= A\n dp = [0] * 5010\n dp[offset] += 1\n dp[X[0] + offset] += 1\n for i, x in enumerate(X):\n if i == 0: continue\n dp2 = [0] * 5010\n for j in range(5010):\n if j < x or j - x >= 5010:\n dp2[j] = dp[j]\n else:\n dp2[j] = dp[j] + dp[j - x]\n dp = dp2\n #print(dp[offset - 3: offset + 4])\n print(dp[offset] - 1)", "main", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "offset = 2500", "2500", "offset" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 31, 13, 0, 13, 21, 22, 17, 17, 28, 13, 13, 28, 13, 13, 4, 18, 4, 18, 13, 13, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 21, 13, 10, 4, 13 ]

[ [ 51, 2 ], [ 51, 15 ], [ 51, 16 ], [ 48, 19 ], [ 26, 25 ], [ 49, 34 ], [ 49, 41 ], [ 51, 46 ], [ 48, 49 ], [ 51, 52 ] ]

[ "_,a,*l=map(int,open(0).read().split())\nd={0:1}\nfor i in l:\n for k,v in d.copy().items(): d[i-a+k]=d.get(i-a+k,0)+v\nprint(d[0]-1)", "_,a,*l=map(int,open(0).read().split())", "_", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "a", "*l", "l", "d={0:1}", "d", "{0:1}", "0", "0", "1", "for i in l:\n for k,v in d.copy().items(): d[i-a+k]=d.get(i-a+k,0)+v", "i", "l", "for k,v in d.copy().items(): d[i-a+k]=d.get(i-a+k,0)", "k", "v", "d.copy().items()", "d.copy().items", "d.copy()", "d.copy", "d", "copy", "items", "print(d[0]-1)", "print", "d[0]-1", "d[0]", "d", "0", "1", "_,a,*l=map(int,open(0).read().split())", "map(int,open(0).read().split())", "_", "d={0:1}", "{0:1}", "d", "a,*l=map(int,open(0).read().split())", "map(int,open(0).read().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 2, 13, 4, 13, 13, 0, 13, 13, 0, 13, 2, 2, 13, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 14, 40, 40, 17, 2, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 134, 2 ], [ 134, 11 ], [ 15, 14 ], [ 135, 22 ], [ 14, 25 ], [ 131, 27 ], [ 143, 30 ], [ 129, 33 ], [ 135, 34 ], [ 39, 38 ], [ 129, 42 ], [ 144, 49 ], [ 140, 52 ], [ 62, 55 ], [ 141, 57 ], [ 129, 60 ], [ 135, 61 ], [ 65, 64 ], [ 129, 67 ], [ 137, 69 ], [ 132, 71 ], [ 64, 72 ], [ 75, 74 ], [ 144, 78 ], [ 88, 81 ], [ 141, 83 ], [ 64, 85 ], [ 74, 87 ], [ 141, 90 ], [ 64, 91 ], [ 74, 92 ], [ 74, 98 ], [ 138, 99 ], [ 144, 100 ], [ 111, 102 ], [ 141, 104 ], [ 64, 106 ], [ 74, 109 ], [ 138, 110 ], [ 141, 113 ], [ 64, 114 ], [ 74, 115 ], [ 141, 121 ], [ 129, 122 ], [ 129, 124 ], [ 135, 125 ], [ 134, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ] ]

[ "N, A = map(int, input().split())\n# 予め-Kした状態で用意しておく\nX = [A-int(x) for x in input().split()]\nMAX = N*A*2\n# dp[i][k] := i枚目までのカードで、合計をkにする通り数\ndp = [[0]*(MAX+1) for _ in range(N+1)]\n# 負の数を考慮して、N*K位置を0とする\ndp[0][N*A] = 1\nfor i in range(N):\n x = X[i]\n for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+x <= MAX:\n dp[i+1][k+x] += dp[i][k]\n \n# N回終わって合計が0になっている通り数 - 1枚も取らないケース \nprint(dp[N][N*A]-1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "A-int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "A-int(x)", "A", "int(x)", "int", "x", "X = [A-int(x) for x in input().split()]", "X", "[A-int(x) for x in input().split()]", "MAX = N*A*2", "MAX", "N*A*2", "N*A", "N", "A", "2", "[0]*(MAX+1) for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0]*(MAX+1)", "[0]", "0", "MAX+1", "MAX", "1", "dp = [[0]*(MAX+1) for _ in range(N+1)]", "dp", "[[0]*(MAX+1) for _ in range(N+1)]", "dp[0][N*A] = 1", "dp[0][N*A]", "[0]", "dp", "0", "N*A", "N", "A", "1", "for i in range(N):\n x = X[i]\n for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+x <= MAX:\n dp[i+1][k+x] += dp[i][k]\n \n# N回終わって合計が0になっている通り数 - 1枚も取らないケース ", "i", "range(N)", "range", "N", "x = X[i]", "x", "X[i]", "X", "i", "for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+x <= MAX:\n dp[i+1][k+x] += dp[i][k]\n \n# N回終わって合計が0になっている通り数 - 1枚も取らないケース ", "k", "range(MAX+1)", "range", "MAX+1", "MAX", "1", "dp[i+1][k] += dp[i][k]", "dp[i+1][k]", "[i+1]", "dp", "i+1", "i", "1", "k", "dp[i][k]", "[i]", "dp", "i", "k", "if 0 <= k+x <= MAX:\n dp[i+1][k+x] += dp[i][k]\n \n# N回終わって合計が0になっている通り数 - 1枚も取らないケース ", "0 <= k+x <= MAX", "0 <= k+x", "0", "k+x", "k", "x", "MAX", "dp[i+1][k+x] += dp[i][k]", "dp[i+1][k+x]", "[i+1]", "dp", "i+1", "i", "1", "k+x", "k", "x", "dp[i][k]", "[i]", "dp", "i", "k", "print(dp[N][N*A]-1)", "print", "dp[N][N*A]-1", "dp[N][N*A]", "[N]", "dp", "N", "N*A", "N", "A", "1", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = [A-int(x) for x in input().split()]", "[A-int(x) for x in input().split()]", "X", "A = map(int, input().split())", "map(int, input().split())", "A", "x = X[i]", "X[i]", "x", "dp = [[0]*(MAX+1) for _ in range(N+1)]", "[[0]*(MAX+1) for _ in range(N+1)]", "dp", "MAX = N*A*2", "N*A*2", "MAX" ]

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 40, 2, 13, 13, 13, 0, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 191, 11 ], [ 188, 18 ], [ 182, 23 ], [ 33, 32 ], [ 192, 39 ], [ 33, 41 ], [ 44, 43 ], [ 192, 52 ], [ 56, 55 ], [ 32, 57 ], [ 41, 58 ], [ 62, 61 ], [ 32, 65 ], [ 71, 70 ], [ 80, 73 ], [ 70, 76 ], [ 83, 82 ], [ 32, 87 ], [ 91, 90 ], [ 43, 92 ], [ 82, 94 ], [ 98, 97 ], [ 32, 100 ], [ 103, 102 ], [ 55, 105 ], [ 114, 107 ], [ 70, 110 ], [ 82, 111 ], [ 97, 112 ], [ 102, 113 ], [ 70, 117 ], [ 82, 119 ], [ 97, 121 ], [ 102, 122 ], [ 102, 126 ], [ 90, 127 ], [ 55, 128 ], [ 141, 130 ], [ 70, 133 ], [ 82, 134 ], [ 97, 136 ], [ 102, 139 ], [ 90, 140 ], [ 70, 144 ], [ 82, 146 ], [ 97, 148 ], [ 102, 149 ], [ 152, 151 ], [ 155, 154 ], [ 32, 159 ], [ 163, 162 ], [ 70, 166 ], [ 154, 168 ], [ 41, 170 ], [ 154, 171 ], [ 162, 174 ], [ 151, 174 ], [ 186, 180 ], [ 182, 183 ], [ 188, 189 ], [ 191, 192 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = n * a\n dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n res = 0\n for k in range(1, n + 1):\n res += dp[-1][k][a * k]\n print(res)\n\n\nif __name__ == '__main__':\n resolve()", "import sys", "sys", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "f_inf = float('inf')", "f_inf", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = n * a\n dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n res = 0\n for k in range(1, n + 1):\n res += dp[-1][k][a * k]\n print(res)", "resolve", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "MAX = n * a", "MAX", "n * a", "n", "a", "[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[[0] * (MAX + 1) for _ in range(n + 1)]", "dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "[[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(1, n + 1):\n x = X[i - 1]\n for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n ", "i", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "x = X[i - 1]", "x", "X[i - 1]", "X", "i - 1", "i", "1", "for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n ", "k", "range(n)", "range", "n", "for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n ", "s", "range(MAX)", "range", "MAX", "dp[i][k][s] += dp[i - 1][k][s]", "dp[i][k][s]", "[k]", "[i]", "dp", "i", "k", "s", "dp[i - 1][k][s]", "[k]", "[i - 1]", "dp", "i - 1", "i", "1", "k", "s", "if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n ", "s + x <= MAX", "s + x", "s", "x", "MAX", "dp[i][k + 1][s + x] += dp[i - 1][k][s]", "dp[i][k + 1][s + x]", "[k + 1]", "[i]", "dp", "i", "k + 1", "k", "1", "s + x", "s", "x", "dp[i - 1][k][s]", "[k]", "[i - 1]", "dp", "i - 1", "i", "1", "k", "s", "res = 0", "res", "0", "for k in range(1, n + 1):\n res += dp[-1][k][a * k]\n ", "k", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "res += dp[-1][k][a * k]", "res", "dp[-1][k][a * k]", "[k]", "[-1]", "dp", "-1", "k", "a * k", "a", "k", "print(res)", "print", "res", "if __name__ == '__main__':\n resolve()", "__name__ == '__main__'", "__name__", "'__main__'", "resolve()", "resolve", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = n * a\n dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n res = 0\n for k in range(1, n + 1):\n res += dp[-1][k][a * k]\n print(res)", "def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = n * a\n dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for k in range(n):\n for s in range(MAX):\n dp[i][k][s] += dp[i - 1][k][s]\n if s + x <= MAX:\n dp[i][k + 1][s + x] += dp[i - 1][k][s]\n res = 0\n for k in range(1, n + 1):\n res += dp[-1][k][a * k]\n print(res)", "resolve", "f_inf = float('inf')", "float('inf')", "f_inf", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 28, 13, 4, 13, 17, 14, 40, 40, 17, 2, 13, 2, 13, 18, 13, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 2, 13, 2, 13, 18, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 122, 2 ], [ 122, 11 ], [ 116, 13 ], [ 26, 25 ], [ 123, 28 ], [ 33, 30 ], [ 117, 31 ], [ 25, 32 ], [ 120, 33 ], [ 37, 36 ], [ 123, 40 ], [ 113, 48 ], [ 56, 51 ], [ 114, 53 ], [ 59, 58 ], [ 123, 61 ], [ 64, 63 ], [ 69, 68 ], [ 63, 77 ], [ 68, 79 ], [ 30, 80 ], [ 117, 81 ], [ 58, 82 ], [ 92, 85 ], [ 114, 87 ], [ 58, 89 ], [ 63, 91 ], [ 114, 94 ], [ 58, 95 ], [ 63, 97 ], [ 68, 99 ], [ 30, 100 ], [ 117, 101 ], [ 58, 102 ], [ 114, 108 ], [ 123, 109 ], [ 113, 114 ], [ 116, 117 ], [ 122, 120 ], [ 122, 123 ] ]

[ "n,a=map(int,input().split())\nx=list(map(int,input().split()))\nfor i in range(n):\n x[i]-=a\n# dp[i][j] = i番目までで(j-2500)を何個作れるか\ndp=[[0]*5001 for i in range(n+1)]\ndp[0][2500]=1\nfor i in range(n):\n for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i+1][j]+=dp[i][j-k*x[i]]\nprint(dp[n][2500]-1)", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n x[i]-=a\n# dp[i][j] = i番目までで(j-2500)を何個作れるか", "i", "range(n)", "range", "n", "x[i]-=a", "x[i]", "x", "i", "a", "[0]*5001 for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "[0]*5001", "[0]", "0", "5001", "dp=[[0]*5001 for i in range(n+1)]", "dp", "[[0]*5001 for i in range(n+1)]", "dp[0][2500]=1", "dp[0][2500]", "[0]", "dp", "0", "2500", "1", "for i in range(n):\n for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i+1][j]+=dp[i][j-k*x[i]]", "i", "range(n)", "range", "n", "for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i+1][j]+=dp[i][j-k*x[i]]", "j", "range(5000)", "range", "5000", "for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i+1][j]+=dp[i][j-k*x[i]]", "k", "range(2)", "range", "2", "if 0<=j-k*x[i]<=5000:\n dp[i+1][j]+=dp[i][j-k*x[i]]", "0<=j-k*x[i]<=5000", "0<=j-k*x[i]", "0", "j-k*x[i]", "j", "k*x[i]", "k", "x[i]", "x", "i", "5000", "dp[i+1][j]+=dp[i][j-k*x[i]]", "dp[i+1][j]", "[i+1]", "dp", "i+1", "i", "1", "j", "dp[i][j-k*x[i]]", "[i]", "dp", "i", "j-k*x[i]", "j", "k*x[i]", "k", "x[i]", "x", "i", "print(dp[n][2500]-1)", "print", "dp[n][2500]-1", "dp[n][2500]", "[n]", "dp", "n", "2500", "1", "dp=[[0]*5001 for i in range(n+1)]", "[[0]*5001 for i in range(n+1)]", "dp", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "a=map(int,input().split())", "map(int,input().split())", "a", "n,a=map(int,input().split())", "map(int,input().split())", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 13, 17, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 17, 13, 17, 14, 2, 40, 13, 17, 40, 13, 18, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 172, 2 ], [ 172, 11 ], [ 175, 13 ], [ 27, 26 ], [ 167, 30 ], [ 160, 35 ], [ 163, 38 ], [ 48, 41 ], [ 161, 44 ], [ 51, 50 ], [ 167, 55 ], [ 59, 58 ], [ 50, 62 ], [ 66, 65 ], [ 58, 71 ], [ 58, 76 ], [ 65, 79 ], [ 176, 81 ], [ 50, 83 ], [ 93, 86 ], [ 161, 89 ], [ 50, 90 ], [ 58, 91 ], [ 65, 92 ], [ 161, 97 ], [ 50, 99 ], [ 58, 102 ], [ 65, 105 ], [ 176, 107 ], [ 50, 109 ], [ 161, 114 ], [ 50, 116 ], [ 58, 118 ], [ 65, 119 ], [ 128, 121 ], [ 161, 124 ], [ 50, 125 ], [ 58, 126 ], [ 65, 127 ], [ 161, 131 ], [ 50, 133 ], [ 58, 135 ], [ 65, 136 ], [ 139, 138 ], [ 167, 143 ], [ 169, 146 ], [ 161, 150 ], [ 167, 151 ], [ 138, 152 ], [ 138, 154 ], [ 173, 155 ], [ 170, 158 ], [ 164, 158 ], [ 160, 161 ], [ 163, 164 ], [ 172, 167 ], [ 169, 170 ], [ 172, 173 ], [ 175, 176 ] ]

[ "n,a = map(int,input().split())\nx = list(map(int,input().split()))\nt = [[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)]\nans = 0\nt[0][0][0] = 1\n\nfor i in range(1, n+1):\n for j in range(i+1):\n for k in range(50*j + 1):\n if j >= 1 and k >= x[i-1]:\n t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]\n else:\n t[i][j][k] = t[i - 1][j][k]\nfor i in range(1,n+1):\n ans += t[n][i][i*a]\nprint(ans)", "n,a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "[[0] * (50*(j+1)+1) for j in range(i+2)]", "t = [[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)]", "t", "[[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)]", "ans = 0", "ans", "0", "t[0][0][0] = 1", "t[0][0][0]", "[0]", "[0]", "t", "0", "0", "0", "1", "for i in range(1, n+1):\n for j in range(i+1):\n for k in range(50*j + 1):\n if j >= 1 and k >= x[i-1]:\n t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]\n else:\n t[i][j][k] = t[i - 1][j][k]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "for j in range(i+1):\n for k in range(50*j + 1):\n if j >= 1 and k >= x[i-1]:\n t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]\n else:\n t[i][j][k] = t[i - 1][j][k]", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(50*j + 1):\n if j >= 1 and k >= x[i-1]:\n t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]\n else:\n t[i][j][k] = t[i - 1][j][k]", "k", "range(50*j + 1)", "range", "50*j + 1", "50*j", "50", "j", "1", "if j >= 1 and k >= x[i-1]:\n t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]\n else:\n t[i][j][k] = t[i - 1][j][k]", "j >= 1 and k >= x[i-1]", "j >= 1", "j", "1", "k >= x[i-1]", "k", "x[i-1]", "x", "i-1", "i", "1", "t[i][j][k] = t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]", "t[i][j][k]", "[j]", "[i]", "t", "i", "j", "k", "t[i - 1][j - 1][k - x[i-1]] + t[i - 1][j][k]", "t[i - 1][j - 1][k - x[i-1]]", "[j - 1]", "[i - 1]", "t", "i - 1", "i", "1", "j - 1", "j", "1", "k - x[i-1]", "k", "x[i-1]", "x", "i-1", "i", "1", "t[i - 1][j][k]", "[j]", "[i - 1]", "t", "i - 1", "i", "1", "j", "k", "t[i][j][k] = t[i - 1][j][k]", "t[i][j][k]", "[j]", "[i]", "t", "i", "j", "k", "t[i - 1][j][k]", "[j]", "[i - 1]", "t", "i - 1", "i", "1", "j", "k", "for i in range(1,n+1):\n ans += t[n][i][i*a]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "ans += t[n][i][i*a]", "ans", "t[n][i][i*a]", "[i]", "[n]", "t", "n", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "t = [[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)]", "[[[0] * (50*(j+1)+1) for j in range(i+2)] for i in range(n+1)]", "t", "ans = 0", "0", "ans", "n,a = map(int,input().split())", "map(int,input().split())", "n", "ans += t[n][i][i*a]", "t[n][i][i*a]", "ans", "a = map(int,input().split())", "map(int,input().split())", "a", "x = list(map(int,input().split()))", "list(map(int,input().split()))", "x" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 2, 13, 13, 17, 0, 13, 18, 13, 13, 0, 18, 13, 17, 17, 28, 13, 13, 0, 18, 13, 39, 17, 4, 18, 18, 13, 39, 17, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 95, 4 ], [ 95, 13 ], [ 17, 16 ], [ 16, 25 ], [ 101, 27 ], [ 98, 30 ], [ 90, 37 ], [ 90, 41 ], [ 96, 42 ], [ 46, 45 ], [ 53, 50 ], [ 99, 51 ], [ 56, 55 ], [ 102, 55 ], [ 62, 58 ], [ 99, 59 ], [ 99, 65 ], [ 104, 70 ], [ 74, 73 ], [ 90, 78 ], [ 92, 81 ], [ 99, 83 ], [ 73, 84 ], [ 93, 87 ], [ 105, 87 ], [ 95, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "import numpy as np\n\nN, A = map(int,input().split())\nX = [int(x) for x in input().split()]\n \ndp = np.zeros((N+1,N*A+1),dtype=np.int64)\ndp[0,0] = 1\n \nfor x in X:\n dp[1:,x:] += dp[:-1,:-x].copy()\n \nans = 0\nfor n in range(1,N+1):\n ans += dp[n,n*A]\n\nprint(ans)", "import numpy as np", "numpy", "N, A = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "X = [int(x) for x in input().split()]", "X", "[int(x) for x in input().split()]", "dp = np.zeros((N+1,N*A+1),dtype=np.int64)", "dp", "np.zeros((N+1,N*A+1),dtype=np.int64)", "np.zeros", "np", "zeros", "(N+1,N*A+1)", "N+1", "N", "1", "N*A+1", "N*A", "N", "A", "1", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "dp[0,0] = 1", "dp[0,0]", "dp", "0", "1", "for x in X:\n dp[1:,x:] += dp[:-1,:-x].copy()\n ", "x", "X", "dp[1:,x:] += dp[:-1,:-x].copy()", "dp[1:,x:]", "dp", "1:", "1", "dp[:-1,:-x].copy()", "[:-1,:-x].copy", "[:-1,:-x]", "dp", ":-1", "-1", "copy", "ans = 0", "ans", "0", "for n in range(1,N+1):\n ans += dp[n,n*A]", "n", "range(1,N+1)", "range", "1", "N+1", "N", "1", "ans += dp[n,n*A]", "ans", "dp[n,n*A]", "dp", "n", "print(ans)", "print", "ans", "N, A = map(int,input().split())", "map(int,input().split())", "N", "ans += dp[n,n*A]", "dp[n,n*A]", "ans", "A = map(int,input().split())", "map(int,input().split())", "A", "dp = np.zeros((N+1,N*A+1),dtype=np.int64)", "np.zeros((N+1,N*A+1),dtype=np.int64)", "dp", "X = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "X", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 18, 18, 13, 13, 13, 0, 13, 17, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 2, 4, 13, 13, 13, 0, 13, 13, 0, 13, 2, 39, 17, 17, 0, 18, 13, 2, 17, 13, 17, 28, 13, 13, 14, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 18, 13, 13, 17, 9, 0, 18, 13, 2, 13, 13, 18, 13, 13, 28, 13, 4, 13, 2, 17, 17, 17, 17, 14, 2, 18, 13, 13, 17, 9, 0, 18, 13, 2, 13, 13, 18, 13, 13, 4, 13, 2, 18, 13, 13, 17, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 136, 11 ], [ 142, 18 ], [ 23, 22 ], [ 137, 26 ], [ 22, 31 ], [ 139, 33 ], [ 139, 35 ], [ 39, 38 ], [ 137, 42 ], [ 38, 48 ], [ 134, 49 ], [ 127, 51 ], [ 130, 54 ], [ 65, 60 ], [ 131, 61 ], [ 143, 64 ], [ 68, 67 ], [ 128, 67 ], [ 67, 71 ], [ 75, 74 ], [ 131, 81 ], [ 74, 82 ], [ 91, 86 ], [ 131, 87 ], [ 74, 89 ], [ 67, 90 ], [ 131, 92 ], [ 74, 93 ], [ 96, 95 ], [ 131, 106 ], [ 95, 107 ], [ 116, 111 ], [ 131, 112 ], [ 95, 114 ], [ 67, 115 ], [ 131, 117 ], [ 95, 118 ], [ 131, 123 ], [ 143, 124 ], [ 127, 128 ], [ 130, 131 ], [ 139, 134 ], [ 136, 137 ], [ 139, 140 ], [ 142, 143 ] ]

[ "#!/usr/bin/env python3\nimport sys\nsys.setrecursionlimit(10**8)\ninput = sys.stdin.readline\n\noffset = 3000\n\nn, a = [int(item) for item in input().split()]\nx = [int(item) - a for item in input().split()]\n\ndp = [0] * 6000\ndp[0 + offset] = 1\n\nfor item in x:\n if item < 0:\n for i in range(6000):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]\n else:\n for i in range(6000 - 1, -1, -1):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]\nprint(dp[offset] - 1)", "import sys", "sys", "sys.setrecursionlimit(10**8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**8", "10", "8", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "offset = 3000", "offset", "3000", "int(item) for item in input().split()", "for item in input().split()", "item", "input().split()", "().split", "()", "input", "split", "for item in input().split()", "int(item)", "int", "item", "n, a = [int(item) for item in input().split()]", "n", "[int(item) for item in input().split()]", "a", "int(item) - a for item in input().split()", "for item in input().split()", "item", "input().split()", "().split", "()", "input", "split", "for item in input().split()", "int(item) - a", "int(item)", "int", "item", "a", "x = [int(item) - a for item in input().split()]", "x", "[int(item) - a for item in input().split()]", "dp = [0] * 6000", "dp", "[0] * 6000", "[0]", "0", "6000", "dp[0 + offset] = 1", "dp[0 + offset]", "dp", "0 + offset", "0", "offset", "1", "for item in x:\n if item < 0:\n for i in range(6000):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]\n else:\n for i in range(6000 - 1, -1, -1):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]", "item", "x", "if item < 0:\n for i in range(6000):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]\n else:\n for i in range(6000 - 1, -1, -1):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]", "item < 0", "item", "0", "for i in range(6000):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]\n ", "i", "range(6000)", "range", "6000", "if dp[i] == 0:\n continue \n ", "dp[i] == 0", "dp[i]", "dp", "i", "0", "continue", "dp[i + item] += dp[i]", "dp[i + item]", "dp", "i + item", "i", "item", "dp[i]", "dp", "i", "for i in range(6000 - 1, -1, -1):\n if dp[i] == 0:\n continue \n dp[i + item] += dp[i]", "i", "range(6000 - 1, -1, -1)", "range", "6000 - 1", "6000", "1", "-1", "-1", "if dp[i] == 0:\n continue \n ", "dp[i] == 0", "dp[i]", "dp", "i", "0", "continue", "dp[i + item] += dp[i]", "dp[i + item]", "dp", "i + item", "i", "item", "dp[i]", "dp", "i", "print(dp[offset] - 1)", "print", "dp[offset] - 1", "dp[offset]", "dp", "offset", "1", "x = [int(item) - a for item in input().split()]", "[int(item) - a for item in input().split()]", "x", "dp = [0] * 6000", "[0] * 6000", "dp", "a = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "a", "input = sys.stdin.readline", "sys.stdin.readline", "input", "n, a = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "n", "offset = 3000", "3000", "offset" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 39, 17, 28, 13, 13, 4, 18, 13, 13, 2, 18, 13, 17, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 18, 13, 13, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 18, 13, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 40, 2, 13, 18, 13, 2, 13, 17, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 4, 13, 13, 3, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 18, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 13, 13 ]

[ [ 196, 2 ], [ 196, 11 ], [ 193, 13 ], [ 199, 25 ], [ 30, 29 ], [ 194, 29 ], [ 200, 33 ], [ 200, 37 ], [ 29, 39 ], [ 43, 42 ], [ 197, 46 ], [ 202, 51 ], [ 61, 54 ], [ 203, 57 ], [ 64, 63 ], [ 197, 68 ], [ 78, 71 ], [ 203, 74 ], [ 63, 75 ], [ 81, 80 ], [ 63, 85 ], [ 89, 88 ], [ 200, 94 ], [ 63, 95 ], [ 105, 98 ], [ 203, 101 ], [ 63, 102 ], [ 80, 103 ], [ 88, 104 ], [ 203, 108 ], [ 63, 110 ], [ 80, 112 ], [ 88, 113 ], [ 88, 117 ], [ 194, 119 ], [ 63, 121 ], [ 132, 125 ], [ 203, 128 ], [ 63, 129 ], [ 80, 130 ], [ 88, 131 ], [ 203, 135 ], [ 63, 137 ], [ 80, 140 ], [ 88, 143 ], [ 194, 145 ], [ 63, 147 ], [ 190, 150 ], [ 154, 153 ], [ 197, 158 ], [ 153, 163 ], [ 188, 164 ], [ 194, 167 ], [ 184, 170 ], [ 203, 174 ], [ 197, 175 ], [ 153, 176 ], [ 153, 178 ], [ 188, 179 ], [ 185, 182 ], [ 191, 182 ], [ 184, 185 ], [ 196, 188 ], [ 190, 191 ], [ 193, 194 ], [ 196, 197 ], [ 199, 200 ], [ 202, 203 ] ]

[ "N,A=map(int,input().split())\nxlist=list(map(int,input().split()))\n\nslist=[0]\nfor x in xlist:\n slist.append(slist[-1]+x)\n#print(slist)\n\ndp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0]=1\nfor i in range(1,N+1):\n dp[i][0][0]=1\n for j in range(1,i+1):\n for k in range(1,slist[i]+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)\n\nanswer=0\nfor j in range(1,N+1):\n if j*A>sum(xlist):\n break\n answer+=dp[N][j][j*A]\n \nprint(answer)", "N,A=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "xlist=list(map(int,input().split()))", "xlist", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "slist=[0]", "slist", "[0]", "0", "for x in xlist:\n slist.append(slist[-1]+x)\n#print(slist)", "x", "xlist", "slist.append(slist[-1]+x)", "slist.append", "slist", "append", "slist[-1]+x", "slist[-1]", "slist", "-1", "x", "[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[[0]*(sum(xlist)+1) for _ in range(N+1)]", "dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]", "dp", "[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(1,N+1):\n dp[i][0][0]=1\n for j in range(1,i+1):\n for k in range(1,slist[i]+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)", "i", "range(1,N+1)", "range", "1", "N+1", "N", "1", "dp[i][0][0]=1", "dp[i][0][0]", "[0]", "[i]", "dp", "i", "0", "0", "1", "for j in range(1,i+1):\n for k in range(1,slist[i]+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)", "j", "range(1,i+1)", "range", "1", "i+1", "i", "1", "for k in range(1,slist[i]+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)", "k", "range(1,slist[i]+1)", "range", "1", "slist[i]+1", "slist[i]", "slist", "i", "1", "dp[i][j][k]=dp[i-1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)", "k-xlist[i-1]>=0", "k-xlist[i-1]", "k", "xlist[i-1]", "xlist", "i-1", "i", "1", "0", "dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j-1][k-xlist[i-1]]", "[j-1]", "[i-1]", "dp", "i-1", "i", "1", "j-1", "j", "1", "k-xlist[i-1]", "k", "xlist[i-1]", "xlist", "i-1", "i", "1", "answer=0", "answer", "0", "for j in range(1,N+1):\n if j*A>sum(xlist):\n break\n answer+=dp[N][j][j*A]\n ", "j", "range(1,N+1)", "range", "1", "N+1", "N", "1", "if j*A>sum(xlist):\n break\n ", "j*A>sum(xlist)", "j*A", "j", "A", "sum(xlist)", "sum", "xlist", "break", "answer+=dp[N][j][j*A]", "answer", "dp[N][j][j*A]", "[j]", "[N]", "dp", "N", "j", "j*A", "j", "A", "print(answer)", "print", "answer", "answer+=dp[N][j][j*A]", "dp[N][j][j*A]", "answer", "A=map(int,input().split())", "map(int,input().split())", "A", "answer=0", "0", "answer", "xlist=list(map(int,input().split()))", "list(map(int,input().split()))", "xlist", "N,A=map(int,input().split())", "map(int,input().split())", "N", "slist=[0]", "[0]", "slist", "dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]", "[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]", "dp" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 14, 2, 18, 18, 18, 13, 13, 13, 13, 17, 9, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 2, 13, 17, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 145, 2 ], [ 145, 11 ], [ 151, 13 ], [ 27, 26 ], [ 143, 30 ], [ 154, 35 ], [ 45, 38 ], [ 155, 41 ], [ 48, 47 ], [ 143, 50 ], [ 53, 52 ], [ 143, 55 ], [ 58, 57 ], [ 155, 66 ], [ 47, 67 ], [ 52, 68 ], [ 57, 69 ], [ 82, 73 ], [ 155, 76 ], [ 47, 78 ], [ 52, 80 ], [ 57, 81 ], [ 155, 85 ], [ 47, 86 ], [ 52, 87 ], [ 57, 88 ], [ 105, 90 ], [ 155, 93 ], [ 47, 95 ], [ 52, 98 ], [ 57, 101 ], [ 152, 103 ], [ 47, 104 ], [ 155, 108 ], [ 47, 109 ], [ 52, 110 ], [ 57, 111 ], [ 148, 113 ], [ 117, 116 ], [ 143, 120 ], [ 139, 123 ], [ 155, 127 ], [ 143, 128 ], [ 116, 129 ], [ 116, 131 ], [ 146, 132 ], [ 140, 136 ], [ 149, 136 ], [ 139, 140 ], [ 145, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ] ]

[ "N, A = map(int, input().split())\nX = list(map(int, input().split()))\ndp = [[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)]\ndp[0][0][0] = 1\nfor i in range(N):\n for j in range(N):\n for k in range(5000):\n if dp[i][j][k] == 0:\n continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]\nC = 0\nfor i in range(N + 1):\n C += dp[N][i][i * A]\nprint(C - 1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[[0] * 6000 for _ in range(N + 1) ]", "dp = [[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)]", "dp", "[[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(N):\n for k in range(5000):\n if dp[i][j][k] == 0:\n continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]", "i", "range(N)", "range", "N", "for j in range(N):\n for k in range(5000):\n if dp[i][j][k] == 0:\n continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]", "j", "range(N)", "range", "N", "for k in range(5000):\n if dp[i][j][k] == 0:\n continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]", "k", "range(5000)", "range", "5000", "if dp[i][j][k] == 0:\n continue\n ", "dp[i][j][k] == 0", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "0", "continue", "dp[i + 1][j][k] += dp[i][j][k]", "dp[i + 1][j][k]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]", "dp[i + 1][j + 1][k + X[i]]", "[j + 1]", "[i + 1]", "dp", "i + 1", "i", "1", "j + 1", "j", "1", "k + X[i]", "k", "X[i]", "X", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "C = 0", "C", "0", "for i in range(N + 1):\n C += dp[N][i][i * A]", "i", "range(N + 1)", "range", "N + 1", "N", "1", "C += dp[N][i][i * A]", "C", "dp[N][i][i * A]", "[i]", "[N]", "dp", "N", "i", "i * A", "i", "A", "print(C - 1)", "print", "C - 1", "C", "1", "C += dp[N][i][i * A]", "dp[N][i][i * A]", "C", "N, A = map(int, input().split())", "map(int, input().split())", "N", "A = map(int, input().split())", "map(int, input().split())", "A", "C = 0", "0", "C", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "dp = [[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)]", "[[[0] * 6000 for _ in range(N + 1) ] for _ in range(N + 1)]", "dp" ]

[ 7, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 17, 17, 17, 0, 13, 39, 17, 17, 17, 17, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 4, 13, 13, 12, 13, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 2, 4, 13, 13, 17, 12, 13, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 4, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 17, 4, 13, 0, 13, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 40, 2, 13, 18, 13, 13, 17, 40, 2, 13, 17, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 2, 13, 18, 13, 13, 2, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 2, 13, 13, 13, 4, 13, 13, 4, 13, 10, 12, 13, 10, 39, 13, 10, 39, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 277, 25 ], [ 265, 30 ], [ 247, 37 ], [ 250, 44 ], [ 53, 52 ], [ 52, 65 ], [ 71, 70 ], [ 70, 84 ], [ 91, 90 ], [ 90, 103 ], [ 117, 116 ], [ 253, 123 ], [ 129, 128 ], [ 257, 130 ], [ 129, 131 ], [ 134, 133 ], [ 257, 135 ], [ 144, 137 ], [ 254, 140 ], [ 147, 146 ], [ 128, 149 ], [ 152, 151 ], [ 157, 156 ], [ 128, 160 ], [ 151, 166 ], [ 133, 168 ], [ 146, 169 ], [ 156, 173 ], [ 186, 177 ], [ 254, 180 ], [ 146, 182 ], [ 151, 184 ], [ 156, 185 ], [ 254, 189 ], [ 146, 190 ], [ 151, 192 ], [ 133, 194 ], [ 146, 195 ], [ 156, 197 ], [ 209, 200 ], [ 254, 203 ], [ 146, 205 ], [ 151, 207 ], [ 156, 208 ], [ 254, 212 ], [ 146, 213 ], [ 151, 214 ], [ 156, 215 ], [ 218, 217 ], [ 221, 220 ], [ 128, 225 ], [ 229, 228 ], [ 254, 232 ], [ 128, 233 ], [ 220, 235 ], [ 131, 236 ], [ 220, 237 ], [ 228, 240 ], [ 217, 240 ], [ 260, 242 ], [ 247, 248 ], [ 250, 251 ], [ 253, 254 ], [ 265, 266 ], [ 277, 278 ] ]

[ "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\nfrom collections import deque\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\nmod = 10**9 + 7\n\nDR = [1, -1, 0, 0]\nDC = [0, 0, 1, -1]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\ndp = [[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)]\n\ndef main():\n N, A = LI()\n X = LI()\n dp[0][0][0] = 1\n # for i in range(51):\n # dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n cnt = 0\n for k in range(1, N+1):\n cnt += dp[N][k*A][k]\n print(cnt)\nmain()\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools", "math", "string", "itertools", "fractions", "heapq", "collections", "re", "array", "bisect", "sys", "random", "time", "copy", "functools", "from collections import deque", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "inf = 10**20", "inf", "10**20", "10", "20", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "DR = [1, -1, 0, 0]", "DR", "[1, -1, 0, 0]", "1", "-1", "0", "0", "DC = [0, 0, 1, -1]", "DC", "[0, 0, 1, -1]", "0", "0", "1", "-1", "int(x) for x in sys.stdin.readline().split()", "for x in sys.stdin.readline().split()", "x", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "for x in sys.stdin.readline().split()", "int(x)", "int", "x", "def LI(): return [int(x) for x in sys.stdin.readline().split()]", "LI", "int(x)-1 for x in sys.stdin.readline().split()", "for x in sys.stdin.readline().split()", "x", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "for x in sys.stdin.readline().split()", "int(x)-1", "int(x)", "int", "x", "1", "def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]", "LI_", "float(x) for x in sys.stdin.readline().split()", "for x in sys.stdin.readline().split()", "x", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "for x in sys.stdin.readline().split()", "float(x)", "float", "x", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "LF", "def LS(): return sys.stdin.readline().split()", "LS", "def I(): return int(sys.stdin.readline())", "I", "def F(): return float(sys.stdin.readline())", "F", "def S(): return input()", "S", "[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)", "for ___ in range(51)", "___", "range(51)", "range", "51", "for ___ in range(51)", "[[0 for _ in range(51)] for __ in range(2501)]", "dp = [[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)]", "dp", "[[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)]", "def main():\n N, A = LI()\n X = LI()\n dp[0][0][0] = 1\n # for i in range(51):\n # dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n cnt = 0\n for k in range(1, N+1):\n cnt += dp[N][k*A][k]\n print(cnt)", "main", "N, A = LI()", "N", "LI()", "LI", "A", "X = LI()", "X", "LI()", "LI", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n ", "i", "range(N)", "range", "N", "for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n ", "j", "range(2501)", "range", "2501", "for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n ", "k", "range(N+1)", "range", "N+1", "N", "1", "if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n ", "j - X[i] >= 0 and k - 1 >= 0", "j - X[i] >= 0", "j - X[i]", "j", "X[i]", "X", "i", "0", "k - 1 >= 0", "k - 1", "k", "1", "0", "dp[i+1][j][k] += dp[i][j-X[i]][k-1]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j-X[i]][k-1]", "[j-X[i]]", "[i]", "dp", "i", "j-X[i]", "j", "X[i]", "X", "i", "k-1", "k", "1", "dp[i+1][j][k] += dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "cnt = 0", "cnt", "0", "for k in range(1, N+1):\n cnt += dp[N][k*A][k]\n ", "k", "range(1, N+1)", "range", "1", "N+1", "N", "1", "cnt += dp[N][k*A][k]", "cnt", "dp[N][k*A][k]", "[k*A]", "[N]", "dp", "N", "k*A", "k", "A", "k", "print(cnt)", "print", "cnt", "main()", "main", "def F(): return float(sys.stdin.readline())", "def F(): return float(sys.stdin.readline())", "F", "DR = [1, -1, 0, 0]", "[1, -1, 0, 0]", "DR", "DC = [0, 0, 1, -1]", "[0, 0, 1, -1]", "DC", "dp = [[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)]", "[[[0 for _ in range(51)] for __ in range(2501)] for ___ in range(51)]", "dp", "def LI(): return [int(x) for x in sys.stdin.readline().split()]", "def LI(): return [int(x) for x in sys.stdin.readline().split()]", "LI", "def main():\n N, A = LI()\n X = LI()\n dp[0][0][0] = 1\n # for i in range(51):\n # dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n cnt = 0\n for k in range(1, N+1):\n cnt += dp[N][k*A][k]\n print(cnt)", "def main():\n N, A = LI()\n X = LI()\n dp[0][0][0] = 1\n # for i in range(51):\n # dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(2501):\n for k in range(N+1):\n if j - X[i] >= 0 and k - 1 >= 0:\n dp[i+1][j][k] += dp[i][j-X[i]][k-1]\n dp[i+1][j][k] += dp[i][j][k]\n cnt = 0\n for k in range(1, N+1):\n cnt += dp[N][k*A][k]\n print(cnt)", "main", "def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]", "def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]", "LI_", "mod = 10**9 + 7", "10**9 + 7", "mod", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "LF", "def LS(): return sys.stdin.readline().split()", "def LS(): return sys.stdin.readline().split()", "LS", "def S(): return input()", "def S(): return input()", "S", "inf = 10**20", "10**20", "inf", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 17, 13, 17, 14, 2, 2, 13, 18, 13, 13, 2, 2, 17, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 160, 2 ], [ 160, 11 ], [ 151, 13 ], [ 27, 26 ], [ 146, 30 ], [ 154, 35 ], [ 45, 38 ], [ 155, 41 ], [ 48, 47 ], [ 146, 50 ], [ 53, 52 ], [ 146, 56 ], [ 60, 59 ], [ 146, 65 ], [ 59, 70 ], [ 152, 72 ], [ 47, 73 ], [ 146, 77 ], [ 89, 80 ], [ 155, 83 ], [ 47, 85 ], [ 52, 87 ], [ 59, 88 ], [ 155, 92 ], [ 47, 93 ], [ 52, 94 ], [ 59, 95 ], [ 112, 97 ], [ 155, 100 ], [ 47, 102 ], [ 52, 105 ], [ 59, 108 ], [ 152, 110 ], [ 47, 111 ], [ 155, 115 ], [ 47, 116 ], [ 52, 117 ], [ 59, 118 ], [ 157, 120 ], [ 124, 123 ], [ 146, 128 ], [ 148, 131 ], [ 155, 135 ], [ 146, 136 ], [ 123, 137 ], [ 123, 139 ], [ 161, 140 ], [ 149, 143 ], [ 158, 143 ], [ 160, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ] ]

[ "N, A = map(int, input().split()) # N枚数のカード, 平均をAにしたい\nX = tuple(map(int, input().split())) # N枚のカードの中身\n\ndp = [[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]\n\ndp[0][0][0] = 1 # 0枚の中から0枚選んで合計が0になる選び方が1通りある\n\nfor i in range(N):\n for j in range(N+1):\n for k in range(50*N+1):\n # if dp[i][j][k]: # ここの分岐が分からん\n if k+X[i] < 50*N+2:\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]\nans = 0\nfor i in range(1, N+1):\n ans += dp[N][i][i*A]\nprint(ans)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = tuple(map(int, input().split()))", "X", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)", "for _ in range(N+2)", "_", "range(N+2)", "range", "N+2", "N", "2", "for _ in range(N+2)", "[[0]*(50*N+2) for _ in range(N+2)]", "dp = [[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]", "dp", "[[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(N+1):\n for k in range(50*N+1):\n # if dp[i][j][k]: # ここの分岐が分からん\n if k+X[i] < 50*N+2:\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]", "i", "range(N)", "range", "N", "for j in range(N+1):\n for k in range(50*N+1):\n # if dp[i][j][k]: # ここの分岐が分からん\n if k+X[i] < 50*N+2:\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]", "j", "range(N+1)", "range", "N+1", "N", "1", "for k in range(50*N+1):\n # if dp[i][j][k]: # ここの分岐が分からん\n if k+X[i] < 50*N+2:\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]", "k", "range(50*N+1)", "range", "50*N+1", "50*N", "50", "N", "1", "if k+X[i] < 50*N+2:\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]", "k+X[i] < 50*N+2", "k+X[i]", "k", "X[i]", "X", "i", "50*N+2", "50*N", "50", "N", "2", "dp[i+1][j][k] += dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j+1][k+X[i]] += dp[i][j][k]", "dp[i+1][j+1][k+X[i]]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k+X[i]", "k", "X[i]", "X", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans = 0", "ans", "0", "for i in range(1, N+1):\n ans += dp[N][i][i*A]", "i", "range(1, N+1)", "range", "1", "N+1", "N", "1", "ans += dp[N][i][i*A]", "ans", "dp[N][i][i*A]", "[i]", "[N]", "dp", "N", "i", "i*A", "i", "A", "print(ans)", "print", "ans", "N, A = map(int, input().split())", "map(int, input().split())", "N", "ans += dp[N][i][i*A]", "dp[N][i][i*A]", "ans", "X = tuple(map(int, input().split()))", "tuple(map(int, input().split()))", "X", "dp = [[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]", "[[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]", "dp", "ans = 0", "0", "ans", "A = map(int, input().split())", "map(int, input().split())", "A" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 31, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 17, 14, 40, 40, 17, 2, 13, 18, 13, 13, 17, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 2, 18, 18, 13, 13, 2, 13, 13, 18, 18, 13, 13, 2, 2, 13, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 17, 13, 10, 18, 13, 10, 12, 13, 10, 2, 13, 10, 18, 13, 10, 18, 13 ]

[ [ 190, 4 ], [ 187, 11 ], [ 178, 18 ], [ 184, 32 ], [ 175, 37 ], [ 43, 42 ], [ 191, 49 ], [ 43, 51 ], [ 43, 52 ], [ 57, 56 ], [ 56, 60 ], [ 51, 61 ], [ 64, 63 ], [ 67, 66 ], [ 71, 70 ], [ 42, 74 ], [ 83, 82 ], [ 90, 85 ], [ 82, 87 ], [ 66, 89 ], [ 93, 92 ], [ 42, 95 ], [ 98, 97 ], [ 97, 107 ], [ 63, 109 ], [ 92, 110 ], [ 122, 113 ], [ 82, 115 ], [ 92, 117 ], [ 97, 120 ], [ 66, 121 ], [ 82, 125 ], [ 92, 126 ], [ 97, 128 ], [ 66, 129 ], [ 82, 132 ], [ 92, 133 ], [ 97, 136 ], [ 63, 138 ], [ 92, 139 ], [ 66, 140 ], [ 151, 142 ], [ 82, 144 ], [ 92, 146 ], [ 97, 149 ], [ 66, 150 ], [ 82, 153 ], [ 92, 154 ], [ 97, 156 ], [ 66, 157 ], [ 82, 163 ], [ 42, 164 ], [ 66, 165 ], [ 182, 173 ], [ 175, 176 ], [ 178, 179 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ] ]

[ "import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\nsys.setrecursionlimit(10 ** 9)\nINF = 1 << 60\nMOD = 1000000007\n\n\ndef main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n for i in range(N):\n for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n print(dp[N][base] - 1)\n\n return\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "MOD = 1000000007", "MOD", "1000000007", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n for i in range(N):\n for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n print(dp[N][base] - 1)\n\n return", "main", "N, A, *X = map(int, read().split())", "N", "map(int, read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "A", "*X", "X", "x - A for x in X", "for x in X", "x", "X", "for x in X", "x - A", "x", "A", "X = [x - A for x in X]", "X", "[x - A for x in X]", "base = 2500", "base", "2500", "[0] * 5001 for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[0] * 5001", "[0]", "0", "5001", "dp = [[0] * 5001 for _ in range(N + 1)]", "dp", "[[0] * 5001 for _ in range(N + 1)]", "dp[0][base] = 1", "dp[0][base]", "[0]", "dp", "0", "base", "1", "for i in range(N):\n for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n ", "i", "range(N)", "range", "N", "for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n ", "j", "range(-2500, 2501)", "range", "-2500", "2501", "if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n ", "-2500 <= j - X[i] <= 2500", "-2500 <= j - X[i]", "-2500", "j - X[i]", "j", "X[i]", "X", "i", "2500", "dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]", "dp[i + 1][j + base]", "[i + 1]", "dp", "i + 1", "i", "1", "j + base", "j", "base", "dp[i][j + base] + dp[i][j - X[i] + base]", "dp[i][j + base]", "[i]", "dp", "i", "j + base", "j", "base", "dp[i][j - X[i] + base]", "[i]", "dp", "i", "j - X[i] + base", "j - X[i]", "j", "X[i]", "X", "i", "base", "dp[i + 1][j + base] = dp[i][j + base]", "dp[i + 1][j + base]", "[i + 1]", "dp", "i + 1", "i", "1", "j + base", "j", "base", "dp[i][j + base]", "[i]", "dp", "i", "j + base", "j", "base", "print(dp[N][base] - 1)", "print", "dp[N][base] - 1", "dp[N][base]", "[N]", "dp", "N", "base", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "MOD = 1000000007", "1000000007", "MOD", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n for i in range(N):\n for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n print(dp[N][base] - 1)\n\n return", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n for i in range(N):\n for j in range(-2500, 2501):\n if -2500 <= j - X[i] <= 2500:\n dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]\n else:\n dp[i + 1][j + base] = dp[i][j + base]\n\n print(dp[N][base] - 1)\n\n return", "main", "INF = 1 << 60", "1 << 60", "INF", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "read = sys.stdin.read", "sys.stdin.read", "read" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 12, 13, 14, 2, 13, 4, 13, 13, 29, 8, 2, 2, 13, 17, 2, 2, 13, 13, 13, 17, 17, 14, 2, 39, 13, 13, 13, 13, 29, 18, 13, 39, 13, 13, 13, 0, 18, 13, 39, 13, 13, 13, 2, 4, 13, 2, 13, 17, 13, 2, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 2, 13, 17, 13, 13, 13, 13, 29, 18, 13, 39, 13, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 13, 4, 13, 17, 13, 17, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 121, 2 ], [ 121, 11 ], [ 124, 13 ], [ 130, 23 ], [ 100, 29 ], [ 102, 32 ], [ 106, 37 ], [ 106, 41 ], [ 108, 42 ], [ 104, 43 ], [ 131, 52 ], [ 131, 55 ], [ 67, 61 ], [ 131, 62 ], [ 100, 71 ], [ 102, 73 ], [ 104, 75 ], [ 102, 77 ], [ 100, 78 ], [ 106, 80 ], [ 108, 82 ], [ 100, 86 ], [ 102, 88 ], [ 104, 89 ], [ 106, 90 ], [ 108, 91 ], [ 131, 94 ], [ 100, 100 ], [ 102, 102 ], [ 104, 104 ], [ 106, 106 ], [ 108, 108 ], [ 128, 111 ], [ 125, 113 ], [ 122, 116 ], [ 121, 119 ], [ 121, 122 ], [ 124, 125 ], [ 130, 131 ] ]

[ "n,a = map(int, raw_input().split())\nais = map(int, raw_input().split())\nmem = {}\ndef dfs(i,ais, cumul,count,a):\n\tif i == len(ais):\n\t\treturn 1 if (count > 0 and count * a == cumul) else 0\n\tif (i,cumul,count) in mem:\n\t\treturn mem[(i,cumul,count)]\n\tmem[(i,cumul,count)] = dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)\n\treturn mem[(i,cumul,count)]\nprint dfs(0,ais,0,0,a)", "n,a = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "a", "ais = map(int, raw_input().split())", "ais", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "mem = {}", "mem", "{}", "def dfs(i,ais, cumul,count,a):\n\tif i == len(ais):\n\t\treturn 1 if (count > 0 and count * a == cumul) else 0\n\tif (i,cumul,count) in mem:\n\t\treturn mem[(i,cumul,count)]\n\tmem[(i,cumul,count)] = dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)\n\treturn mem[(i,cumul,count)]", "dfs", "if i == len(ais):\n\t\treturn 1 if (count > 0 and count * a == cumul) else 0\n\t", "i == len(ais)", "i", "len(ais)", "len", "ais", "return 1 if (count > 0 and count * a == cumul) else 0", "1 if (count > 0 and count * a == cumul) else 0", "count > 0 and count * a == cumul", "count > 0", "count", "0", "count * a == cumul", "count * a", "count", "a", "cumul", "1", "0", "if (i,cumul,count) in mem:\n\t\treturn mem[(i,cumul,count)]\n\t", "(i,cumul,count) in mem", "(i,cumul,count)", "i", "cumul", "count", "mem", "return mem[(i,cumul,count)]", "mem[(i,cumul,count)]", "mem", "(i,cumul,count)", "i", "cumul", "count", "mem[(i,cumul,count)] = dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)", "mem[(i,cumul,count)]", "mem", "(i,cumul,count)", "i", "cumul", "count", "dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)", "dfs(i+1, ais, cumul + ais[i], count +1, a)", "dfs", "i+1", "i", "1", "ais", "cumul + ais[i]", "cumul", "ais[i]", "ais", "i", "count +1", "count", "1", "a", "dfs(i+1, ais, cumul, count, a)", "dfs", "i+1", "i", "1", "ais", "cumul", "count", "a", "return mem[(i,cumul,count)]", "mem[(i,cumul,count)]", "mem", "(i,cumul,count)", "i", "cumul", "count", "i", "i", "ais", "ais", "cumul", "cumul", "count", "count", "a", "a", "print", "dfs(0,ais,0,0,a)", "dfs", "0", "ais", "0", "0", "a", "n,a = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "a = map(int, raw_input().split())", "map(int, raw_input().split())", "a", "ais = map(int, raw_input().split())", "map(int, raw_input().split())", "ais", "def dfs(i,ais, cumul,count,a):\n\tif i == len(ais):\n\t\treturn 1 if (count > 0 and count * a == cumul) else 0\n\tif (i,cumul,count) in mem:\n\t\treturn mem[(i,cumul,count)]\n\tmem[(i,cumul,count)] = dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)\n\treturn mem[(i,cumul,count)]", "def dfs(i,ais, cumul,count,a):\n\tif i == len(ais):\n\t\treturn 1 if (count > 0 and count * a == cumul) else 0\n\tif (i,cumul,count) in mem:\n\t\treturn mem[(i,cumul,count)]\n\tmem[(i,cumul,count)] = dfs(i+1, ais, cumul + ais[i], count +1, a) + dfs(i+1, ais, cumul, count, a)\n\treturn mem[(i,cumul,count)]", "dfs", "mem = {}", "{}", "mem" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 40, 18, 18, 13, 13, 13, 17, 0, 18, 18, 13, 2, 13, 18, 13, 13, 2, 13, 17, 18, 18, 13, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 4, 13, 2, 13, 13, 13, 0, 13, 18, 18, 13, 2, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 201, 2 ], [ 201, 11 ], [ 189, 13 ], [ 190, 26 ], [ 30, 29 ], [ 204, 32 ], [ 190, 35 ], [ 39, 38 ], [ 205, 42 ], [ 187, 49 ], [ 192, 52 ], [ 60, 55 ], [ 193, 57 ], [ 63, 62 ], [ 187, 65 ], [ 69, 68 ], [ 205, 72 ], [ 187, 79 ], [ 198, 82 ], [ 86, 85 ], [ 205, 89 ], [ 93, 92 ], [ 187, 96 ], [ 85, 102 ], [ 92, 105 ], [ 146, 108 ], [ 193, 110 ], [ 85, 111 ], [ 92, 112 ], [ 126, 115 ], [ 199, 117 ], [ 85, 119 ], [ 190, 121 ], [ 62, 122 ], [ 92, 124 ], [ 146, 126 ], [ 193, 128 ], [ 85, 129 ], [ 92, 130 ], [ 133, 132 ], [ 205, 136 ], [ 140, 139 ], [ 187, 143 ], [ 151, 146 ], [ 193, 148 ], [ 132, 149 ], [ 139, 150 ], [ 199, 153 ], [ 132, 154 ], [ 139, 155 ], [ 195, 157 ], [ 161, 160 ], [ 205, 166 ], [ 202, 167 ], [ 187, 168 ], [ 207, 170 ], [ 193, 173 ], [ 202, 175 ], [ 160, 177 ], [ 160, 180 ], [ 208, 184 ], [ 196, 184 ], [ 201, 187 ], [ 189, 190 ], [ 192, 193 ], [ 195, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ] ]

[ "n,a=map(int,input().split())\nx=list(map(int,input().split()))\nx.sort(reverse=True)\nsx=sum(x)\ndp=[[0]*(n+1) for i in range(sx+1)]\ndp[0][0]=1\nfor i in range(n):\n dp_sub=[[0]*(n+1) for j in range(sx+1)]\n for j in range(sx+1):\n for k in range(n+1):\n if (j==0 and k==0) or dp[j][k]!=0:\n dp_sub[j+x[i]][k+1]=dp[j][k]\n for j in range(sx+1):\n for k in range(n+1):\n dp[j][k]+=dp_sub[j][k]\ncnt=0\n\nfor i in range(min(sx//a,n)):\n cnt+=dp[a*(i+1)][i+1]\n#print(dp)\nprint(cnt)", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x.sort(reverse=True)", "x.sort", "x", "sort", "reverse=True", "reverse", "True", "sx=sum(x)", "sx", "sum(x)", "sum", "x", "[0]*(n+1) for i in range(sx+1)", "for i in range(sx+1)", "i", "range(sx+1)", "range", "sx+1", "sx", "1", "for i in range(sx+1)", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "dp=[[0]*(n+1) for i in range(sx+1)]", "dp", "[[0]*(n+1) for i in range(sx+1)]", "dp[0][0]=1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(n):\n dp_sub=[[0]*(n+1) for j in range(sx+1)]\n for j in range(sx+1):\n for k in range(n+1):\n if (j==0 and k==0) or dp[j][k]!=0:\n dp_sub[j+x[i]][k+1]=dp[j][k]\n for j in range(sx+1):\n for k in range(n+1):\n dp[j][k]+=dp_sub[j][k]", "i", "range(n)", "range", "n", "[0]*(n+1) for j in range(sx+1)", "for j in range(sx+1)", "j", "range(sx+1)", "range", "sx+1", "sx", "1", "for j in range(sx+1)", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "dp_sub=[[0]*(n+1) for j in range(sx+1)]", "dp_sub", "[[0]*(n+1) for j in range(sx+1)]", "for j in range(sx+1):\n for k in range(n+1):\n if (j==0 and k==0) or dp[j][k]!=0:\n dp_sub[j+x[i]][k+1]=dp[j][k]\n ", "j", "range(sx+1)", "range", "sx+1", "sx", "1", "for k in range(n+1):\n if (j==0 and k==0) or dp[j][k]!=0:\n dp_sub[j+x[i]][k+1]=dp[j][k]\n ", "k", "range(n+1)", "range", "n+1", "n", "1", "if (j==0 and k==0) or dp[j][k]!=0:\n dp_sub[j+x[i]][k+1]=dp[j][k]\n ", "(j==0 and k==0) or dp[j][k]!=0", "j==0 and k==0", "j==0", "j", "0", "k==0", "k", "0", "dp[j][k]!=0", "dp[j][k]", "[j]", "dp", "j", "k", "0", "dp_sub[j+x[i]][k+1]=dp[j][k]", "dp_sub[j+x[i]][k+1]", "[j+x[i]]", "dp_sub", "j+x[i]", "j", "x[i]", "x", "i", "k+1", "k", "1", "dp[j][k]", "[j]", "dp", "j", "k", "for j in range(sx+1):\n for k in range(n+1):\n dp[j][k]+=dp_sub[j][k]", "j", "range(sx+1)", "range", "sx+1", "sx", "1", "for k in range(n+1):\n dp[j][k]+=dp_sub[j][k]", "k", "range(n+1)", "range", "n+1", "n", "1", "dp[j][k]+=dp_sub[j][k]", "dp[j][k]", "[j]", "dp", "j", "k", "dp_sub[j][k]", "[j]", "dp_sub", "j", "k", "cnt=0", "cnt", "0", "for i in range(min(sx//a,n)):\n cnt+=dp[a*(i+1)][i+1]\n#print(dp)", "i", "range(min(sx//a,n))", "range", "min(sx//a,n)", "min", "sx//a", "sx", "a", "n", "cnt+=dp[a*(i+1)][i+1]", "cnt", "dp[a*(i+1)][i+1]", "[a*(i+1)]", "dp", "a*(i+1)", "a", "i+1", "i", "1", "i+1", "i", "1", "print(cnt)", "print", "cnt", "n,a=map(int,input().split())", "map(int,input().split())", "n", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "dp=[[0]*(n+1) for i in range(sx+1)]", "[[0]*(n+1) for i in range(sx+1)]", "dp", "cnt=0", "0", "cnt", "dp_sub=[[0]*(n+1) for j in range(sx+1)]", "[[0]*(n+1) for j in range(sx+1)]", "dp_sub", "a=map(int,input().split())", "map(int,input().split())", "a", "sx=sum(x)", "sum(x)", "sx", "cnt+=dp[a*(i+1)][i+1]", "dp[a*(i+1)][i+1]", "cnt" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 2, 4, 13, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 17, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 2, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 2, 2, 2, 17, 13, 17, 17, 0, 18, 18, 13, 2, 13, 17, 13, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 18, 13, 13, 4, 13, 2, 18, 18, 13, 13, 2, 17, 13, 17, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 113, 2 ], [ 113, 11 ], [ 15, 14 ], [ 14, 24 ], [ 111, 25 ], [ 116, 27 ], [ 32, 31 ], [ 114, 35 ], [ 114, 44 ], [ 119, 47 ], [ 57, 50 ], [ 120, 52 ], [ 114, 56 ], [ 60, 59 ], [ 114, 62 ], [ 65, 64 ], [ 114, 72 ], [ 83, 76 ], [ 120, 78 ], [ 59, 80 ], [ 64, 82 ], [ 120, 86 ], [ 59, 87 ], [ 64, 88 ], [ 120, 91 ], [ 59, 92 ], [ 64, 94 ], [ 117, 96 ], [ 59, 97 ], [ 120, 103 ], [ 114, 104 ], [ 114, 107 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ] ]

[ "N, A = map(int, input().split())\nlst = [int(x) - A for x in input().split()]\ndp = [[0] * (100 * N + 1) for _ in range(N + 1)]\ndp[0][50 * N] = 1\nfor i in range(N):\n for j in range(50, 100 * N + 1 - 50):\n dp[i + 1][j] = dp[i][j] + dp[i][j - lst[i]]\nprint(dp[N][50 * N] - 1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "int(x) - A for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x) - A", "int(x)", "int", "x", "A", "lst = [int(x) - A for x in input().split()]", "lst", "[int(x) - A for x in input().split()]", "[0] * (100 * N + 1) for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[0] * (100 * N + 1)", "[0]", "0", "100 * N + 1", "100 * N", "100", "N", "1", "dp = [[0] * (100 * N + 1) for _ in range(N + 1)]", "dp", "[[0] * (100 * N + 1) for _ in range(N + 1)]", "dp[0][50 * N] = 1", "dp[0][50 * N]", "[0]", "dp", "0", "50 * N", "50", "N", "1", "for i in range(N):\n for j in range(50, 100 * N + 1 - 50):\n dp[i + 1][j] = dp[i][j] + dp[i][j - lst[i]]", "i", "range(N)", "range", "N", "for j in range(50, 100 * N + 1 - 50):\n dp[i + 1][j] = dp[i][j] + dp[i][j - lst[i]]", "j", "range(50, 100 * N + 1 - 50)", "range", "50", "100 * N + 1 - 50", "100 * N + 1", "100 * N", "100", "N", "1", "50", "dp[i + 1][j] = dp[i][j] + dp[i][j - lst[i]]", "dp[i + 1][j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "dp[i][j] + dp[i][j - lst[i]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i][j - lst[i]]", "[i]", "dp", "i", "j - lst[i]", "j", "lst[i]", "lst", "i", "print(dp[N][50 * N] - 1)", "print", "dp[N][50 * N] - 1", "dp[N][50 * N]", "[N]", "dp", "N", "50 * N", "50", "N", "1", "A = map(int, input().split())", "map(int, input().split())", "A", "N, A = map(int, input().split())", "map(int, input().split())", "N", "lst = [int(x) - A for x in input().split()]", "[int(x) - A for x in input().split()]", "lst", "dp = [[0] * (100 * N + 1) for _ in range(N + 1)]", "[[0] * (100 * N + 1) for _ in range(N + 1)]", "dp" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 40, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 2, 2, 40, 13, 17, 40, 13, 17, 40, 13, 18, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 9, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 199, 2 ], [ 199, 11 ], [ 196, 13 ], [ 184, 25 ], [ 197, 30 ], [ 200, 31 ], [ 35, 34 ], [ 194, 38 ], [ 187, 43 ], [ 53, 46 ], [ 188, 49 ], [ 56, 55 ], [ 194, 59 ], [ 63, 62 ], [ 194, 66 ], [ 70, 69 ], [ 194, 74 ], [ 185, 75 ], [ 55, 80 ], [ 69, 83 ], [ 197, 85 ], [ 55, 87 ], [ 97, 90 ], [ 188, 93 ], [ 55, 94 ], [ 62, 95 ], [ 69, 96 ], [ 188, 100 ], [ 55, 102 ], [ 62, 104 ], [ 69, 105 ], [ 55, 110 ], [ 62, 113 ], [ 69, 116 ], [ 197, 118 ], [ 55, 120 ], [ 130, 123 ], [ 188, 126 ], [ 55, 127 ], [ 62, 128 ], [ 69, 129 ], [ 188, 134 ], [ 55, 136 ], [ 62, 138 ], [ 69, 139 ], [ 188, 143 ], [ 55, 145 ], [ 62, 148 ], [ 69, 151 ], [ 197, 153 ], [ 55, 155 ], [ 202, 159 ], [ 163, 162 ], [ 194, 167 ], [ 190, 170 ], [ 188, 174 ], [ 194, 175 ], [ 162, 176 ], [ 162, 178 ], [ 200, 179 ], [ 191, 182 ], [ 203, 182 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ], [ 199, 194 ], [ 196, 197 ], [ 199, 200 ], [ 202, 203 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nmax_x = max(max(x), a)\ndp = [[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)]\ndp[0][0][0] = 1\nfor i in range(n + 1):\n for j in range(n + 1):\n for k in range(n * max_x + 1):\n if i >= 1 and k < x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n else:\n continue\nans = 0\nfor j in range(1, n + 1):\n ans += dp[n][j][j * a]\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_x = max(max(x), a)", "max_x", "max(max(x), a)", "max", "max(x)", "max", "x", "a", "[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[[0] * (n * max_x + 1) for _ in range(n + 1)]", "dp = [[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "[[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n + 1):\n for j in range(n + 1):\n for k in range(n * max_x + 1):\n if i >= 1 and k < x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n else:\n continue", "i", "range(n + 1)", "range", "n + 1", "n", "1", "for j in range(n + 1):\n for k in range(n * max_x + 1):\n if i >= 1 and k < x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n else:\n continue", "j", "range(n + 1)", "range", "n + 1", "n", "1", "for k in range(n * max_x + 1):\n if i >= 1 and k < x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n else:\n continue", "k", "range(n * max_x + 1)", "range", "n * max_x + 1", "n * max_x", "n", "max_x", "1", "if i >= 1 and k < x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n else:\n continue", "i >= 1 and k < x[i - 1]", "i >= 1", "i", "1", "k < x[i - 1]", "k", "x[i - 1]", "x", "i - 1", "i", "1", "dp[i][j][k] = dp[i - 1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "elif i >= 1 and j >= 1 and k >= x[i - 1]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]\n ", "i >= 1 and j >= 1 and k >= x[i - 1]", "i >= 1 and j >= 1", "i >= 1", "i", "1", "j >= 1", "j", "1", "k >= x[i - 1]", "k", "x[i - 1]", "x", "i - 1", "i", "1", "dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i - 1][j][k] + dp[i - 1][j - 1][k - x[i - 1]]", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "dp[i - 1][j - 1][k - x[i - 1]]", "[j - 1]", "[i - 1]", "dp", "i - 1", "i", "1", "j - 1", "j", "1", "k - x[i - 1]", "k", "x[i - 1]", "x", "i - 1", "i", "1", "continue", "ans = 0", "ans", "0", "for j in range(1, n + 1):\n ans += dp[n][j][j * a]", "j", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "ans += dp[n][j][j * a]", "ans", "dp[n][j][j * a]", "[j]", "[n]", "dp", "n", "j", "j * a", "j", "a", "print(ans)", "print", "ans", "max_x = max(max(x), a)", "max(max(x), a)", "max_x", "dp = [[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "[[[0] * (n * max_x + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "ans += dp[n][j][j * a]", "dp[n][j][j * a]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 31, 13, 12, 13, 0, 13, 17, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 13, 17, 0, 13, 18, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 39, 18, 13, 13, 18, 18, 13, 2, 13, 17, 39, 2, 2, 13, 18, 13, 13, 17, 0, 13, 13, 0, 13, 4, 18, 13, 13, 17, 2, 13, 17, 4, 13, 4, 18, 13, 13, 18, 13, 13, 14, 2, 13, 17, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 128, 6 ], [ 128, 19 ], [ 128, 20 ], [ 26, 25 ], [ 29, 28 ], [ 123, 35 ], [ 25, 38 ], [ 42, 41 ], [ 49, 46 ], [ 28, 47 ], [ 52, 51 ], [ 123, 54 ], [ 57, 56 ], [ 28, 61 ], [ 94, 61 ], [ 64, 63 ], [ 123, 68 ], [ 79, 71 ], [ 56, 73 ], [ 63, 74 ], [ 51, 78 ], [ 28, 81 ], [ 94, 81 ], [ 63, 83 ], [ 25, 88 ], [ 51, 91 ], [ 95, 94 ], [ 56, 95 ], [ 98, 97 ], [ 123, 104 ], [ 94, 113 ], [ 28, 113 ], [ 97, 114 ], [ 126, 120 ], [ 128, 123 ], [ 128, 129 ] ]

[ "import sys\nimport numpy as np\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "import numpy as np", "numpy", "n, a, *x = map(int, sys.stdin.read().split())", "n", "map(int, sys.stdin.read().split())", "map", "int", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "a", "*x", "x", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "main", "m = 2500", "m", "2500", "dp = np.zeros((n + 1, m + 1), dtype=np.int64)", "dp", "np.zeros((n + 1, m + 1), dtype=np.int64)", "np.zeros", "np", "zeros", "(n + 1, m + 1)", "n + 1", "n", "1", "m + 1", "m", "1", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "dp[0, 0] = 1", "dp[0, 0]", "dp", "0", "1", "for i in range(n):\n ndp = np.copy(dp)\n for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n dp = ndp\n ", "i", "range(n)", "range", "n", "ndp = np.copy(dp)", "ndp", "np.copy(dp)", "np.copy", "np", "copy", "dp", "for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n ", "j", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]", "ndp[j][x[i]:]", "[j]", "ndp", "j", "x[i]:", "x[i]", "x", "i", "dp[j-1][:m-x[i]+1]", "[j-1]", "dp", "j-1", "j", "1", ":m-x[i]+1", "m-x[i]+1", "m-x[i]", "m", "x[i]", "x", "i", "1", "dp = ndp", "dp", "ndp", "i = np.arange(1, n + 1)", "i", "np.arange(1, n + 1)", "np.arange", "np", "arange", "1", "n + 1", "n", "1", "print(np.sum(dp[i, i * a]))", "print", "np.sum(dp[i, i * a])", "np.sum", "np", "sum", "dp[i, i * a]", "dp", "i", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "n, a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "n", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n for j in range(1, n + 1):\n ndp[j][x[i]:] += dp[j-1][:m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "main", "a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "a" ]

[ 7, 15, 13, 12, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 0, 13, 2, 39, 17, 17, 0, 18, 13, 17, 17, 28, 13, 13, 14, 2, 13, 17, 28, 13, 4, 13, 17, 0, 18, 13, 2, 13, 13, 18, 13, 13, 14, 2, 13, 17, 28, 13, 4, 13, 2, 17, 13, 17, 17, 0, 18, 13, 2, 13, 13, 18, 13, 13, 14, 2, 13, 17, 28, 13, 4, 13, 2, 17, 13, 0, 18, 13, 2, 13, 13, 18, 13, 13, 4, 13, 2, 18, 13, 17, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 16, 15 ], [ 23, 22 ], [ 6, 31 ], [ 23, 33 ], [ 36, 35 ], [ 6, 44 ], [ 48, 47 ], [ 22, 50 ], [ 55, 52 ], [ 35, 53 ], [ 47, 54 ], [ 33, 55 ], [ 58, 57 ], [ 66, 63 ], [ 57, 64 ], [ 69, 68 ], [ 35, 68 ], [ 68, 72 ], [ 76, 75 ], [ 85, 80 ], [ 57, 81 ], [ 75, 83 ], [ 68, 84 ], [ 57, 86 ], [ 75, 87 ], [ 68, 90 ], [ 94, 93 ], [ 68, 98 ], [ 107, 102 ], [ 57, 103 ], [ 93, 105 ], [ 68, 106 ], [ 57, 108 ], [ 93, 109 ], [ 68, 112 ], [ 116, 115 ], [ 68, 120 ], [ 127, 122 ], [ 57, 123 ], [ 115, 125 ], [ 68, 126 ], [ 57, 128 ], [ 115, 129 ], [ 57, 134 ], [ 145, 142 ] ]

[ "import sys\n\n\ndef solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, a = list(map(int, readline().split()))\n x = list(map(int, readline().split()))\n for i in range(n):\n x[i] -= a\n ls = [0] * 5010\n ls[2500] = 1\n for v in x:\n if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n print(ls[2500] - 1)\n\n\nif __name__ == '__main__':\n solve()", "import sys", "sys", "def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, a = list(map(int, readline().split()))\n x = list(map(int, readline().split()))\n for i in range(n):\n x[i] -= a\n ls = [0] * 5010\n ls[2500] = 1\n for v in x:\n if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n print(ls[2500] - 1)", "solve", "readline = sys.stdin.buffer.readline", "readline", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "n, a = list(map(int, readline().split()))", "n", "list(map(int, readline().split()))", "list", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "a", "x = list(map(int, readline().split()))", "x", "list(map(int, readline().split()))", "list", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "for i in range(n):\n x[i] -= a\n ", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "ls = [0] * 5010", "ls", "[0] * 5010", "[0]", "0", "5010", "ls[2500] = 1", "ls[2500]", "ls", "2500", "1", "for v in x:\n if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n ", "v", "x", "if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n ", "v == 0", "v", "0", "for i in range(5010):\n ls[i+v] += ls[i]\n ", "i", "range(5010)", "range", "5010", "ls[i+v] += ls[i]", "ls[i+v]", "ls", "i+v", "i", "v", "ls[i]", "ls", "i", "elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n ", "v > 0", "v", "0", "for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n ", "i", "range(5009 - v, -1, -1)", "range", "5009 - v", "5009", "v", "-1", "-1", "ls[i+v] += ls[i]", "ls[i+v]", "ls", "i+v", "i", "v", "ls[i]", "ls", "i", "elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n ", "v < 0", "v", "0", "for i in range(5009 + v):\n ls[i+v] += ls[i]\n ", "i", "range(5009 + v)", "range", "5009 + v", "5009", "v", "ls[i+v] += ls[i]", "ls[i+v]", "ls", "i+v", "i", "v", "ls[i]", "ls", "i", "print(ls[2500] - 1)", "print", "ls[2500] - 1", "ls[2500]", "ls", "2500", "1", "if __name__ == '__main__':\n solve()", "__name__ == '__main__'", "__name__", "'__main__'", "solve()", "solve", "def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, a = list(map(int, readline().split()))\n x = list(map(int, readline().split()))\n for i in range(n):\n x[i] -= a\n ls = [0] * 5010\n ls[2500] = 1\n for v in x:\n if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n print(ls[2500] - 1)", "def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, a = list(map(int, readline().split()))\n x = list(map(int, readline().split()))\n for i in range(n):\n x[i] -= a\n ls = [0] * 5010\n ls[2500] = 1\n for v in x:\n if v == 0:\n for i in range(5010):\n ls[i+v] += ls[i]\n elif v > 0:\n for i in range(5009 - v, -1, -1):\n ls[i+v] += ls[i]\n elif v < 0:\n for i in range(5009 + v):\n ls[i+v] += ls[i]\n print(ls[2500] - 1)", "solve" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 4, 13, 2, 13, 39, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 2, 2, 13, 13, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 17, 14, 2, 2, 13, 17, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 2, 2, 2, 13, 17, 40, 13, 17, 40, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 4, 13, 4, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 191, 2 ], [ 191, 11 ], [ 182, 13 ], [ 179, 25 ], [ 183, 29 ], [ 194, 31 ], [ 180, 35 ], [ 183, 35 ], [ 41, 40 ], [ 192, 44 ], [ 185, 49 ], [ 53, 52 ], [ 192, 56 ], [ 60, 59 ], [ 52, 63 ], [ 67, 66 ], [ 192, 71 ], [ 195, 72 ], [ 52, 78 ], [ 59, 79 ], [ 66, 80 ], [ 90, 83 ], [ 186, 86 ], [ 52, 87 ], [ 59, 88 ], [ 66, 89 ], [ 52, 94 ], [ 66, 97 ], [ 180, 99 ], [ 183, 99 ], [ 52, 100 ], [ 109, 102 ], [ 186, 105 ], [ 52, 106 ], [ 59, 107 ], [ 66, 108 ], [ 186, 112 ], [ 52, 114 ], [ 59, 116 ], [ 66, 117 ], [ 52, 122 ], [ 59, 125 ], [ 66, 128 ], [ 180, 130 ], [ 183, 130 ], [ 52, 131 ], [ 140, 133 ], [ 186, 136 ], [ 52, 137 ], [ 59, 138 ], [ 66, 139 ], [ 186, 144 ], [ 52, 146 ], [ 59, 148 ], [ 66, 149 ], [ 186, 153 ], [ 52, 155 ], [ 59, 158 ], [ 66, 161 ], [ 180, 163 ], [ 183, 163 ], [ 52, 164 ], [ 186, 172 ], [ 192, 173 ], [ 189, 177 ], [ 179, 180 ], [ 182, 183 ], [ 185, 186 ], [ 191, 189 ], [ 191, 192 ], [ 194, 195 ] ]

[ "n, a = map(int, input().split())\nns = list(map(int, input().split()))\nns = [0] + ns\nma = max(ns+[a])\ndp = [[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)]\nfor i in range(n+1):\n for j in range(i+1):\n for k in range(n * ma+1):\n if i == j == k == 0:\n dp[i][j][k] = 1\n elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]\nprint(sum(dp[n][i][i*a] for i in range(1, n+1)))\n", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "ns = list(map(int, input().split()))", "ns", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ns = [0] + ns", "ns", "[0] + ns", "[0]", "0", "ns", "ma = max(ns+[a])", "ma", "max(ns+[a])", "max", "ns+[a]", "ns", "[a]", "a", "[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "[[0] * (ma * n+1) for i in range(n+1)]", "dp = [[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)]", "dp", "[[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)]", "for i in range(n+1):\n for j in range(i+1):\n for k in range(n * ma+1):\n if i == j == k == 0:\n dp[i][j][k] = 1\n elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "i", "range(n+1)", "range", "n+1", "n", "1", "for j in range(i+1):\n for k in range(n * ma+1):\n if i == j == k == 0:\n dp[i][j][k] = 1\n elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(n * ma+1):\n if i == j == k == 0:\n dp[i][j][k] = 1\n elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "k", "range(n * ma+1)", "range", "n * ma+1", "n * ma", "n", "ma", "1", "if i == j == k == 0:\n dp[i][j][k] = 1\n elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "i == j == k == 0", "i == j == k", "i == j", "i", "j", "k", "0", "dp[i][j][k] = 1", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "1", "elif i > 0 and k < ns[i]:\n dp[i][j][k] = dp[i - 1][j][k]\n ", "i > 0 and k < ns[i]", "i > 0", "i", "0", "k < ns[i]", "k", "ns[i]", "ns", "i", "dp[i][j][k] = dp[i - 1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "elif i > 0 and j >= 1 and k >= ns[i]:\n dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "i > 0 and j >= 1 and k >= ns[i]", "i > 0 and j >= 1", "i > 0", "i", "0", "j >= 1", "j", "1", "k >= ns[i]", "k", "ns[i]", "ns", "i", "dp[i][j][k] = dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i - 1][j][k] + dp[i - 1][j - 1][k - ns[i]]", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "dp[i - 1][j - 1][k - ns[i]]", "[j - 1]", "[i - 1]", "dp", "i - 1", "i", "1", "j - 1", "j", "1", "k - ns[i]", "k", "ns[i]", "ns", "i", "print(sum(dp[n][i][i*a] for i in range(1, n+1)))", "print", "sum(dp[n][i][i*a] for i in range(1, n+1))", "sum", "dp[n][i][i*a]", "[i]", "[n]", "dp", "n", "i", "i*a", "i", "a", "ns = [0] + ns", "[0] + ns", "ns", "ns = list(map(int, input().split()))", "list(map(int, input().split()))", "ns", "dp = [[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)]", "[[[0] * (ma * n+1) for i in range(n+1)] for i in range(n+1)]", "dp", "a = map(int, input().split())", "map(int, input().split())", "a", "n, a = map(int, input().split())", "map(int, input().split())", "n", "ma = max(ns+[a])", "max(ns+[a])", "ma" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 0, 13, 4, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 28, 13, 4, 13, 13, 17, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 13, 13, 9, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 28, 13, 4, 13, 13, 0, 13, 18, 18, 13, 2, 13, 17, 2, 2, 13, 17, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 116, 2 ], [ 116, 11 ], [ 107, 13 ], [ 119, 25 ], [ 122, 28 ], [ 111, 36 ], [ 117, 37 ], [ 45, 40 ], [ 123, 42 ], [ 48, 47 ], [ 108, 47 ], [ 51, 50 ], [ 111, 53 ], [ 58, 57 ], [ 111, 62 ], [ 117, 63 ], [ 47, 67 ], [ 57, 68 ], [ 76, 71 ], [ 123, 73 ], [ 50, 74 ], [ 57, 75 ], [ 123, 78 ], [ 50, 80 ], [ 57, 83 ], [ 47, 84 ], [ 87, 86 ], [ 111, 89 ], [ 113, 91 ], [ 123, 94 ], [ 86, 96 ], [ 86, 100 ], [ 117, 102 ], [ 114, 105 ], [ 120, 105 ], [ 107, 108 ], [ 116, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ] ]

[ "n, a = map(int, input().split())\nl = list(map(int, input().split()))\nans = 0\ndp = list([0]*(n*a+1) for _ in range(n+1))#動的計画法で解く\ndp[0][0] = 1\nfor x in l:\n for i in range(n, 0, -1):#下行から順に格納していく(上からだと格納したばかりの値が参照されてしまう)\n for j in range(n*a+1):\n if x > j:\n continue\n dp[i][j] += dp[i-1][j-x]\n\nfor i in range(n):\n ans += dp[i+1][(i+1)*a]\n\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 0", "ans", "0", "dp = list([0]*(n*a+1) for _ in range(n+1))", "dp", "list([0]*(n*a+1) for _ in range(n+1))", "list", "[0]*(n*a+1)", "[0]", "0", "n*a+1", "n*a", "n", "a", "1", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for x in l:\n for i in range(n, 0, -1):#下行から順に格納していく(上からだと格納したばかりの値が参照されてしまう)\n for j in range(n*a+1):\n if x > j:\n continue\n dp[i][j] += dp[i-1][j-x]", "x", "l", "for i in range(n, 0, -1):#下行から順に格納していく(上からだと格納したばかりの値が参照されてしまう)\n for j in range(n*a+1):\n if x > j:\n continue\n dp[i][j] += dp[i-1][j-x]", "i", "range(n, 0, -1)", "range", "n", "0", "-1", "for j in range(n*a+1):\n if x > j:\n continue\n dp[i][j] += dp[i-1][j-x]", "j", "range(n*a+1)", "range", "n*a+1", "n*a", "n", "a", "1", "if x > j:\n continue\n ", "x > j", "x", "j", "continue", "dp[i][j] += dp[i-1][j-x]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j-x]", "[i-1]", "dp", "i-1", "i", "1", "j-x", "j", "x", "for i in range(n):\n ans += dp[i+1][(i+1)*a]", "i", "range(n)", "range", "n", "ans += dp[i+1][(i+1)*a]", "ans", "dp[i+1][(i+1)*a]", "[i+1]", "dp", "i+1", "i", "1", "(i+1)*a", "i+1", "i", "1", "a", "print(ans)", "print", "ans", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l", "n, a = map(int, input().split())", "map(int, input().split())", "n", "ans += dp[i+1][(i+1)*a]", "dp[i+1][(i+1)*a]", "ans", "a = map(int, input().split())", "map(int, input().split())", "a", "ans = 0", "0", "ans", "dp = list([0]*(n*a+1) for _ in range(n+1))", "list([0]*(n*a+1) for _ in range(n+1))", "dp" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 4, 18, 13, 13, 17, 15, 15, 15, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 40, 2, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 2, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 18, 13 ]

[ [ 204, 4 ], [ 201, 11 ], [ 195, 16 ], [ 34, 33 ], [ 205, 40 ], [ 34, 42 ], [ 45, 44 ], [ 205, 53 ], [ 58, 57 ], [ 33, 61 ], [ 67, 66 ], [ 70, 69 ], [ 33, 73 ], [ 83, 76 ], [ 66, 79 ], [ 69, 80 ], [ 86, 85 ], [ 33, 88 ], [ 91, 90 ], [ 44, 92 ], [ 85, 93 ], [ 96, 95 ], [ 33, 100 ], [ 104, 103 ], [ 33, 108 ], [ 42, 109 ], [ 103, 114 ], [ 90, 115 ], [ 127, 118 ], [ 66, 121 ], [ 85, 123 ], [ 95, 125 ], [ 103, 126 ], [ 66, 131 ], [ 85, 132 ], [ 95, 133 ], [ 103, 134 ], [ 66, 138 ], [ 85, 139 ], [ 95, 141 ], [ 103, 144 ], [ 90, 145 ], [ 156, 147 ], [ 66, 150 ], [ 85, 152 ], [ 95, 154 ], [ 103, 155 ], [ 66, 159 ], [ 85, 160 ], [ 95, 161 ], [ 103, 162 ], [ 165, 164 ], [ 168, 167 ], [ 33, 172 ], [ 176, 175 ], [ 66, 179 ], [ 167, 181 ], [ 167, 183 ], [ 42, 184 ], [ 175, 187 ], [ 164, 187 ], [ 199, 193 ], [ 195, 196 ], [ 201, 202 ], [ 204, 205 ] ]

[ "import sys\ninput = sys.stdin.readline\nINF = 10**10\nMOD = 10**9 + 7\nsys.setrecursionlimit(100000000)\nfrom functools import lru_cache\nfrom itertools import permutations\nfrom math import factorial\n\n\ndef main():\n n,a = map(int,input().split())\n x = list(map(int,input().split()))\n dp = [[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n for i in range(n + 1):\n dp[i][0][0] = 1\n\n for i in range(n):\n num = x[i]\n for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ans = 0\n for i in range(1,n + 1):\n ans += dp[-1][i][i * a]\n print(ans)\n \n\nif __name__=='__main__':\n main() ", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "INF = 10**10", "INF", "10**10", "10", "10", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "sys.setrecursionlimit(100000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "100000000", "from functools import lru_cache", "from itertools import permutations", "from math import factorial", "def main():\n n,a = map(int,input().split())\n x = list(map(int,input().split()))\n dp = [[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n for i in range(n + 1):\n dp[i][0][0] = 1\n\n for i in range(n):\n num = x[i]\n for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ans = 0\n for i in range(1,n + 1):\n ans += dp[-1][i][i * a]\n print(ans)\n ", "main", "n,a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[[0] * (n * a + 1) for _ in range(n + 1)]", "dp = [[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "[[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "for i in range(n + 1):\n dp[i][0][0] = 1\n\n ", "i", "range(n + 1)", "range", "n + 1", "n", "1", "dp[i][0][0] = 1", "dp[i][0][0]", "[0]", "[i]", "dp", "i", "0", "0", "1", "for i in range(n):\n num = x[i]\n for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ", "i", "range(n)", "range", "n", "num = x[i]", "num", "x[i]", "x", "i", "for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ", "j", "range(1,n + 1)", "range", "1", "n + 1", "n", "1", "for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ", "s", "range(n * a + 1)", "range", "n * a + 1", "n * a", "n", "a", "1", "if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ", "s - num >= 0", "s - num", "s", "num", "0", "dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]", "dp[i + 1][j][s]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "s", "dp[i][j][s] + dp[i][j - 1][s - num]", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "dp[i][j - 1][s - num]", "[j - 1]", "[i]", "dp", "i", "j - 1", "j", "1", "s - num", "s", "num", "dp[i + 1][j][s] = dp[i][j][s]", "dp[i + 1][j][s]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "s", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "ans = 0", "ans", "0", "for i in range(1,n + 1):\n ans += dp[-1][i][i * a]\n ", "i", "range(1,n + 1)", "range", "1", "n + 1", "n", "1", "ans += dp[-1][i][i * a]", "ans", "dp[-1][i][i * a]", "[i]", "[-1]", "dp", "-1", "i", "i * a", "i", "a", "print(ans)", "print", "ans", "if __name__=='__main__':\n main() ", "__name__=='__main__'", "__name__", "'__main__'", "main()", "main", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "def main():\n n,a = map(int,input().split())\n x = list(map(int,input().split()))\n dp = [[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n for i in range(n + 1):\n dp[i][0][0] = 1\n\n for i in range(n):\n num = x[i]\n for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ans = 0\n for i in range(1,n + 1):\n ans += dp[-1][i][i * a]\n print(ans)\n ", "def main():\n n,a = map(int,input().split())\n x = list(map(int,input().split()))\n dp = [[[0] * (n * a + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n for i in range(n + 1):\n dp[i][0][0] = 1\n\n for i in range(n):\n num = x[i]\n for j in range(1,n + 1):\n for s in range(n * a + 1):\n if s - num >= 0:\n dp[i + 1][j][s] = dp[i][j][s] + dp[i][j - 1][s - num]\n else:\n dp[i + 1][j][s] = dp[i][j][s]\n \n ans = 0\n for i in range(1,n + 1):\n ans += dp[-1][i][i * a]\n print(ans)\n ", "main", "INF = 10**10", "10**10", "INF", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 15, 13, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 13, 0, 13, 2, 39, 17, 4, 13, 13, 28, 13, 4, 13, 4, 13, 13, 0, 18, 13, 13, 2, 18, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 2, 17, 13, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 40, 13, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 14, 2, 40, 13, 17, 2, 2, 2, 13, 18, 13, 2, 13, 17, 2, 40, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 14, 2, 40, 13, 17, 40, 40, 2, 40, 13, 13, 2, 13, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 12, 13 ]

[ [ 26, 25 ], [ 276, 31 ], [ 35, 35 ], [ 269, 44 ], [ 284, 49 ], [ 293, 56 ], [ 276, 58 ], [ 293, 59 ], [ 290, 61 ], [ 261, 63 ], [ 287, 65 ], [ 291, 70 ], [ 294, 71 ], [ 278, 73 ], [ 291, 79 ], [ 82, 81 ], [ 291, 86 ], [ 91, 88 ], [ 279, 89 ], [ 81, 90 ], [ 291, 93 ], [ 81, 94 ], [ 294, 95 ], [ 99, 98 ], [ 282, 102 ], [ 282, 112 ], [ 288, 113 ], [ 296, 116 ], [ 120, 119 ], [ 282, 123 ], [ 127, 126 ], [ 282, 131 ], [ 288, 132 ], [ 282, 135 ], [ 288, 136 ], [ 119, 141 ], [ 126, 144 ], [ 152, 147 ], [ 297, 149 ], [ 119, 150 ], [ 126, 151 ], [ 119, 156 ], [ 126, 161 ], [ 279, 163 ], [ 119, 165 ], [ 282, 169 ], [ 288, 170 ], [ 126, 173 ], [ 279, 175 ], [ 119, 177 ], [ 282, 180 ], [ 288, 181 ], [ 188, 183 ], [ 297, 185 ], [ 119, 186 ], [ 126, 187 ], [ 297, 190 ], [ 119, 192 ], [ 126, 194 ], [ 119, 198 ], [ 282, 204 ], [ 288, 205 ], [ 126, 207 ], [ 279, 209 ], [ 119, 211 ], [ 282, 214 ], [ 288, 215 ], [ 222, 217 ], [ 297, 219 ], [ 119, 220 ], [ 126, 221 ], [ 297, 225 ], [ 119, 227 ], [ 126, 229 ], [ 297, 232 ], [ 119, 234 ], [ 126, 237 ], [ 279, 239 ], [ 119, 241 ], [ 249, 244 ], [ 297, 246 ], [ 119, 247 ], [ 126, 248 ], [ 297, 255 ], [ 282, 256 ], [ 269, 270 ], [ 278, 279 ], [ 293, 282 ], [ 284, 285 ], [ 287, 288 ], [ 290, 291 ], [ 293, 294 ], [ 296, 297 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom heapq import heappush, heappop\nfrom functools import reduce, lru_cache\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef TUPLE(): return tuple(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7 \n#mod = 998244353\n#from decimal import *\n#import numpy as np\n#decimal.getcontext().prec = 10\n\nN, A = MAP()\nx = LIST()\n\nX = max(max(x), A)\n\ny = [0]*len(x)\nfor i in range(len(x)):\n\ty[i] = x[i]-A\n\ndp = [[0]*(2*N*X+1) for _ in range(N+1)] #dp[j][t] = y1...yj から0枚以上選んで合計がt-N*Xにするような選び方\n\nfor j in range(N+1):\n\tfor t in range(-N*X, N*X+1):\n\t\tif j == 0 and t == 0:\n\t\t\tdp[j][t] = 1\n\t\telif j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X):\n\t\t\tdp[j][t] = dp[j-1][t]\n\t\telif j >= 1 and -N*X <= t-y[j-1] <= N*X:\n\t\t\tdp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]\n\t\telse:\n\t\t\tdp[j][t] = 0\n\nprint(dp[N][0]-1)\n", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd", "from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left, insort, insort_left", "from heapq import heappush, heappop", "from functools import reduce, lru_cache", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "def TUPLE(): return tuple(map(int, input().split()))", "TUPLE", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, A = MAP()", "N", "MAP()", "MAP", "A", "x = LIST()", "x", "LIST()", "LIST", "X = max(max(x), A)", "X", "max(max(x), A)", "max", "max(x)", "max", "x", "A", "y = [0]*len(x)", "y", "[0]*len(x)", "[0]", "0", "len(x)", "len", "x", "for i in range(len(x)):\n\ty[i] = x[i]-A", "i", "range(len(x))", "range", "len(x)", "len", "x", "y[i] = x[i]-A", "y[i]", "y", "i", "x[i]-A", "x[i]", "x", "i", "A", "[0]*(2*N*X+1) for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0]*(2*N*X+1)", "[0]", "0", "2*N*X+1", "2*N*X", "2*N", "2", "N", "X", "1", "dp = [[0]*(2*N*X+1) for _ in range(N+1)]", "dp", "[[0]*(2*N*X+1) for _ in range(N+1)]", "for j in range(N+1):\n\tfor t in range(-N*X, N*X+1):\n\t\tif j == 0 and t == 0:\n\t\t\tdp[j][t] = 1\n\t\telif j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X):\n\t\t\tdp[j][t] = dp[j-1][t]\n\t\telif j >= 1 and -N*X <= t-y[j-1] <= N*X:\n\t\t\tdp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]\n\t\telse:\n\t\t\tdp[j][t] = 0", "j", "range(N+1)", "range", "N+1", "N", "1", "for t in range(-N*X, N*X+1):\n\t\tif j == 0 and t == 0:\n\t\t\tdp[j][t] = 1\n\t\telif j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X):\n\t\t\tdp[j][t] = dp[j-1][t]\n\t\telif j >= 1 and -N*X <= t-y[j-1] <= N*X:\n\t\t\tdp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]\n\t\telse:\n\t\t\tdp[j][t] = 0", "t", "range(-N*X, N*X+1)", "range", "-N*X", "-N", "N", "X", "N*X+1", "N*X", "N", "X", "1", "if j == 0 and t == 0:\n\t\t\tdp[j][t] = 1\n\t\telif j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X):\n\t\t\tdp[j][t] = dp[j-1][t]\n\t\telif j >= 1 and -N*X <= t-y[j-1] <= N*X:\n\t\t\tdp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]\n\t\telse:\n\t\t\tdp[j][t] = 0", "j == 0 and t == 0", "j == 0", "j", "0", "t == 0", "t", "0", "dp[j][t] = 1", "dp[j][t]", "[j]", "dp", "j", "t", "1", "elif j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X):\n\t\t\tdp[j][t] = dp[j-1][t]\n\t\t", "j >= 1 and (t-y[j-1] < -N*X or t-y[j-1] > N*X)", "j >= 1", "j", "1", "t-y[j-1] < -N*X or t-y[j-1] > N*X", "t-y[j-1] < -N*X", "t-y[j-1]", "t", "y[j-1]", "y", "j-1", "j", "1", "-N*X", "-N", "N", "X", "t-y[j-1] > N*X", "t-y[j-1]", "t", "y[j-1]", "y", "j-1", "j", "1", "N*X", "N", "X", "dp[j][t] = dp[j-1][t]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j-1][t]", "[j-1]", "dp", "j-1", "j", "1", "t", "elif j >= 1 and -N*X <= t-y[j-1] <= N*X:\n\t\t\tdp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]\n\t\t", "j >= 1 and -N*X <= t-y[j-1] <= N*X", "j >= 1", "j", "1", "-N*X <= t-y[j-1] <= N*X", "-N*X <= t-y[j-1]", "-N*X", "-N", "N", "X", "t-y[j-1]", "t", "y[j-1]", "y", "j-1", "j", "1", "N*X", "N", "X", "dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j-1][t] + dp[j-1][t-y[j-1]]", "dp[j-1][t]", "[j-1]", "dp", "j-1", "j", "1", "t", "dp[j-1][t-y[j-1]]", "[j-1]", "dp", "j-1", "j", "1", "t-y[j-1]", "t", "y[j-1]", "y", "j-1", "j", "1", "dp[j][t] = 0", "dp[j][t]", "[j]", "dp", "j", "t", "0", "print(dp[N][0]-1)", "print", "dp[N][0]-1", "dp[N][0]", "[N]", "dp", "N", "0", "1", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "INF = float('inf')", "float('inf')", "INF", "def TUPLE(): return tuple(map(int, input().split()))", "def TUPLE(): return tuple(map(int, input().split()))", "TUPLE", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "y = [0]*len(x)", "[0]*len(x)", "y", "N, A = MAP()", "MAP()", "N", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "X = max(max(x), A)", "max(max(x), A)", "X", "x = LIST()", "LIST()", "x", "A = MAP()", "MAP()", "A", "dp = [[0]*(2*N*X+1) for _ in range(N+1)]", "[[0]*(2*N*X+1) for _ in range(N+1)]", "dp", "def INT(): return int(input())", "def INT(): return int(input())", "INT" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 21, 22, 17, 17, 28, 13, 13, 28, 13, 13, 4, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 2, 4, 18, 13, 13, 2, 13, 13, 17, 13, 4, 13, 2, 18, 13, 17, 17, 10, 13, 13, 10, 21, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 89, 2 ], [ 89, 11 ], [ 83, 13 ], [ 27, 26 ], [ 84, 26 ], [ 26, 30 ], [ 90, 31 ], [ 77, 33 ], [ 80, 36 ], [ 43, 42 ], [ 78, 42 ], [ 84, 42 ], [ 81, 51 ], [ 59, 54 ], [ 81, 55 ], [ 42, 57 ], [ 81, 62 ], [ 42, 65 ], [ 81, 73 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 89, 87 ], [ 89, 90 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nx = [i - a for i in x]\ndic = {0:1}\nfor i in x:\n for j, k in list(dic.items()):\n dic[i+j] = dic.get(i+j, 0) + k\n\nprint(dic[0] - 1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "i - a for i in x", "for i in x", "i", "x", "for i in x", "i - a", "i", "a", "x = [i - a for i in x]", "x", "[i - a for i in x]", "dic = {0:1}", "dic", "{0:1}", "0", "0", "1", "for i in x:\n for j, k in list(dic.items()):\n dic[i+j] = dic.get(i+j, 0) + k", "i", "x", "for j, k in list(dic.items()):\n dic[i+j] = dic.get(i+j, 0) + k", "j", "k", "list(dic.items())", "list", "dic.items()", "dic.items", "dic", "items", "dic[i+j] = dic.get(i+j, 0) + k", "dic[i+j]", "dic", "i+j", "i", "j", "dic.get(i+j, 0) + k", "dic.get(i+j, 0)", "dic.get", "dic", "get", "i+j", "i", "j", "0", "k", "print(dic[0] - 1)", "print", "dic[0] - 1", "dic[0]", "dic", "0", "1", "x = [i - a for i in x]", "[i - a for i in x]", "x", "dic = {0:1}", "{0:1}", "dic", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 0, 13, 21, 22, 17, 17, 28, 13, 13, 28, 13, 13, 4, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 2, 4, 18, 13, 13, 2, 13, 13, 17, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 21, 13 ]

[ [ 75, 2 ], [ 75, 11 ], [ 78, 13 ], [ 76, 23 ], [ 81, 31 ], [ 38, 37 ], [ 79, 37 ], [ 82, 46 ], [ 54, 49 ], [ 82, 50 ], [ 37, 52 ], [ 82, 57 ], [ 37, 60 ], [ 82, 68 ], [ 75, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ] ]

[ "N, A = map(int, input().split())\nX = list(map(lambda x: int(x) - A, input().split()))\n\nd = {0: 1}\n\nfor cur in X:\n for k, v in list(d.items()):\n d[cur + k] = d.get(cur + k, 0) + v\n \nprint(d[0]-1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(lambda x: int(x) - A, input().split()))", "X", "list(map(lambda x: int(x) - A, input().split()))", "list", "map(lambda x: int(x) - A, input().split())", "map", "lambda x: int(x) - A", "int(x) - A", "int(x)", "int", "x", "A", "x", "input().split()", "().split", "()", "input", "split", "d = {0: 1}", "d", "{0: 1}", "0", "0", "1", "for cur in X:\n for k, v in list(d.items()):\n d[cur + k] = d.get(cur + k, 0) + v\n ", "cur", "X", "for k, v in list(d.items()):\n d[cur + k] = d.get(cur + k, 0) + v\n ", "k", "v", "list(d.items())", "list", "d.items()", "d.items", "d", "items", "d[cur + k] = d.get(cur + k, 0) + v", "d[cur + k]", "d", "cur + k", "cur", "k", "d.get(cur + k, 0) + v", "d.get(cur + k, 0)", "d.get", "d", "get", "cur + k", "cur", "k", "0", "v", "print(d[0]-1)", "print", "d[0]-1", "d[0]", "d", "0", "1", "N, A = map(int, input().split())", "map(int, input().split())", "N", "A = map(int, input().split())", "map(int, input().split())", "A", "X = list(map(lambda x: int(x) - A, input().split()))", "list(map(lambda x: int(x) - A, input().split()))", "X", "d = {0: 1}", "{0: 1}", "d" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 4, 18, 13, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 21, 22, 17, 17, 28, 13, 13, 28, 13, 13, 4, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 2, 4, 18, 13, 13, 2, 13, 13, 17, 13, 4, 13, 2, 18, 13, 17, 17, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 21, 13 ]

[ [ 93, 2 ], [ 93, 11 ], [ 15, 14 ], [ 14, 23 ], [ 84, 25 ], [ 85, 29 ], [ 34, 33 ], [ 85, 33 ], [ 33, 37 ], [ 88, 38 ], [ 90, 40 ], [ 96, 43 ], [ 50, 49 ], [ 91, 49 ], [ 85, 49 ], [ 97, 58 ], [ 66, 61 ], [ 97, 62 ], [ 49, 64 ], [ 97, 69 ], [ 49, 72 ], [ 97, 80 ], [ 84, 85 ], [ 93, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ] ]

[ "N, A = map(int, input().split())\nx = [int(i) for i in input().split()]\n\nx.sort()\nx = [i - A for i in x]\nD = {0 : 1}\nfor i in x :\n for j, k in list(D.items()) :\n D[i+j] = D.get(i+j, 0) + k\n\nprint(D[0] - 1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "x = [int(i) for i in input().split()]", "x", "[int(i) for i in input().split()]", "x.sort()", "x.sort", "x", "sort", "i - A for i in x", "for i in x", "i", "x", "for i in x", "i - A", "i", "A", "x = [i - A for i in x]", "x", "[i - A for i in x]", "D = {0 : 1}", "D", "{0 : 1}", "0", "0", "1", "for i in x :\n for j, k in list(D.items()) :\n D[i+j] = D.get(i+j, 0) + k", "i", "x", "for j, k in list(D.items()) :\n D[i+j] = D.get(i+j, 0) + k", "j", "k", "list(D.items())", "list", "D.items()", "D.items", "D", "items", "D[i+j] = D.get(i+j, 0) + k", "D[i+j]", "D", "i+j", "i", "j", "D.get(i+j, 0) + k", "D.get(i+j, 0)", "D.get", "D", "get", "i+j", "i", "j", "0", "k", "print(D[0] - 1)", "print", "D[0] - 1", "D[0]", "D", "0", "1", "x = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "x", "A = map(int, input().split())", "map(int, input().split())", "A", "x = [i - A for i in x]", "[i - A for i in x]", "x", "N, A = map(int, input().split())", "map(int, input().split())", "N", "D = {0 : 1}", "{0 : 1}", "D" ]

[ 7, 15, 13, 15, 0, 13, 18, 18, 13, 13, 13, 0, 13, 17, 0, 13, 39, 0, 13, 17, 12, 13, 41, 14, 2, 13, 4, 13, 13, 14, 2, 40, 13, 17, 2, 13, 2, 13, 13, 29, 17, 29, 17, 0, 13, 17, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 4, 13, 2, 13, 17, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 4, 13, 0, 13, 17, 13, 12, 13, 41, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 4, 13, 4, 13, 17, 17, 17, 14, 2, 13, 17, 4, 13, 10, 39, 13, 10, 18, 13, 10, 12, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13 ]

[ [ 138, 5 ], [ 144, 12 ], [ 135, 15 ], [ 147, 18 ], [ 151, 21 ], [ 80, 21 ], [ 73, 25 ], [ 75, 32 ], [ 77, 35 ], [ 75, 37 ], [ 148, 38 ], [ 45, 44 ], [ 48, 47 ], [ 73, 51 ], [ 75, 54 ], [ 77, 57 ], [ 73, 60 ], [ 63, 62 ], [ 73, 66 ], [ 75, 68 ], [ 77, 69 ], [ 62, 71 ], [ 47, 71 ], [ 44, 71 ], [ 73, 73 ], [ 75, 75 ], [ 77, 77 ], [ 151, 79 ], [ 80, 79 ], [ 85, 84 ], [ 151, 86 ], [ 80, 86 ], [ 93, 92 ], [ 139, 96 ], [ 92, 101 ], [ 104, 103 ], [ 104, 105 ], [ 109, 108 ], [ 139, 112 ], [ 108, 117 ], [ 120, 119 ], [ 151, 124 ], [ 142, 133 ], [ 135, 136 ], [ 138, 139 ], [ 144, 145 ], [ 147, 148 ], [ 151, 151 ], [ 80, 151 ] ]

[ "import sys\nfrom functools import lru_cache\n\ninput = sys.stdin.readline\n\n\nans = 0\nX = []\nA = 0\n\n@lru_cache(maxsize=None)\ndef solve(i, selected, total):\n global X, ans\n\n if i == len(X):\n if selected != 0 and total == (selected * A):\n return 1\n return 0\n\n ret = 0\n ret += solve(i + 1, selected + 1, total + X[i])\n ret += solve(i + 1, selected, total)\n return ret\n\n\ndef main():\n global X, ans, A\n N, A = [int(x) for x in input().split()]\n X = [int(x) for x in input().split()]\n\n print(solve(0, 0, 0))\n\n \nif __name__ == '__main__':\n main()", "import sys", "sys", "from functools import lru_cache", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "ans = 0", "ans", "0", "X = []", "X", "[]", "A = 0", "A", "0", "def solve(i, selected, total):\n global X, ans\n\n if i == len(X):\n if selected != 0 and total == (selected * A):\n return 1\n return 0\n\n ret = 0\n ret += solve(i + 1, selected + 1, total + X[i])\n ret += solve(i + 1, selected, total)\n return ret", "solve", "global X, ans", "if i == len(X):\n if selected != 0 and total == (selected * A):\n return 1\n return 0\n\n ", "i == len(X)", "i", "len(X)", "len", "X", "if selected != 0 and total == (selected * A):\n return 1\n ", "selected != 0 and total == (selected * A)", "selected != 0", "selected", "0", "total == (selected * A)", "total", "selected * A", "selected", "A", "return 1", "1", "return 0", "0", "ret = 0", "ret", "0", "ret += solve(i + 1, selected + 1, total + X[i])", "ret", "solve(i + 1, selected + 1, total + X[i])", "solve", "i + 1", "i", "1", "selected + 1", "selected", "1", "total + X[i]", "total", "X[i]", "X", "i", "ret += solve(i + 1, selected, total)", "ret", "solve(i + 1, selected, total)", "solve", "i + 1", "i", "1", "selected", "total", "return ret", "ret", "i", "i", "selected", "selected", "total", "total", "@lru_cache(maxsize=None)", "solve", "maxsize=None", "@lru_cache(maxsize=None)", "lru_cache", "maxsize=None", "maxsize", "None", "solve", "def main():\n global X, ans, A\n N, A = [int(x) for x in input().split()]\n X = [int(x) for x in input().split()]\n\n print(solve(0, 0, 0))\n\n ", "main", "global X, ans, A", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "N, A = [int(x) for x in input().split()]", "N", "[int(x) for x in input().split()]", "A", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "X = [int(x) for x in input().split()]", "X", "[int(x) for x in input().split()]", "print(solve(0, 0, 0))", "print", "solve(0, 0, 0)", "solve", "0", "0", "0", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "X = []", "[]", "X", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n global X, ans, A\n N, A = [int(x) for x in input().split()]\n X = [int(x) for x in input().split()]\n\n print(solve(0, 0, 0))\n\n ", "def main():\n global X, ans, A\n N, A = [int(x) for x in input().split()]\n X = [int(x) for x in input().split()]\n\n print(solve(0, 0, 0))\n\n ", "main", "ans = 0", "0", "ans", "A = 0", "0", "A", "def solve(i, selected, total):\n global X, ans\n\n if i == len(X):\n if selected != 0 and total == (selected * A):\n return 1\n return 0\n\n ret = 0\n ret += solve(i + 1, selected + 1, total + X[i])\n ret += solve(i + 1, selected, total)\n return ret", "def solve(i, selected, total):\n global X, ans\n\n if i == len(X):\n if selected != 0 and total == (selected * A):\n return 1\n return 0\n\n ret = 0\n ret += solve(i + 1, selected + 1, total + X[i])\n ret += solve(i + 1, selected, total)\n return ret", "solve" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 2, 13, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 14, 40, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 4, 13, 4, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 145, 2 ], [ 145, 11 ], [ 148, 13 ], [ 151, 25 ], [ 146, 29 ], [ 143, 30 ], [ 149, 33 ], [ 37, 36 ], [ 146, 40 ], [ 154, 45 ], [ 55, 48 ], [ 155, 51 ], [ 58, 57 ], [ 146, 60 ], [ 63, 62 ], [ 146, 66 ], [ 70, 69 ], [ 152, 73 ], [ 155, 80 ], [ 57, 81 ], [ 62, 82 ], [ 69, 83 ], [ 94, 85 ], [ 155, 88 ], [ 57, 90 ], [ 62, 92 ], [ 69, 93 ], [ 155, 97 ], [ 57, 98 ], [ 62, 99 ], [ 69, 100 ], [ 62, 103 ], [ 146, 104 ], [ 121, 106 ], [ 155, 109 ], [ 57, 111 ], [ 62, 114 ], [ 69, 117 ], [ 149, 119 ], [ 57, 120 ], [ 155, 124 ], [ 57, 125 ], [ 62, 126 ], [ 69, 127 ], [ 155, 135 ], [ 146, 136 ], [ 143, 140 ], [ 145, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ] ]

[ "N, A = map(int, input().split())\nX = list(map(int, input().split()))\nS = max(N * A, sum(X))\nDP = [[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)]\nDP[0][0][0] = 1\nfor i in range(N):\n for j in range(N+1):\n for k in range(S+1):\n if not DP[i][j][k]: continue\n DP[i+1][j][k] += DP[i][j][k]\n if j != N:\n DP[i+1][j+1][k+X[i]] += DP[i][j][k]\nprint(sum(DP[N][j][j*A] for j in range(1, N+1) if j * A <= S))", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "S = max(N * A, sum(X))", "S", "max(N * A, sum(X))", "max", "N * A", "N", "A", "sum(X)", "sum", "X", "[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[[0] * (S+1) for _ in range(N+1)]", "DP = [[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)]", "DP", "[[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)]", "DP[0][0][0] = 1", "DP[0][0][0]", "[0]", "[0]", "DP", "0", "0", "0", "1", "for i in range(N):\n for j in range(N+1):\n for k in range(S+1):\n if not DP[i][j][k]: continue\n DP[i+1][j][k] += DP[i][j][k]\n if j != N:\n DP[i+1][j+1][k+X[i]] += DP[i][j][k]", "i", "range(N)", "range", "N", "for j in range(N+1):\n for k in range(S+1):\n if not DP[i][j][k]: continue\n DP[i+1][j][k] += DP[i][j][k]\n if j != N:\n DP[i+1][j+1][k+X[i]] += DP[i][j][k]", "j", "range(N+1)", "range", "N+1", "N", "1", "for k in range(S+1):\n if not DP[i][j][k]: continue\n DP[i+1][j][k] += DP[i][j][k]\n if j != N:\n DP[i+1][j+1][k+X[i]] += DP[i][j][k]", "k", "range(S+1)", "range", "S+1", "S", "1", "if not DP[i][j][k]: continue\n ", "not DP[i][j][k]", "DP[i][j][k]", "[j]", "[i]", "DP", "i", "j", "k", "DP[i+1][j][k] += DP[i][j][k]", "DP[i+1][j][k]", "[j]", "[i+1]", "DP", "i+1", "i", "1", "j", "k", "DP[i][j][k]", "[j]", "[i]", "DP", "i", "j", "k", "if j != N:\n DP[i+1][j+1][k+X[i]] += DP[i][j][k]", "j != N", "j", "N", "DP[i+1][j+1][k+X[i]] += DP[i][j][k]", "DP[i+1][j+1][k+X[i]]", "[j+1]", "[i+1]", "DP", "i+1", "i", "1", "j+1", "j", "1", "k+X[i]", "k", "X[i]", "X", "i", "DP[i][j][k]", "[j]", "[i]", "DP", "i", "j", "k", "print(sum(DP[N][j][j*A] for j in range(1, N+1) if j * A <= S))", "print", "sum(DP[N][j][j*A] for j in range(1, N+1) if j * A <= S)", "sum", "DP[N][j][j*A]", "[j]", "[N]", "DP", "N", "j", "j*A", "j", "A", "A = map(int, input().split())", "map(int, input().split())", "A", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "S = max(N * A, sum(X))", "max(N * A, sum(X))", "S", "DP = [[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)]", "[[[0] * (S+1) for _ in range(N+1)] for _ in range(N+1)]", "DP" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 4, 13, 4, 13, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 2, 40, 13, 18, 13, 2, 13, 17, 40, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 2, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 198, 2 ], [ 198, 11 ], [ 195, 13 ], [ 207, 25 ], [ 196, 31 ], [ 193, 32 ], [ 199, 33 ], [ 37, 36 ], [ 199, 40 ], [ 204, 45 ], [ 55, 48 ], [ 205, 51 ], [ 58, 57 ], [ 199, 62 ], [ 66, 65 ], [ 199, 70 ], [ 74, 73 ], [ 208, 78 ], [ 73, 82 ], [ 196, 84 ], [ 57, 86 ], [ 96, 89 ], [ 205, 92 ], [ 57, 93 ], [ 65, 94 ], [ 73, 95 ], [ 205, 99 ], [ 57, 101 ], [ 65, 103 ], [ 73, 104 ], [ 73, 108 ], [ 196, 110 ], [ 57, 112 ], [ 65, 115 ], [ 125, 118 ], [ 205, 121 ], [ 57, 122 ], [ 65, 123 ], [ 73, 124 ], [ 205, 129 ], [ 57, 131 ], [ 65, 133 ], [ 73, 134 ], [ 205, 138 ], [ 57, 140 ], [ 65, 143 ], [ 73, 146 ], [ 196, 148 ], [ 57, 150 ], [ 160, 153 ], [ 205, 156 ], [ 57, 157 ], [ 65, 158 ], [ 73, 159 ], [ 201, 162 ], [ 166, 165 ], [ 199, 170 ], [ 189, 173 ], [ 202, 175 ], [ 190, 175 ], [ 205, 179 ], [ 199, 180 ], [ 165, 181 ], [ 165, 183 ], [ 193, 184 ], [ 190, 187 ], [ 202, 187 ], [ 189, 190 ], [ 198, 193 ], [ 195, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ] ]

[ "n,a=map(int,input().split())\nx=list(map(int,input().split()))\n\nxsum=max(max(x),a)*n\ndp=[[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)]\n\ndp[0][0][0]=1\n\nfor j in range(1,n+1):\n for k in range(0,n+1): \n for s in range(0,xsum+1): \n if s<x[j-1] :\n dp[j][k][s]=dp[j-1][k][s]\n elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s]=0\ndsum=0\nfor k in range(1,n+1):\n dsum=dsum+dp[n][k][k*a]\nprint(dsum)\n ", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "xsum=max(max(x),a)*n", "xsum", "max(max(x),a)*n", "max(max(x),a)", "max", "max(x)", "max", "x", "a", "n", "[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)", "for ii in range(n+1)", "ii", "range(n+1)", "range", "n+1", "n", "1", "for ii in range(n+1)", "[[0]*(xsum+1) for i in range(n+1)]", "dp=[[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)]", "dp", "[[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for j in range(1,n+1):\n for k in range(0,n+1): \n for s in range(0,xsum+1): \n if s<x[j-1] :\n dp[j][k][s]=dp[j-1][k][s]\n elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s]=0", "j", "range(1,n+1)", "range", "1", "n+1", "n", "1", "for k in range(0,n+1): \n for s in range(0,xsum+1): \n if s<x[j-1] :\n dp[j][k][s]=dp[j-1][k][s]\n elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s]=0", "k", "range(0,n+1)", "range", "0", "n+1", "n", "1", "for s in range(0,xsum+1): \n if s<x[j-1] :\n dp[j][k][s]=dp[j-1][k][s]\n elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s]=0", "s", "range(0,xsum+1)", "range", "0", "xsum+1", "xsum", "1", "if s<x[j-1] :\n dp[j][k][s]=dp[j-1][k][s]\n elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s]=0", "s<x[j-1]", "s", "x[j-1]", "x", "j-1", "j", "1", "dp[j][k][s]=dp[j-1][k][s]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "s", "elif s>=x[j-1] and k>=1:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]\n ", "s>=x[j-1] and k>=1", "s>=x[j-1]", "s", "x[j-1]", "x", "j-1", "j", "1", "k>=1", "k", "1", "dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "s", "dp[j-1][k-1][s-x[j-1]]", "[k-1]", "[j-1]", "dp", "j-1", "j", "1", "k-1", "k", "1", "s-x[j-1]", "s", "x[j-1]", "x", "j-1", "j", "1", "dp[j][k][s]=0", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "0", "dsum=0", "dsum", "0", "for k in range(1,n+1):\n dsum=dsum+dp[n][k][k*a]", "k", "range(1,n+1)", "range", "1", "n+1", "n", "1", "dsum=dsum+dp[n][k][k*a]", "dsum", "dsum+dp[n][k][k*a]", "dsum", "dp[n][k][k*a]", "[k]", "[n]", "dp", "n", "k", "k*a", "k", "a", "print(dsum)", "print", "dsum", "dsum=dsum+dp[n][k][k*a]", "dsum+dp[n][k][k*a]", "dsum", "a=map(int,input().split())", "map(int,input().split())", "a", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "n,a=map(int,input().split())", "map(int,input().split())", "n", "dsum=0", "0", "dsum", "dp=[[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)]", "[[[0]*(xsum+1) for i in range(n+1)] for ii in range(n+1)]", "dp", "xsum=max(max(x),a)*n", "max(max(x),a)*n", "xsum" ]

[ 7, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 2, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 165, 3 ], [ 165, 12 ], [ 174, 14 ], [ 168, 26 ], [ 175, 31 ], [ 166, 32 ], [ 36, 35 ], [ 163, 39 ], [ 156, 44 ], [ 54, 47 ], [ 157, 50 ], [ 57, 56 ], [ 163, 59 ], [ 62, 61 ], [ 163, 65 ], [ 69, 68 ], [ 163, 73 ], [ 169, 74 ], [ 68, 78 ], [ 175, 80 ], [ 56, 81 ], [ 92, 83 ], [ 157, 86 ], [ 56, 88 ], [ 61, 90 ], [ 68, 91 ], [ 157, 95 ], [ 56, 96 ], [ 61, 97 ], [ 68, 98 ], [ 109, 100 ], [ 157, 103 ], [ 56, 105 ], [ 61, 107 ], [ 68, 108 ], [ 157, 113 ], [ 56, 114 ], [ 61, 115 ], [ 68, 116 ], [ 157, 120 ], [ 56, 121 ], [ 61, 123 ], [ 68, 126 ], [ 175, 128 ], [ 56, 129 ], [ 171, 131 ], [ 135, 134 ], [ 163, 139 ], [ 159, 142 ], [ 157, 146 ], [ 163, 147 ], [ 134, 148 ], [ 134, 150 ], [ 166, 151 ], [ 160, 154 ], [ 172, 154 ], [ 156, 157 ], [ 159, 160 ], [ 165, 163 ], [ 165, 166 ], [ 168, 169 ], [ 171, 172 ], [ 174, 175 ] ]

[ "# DP\n\n# https://atcoder.jp/contests/abc044/tasks/arc060_a\n\nfrom itertools import combinations\n\n\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\nX = max(max(x), a)\n\n\n# dp[j][k][s] (0 <= j <= N, 0 <= k <= N, 0 <= s <= NX)\n# dp[j][k][s] = x1,...,xjまでからk枚使って，合計をsにする選び方の総数\n# dp[0][0][0] = 1\n# j >= 1, s < xjのとき，dp[j][k][s] = dp[j-1][k][s] (xjは使わない)\n# j >= 1, k >= 1, s >= xjのとき，dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-xj]\n# ... 1枚少なく使ってxjを入れる + 使わない\n# それ以外 0\n\ndp = [\n [[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)\n]\n\ndp[0][0][0] = 1\nfor i in range(n):\n for j in range(n+1):\n for k in range(n * X + 1):\n if k < x[i]:\n dp[i + 1][j][k] = dp[i][j][k]\n else:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]\nans = 0\nfor i in range(1, n + 1):\n ans += dp[n][i][i*a]\nprint(ans)", "from itertools import combinations", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X = max(max(x), a)", "X", "max(max(x), a)", "max", "max(x)", "max", "x", "a", "[[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)", "for _ in range(n + 2)", "_", "range(n + 2)", "range", "n + 2", "n", "2", "for _ in range(n + 2)", "[[0 for _ in range(n * X + 1)] for _ in range(n + 2)]", "dp = [\n [[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)\n]", "dp", "[\n [[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)\n]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n for j in range(n+1):\n for k in range(n * X + 1):\n if k < x[i]:\n dp[i + 1][j][k] = dp[i][j][k]\n else:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]", "i", "range(n)", "range", "n", "for j in range(n+1):\n for k in range(n * X + 1):\n if k < x[i]:\n dp[i + 1][j][k] = dp[i][j][k]\n else:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]", "j", "range(n+1)", "range", "n+1", "n", "1", "for k in range(n * X + 1):\n if k < x[i]:\n dp[i + 1][j][k] = dp[i][j][k]\n else:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]", "k", "range(n * X + 1)", "range", "n * X + 1", "n * X", "n", "X", "1", "if k < x[i]:\n dp[i + 1][j][k] = dp[i][j][k]\n else:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]", "k < x[i]", "k", "x[i]", "x", "i", "dp[i + 1][j][k] = dp[i][j][k]", "dp[i + 1][j][k]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i + 1][j][k] = dp[i][j][k] + dp[i][j-1][k-x[i]]", "dp[i + 1][j][k]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "k", "dp[i][j][k] + dp[i][j-1][k-x[i]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i][j-1][k-x[i]]", "[j-1]", "[i]", "dp", "i", "j-1", "j", "1", "k-x[i]", "k", "x[i]", "x", "i", "ans = 0", "ans", "0", "for i in range(1, n + 1):\n ans += dp[n][i][i*a]", "i", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "ans += dp[n][i][i*a]", "ans", "dp[n][i][i*a]", "[i]", "[n]", "dp", "n", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "dp = [\n [[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)\n]", "[\n [[0 for _ in range(n * X + 1)] for _ in range(n + 2)]\n for _ in range(n + 2)\n]", "dp", "ans += dp[n][i][i*a]", "dp[n][i][i*a]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "X = max(max(x), a)", "max(max(x), a)", "X", "ans = 0", "0", "ans", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 23, 13, 23, 13, 17, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 12, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 2, 4, 13, 2, 13, 17, 17, 14, 40, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 13, 29, 13, 23, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 18, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 13, 2, 18, 18, 18, 13, 13, 2, 13, 17, 13, 18, 18, 18, 13, 13, 13, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 13, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 375, 29 ], [ 357, 36 ], [ 43, 43 ], [ 45, 45 ], [ 49, 49 ], [ 51, 51 ], [ 75, 75 ], [ 78, 77 ], [ 82, 82 ], [ 84, 84 ], [ 88, 88 ], [ 90, 90 ], [ 94, 94 ], [ 96, 96 ], [ 100, 100 ], [ 102, 102 ], [ 106, 106 ], [ 108, 108 ], [ 110, 110 ], [ 112, 112 ], [ 116, 116 ], [ 118, 118 ], [ 122, 122 ], [ 127, 126 ], [ 174, 131 ], [ 137, 134 ], [ 126, 135 ], [ 142, 139 ], [ 126, 140 ], [ 145, 144 ], [ 174, 152 ], [ 126, 158 ], [ 144, 159 ], [ 162, 161 ], [ 144, 165 ], [ 174, 168 ], [ 144, 170 ], [ 126, 172 ], [ 174, 174 ], [ 366, 176 ], [ 391, 178 ], [ 366, 179 ], [ 333, 181 ], [ 364, 183 ], [ 372, 185 ], [ 190, 189 ], [ 346, 193 ], [ 342, 198 ], [ 208, 201 ], [ 343, 204 ], [ 211, 210 ], [ 346, 213 ], [ 216, 215 ], [ 346, 218 ], [ 221, 220 ], [ 346, 225 ], [ 373, 226 ], [ 220, 231 ], [ 334, 233 ], [ 210, 234 ], [ 246, 237 ], [ 343, 240 ], [ 210, 242 ], [ 215, 244 ], [ 220, 245 ], [ 343, 249 ], [ 210, 250 ], [ 215, 251 ], [ 220, 252 ], [ 265, 254 ], [ 343, 257 ], [ 210, 259 ], [ 215, 262 ], [ 220, 264 ], [ 343, 269 ], [ 210, 270 ], [ 215, 272 ], [ 220, 274 ], [ 343, 278 ], [ 210, 279 ], [ 215, 280 ], [ 220, 282 ], [ 334, 284 ], [ 210, 285 ], [ 315, 287 ], [ 291, 290 ], [ 346, 295 ], [ 384, 298 ], [ 343, 302 ], [ 346, 303 ], [ 290, 304 ], [ 290, 306 ], [ 367, 307 ], [ 385, 310 ], [ 316, 310 ], [ 315, 316 ], [ 333, 334 ], [ 342, 343 ], [ 366, 346 ], [ 357, 358 ], [ 366, 367 ], [ 372, 373 ], [ 375, 376 ], [ 384, 385 ] ]

[ "# python3.4.2用\nimport math\nimport fractions\nimport bisect\nimport collections\nimport itertools\nimport heapq\nimport string\nimport sys\nimport copy\nfrom decimal import *\nfrom collections import deque\nsys.setrecursionlimit(10**7)\nMOD = 10**9+7\nINF = float('inf') #無限大\ndef gcd(a,b):return fractions.gcd(a,b) #最大公約数\ndef lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数\ndef iin(): return int(sys.stdin.readline()) #整数読み込み\ndef ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み\ndef isn(): return sys.stdin.readline().split() #文字列読み込み\ndef imn(): return map(int, sys.stdin.readline().split()) #整数map取得\ndef imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得\ndef fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得\ndef iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得\ndef iln_s(): return sorted(iln()) # 昇順の整数リスト取得\ndef iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得\ndef fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得\ndef join(l, s=''): return s.join(l) #リストを文字列に変換\ndef perm(l, n): return itertools.permutations(l, n) # 順列取得\ndef perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数\ndef comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得\ndef comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数\ndef two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離\ndef m_add(a,b): return (a+b) % MOD\ndef lprint(l): print(*l, sep='\\n')\ndef sieves_of_e(n):\n is_prime = [True] * (n+1)\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, int(n**0.5)+1):\n if not is_prime[i]: continue\n for j in range(i * 2, n+1, i): is_prime[j] = False\n return is_prime\n\n# ABC044-C\n# N枚のカードがあり、i番目(1<i<N)番目のカードには整数x(i)が書かれている\n# カードを一枚以上選び、選んだカードの平均をAとしたい\n# このような選び方は何通りあるか\n# 三次元配列を用いたdpを行う。計算量はO(N^3*X)\n\nN,A=imn()\nx = iln()\n# 数値の最大値\nX = 50\n\n# dp[i][j][k]とする\n# xの中からj枚を選んで、x(i)の合計をkにするような選び方の総数\ndp = [[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\n\nfor j in range(N):\n for k in range(N):\n for s in range(N*X+1):\n # 選択したカードの数値がS未満の場合\n if s-x[j] < 0:\n # 選択できないので、前回値をそのまま移行\n dp[j+1][k][s] = dp[j][k][s]\n else:\n # 選択した場合の値は下記の2値を加算\n # 1.dp[j][k+1][s]は今回選択してないが、既に合計がsのなる場合の数\n # 2.dp[j][k][s-x[j]]は今回選択することにより、合計がsとなる場合の数 \n dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]\n\n\nans = 0\nfor i in range(1, N+1):\n # 合計が選んだカード数*平均値となっている場合の数を加算\n ans += dp[N][i][i*A]\nprint(ans)\n\n ", "import math", "math", "import fractions", "fractions", "import bisect", "bisect", "import collections", "collections", "import itertools", "itertools", "import heapq", "heapq", "import string", "string", "import sys", "sys", "import copy", "copy", "from decimal import *", "from collections import deque", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def gcd(a,b):return fractions.gcd(a,b) #最大公約数", "gcd", "a", "a", "b", "b", "def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数", "lcm", "a", "a", "b", "b", "def iin(): return int(sys.stdin.readline()) #整数読み込み", "iin", "def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み", "ifn", "def isn(): return sys.stdin.readline().split() #文字列読み込み", "isn", "def imn(): return map(int, sys.stdin.readline().split()) #整数map取得", "imn", "def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得", "imnn", "def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得", "fmn", "def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得", "iln", "def iln_s(): return sorted(iln()) # 昇順の整数リスト取得", "iln_s", "def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得", "iln_r", "def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得", "fln", "def join(l, s=''): return s.join(l) #リストを文字列に変換", "join", "l", "l", "s=''", "s", "''", "def perm(l, n): return itertools.permutations(l, n) # 順列取得", "perm", "l", "l", "n", "n", "def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数", "perm_count", "n", "n", "r", "r", "def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得", "comb", "l", "l", "n", "n", "def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数", "comb_count", "n", "n", "r", "r", "def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離", "two_distance", "a", "a", "b", "b", "c", "c", "d", "d", "def m_add(a,b): return (a+b) % MOD", "m_add", "a", "a", "b", "b", "def lprint(l): print(*l, sep='\\n')", "lprint", "l", "l", "def sieves_of_e(n):\n is_prime = [True] * (n+1)\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, int(n**0.5)+1):\n if not is_prime[i]: continue\n for j in range(i * 2, n+1, i): is_prime[j] = False\n return is_prime\n\n# ABC044-C\n# N枚のカードがあり、i番目(1<i<N)番目のカードには整数x(i)が書かれている\n# カードを一枚以上選び、選んだカードの平均をAとしたい\n# このような選び方は何通りあるか\n# 三次元配列を用いたdpを行う。計算量はO(N^3*X)", "sieves_of_e", "is_prime = [True] * (n+1)", "is_prime", "[True] * (n+1)", "[True]", "True", "n+1", "n", "1", "is_prime[0] = False", "is_prime[0]", "is_prime", "0", "False", "is_prime[1] = False", "is_prime[1]", "is_prime", "1", "False", "for i in range(2, int(n**0.5)+1):\n if not is_prime[i]: continue\n for j in range(i * 2, n+1, i): is_prime[j] = False\n ", "i", "range(2, int(n**0.5)+1)", "range", "2", "int(n**0.5)+1", "int(n**0.5)", "int", "n**0.5", "n", "0.5", "1", "if not is_prime[i]: continue\n ", "not is_prime[i]", "is_prime[i]", "is_prime", "i", "for j in range(i * 2, n+1, i): is_prime[j] = False\n ", "j", "range(i * 2, n+1, i)", "range", "i * 2", "i", "2", "n+1", "n", "1", "i", "return is_prime", "is_prime", "n", "n", "N,A=imn()", "N", "imn()", "imn", "A", "x = iln()", "x", "iln()", "iln", "X = 50", "X", "50", "[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[[0 for _ in range(N*X+1)] for _ in range(N+1)]", "dp = [[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)]", "dp", "[[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for j in range(N):\n for k in range(N):\n for s in range(N*X+1):\n # 選択したカードの数値がS未満の場合\n if s-x[j] < 0:\n # 選択できないので、前回値をそのまま移行\n dp[j+1][k][s] = dp[j][k][s]\n else:\n # 選択した場合の値は下記の2値を加算\n # 1.dp[j][k+1][s]は今回選択してないが、既に合計がsのなる場合の数\n # 2.dp[j][k][s-x[j]]は今回選択することにより、合計がsとなる場合の数 \n dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]", "j", "range(N)", "range", "N", "for k in range(N):\n for s in range(N*X+1):\n # 選択したカードの数値がS未満の場合\n if s-x[j] < 0:\n # 選択できないので、前回値をそのまま移行\n dp[j+1][k][s] = dp[j][k][s]\n else:\n # 選択した場合の値は下記の2値を加算\n # 1.dp[j][k+1][s]は今回選択してないが、既に合計がsのなる場合の数\n # 2.dp[j][k][s-x[j]]は今回選択することにより、合計がsとなる場合の数 \n dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]", "k", "range(N)", "range", "N", "for s in range(N*X+1):\n # 選択したカードの数値がS未満の場合\n if s-x[j] < 0:\n # 選択できないので、前回値をそのまま移行\n dp[j+1][k][s] = dp[j][k][s]\n else:\n # 選択した場合の値は下記の2値を加算\n # 1.dp[j][k+1][s]は今回選択してないが、既に合計がsのなる場合の数\n # 2.dp[j][k][s-x[j]]は今回選択することにより、合計がsとなる場合の数 \n dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]", "s", "range(N*X+1)", "range", "N*X+1", "N*X", "N", "X", "1", "if s-x[j] < 0:\n # 選択できないので、前回値をそのまま移行\n dp[j+1][k][s] = dp[j][k][s]\n else:\n # 選択した場合の値は下記の2値を加算\n # 1.dp[j][k+1][s]は今回選択してないが、既に合計がsのなる場合の数\n # 2.dp[j][k][s-x[j]]は今回選択することにより、合計がsとなる場合の数 \n dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]", "s-x[j] < 0", "s-x[j]", "s", "x[j]", "x", "j", "0", "dp[j+1][k][s] = dp[j][k][s]", "dp[j+1][k][s]", "[k]", "[j+1]", "dp", "j+1", "j", "1", "k", "s", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j+1][k+1][s] = dp[j][k+1][s] + dp[j][k][s-x[j]]", "dp[j+1][k+1][s]", "[k+1]", "[j+1]", "dp", "j+1", "j", "1", "k+1", "k", "1", "s", "dp[j][k+1][s] + dp[j][k][s-x[j]]", "dp[j][k+1][s]", "[k+1]", "[j]", "dp", "j", "k+1", "k", "1", "s", "dp[j][k][s-x[j]]", "[k]", "[j]", "dp", "j", "k", "s-x[j]", "s", "x[j]", "x", "j", "ans = 0", "ans", "0", "for i in range(1, N+1):\n # 合計が選んだカード数*平均値となっている場合の数を加算\n ans += dp[N][i][i*A]", "i", "range(1, N+1)", "range", "1", "N+1", "N", "1", "ans += dp[N][i][i*A]", "ans", "dp[N][i][i*A]", "[i]", "[N]", "dp", "N", "i", "i*A", "i", "A", "print(ans)", "print", "ans", "def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得", "def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得", "iln_r", "ans = 0", "0", "ans", "def iln_s(): return sorted(iln()) # 昇順の整数リスト取得", "def iln_s(): return sorted(iln()) # 昇順の整数リスト取得", "iln_s", "def iin(): return int(sys.stdin.readline()) #整数読み込み", "def iin(): return int(sys.stdin.readline()) #整数読み込み", "iin", "def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得", "def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得", "fln", "def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得", "def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得", "imnn", "def lprint(l): print(*l, sep='\\n')", "def lprint(l): print(*l, sep='\\n')", "lprint", "x = iln()", "iln()", "x", "def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み", "def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み", "ifn", "def join(l, s=''): return s.join(l) #リストを文字列に変換", "def join(l, s=''): return s.join(l) #リストを文字列に変換", "join", "dp = [[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)]", "[[[0 for _ in range(N*X+1)] for _ in range(N+1)] for _ in range(N+1)]", "dp", "N,A=imn()", "imn()", "N", "def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得", "def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得", "comb", "def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得", "def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得", "fmn", "def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数", "def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数", "comb_count", "INF = float('inf')", "float('inf')", "INF", "def isn(): return sys.stdin.readline().split() #文字列読み込み", "def isn(): return sys.stdin.readline().split() #文字列読み込み", "isn", "def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得", "def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得", "iln", "A=imn()", "imn()", "A", "def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離", "def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離", "two_distance", "X = 50", "50", "X", "MOD = 10**9+7", "10**9+7", "MOD", "def sieves_of_e(n):\n is_prime = [True] * (n+1)\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, int(n**0.5)+1):\n if not is_prime[i]: continue\n for j in range(i * 2, n+1, i): is_prime[j] = False\n return is_prime\n\n# ABC044-C\n# N枚のカードがあり、i番目(1<i<N)番目のカードには整数x(i)が書かれている\n# カードを一枚以上選び、選んだカードの平均をAとしたい\n# このような選び方は何通りあるか\n# 三次元配列を用いたdpを行う。計算量はO(N^3*X)", "def sieves_of_e(n):\n is_prime = [True] * (n+1)\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, int(n**0.5)+1):\n if not is_prime[i]: continue\n for j in range(i * 2, n+1, i): is_prime[j] = False\n return is_prime\n\n# ABC044-C\n# N枚のカードがあり、i番目(1<i<N)番目のカードには整数x(i)が書かれている\n# カードを一枚以上選び、選んだカードの平均をAとしたい\n# このような選び方は何通りあるか\n# 三次元配列を用いたdpを行う。計算量はO(N^3*X)", "sieves_of_e", "def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数", "def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数", "perm_count", "ans += dp[N][i][i*A]", "dp[N][i][i*A]", "ans", "def gcd(a,b):return fractions.gcd(a,b) #最大公約数", "def gcd(a,b):return fractions.gcd(a,b) #最大公約数", "gcd", "def imn(): return map(int, sys.stdin.readline().split()) #整数map取得", "def imn(): return map(int, sys.stdin.readline().split()) #整数map取得", "imn", "def perm(l, n): return itertools.permutations(l, n) # 順列取得", "def perm(l, n): return itertools.permutations(l, n) # 順列取得", "perm", "def m_add(a,b): return (a+b) % MOD", "def m_add(a,b): return (a+b) % MOD", "m_add", "def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数", "def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数", "lcm" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 41, 28, 13, 4, 18, 4, 13, 13, 17, 4, 2, 4, 13, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 4, 13, 13, 28, 13, 18, 13, 13, 0, 13, 18, 18, 13, 13, 13, 14, 40, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 13, 14, 40, 2, 13, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 17, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 146, 2 ], [ 146, 12 ], [ 16, 15 ], [ 15, 26 ], [ 147, 27 ], [ 137, 29 ], [ 34, 33 ], [ 144, 37 ], [ 140, 42 ], [ 50, 45 ], [ 141, 47 ], [ 138, 56 ], [ 59, 58 ], [ 141, 60 ], [ 149, 63 ], [ 141, 66 ], [ 58, 68 ], [ 58, 71 ], [ 141, 73 ], [ 85, 78 ], [ 141, 80 ], [ 58, 84 ], [ 94, 87 ], [ 141, 89 ], [ 58, 93 ], [ 150, 94 ], [ 58, 98 ], [ 141, 101 ], [ 115, 106 ], [ 141, 108 ], [ 58, 113 ], [ 126, 117 ], [ 141, 119 ], [ 58, 124 ], [ 150, 126 ], [ 141, 132 ], [ 144, 133 ], [ 137, 138 ], [ 140, 141 ], [ 146, 144 ], [ 146, 147 ], [ 149, 150 ] ]

[ "n, a = map(int, input().split(\" \"))\nlist_x = [int(x) - a for x in input().split(\" \")]\ncounts = [{} for i in range(n + 1)]\ncounts[0][0] = 1\nfor i, x in enumerate(list_x):\n for v in counts[i]:\n c = counts[i][v]\n if v not in counts[i + 1]:\n counts[i + 1][v] = 0\n counts[i + 1][v] += c\n if v + x not in counts[i + 1]:\n counts[i + 1][v + x] = 0\n counts[i + 1][v + x] += c\nprint(counts[n][0] - 1)", "n, a = map(int, input().split(\" \"))", "n", "map(int, input().split(\" \"))", "map", "int", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "a", "int(x) - a for x in input().split(\" \")", "for x in input().split(\" \")", "x", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "for x in input().split(\" \")", "int(x) - a", "int(x)", "int", "x", "a", "list_x = [int(x) - a for x in input().split(\" \")]", "list_x", "[int(x) - a for x in input().split(\" \")]", "{} for i in range(n + 1)", "for i in range(n + 1)", "i", "range(n + 1)", "range", "n + 1", "n", "1", "for i in range(n + 1)", "{}", "counts = [{} for i in range(n + 1)]", "counts", "[{} for i in range(n + 1)]", "counts[0][0] = 1", "counts[0][0]", "[0]", "counts", "0", "0", "1", "for i, x in enumerate(list_x):\n for v in counts[i]:\n c = counts[i][v]\n if v not in counts[i + 1]:\n counts[i + 1][v] = 0\n counts[i + 1][v] += c\n if v + x not in counts[i + 1]:\n counts[i + 1][v + x] = 0\n counts[i + 1][v + x] += c", "i", "x", "enumerate(list_x)", "enumerate", "list_x", "for v in counts[i]:\n c = counts[i][v]\n if v not in counts[i + 1]:\n counts[i + 1][v] = 0\n counts[i + 1][v] += c\n if v + x not in counts[i + 1]:\n counts[i + 1][v + x] = 0\n counts[i + 1][v + x] += c", "v", "counts[i]", "counts", "i", "c = counts[i][v]", "c", "counts[i][v]", "[i]", "counts", "i", "v", "if v not in counts[i + 1]:\n counts[i + 1][v] = 0\n ", "v not in counts[i + 1]", "v", "counts[i + 1]", "counts", "i + 1", "i", "1", "counts[i + 1][v] = 0", "counts[i + 1][v]", "[i + 1]", "counts", "i + 1", "i", "1", "v", "0", "counts[i + 1][v] += c", "counts[i + 1][v]", "[i + 1]", "counts", "i + 1", "i", "1", "v", "c", "if v + x not in counts[i + 1]:\n counts[i + 1][v + x] = 0\n ", "v + x not in counts[i + 1]", "v + x", "v", "x", "counts[i + 1]", "counts", "i + 1", "i", "1", "counts[i + 1][v + x] = 0", "counts[i + 1][v + x]", "[i + 1]", "counts", "i + 1", "i", "1", "v + x", "v", "x", "0", "counts[i + 1][v + x] += c", "counts[i + 1][v + x]", "[i + 1]", "counts", "i + 1", "i", "1", "v + x", "v", "x", "c", "print(counts[n][0] - 1)", "print", "counts[n][0] - 1", "counts[n][0]", "[n]", "counts", "n", "0", "1", "list_x = [int(x) - a for x in input().split(\" \")]", "[int(x) - a for x in input().split(\" \")]", "list_x", "counts = [{} for i in range(n + 1)]", "[{} for i in range(n + 1)]", "counts", "n, a = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "n", "a = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "a", "c = counts[i][v]", "counts[i][v]", "c" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 2, 13, 39, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 0, 13, 2, 2, 17, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 13, 4, 13, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 40, 17, 2, 13, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 0, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 28, 27 ], [ 15, 31 ], [ 36, 35 ], [ 4, 38 ], [ 43, 40 ], [ 15, 41 ], [ 35, 42 ], [ 13, 43 ], [ 46, 45 ], [ 4, 49 ], [ 27, 50 ], [ 54, 53 ], [ 4, 57 ], [ 45, 64 ], [ 68, 67 ], [ 77, 70 ], [ 67, 72 ], [ 4, 75 ], [ 27, 76 ], [ 15, 83 ], [ 87, 86 ], [ 45, 90 ], [ 86, 97 ], [ 45, 99 ], [ 106, 101 ], [ 67, 103 ], [ 86, 105 ], [ 67, 109 ], [ 86, 113 ], [ 67, 116 ], [ 86, 121 ], [ 129, 124 ], [ 67, 126 ], [ 86, 128 ], [ 67, 131 ], [ 86, 135 ], [ 138, 137 ], [ 67, 141 ], [ 4, 142 ], [ 4, 144 ], [ 27, 145 ], [ 137, 149 ], [ 158, 155 ] ]

[ "def main():\n n, a = map(int, input().split())\n x = list(map(int, input().split()))\n\n mx = max(x + [a])\n\n for i in range(n):\n x[i] -= a\n\n sm = 2 * n * mx\n\n dp = [[0] * (sm + 1) for _ in range(n + 1)]\n\n dp[0][n*mx] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ans = dp[n][n*mx] - 1\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, a = map(int, input().split())\n x = list(map(int, input().split()))\n\n mx = max(x + [a])\n\n for i in range(n):\n x[i] -= a\n\n sm = 2 * n * mx\n\n dp = [[0] * (sm + 1) for _ in range(n + 1)]\n\n dp[0][n*mx] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ans = dp[n][n*mx] - 1\n\n print(ans)", "main", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mx = max(x + [a])", "mx", "max(x + [a])", "max", "x + [a]", "x", "[a]", "a", "for i in range(n):\n x[i] -= a\n\n ", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "sm = 2 * n * mx", "sm", "2 * n * mx", "2 * n", "2", "n", "mx", "[0] * (sm + 1) for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[0] * (sm + 1)", "[0]", "0", "sm + 1", "sm", "1", "dp = [[0] * (sm + 1) for _ in range(n + 1)]", "dp", "[[0] * (sm + 1) for _ in range(n + 1)]", "dp[0][n*mx] = 1", "dp[0][n*mx]", "[0]", "dp", "0", "n*mx", "n", "mx", "1", "for i, e in enumerate(x, 1):\n for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ", "i", "e", "enumerate(x, 1)", "enumerate", "x", "1", "for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ", "j", "range(sm + 1)", "range", "sm + 1", "sm", "1", "if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ", "0 <= j - e <= sm", "0 <= j - e", "0", "j - e", "j", "e", "sm", "dp[i][j] = dp[i-1][j] + dp[i-1][j-e]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j] + dp[i-1][j-e]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][j-e]", "[i-1]", "dp", "i-1", "i", "1", "j-e", "j", "e", "dp[i][j] = dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "ans = dp[n][n*mx] - 1", "ans", "dp[n][n*mx] - 1", "dp[n][n*mx]", "[n]", "dp", "n", "n*mx", "n", "mx", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, a = map(int, input().split())\n x = list(map(int, input().split()))\n\n mx = max(x + [a])\n\n for i in range(n):\n x[i] -= a\n\n sm = 2 * n * mx\n\n dp = [[0] * (sm + 1) for _ in range(n + 1)]\n\n dp[0][n*mx] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ans = dp[n][n*mx] - 1\n\n print(ans)", "def main():\n n, a = map(int, input().split())\n x = list(map(int, input().split()))\n\n mx = max(x + [a])\n\n for i in range(n):\n x[i] -= a\n\n sm = 2 * n * mx\n\n dp = [[0] * (sm + 1) for _ in range(n + 1)]\n\n dp[0][n*mx] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(sm + 1):\n if 0 <= j - e <= sm:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-e]\n else:\n dp[i][j] = dp[i-1][j]\n\n ans = dp[n][n*mx] - 1\n\n print(ans)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 21, 22, 39, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 21, 22, 39, 17, 17, 17, 28, 39, 13, 13, 13, 4, 18, 13, 13, 14, 2, 39, 13, 13, 13, 0, 18, 13, 39, 13, 13, 13, 0, 18, 13, 39, 13, 13, 13, 14, 2, 39, 2, 13, 18, 13, 13, 2, 13, 17, 13, 0, 18, 13, 39, 2, 13, 18, 13, 13, 2, 13, 17, 13, 0, 18, 13, 39, 2, 13, 18, 13, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 39, 2, 13, 13, 13, 13, 0, 13, 18, 13, 39, 2, 13, 13, 13, 4, 13, 13, 10, 4, 13, 10, 21, 13, 10, 21, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 18, 13 ]

[ [ 159, 2 ], [ 159, 11 ], [ 162, 13 ], [ 150, 25 ], [ 34, 33 ], [ 160, 36 ], [ 153, 38 ], [ 151, 52 ], [ 157, 52 ], [ 154, 59 ], [ 66, 61 ], [ 154, 62 ], [ 73, 68 ], [ 154, 69 ], [ 163, 80 ], [ 33, 81 ], [ 154, 85 ], [ 98, 87 ], [ 154, 88 ], [ 163, 93 ], [ 33, 94 ], [ 111, 100 ], [ 154, 101 ], [ 163, 106 ], [ 33, 107 ], [ 156, 113 ], [ 154, 114 ], [ 165, 116 ], [ 120, 119 ], [ 160, 124 ], [ 119, 130 ], [ 148, 131 ], [ 157, 133 ], [ 151, 133 ], [ 168, 135 ], [ 157, 137 ], [ 151, 137 ], [ 119, 140 ], [ 148, 141 ], [ 169, 145 ], [ 166, 145 ], [ 159, 148 ], [ 150, 151 ], [ 153, 154 ], [ 154, 156 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 168, 169 ] ]

[ "\nn,k = map(int,input().split())\nA = list(map(int,input().split()))\ndic1 = {(0,0):1}\nfor i in range(n):\n dic2 = {(0,0):0}\n for (total,num),amount in dic1.items():\n if (total,num) in dic2:\n dic2[(total,num)] += amount\n else:\n dic2[(total,num)] = amount\n if (total+A[i],num+1) in dic2:\n dic2[(total+A[i],num+1)] += amount\n else:\n dic2[(total+A[i],num+1)] = amount\n \n dic1 = dic2\n\nans = 0\nfor i in range(1,n+1):\n if (i*k,i) in dic1:\n ans += dic1[(i*k,i)]\n\nprint(ans)", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "dic1 = {(0,0):1}", "dic1", "{(0,0):1}", "(0,0)", "(0,0)", "0", "0", "1", "for i in range(n):\n dic2 = {(0,0):0}\n for (total,num),amount in dic1.items():\n if (total,num) in dic2:\n dic2[(total,num)] += amount\n else:\n dic2[(total,num)] = amount\n if (total+A[i],num+1) in dic2:\n dic2[(total+A[i],num+1)] += amount\n else:\n dic2[(total+A[i],num+1)] = amount\n \n dic1 = dic2", "i", "range(n)", "range", "n", "dic2 = {(0,0):0}", "dic2", "{(0,0):0}", "(0,0)", "(0,0)", "0", "0", "0", "for (total,num),amount in dic1.items():\n if (total,num) in dic2:\n dic2[(total,num)] += amount\n else:\n dic2[(total,num)] = amount\n if (total+A[i],num+1) in dic2:\n dic2[(total+A[i],num+1)] += amount\n else:\n dic2[(total+A[i],num+1)] = amount\n \n ", "(total,num)", "total", "num", "amount", "dic1.items()", "dic1.items", "dic1", "items", "if (total,num) in dic2:\n dic2[(total,num)] += amount\n else:\n dic2[(total,num)] = amount\n ", "(total,num) in dic2", "(total,num)", "total", "num", "dic2", "dic2[(total,num)] += amount", "dic2[(total,num)]", "dic2", "(total,num)", "total", "num", "amount", "dic2[(total,num)] = amount", "dic2[(total,num)]", "dic2", "(total,num)", "total", "num", "amount", "if (total+A[i],num+1) in dic2:\n dic2[(total+A[i],num+1)] += amount\n else:\n dic2[(total+A[i],num+1)] = amount\n \n ", "(total+A[i],num+1) in dic2", "(total+A[i],num+1)", "total+A[i]", "total", "A[i]", "A", "i", "num+1", "num", "1", "dic2", "dic2[(total+A[i],num+1)] += amount", "dic2[(total+A[i],num+1)]", "dic2", "(total+A[i],num+1)", "total+A[i]", "total", "A[i]", "A", "i", "num+1", "num", "1", "amount", "dic2[(total+A[i],num+1)] = amount", "dic2[(total+A[i],num+1)]", "dic2", "(total+A[i],num+1)", "total+A[i]", "total", "A[i]", "A", "i", "num+1", "num", "1", "amount", "dic1 = dic2", "dic1", "dic2", "ans = 0", "ans", "0", "for i in range(1,n+1):\n if (i*k,i) in dic1:\n ans += dic1[(i*k,i)]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "if (i*k,i) in dic1:\n ans += dic1[(i*k,i)]", "(i*k,i) in dic1", "(i*k,i)", "i*k", "i", "k", "i", "dic1", "ans += dic1[(i*k,i)]", "ans", "dic1[(i*k,i)]", "dic1", "(i*k,i)", "i*k", "i", "k", "i", "print(ans)", "print", "ans", "k = map(int,input().split())", "map(int,input().split())", "k", "dic1 = {(0,0):1}", "{(0,0):1}", "dic1", "dic2 = {(0,0):0}", "{(0,0):0}", "dic2", "dic1 = dic2", "dic2", "dic1", "n,k = map(int,input().split())", "map(int,input().split())", "n", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "ans = 0", "0", "ans", "ans += dic1[(i*k,i)]", "dic1[(i*k,i)]", "ans" ]

[ 7, 15, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 31, 13, 12, 13, 0, 13, 17, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 13, 17, 0, 13, 18, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 0, 18, 13, 39, 17, 18, 13, 39, 17, 0, 13, 13, 0, 13, 4, 18, 13, 13, 17, 2, 13, 17, 4, 13, 4, 18, 13, 13, 18, 13, 13, 14, 2, 13, 17, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 103, 6 ], [ 103, 19 ], [ 103, 20 ], [ 26, 25 ], [ 29, 28 ], [ 101, 35 ], [ 25, 38 ], [ 42, 41 ], [ 49, 46 ], [ 28, 47 ], [ 52, 51 ], [ 101, 54 ], [ 57, 56 ], [ 28, 61 ], [ 72, 61 ], [ 67, 63 ], [ 56, 64 ], [ 28, 68 ], [ 72, 68 ], [ 73, 72 ], [ 56, 73 ], [ 76, 75 ], [ 101, 82 ], [ 72, 91 ], [ 28, 91 ], [ 75, 92 ], [ 107, 98 ], [ 103, 101 ], [ 103, 104 ] ]

[ "import sys\nimport numpy as np\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "import numpy as np", "numpy", "n, a, *x = map(int, sys.stdin.read().split())", "n", "map(int, sys.stdin.read().split())", "map", "int", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "a", "*x", "x", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "main", "m = 2500", "m", "2500", "dp = np.zeros((n + 1, m + 1), dtype=np.int64)", "dp", "np.zeros((n + 1, m + 1), dtype=np.int64)", "np.zeros", "np", "zeros", "(n + 1, m + 1)", "n + 1", "n", "1", "m + 1", "m", "1", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "dp[0, 0] = 1", "dp[0, 0]", "dp", "0", "1", "for i in range(n):\n ndp = np.copy(dp)\n ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]\n dp = ndp\n ", "i", "range(n)", "range", "n", "ndp = np.copy(dp)", "ndp", "np.copy(dp)", "np.copy", "np", "copy", "dp", "ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]", "ndp[1:, x[i]:]", "ndp", "1:", "1", "dp[:-1, :m-x[i]+1]", "dp", ":-1", "-1", "dp = ndp", "dp", "ndp", "i = np.arange(1, n + 1)", "i", "np.arange(1, n + 1)", "np.arange", "np", "arange", "1", "n + 1", "n", "1", "print(np.sum(dp[i, i * a]))", "print", "np.sum(dp[i, i * a])", "np.sum", "np", "sum", "dp[i, i * a]", "dp", "i", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "n, a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "n", "a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "a", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "def main():\n m = 2500\n dp = np.zeros((n + 1, m + 1), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n ndp = np.copy(dp)\n ndp[1:, x[i]:] += dp[:-1, :m-x[i]+1]\n dp = ndp\n i = np.arange(1, n + 1)\n print(np.sum(dp[i, i * a]))", "main" ]

[ 7, 15, 13, 13, 13, 4, 18, 13, 13, 17, 0, 13, 18, 18, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 18, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 0, 13, 39, 14, 2, 4, 13, 13, 17, 29, 39, 0, 13, 18, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 4, 13, 13, 17, 14, 40, 13, 18, 13, 2, 13, 17, 4, 18, 13, 13, 39, 13, 13, 0, 13, 18, 13, 2, 13, 17, 0, 13, 17, 0, 13, 17, 4, 18, 13, 13, 39, 13, 13, 29, 13, 23, 13, 12, 13, 29, 4, 18, 17, 13, 4, 13, 13, 13, 23, 13, 12, 13, 29, 4, 13, 4, 13, 13, 13, 23, 13, 12, 13, 0, 13, 4, 18, 13, 13, 13, 13, 14, 2, 40, 13, 4, 13, 13, 2, 18, 13, 13, 13, 29, 17, 29, 17, 23, 13, 23, 13, 12, 13, 0, 13, 17, 42, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 40, 2, 13, 18, 13, 13, 17, 0, 18, 18, 13, 40, 13, 13, 18, 18, 13, 40, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 40, 2, 13, 13, 2, 13, 13, 0, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13, 10, 12, 13 ]

[ [ 370, 11 ], [ 340, 18 ], [ 364, 25 ], [ 371, 40 ], [ 371, 51 ], [ 371, 59 ], [ 64, 63 ], [ 128, 69 ], [ 75, 74 ], [ 128, 76 ], [ 80, 79 ], [ 83, 82 ], [ 128, 88 ], [ 74, 92 ], [ 106, 92 ], [ 128, 94 ], [ 82, 96 ], [ 63, 100 ], [ 107, 106 ], [ 128, 108 ], [ 82, 110 ], [ 114, 113 ], [ 117, 116 ], [ 63, 120 ], [ 63, 126 ], [ 128, 128 ], [ 141, 139 ], [ 141, 141 ], [ 152, 150 ], [ 152, 152 ], [ 157, 156 ], [ 182, 161 ], [ 180, 162 ], [ 156, 166 ], [ 182, 169 ], [ 182, 172 ], [ 156, 173 ], [ 180, 174 ], [ 180, 180 ], [ 182, 182 ], [ 187, 186 ], [ 208, 192 ], [ 201, 192 ], [ 196, 195 ], [ 206, 196 ], [ 198, 196 ], [ 199, 198 ], [ 198, 199 ], [ 206, 199 ], [ 202, 201 ], [ 195, 204 ], [ 186, 204 ], [ 206, 206 ], [ 208, 208 ], [ 367, 211 ], [ 329, 213 ], [ 367, 214 ], [ 334, 216 ], [ 347, 218 ], [ 325, 220 ], [ 335, 223 ], [ 227, 226 ], [ 350, 230 ], [ 355, 235 ], [ 243, 238 ], [ 356, 240 ], [ 246, 245 ], [ 350, 248 ], [ 251, 250 ], [ 350, 255 ], [ 259, 258 ], [ 326, 263 ], [ 350, 264 ], [ 258, 269 ], [ 335, 271 ], [ 245, 272 ], [ 281, 275 ], [ 356, 277 ], [ 250, 279 ], [ 258, 280 ], [ 356, 283 ], [ 250, 286 ], [ 258, 289 ], [ 335, 291 ], [ 245, 292 ], [ 373, 294 ], [ 298, 297 ], [ 350, 302 ], [ 297, 307 ], [ 368, 308 ], [ 326, 310 ], [ 350, 311 ], [ 352, 313 ], [ 356, 316 ], [ 297, 317 ], [ 297, 319 ], [ 368, 320 ], [ 353, 323 ], [ 374, 323 ], [ 325, 326 ], [ 334, 335 ], [ 340, 341 ], [ 367, 350 ], [ 352, 353 ], [ 355, 356 ], [ 364, 365 ], [ 367, 368 ], [ 370, 371 ], [ 373, 374 ] ]

[ "import sys,collections as cl,bisect as bs\nsys.setrecursionlimit(100000)\ninput = sys.stdin.readline\nmod = 10**9+7\nMax = sys.maxsize\ndef l(): #intのlist\n return list(map(int,input().split()))\ndef m(): #複数文字\n return map(int,input().split())\ndef onem(): #Nとかの取得\n return int(input())\ndef s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a\ndef jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))\ndef max2(x): #他のときもどうように作成可能\n return max(map(max,x))\ndef In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False\n\ndef pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans\n\n\"\"\"\ndef nibu(x,n,r):\n ll = 0\n rr = r\n while True:\n mid = (ll+rr)//2\n\n if rr == mid:\n return ll\n if (ここに評価入れる):\n rr = mid\n else:\n ll = mid+1\n\"\"\"\n\nn,a = m()\n\nx = l()\n\nma = max(x)\n\ndp = [[0 for j in range(ma*n+1)] for i in range(n+1)]\n\ndp[0][0] = 1\n\nfor i in range(n):\n for j in range(1,n+1):\n for k in range(ma*n+1):\n if k-x[i] >= 0:\n dp[-(j)][k] += dp[-(j+1)][k-x[i]]\n\nans = 0\n\nfor i in range(1,n+1):\n if i*a <= ma*n:\n ans += dp[i][i*a]\n\nprint(ans)\n\n\n\n\n", "import sys,collections as cl,bisect as bs", "sys", "collections", "bisect", "sys.setrecursionlimit(100000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "100000", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "Max = sys.maxsize", "Max", "sys.maxsize", "sys", "maxsize", "def l(): #intのlist\n return list(map(int,input().split()))", "l", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def m(): #複数文字\n return map(int,input().split())", "m", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def onem(): #Nとかの取得\n return int(input())", "onem", "return int(input())", "int(input())", "int", "input()", "input", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "s", "a = []", "a", "[]", "if len(x) == 0:\n return []\n ", "len(x) == 0", "len(x)", "len", "x", "0", "return []", "[]", "aa = x[0]", "aa", "x[0]", "x", "0", "su = 1", "su", "1", "for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n ", "i", "range(len(x)-1)", "range", "len(x)-1", "len(x)", "len", "x", "1", "if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n ", "aa != x[i+1]", "aa", "x[i+1]", "x", "i+1", "i", "1", "a.append([aa,su])", "a.append", "a", "append", "[aa,su]", "aa", "su", "aa = x[i+1]", "aa", "x[i+1]", "x", "i+1", "i", "1", "su = 1", "su", "1", "su += 1", "su", "1", "a.append([aa,su])", "a.append", "a", "append", "[aa,su]", "aa", "su", "return a", "a", "x", "x", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "jo", "return \" \".join(map(str,x))", "\" \".join(map(str,x))", "\" \".join", "\" \"", "join", "map(str,x)", "map", "str", "x", "x", "x", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "max2", "return max(map(max,x))", "max(map(max,x))", "max", "map(max,x)", "map", "max", "x", "x", "x", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "In", "k = bs.bisect_left(a,x)", "k", "bs.bisect_left(a,x)", "bs.bisect_left", "bs", "bisect_left", "a", "x", "if k != len(a) and a[k] == x:\n return True\n else:\n return False", "k != len(a) and a[k] == x", "k != len(a)", "k", "len(a)", "len", "a", "a[k] == x", "a[k]", "a", "k", "x", "return True", "True", "return False", "False", "x", "x", "a", "a", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "pow_k", "ans = 1", "ans", "1", "while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n ", "n", "if n % 2:\n ans *= x\n ", "n % 2", "n", "2", "ans *= x", "ans", "x", "x *= x", "x", "x", "n >>= 1", "n", "1", "return ans", "ans", "x", "x", "n", "n", "\"\"\"\ndef nibu(x,n,r):\n ll = 0\n rr = r\n while True:\n mid = (ll+rr)//2\n\n if rr == mid:\n return ll\n if (ここに評価入れる):\n rr = mid\n else:\n ll = mid+1\n\"\"\"", "n,a = m()", "n", "m()", "m", "a", "x = l()", "x", "l()", "l", "ma = max(x)", "ma", "max(x)", "max", "x", "[0 for j in range(ma*n+1)] for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "[0 for j in range(ma*n+1)]", "dp = [[0 for j in range(ma*n+1)] for i in range(n+1)]", "dp", "[[0 for j in range(ma*n+1)] for i in range(n+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(n):\n for j in range(1,n+1):\n for k in range(ma*n+1):\n if k-x[i] >= 0:\n dp[-(j)][k] += dp[-(j+1)][k-x[i]]", "i", "range(n)", "range", "n", "for j in range(1,n+1):\n for k in range(ma*n+1):\n if k-x[i] >= 0:\n dp[-(j)][k] += dp[-(j+1)][k-x[i]]", "j", "range(1,n+1)", "range", "1", "n+1", "n", "1", "for k in range(ma*n+1):\n if k-x[i] >= 0:\n dp[-(j)][k] += dp[-(j+1)][k-x[i]]", "k", "range(ma*n+1)", "range", "ma*n+1", "ma*n", "ma", "n", "1", "if k-x[i] >= 0:\n dp[-(j)][k] += dp[-(j+1)][k-x[i]]", "k-x[i] >= 0", "k-x[i]", "k", "x[i]", "x", "i", "0", "dp[-(j)][k] += dp[-(j+1)][k-x[i]]", "dp[-(j)][k]", "[-(j)]", "dp", "-(j)", "j", "k", "dp[-(j+1)][k-x[i]]", "[-(j+1)]", "dp", "-(j+1)", "j+1", "j", "1", "k-x[i]", "k", "x[i]", "x", "i", "ans = 0", "ans", "0", "for i in range(1,n+1):\n if i*a <= ma*n:\n ans += dp[i][i*a]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "if i*a <= ma*n:\n ans += dp[i][i*a]", "i*a <= ma*n", "i*a", "i", "a", "ma*n", "ma", "n", "ans += dp[i][i*a]", "ans", "dp[i][i*a]", "[i]", "dp", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "ma = max(x)", "max(x)", "ma", "def m(): #複数文字\n return map(int,input().split())", "def m(): #複数文字\n return map(int,input().split())", "m", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "max2", "x = l()", "l()", "x", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "In", "mod = 10**9+7", "10**9+7", "mod", "def onem(): #Nとかの取得\n return int(input())", "def onem(): #Nとかの取得\n return int(input())", "onem", "def l(): #intのlist\n return list(map(int,input().split()))", "def l(): #intのlist\n return list(map(int,input().split()))", "l", "n,a = m()", "m()", "n", "ans += dp[i][i*a]", "dp[i][i*a]", "ans", "dp = [[0 for j in range(ma*n+1)] for i in range(n+1)]", "[[0 for j in range(ma*n+1)] for i in range(n+1)]", "dp", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "jo", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "s", "Max = sys.maxsize", "sys.maxsize", "Max", "a = m()", "m()", "a", "input = sys.stdin.readline", "sys.stdin.readline", "input", "ans = 0", "0", "ans", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "pow_k" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 39, 13, 2, 13, 17, 0, 13, 18, 13, 13, 28, 13, 4, 13, 13, 28, 13, 18, 4, 13, 13, 39, 17, 0, 18, 18, 13, 2, 13, 17, 39, 18, 13, 13, 18, 18, 13, 13, 39, 40, 18, 13, 13, 0, 18, 18, 13, 17, 18, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 14, 40, 2, 2, 13, 17, 13, 13, 0, 13, 18, 18, 13, 13, 2, 2, 13, 17, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 129, 4 ], [ 129, 13 ], [ 135, 15 ], [ 123, 27 ], [ 136, 30 ], [ 120, 32 ], [ 124, 40 ], [ 44, 43 ], [ 49, 48 ], [ 127, 51 ], [ 54, 53 ], [ 48, 57 ], [ 71, 61 ], [ 121, 63 ], [ 53, 65 ], [ 136, 69 ], [ 48, 70 ], [ 121, 73 ], [ 53, 74 ], [ 136, 78 ], [ 48, 79 ], [ 88, 81 ], [ 121, 83 ], [ 136, 86 ], [ 48, 87 ], [ 132, 90 ], [ 94, 93 ], [ 127, 96 ], [ 93, 101 ], [ 130, 103 ], [ 124, 104 ], [ 138, 106 ], [ 121, 109 ], [ 93, 110 ], [ 93, 113 ], [ 130, 115 ], [ 139, 118 ], [ 133, 118 ], [ 120, 121 ], [ 123, 124 ], [ 129, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ] ]

[ "import numpy as np\nn,a=map(int,input().split())\nx=list(map(int,input().split()))\ns=sum(x)\ndp=np.zeros((n,s+1),dtype=np.int64)\nfor i in range(n):\n for j in range(i)[::-1]:\n dp[j+1][x[i]:]+=dp[j][:-x[i]]\n dp[0][x[i]]+=1\nt=0\nfor k in range(n):\n if (k+1)*a<=s:\n t+=dp[k][(k+1)*a]\nprint(t)", "import numpy as np", "numpy", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "s=sum(x)", "s", "sum(x)", "sum", "x", "dp=np.zeros((n,s+1),dtype=np.int64)", "dp", "np.zeros((n,s+1),dtype=np.int64)", "np.zeros", "np", "zeros", "(n,s+1)", "n", "s+1", "s", "1", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "for i in range(n):\n for j in range(i)[::-1]:\n dp[j+1][x[i]:]+=dp[j][:-x[i]]\n dp[0][x[i]]+=1", "i", "range(n)", "range", "n", "for j in range(i)[::-1]:\n dp[j+1][x[i]:]+=dp[j][:-x[i]]\n ", "j", "range(i)[::-1]", "(i)", "range", "i", "::-1", "-1", "dp[j+1][x[i]:]+=dp[j][:-x[i]]", "dp[j+1][x[i]:]", "[j+1]", "dp", "j+1", "j", "1", "x[i]:", "x[i]", "x", "i", "dp[j][:-x[i]]", "[j]", "dp", "j", ":-x[i]", "-x[i]", "x[i]", "x", "i", "dp[0][x[i]]+=1", "dp[0][x[i]]", "[0]", "dp", "0", "x[i]", "x", "i", "1", "t=0", "t", "0", "for k in range(n):\n if (k+1)*a<=s:\n t+=dp[k][(k+1)*a]", "k", "range(n)", "range", "n", "if (k+1)*a<=s:\n t+=dp[k][(k+1)*a]", "(k+1)*a<=s", "(k+1)*a", "k+1", "k", "1", "a", "s", "t+=dp[k][(k+1)*a]", "t", "dp[k][(k+1)*a]", "[k]", "dp", "k", "(k+1)*a", "k+1", "k", "1", "a", "print(t)", "print", "t", "dp=np.zeros((n,s+1),dtype=np.int64)", "np.zeros((n,s+1),dtype=np.int64)", "dp", "s=sum(x)", "sum(x)", "s", "n,a=map(int,input().split())", "map(int,input().split())", "n", "a=map(int,input().split())", "map(int,input().split())", "a", "t=0", "0", "t", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "t+=dp[k][(k+1)*a]", "dp[k][(k+1)*a]", "t" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 15, 13, 15, 13, 15, 13, 15, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 12, 13, 23, 13, 12, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 4, 13, 0, 13, 2, 13, 4, 13, 2, 13, 39, 13, 0, 13, 2, 13, 13, 0, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 2, 17, 13, 17, 13, 12, 13, 0, 13, 18, 13, 13, 14, 2, 13, 13, 14, 2, 2, 13, 17, 2, 13, 13, 0, 13, 17, 14, 2, 40, 13, 17, 2, 2, 18, 13, 2, 13, 17, 2, 13, 2, 17, 13, 2, 18, 13, 2, 13, 17, 13, 0, 13, 4, 13, 2, 13, 17, 13, 14, 2, 40, 13, 17, 40, 40, 17, 2, 13, 18, 13, 2, 13, 17, 2, 17, 13, 0, 13, 2, 4, 13, 2, 13, 17, 13, 4, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 13, 17, 0, 18, 13, 13, 13, 29, 4, 13, 13, 23, 13, 23, 13, 4, 13, 2, 4, 13, 13, 13, 17, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 304, 24 ], [ 39, 38 ], [ 314, 44 ], [ 48, 48 ], [ 52, 51 ], [ 329, 57 ], [ 61, 61 ], [ 65, 64 ], [ 320, 70 ], [ 74, 74 ], [ 78, 77 ], [ 347, 83 ], [ 87, 87 ], [ 91, 90 ], [ 320, 98 ], [ 102, 102 ], [ 106, 105 ], [ 114, 114 ], [ 118, 118 ], [ 122, 122 ], [ 124, 124 ], [ 128, 128 ], [ 130, 130 ], [ 334, 132 ], [ 138, 137 ], [ 329, 139 ], [ 138, 140 ], [ 143, 142 ], [ 329, 148 ], [ 151, 150 ], [ 137, 152 ], [ 142, 156 ], [ 161, 160 ], [ 142, 162 ], [ 140, 163 ], [ 166, 165 ], [ 137, 172 ], [ 150, 177 ], [ 305, 179 ], [ 184, 183 ], [ 165, 185 ], [ 286, 186 ], [ 183, 189 ], [ 305, 190 ], [ 286, 194 ], [ 288, 197 ], [ 150, 198 ], [ 201, 200 ], [ 286, 205 ], [ 160, 210 ], [ 286, 212 ], [ 288, 215 ], [ 150, 218 ], [ 160, 221 ], [ 286, 223 ], [ 288, 225 ], [ 228, 227 ], [ 286, 231 ], [ 288, 233 ], [ 286, 237 ], [ 288, 243 ], [ 160, 245 ], [ 286, 247 ], [ 150, 251 ], [ 254, 253 ], [ 286, 258 ], [ 288, 260 ], [ 286, 264 ], [ 288, 267 ], [ 160, 269 ], [ 286, 271 ], [ 275, 274 ], [ 280, 277 ], [ 165, 278 ], [ 286, 279 ], [ 274, 280 ], [ 253, 280 ], [ 227, 280 ], [ 200, 280 ], [ 183, 280 ], [ 274, 284 ], [ 253, 284 ], [ 227, 284 ], [ 200, 284 ], [ 183, 284 ], [ 286, 286 ], [ 288, 288 ], [ 181, 293 ], [ 137, 294 ], [ 150, 295 ], [ 341, 302 ], [ 304, 305 ], [ 334, 335 ] ]

[ "import sys\nimport numpy as np\nimport random\nfrom decimal import Decimal\nimport itertools\nimport re\nimport bisect\nfrom collections import deque, Counter\nfrom functools import lru_cache\n\nsys.setrecursionlimit(10**9)\nINF = 10**13\ndef LI(): return list(map(int, sys.stdin.buffer.readline().split()))\ndef I(): return int(sys.stdin.buffer.readline())\ndef LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()\ndef S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\ndef SRL(n): return [list(S()) for i in range(n)]\ndef MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]\ndef SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')\ndef GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]\ndef GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]\nMOD = 1000000007\n\ndef main():\n\tn, a = LI()\n\tx_list = np.array(LI())\n\tnx = n*max(x_list+[a])\n\ty_list = x_list - a\n\tdp = np.full((n+1,2*nx+1),INF)\n\n\tdef dfs(j,t):\n\t\tdp_value = dp[j,t]\n\t\tif dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\treturn int(dp_value)\n\n\tprint(dfs(n, nx) -1)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "import numpy as np", "numpy", "import random", "random", "from decimal import Decimal", "import itertools", "itertools", "import re", "re", "import bisect", "bisect", "from collections import deque, Counter", "from functools import lru_cache", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "INF = 10**13", "INF", "10**13", "10", "13", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "LI", "def I(): return int(sys.stdin.buffer.readline())", "I", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "LS", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "S", "I() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "I()", "I", "def IR(n): return [I() for i in range(n)]", "IR", "n", "n", "LI() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LI()", "LI", "def LIR(n): return [LI() for i in range(n)]", "LIR", "n", "n", "S() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "S()", "S", "def SR(n): return [S() for i in range(n)]", "SR", "n", "n", "LS() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LS()", "LS", "def LSR(n): return [LS() for i in range(n)]", "LSR", "n", "n", "list(S()) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(S())", "list", "S()", "S", "def SRL(n): return [list(S()) for i in range(n)]", "SRL", "n", "n", "[int(j) for j in list(S())] for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "[int(j) for j in list(S())]", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "MSRL", "n", "n", "def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')", "SERIES", "n", "n", "def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]", "GRID", "h", "h", "w", "w", "def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]", "GRIDfromString", "h", "h", "w", "w", "MOD = 1000000007", "MOD", "1000000007", "def main():\n\tn, a = LI()\n\tx_list = np.array(LI())\n\tnx = n*max(x_list+[a])\n\ty_list = x_list - a\n\tdp = np.full((n+1,2*nx+1),INF)\n\n\tdef dfs(j,t):\n\t\tdp_value = dp[j,t]\n\t\tif dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\treturn int(dp_value)\n\n\tprint(dfs(n, nx) -1)", "main", "n, a = LI()", "n", "LI()", "LI", "a", "x_list = np.array(LI())", "x_list", "np.array(LI())", "np.array", "np", "array", "LI()", "LI", "nx = n*max(x_list+[a])", "nx", "n*max(x_list+[a])", "n", "max(x_list+[a])", "max", "x_list+[a]", "x_list", "[a]", "a", "y_list = x_list - a", "y_list", "x_list - a", "x_list", "a", "dp = np.full((n+1,2*nx+1),INF)", "dp", "np.full((n+1,2*nx+1),INF)", "np.full", "np", "full", "(n+1,2*nx+1)", "n+1", "n", "1", "2*nx+1", "2*nx", "2", "nx", "1", "INF", "def dfs(j,t):\n\t\tdp_value = dp[j,t]\n\t\tif dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\treturn int(dp_value)\n\n\t", "dfs", "dp_value = dp[j,t]", "dp_value", "dp[j,t]", "dp", "j", "if dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\t", "dp_value == INF", "dp_value", "INF", "if j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\t", "j == 0 and t == nx", "j == 0", "j", "0", "t == nx", "t", "nx", "dp_value = 1", "dp_value", "1", "elif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\t", "j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t)", "j >= 1", "j", "1", "y_list[j-1] < t - 2*nx or y_list[j-1] > t", "y_list[j-1] < t - 2*nx", "y_list[j-1]", "y_list", "j-1", "j", "1", "t - 2*nx", "t", "2*nx", "2", "nx", "y_list[j-1] > t", "y_list[j-1]", "y_list", "j-1", "j", "1", "t", "dp_value = dfs(j-1, t)", "dp_value", "dfs(j-1, t)", "dfs", "j-1", "j", "1", "t", "elif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\t", "j >= 1 and 0 <= t - y_list[j-1] <= 2*nx", "j >= 1", "j", "1", "0 <= t - y_list[j-1] <= 2*nx", "0 <= t - y_list[j-1]", "0", "t - y_list[j-1]", "t", "y_list[j-1]", "y_list", "j-1", "j", "1", "2*nx", "2", "nx", "dp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])", "dp_value", "dfs(j-1, t) + dfs(j-1, t-y_list[j-1])", "dfs(j-1, t)", "dfs", "j-1", "j", "1", "t", "dfs(j-1, t-y_list[j-1])", "dfs", "j-1", "j", "1", "t-y_list[j-1]", "t", "y_list[j-1]", "y_list", "j-1", "j", "1", "dp_value = 0", "dp_value", "0", "dp[j,t] = dp_value", "dp[j,t]", "dp", "j", "dp_value", "return int(dp_value)", "int(dp_value)", "int", "dp_value", "j", "j", "t", "t", "print(dfs(n, nx) -1)", "print", "dfs(n, nx) -1", "dfs(n, nx)", "dfs", "n", "nx", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "INF = 10**13", "10**13", "INF", "def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]", "def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]", "GRIDfromString", "def LSR(n): return [LS() for i in range(n)]", "def LSR(n): return [LS() for i in range(n)]", "LSR", "def I(): return int(sys.stdin.buffer.readline())", "def I(): return int(sys.stdin.buffer.readline())", "I", "def LIR(n): return [LI() for i in range(n)]", "def LIR(n): return [LI() for i in range(n)]", "LIR", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "S", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "MSRL", "def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')", "def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')", "SERIES", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "LI", "def SRL(n): return [list(S()) for i in range(n)]", "def SRL(n): return [list(S()) for i in range(n)]", "SRL", "MOD = 1000000007", "1000000007", "MOD", "def SR(n): return [S() for i in range(n)]", "def SR(n): return [S() for i in range(n)]", "SR", "def main():\n\tn, a = LI()\n\tx_list = np.array(LI())\n\tnx = n*max(x_list+[a])\n\ty_list = x_list - a\n\tdp = np.full((n+1,2*nx+1),INF)\n\n\tdef dfs(j,t):\n\t\tdp_value = dp[j,t]\n\t\tif dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\treturn int(dp_value)\n\n\tprint(dfs(n, nx) -1)", "def main():\n\tn, a = LI()\n\tx_list = np.array(LI())\n\tnx = n*max(x_list+[a])\n\ty_list = x_list - a\n\tdp = np.full((n+1,2*nx+1),INF)\n\n\tdef dfs(j,t):\n\t\tdp_value = dp[j,t]\n\t\tif dp_value == INF:\n\t\t\tif j == 0 and t == nx:\n\t\t\t\tdp_value = 1\n\t\t\telif j >= 1 and (y_list[j-1] < t - 2*nx or y_list[j-1] > t):\n\t\t\t\tdp_value = dfs(j-1, t)\n\t\t\telif j >= 1 and 0 <= t - y_list[j-1] <= 2*nx:\n\t\t\t\tdp_value = dfs(j-1, t) + dfs(j-1, t-y_list[j-1])\n\t\t\telse:\n\t\t\t\tdp_value = 0\n\t\t\tdp[j,t] = dp_value\n\t\treturn int(dp_value)\n\n\tprint(dfs(n, nx) -1)", "main", "def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]", "def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]", "GRID", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "LS", "def IR(n): return [I() for i in range(n)]", "def IR(n): return [I() for i in range(n)]", "IR" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 31, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 13, 0, 13, 2, 13, 13, 0, 13, 40, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 14, 40, 40, 17, 2, 13, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 2, 13, 18, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 18, 13, 10, 18, 13 ]

[ [ 199, 4 ], [ 187, 11 ], [ 202, 18 ], [ 196, 32 ], [ 193, 37 ], [ 43, 42 ], [ 200, 49 ], [ 43, 51 ], [ 43, 52 ], [ 57, 56 ], [ 56, 60 ], [ 51, 61 ], [ 64, 63 ], [ 70, 66 ], [ 70, 69 ], [ 73, 72 ], [ 63, 72 ], [ 72, 76 ], [ 80, 79 ], [ 72, 80 ], [ 83, 82 ], [ 72, 83 ], [ 86, 85 ], [ 79, 87 ], [ 69, 87 ], [ 82, 88 ], [ 66, 88 ], [ 91, 90 ], [ 82, 92 ], [ 66, 92 ], [ 96, 95 ], [ 42, 99 ], [ 85, 106 ], [ 110, 109 ], [ 117, 112 ], [ 109, 114 ], [ 90, 116 ], [ 120, 119 ], [ 42, 122 ], [ 125, 124 ], [ 85, 128 ], [ 138, 131 ], [ 109, 133 ], [ 119, 135 ], [ 124, 137 ], [ 109, 140 ], [ 119, 141 ], [ 124, 142 ], [ 124, 148 ], [ 63, 150 ], [ 119, 151 ], [ 85, 152 ], [ 161, 154 ], [ 109, 156 ], [ 119, 158 ], [ 124, 160 ], [ 109, 163 ], [ 119, 164 ], [ 124, 166 ], [ 63, 168 ], [ 119, 169 ], [ 109, 175 ], [ 42, 176 ], [ 90, 177 ], [ 191, 185 ], [ 187, 188 ], [ 193, 194 ], [ 196, 197 ], [ 199, 200 ], [ 202, 203 ] ]

[ "import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\nsys.setrecursionlimit(10 ** 9)\nINF = 1 << 60\nMOD = 1000000007\n\n\ndef main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n neg = pos = 0\n for x in X:\n if x > 0:\n pos += x\n else:\n neg += x\n\n M = pos - neg\n base = -neg\n\n dp = [[0] * (M + 1) for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "MOD = 1000000007", "MOD", "1000000007", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n neg = pos = 0\n for x in X:\n if x > 0:\n pos += x\n else:\n neg += x\n\n M = pos - neg\n base = -neg\n\n dp = [[0] * (M + 1) for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "main", "N, A, *X = map(int, read().split())", "N", "map(int, read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "A", "*X", "X", "x - A for x in X", "for x in X", "x", "X", "for x in X", "x - A", "x", "A", "X = [x - A for x in X]", "X", "[x - A for x in X]", "neg = pos = 0", "neg", "0", "= pos = 0", "pos", "0", "for x in X:\n if x > 0:\n pos += x\n else:\n neg += x\n\n ", "x", "X", "if x > 0:\n pos += x\n else:\n neg += x\n\n ", "x > 0", "x", "0", "pos += x", "pos", "x", "neg += x", "neg", "x", "M = pos - neg", "M", "pos - neg", "pos", "neg", "base = -neg", "base", "-neg", "neg", "[0] * (M + 1) for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[0] * (M + 1)", "[0]", "0", "M + 1", "M", "1", "dp = [[0] * (M + 1) for _ in range(N + 1)]", "dp", "[[0] * (M + 1) for _ in range(N + 1)]", "dp[0][base] = 1", "dp[0][base]", "[0]", "dp", "0", "base", "1", "for i in range(N):\n for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "i", "range(N)", "range", "N", "for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "s", "range(M + 1)", "range", "M + 1", "M", "1", "dp[i + 1][s] = dp[i][s]", "dp[i + 1][s]", "[i + 1]", "dp", "i + 1", "i", "1", "s", "dp[i][s]", "[i]", "dp", "i", "s", "if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "0 <= s - X[i] <= M", "0 <= s - X[i]", "0", "s - X[i]", "s", "X[i]", "X", "i", "M", "dp[i + 1][s] += dp[i][s - X[i]]", "dp[i + 1][s]", "[i + 1]", "dp", "i + 1", "i", "1", "s", "dp[i][s - X[i]]", "[i]", "dp", "i", "s - X[i]", "s", "X[i]", "X", "i", "print(dp[N][base] - 1)", "print", "dp[N][base] - 1", "dp[N][base]", "[N]", "dp", "N", "base", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n neg = pos = 0\n for x in X:\n if x > 0:\n pos += x\n else:\n neg += x\n\n M = pos - neg\n base = -neg\n\n dp = [[0] * (M + 1) for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n neg = pos = 0\n for x in X:\n if x > 0:\n pos += x\n else:\n neg += x\n\n M = pos - neg\n base = -neg\n\n dp = [[0] * (M + 1) for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(M + 1):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= M:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "main", "MOD = 1000000007", "1000000007", "MOD", "INF = 1 << 60", "1 << 60", "INF", "read = sys.stdin.read", "sys.stdin.read", "read", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines" ]

[ 7, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 15, 15, 15, 15, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 14, 40, 40, 17, 2, 13, 18, 13, 2, 13, 17, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 4, 13, 2, 18, 18, 13, 17, 17, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 26, 25 ], [ 6, 32 ], [ 26, 34 ], [ 37, 36 ], [ 6, 45 ], [ 49, 48 ], [ 25, 51 ], [ 56, 53 ], [ 36, 54 ], [ 48, 55 ], [ 34, 56 ], [ 60, 59 ], [ 25, 63 ], [ 72, 71 ], [ 79, 74 ], [ 71, 76 ], [ 82, 81 ], [ 25, 86 ], [ 90, 89 ], [ 100, 95 ], [ 71, 97 ], [ 81, 98 ], [ 89, 99 ], [ 71, 102 ], [ 81, 104 ], [ 89, 106 ], [ 89, 112 ], [ 36, 114 ], [ 81, 116 ], [ 125, 120 ], [ 71, 122 ], [ 81, 123 ], [ 89, 124 ], [ 71, 127 ], [ 81, 129 ], [ 89, 132 ], [ 36, 134 ], [ 81, 136 ], [ 71, 143 ], [ 155, 152 ] ]

[ "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,a = map(int, input().split())\n x = list(map(int, input().split()))\n for i in range(n):\n x[i] -= a\n dp = [[0]*5001 for _ in range(n+1)]\n\n dp[0][0] = 1\n\n for i in range(1, n+1):\n for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n print(dp[-1][0]-1)\n\nif __name__ == '__main__':\n main()", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,a = map(int, input().split())\n x = list(map(int, input().split()))\n for i in range(n):\n x[i] -= a\n dp = [[0]*5001 for _ in range(n+1)]\n\n dp[0][0] = 1\n\n for i in range(1, n+1):\n for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n print(dp[-1][0]-1)", "main", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "from collections import Counter, deque", "from itertools import combinations, permutations, accumulate, groupby, product", "from bisect import bisect_left,bisect_right", "from heapq import heapify, heappop, heappush", "from math import floor, ceil", "n,a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n x[i] -= a\n ", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "[0]*5001 for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0]*5001", "[0]", "0", "5001", "dp = [[0]*5001 for _ in range(n+1)]", "dp", "[[0]*5001 for _ in range(n+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(1, n+1):\n for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n ", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n ", "j", "range(-2500, 2501)", "range", "-2500", "2501", "dp[i][j] += dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n ", "-2500 <= j-x[i-1] <= 2500", "-2500 <= j-x[i-1]", "-2500", "j-x[i-1]", "j", "x[i-1]", "x", "i-1", "i", "1", "2500", "dp[i][j] += dp[i-1][j-x[i-1]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j-x[i-1]]", "[i-1]", "dp", "i-1", "i", "1", "j-x[i-1]", "j", "x[i-1]", "x", "i-1", "i", "1", "print(dp[-1][0]-1)", "print", "dp[-1][0]-1", "dp[-1][0]", "[-1]", "dp", "-1", "0", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,a = map(int, input().split())\n x = list(map(int, input().split()))\n for i in range(n):\n x[i] -= a\n dp = [[0]*5001 for _ in range(n+1)]\n\n dp[0][0] = 1\n\n for i in range(1, n+1):\n for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n print(dp[-1][0]-1)", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,a = map(int, input().split())\n x = list(map(int, input().split()))\n for i in range(n):\n x[i] -= a\n dp = [[0]*5001 for _ in range(n+1)]\n\n dp[0][0] = 1\n\n for i in range(1, n+1):\n for j in range(-2500, 2501):\n dp[i][j] += dp[i-1][j]\n if -2500 <= j-x[i-1] <= 2500:\n dp[i][j] += dp[i-1][j-x[i-1]]\n print(dp[-1][0]-1)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 39, 17, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 4, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 4, 13, 13, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 17, 14, 2, 40, 13, 17, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 2, 2, 40, 13, 17, 40, 13, 17, 40, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 38, 5, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 213, 2 ], [ 213, 11 ], [ 216, 13 ], [ 204, 25 ], [ 217, 29 ], [ 33, 32 ], [ 214, 36 ], [ 219, 41 ], [ 205, 45 ], [ 217, 45 ], [ 49, 48 ], [ 214, 52 ], [ 56, 55 ], [ 214, 59 ], [ 63, 62 ], [ 205, 69 ], [ 217, 69 ], [ 214, 70 ], [ 48, 76 ], [ 55, 79 ], [ 62, 82 ], [ 92, 85 ], [ 220, 88 ], [ 48, 89 ], [ 55, 90 ], [ 62, 91 ], [ 48, 96 ], [ 62, 99 ], [ 205, 101 ], [ 217, 101 ], [ 48, 102 ], [ 111, 104 ], [ 220, 107 ], [ 48, 108 ], [ 55, 109 ], [ 62, 110 ], [ 220, 114 ], [ 48, 116 ], [ 55, 118 ], [ 62, 119 ], [ 48, 124 ], [ 55, 127 ], [ 62, 130 ], [ 205, 132 ], [ 217, 132 ], [ 48, 133 ], [ 142, 135 ], [ 220, 138 ], [ 48, 139 ], [ 55, 140 ], [ 62, 141 ], [ 220, 146 ], [ 48, 148 ], [ 55, 150 ], [ 62, 151 ], [ 220, 155 ], [ 48, 157 ], [ 55, 160 ], [ 62, 163 ], [ 205, 165 ], [ 217, 165 ], [ 48, 166 ], [ 175, 168 ], [ 220, 171 ], [ 48, 172 ], [ 55, 173 ], [ 62, 174 ], [ 222, 177 ], [ 181, 180 ], [ 214, 185 ], [ 210, 190 ], [ 220, 194 ], [ 214, 195 ], [ 180, 196 ], [ 180, 198 ], [ 208, 199 ], [ 211, 202 ], [ 223, 202 ], [ 204, 205 ], [ 213, 208 ], [ 210, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 222, 223 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nx = [0] + x\ndp = [[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)]\nx.sort()\nfor j in range(n+1):\n for k in range(n+1):\n for s in range(max(x)*n+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n else:\n dp[j][k][s] = 0\n\nans = 0\nfor k in range(1, n+1):\n try:\n ans += dp[n][k][k*a]\n except:\n pass\n\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x = [0] + x", "x", "[0] + x", "[0]", "0", "x", "[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)]", "dp = [[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)]", "dp", "[[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)]", "x.sort()", "x.sort", "x", "sort", "for j in range(n+1):\n for k in range(n+1):\n for s in range(max(x)*n+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n else:\n dp[j][k][s] = 0", "j", "range(n+1)", "range", "n+1", "n", "1", "for k in range(n+1):\n for s in range(max(x)*n+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n else:\n dp[j][k][s] = 0", "k", "range(n+1)", "range", "n+1", "n", "1", "for s in range(max(x)*n+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n else:\n dp[j][k][s] = 0", "s", "range(max(x)*n+1)", "range", "max(x)*n+1", "max(x)*n", "max(x)", "max", "x", "n", "1", "if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n else:\n dp[j][k][s] = 0", "j == 0 and k == 0 and s == 0", "j == 0 and k == 0", "j == 0", "j", "0", "k == 0", "k", "0", "s == 0", "s", "0", "dp[j][k][s] = 1", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "1", "elif j >= 1 and s < x[j]:\n dp[j][k][s] = dp[j-1][k][s]\n ", "j >= 1 and s < x[j]", "j >= 1", "j", "1", "s < x[j]", "s", "x[j]", "x", "j", "dp[j][k][s] = dp[j-1][k][s]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "s", "elif j >= 1 and k >= 1 and s >= x[j]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n ", "j >= 1 and k >= 1 and s >= x[j]", "j >= 1 and k >= 1", "j >= 1", "j", "1", "k >= 1", "k", "1", "s >= x[j]", "s", "x[j]", "x", "j", "dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "s", "dp[j-1][k-1][s-x[j]]", "[k-1]", "[j-1]", "dp", "j-1", "j", "1", "k-1", "k", "1", "s-x[j]", "s", "x[j]", "x", "j", "dp[j][k][s] = 0", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "0", "ans = 0", "ans", "0", "for k in range(1, n+1):\n try:\n ans += dp[n][k][k*a]\n except:\n pass", "k", "range(1, n+1)", "range", "1", "n+1", "n", "1", "try:\n ans += dp[n][k][k*a]\n except:\n pass", "except:\n pass", "ans += dp[n][k][k*a]", "ans", "dp[n][k][k*a]", "[k]", "[n]", "dp", "n", "k", "k*a", "k", "a", "print(ans)", "print", "ans", "x = [0] + x", "[0] + x", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "ans += dp[n][k][k*a]", "dp[n][k][k*a]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "dp = [[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)]", "[[[0 for _ in range(max(x)*n+1)] for _ in range(n+1)] for _ in range(n+1)]", "dp", "ans = 0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 18, 18, 18, 13, 13, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 166, 2 ], [ 166, 11 ], [ 151, 13 ], [ 154, 25 ], [ 152, 30 ], [ 167, 31 ], [ 35, 34 ], [ 164, 38 ], [ 160, 43 ], [ 53, 46 ], [ 161, 49 ], [ 56, 55 ], [ 164, 58 ], [ 61, 60 ], [ 164, 64 ], [ 68, 67 ], [ 164, 72 ], [ 167, 73 ], [ 161, 80 ], [ 55, 81 ], [ 60, 82 ], [ 67, 83 ], [ 95, 86 ], [ 161, 89 ], [ 55, 91 ], [ 60, 93 ], [ 67, 94 ], [ 161, 98 ], [ 55, 99 ], [ 60, 100 ], [ 67, 101 ], [ 118, 103 ], [ 161, 106 ], [ 55, 108 ], [ 60, 111 ], [ 67, 114 ], [ 152, 116 ], [ 55, 117 ], [ 161, 121 ], [ 55, 122 ], [ 60, 123 ], [ 67, 124 ], [ 169, 126 ], [ 130, 129 ], [ 164, 134 ], [ 157, 137 ], [ 161, 141 ], [ 164, 142 ], [ 129, 143 ], [ 167, 145 ], [ 129, 146 ], [ 158, 149 ], [ 170, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ], [ 166, 164 ], [ 166, 167 ], [ 169, 170 ] ]

[ "N, A = map(int, input().split())\nx = list(map(int, input().split()))\nmaxX = max(max(x), A)\ndp = [[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)]\ndp[0][0][0] = 1\nfor i in range(N):\n for j in range(N + 1):\n for k in range(N * A + 1):\n if dp[i][j][k] == 0: continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]\n\nans = 0\nfor i in range(1, N + 1):\n ans += dp[N][i][A * i]\nprint(ans)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "maxX = max(max(x), A)", "maxX", "max(max(x), A)", "max", "max(x)", "max", "x", "A", "[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)]", "dp = [[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)]", "dp", "[[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(N + 1):\n for k in range(N * A + 1):\n if dp[i][j][k] == 0: continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]", "i", "range(N)", "range", "N", "for j in range(N + 1):\n for k in range(N * A + 1):\n if dp[i][j][k] == 0: continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]", "j", "range(N + 1)", "range", "N + 1", "N", "1", "for k in range(N * A + 1):\n if dp[i][j][k] == 0: continue\n dp[i + 1][j][k] += dp[i][j][k]\n dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]", "k", "range(N * A + 1)", "range", "N * A + 1", "N * A", "N", "A", "1", "if dp[i][j][k] == 0: continue\n ", "dp[i][j][k] == 0", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "0", "dp[i + 1][j][k] += dp[i][j][k]", "dp[i + 1][j][k]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]", "dp[i + 1][j + 1][k + x[i]]", "[j + 1]", "[i + 1]", "dp", "i + 1", "i", "1", "j + 1", "j", "1", "k + x[i]", "k", "x[i]", "x", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans = 0", "ans", "0", "for i in range(1, N + 1):\n ans += dp[N][i][A * i]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "ans += dp[N][i][A * i]", "ans", "dp[N][i][A * i]", "[i]", "[N]", "dp", "N", "i", "A * i", "A", "i", "print(ans)", "print", "ans", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "maxX = max(max(x), A)", "max(max(x), A)", "maxX", "ans += dp[N][i][A * i]", "dp[N][i][A * i]", "ans", "dp = [[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)]", "[[[0 for _ in range(N * maxX + 1)] for _ in range(N + 1)] for _ in range(N + 1)]", "dp", "N, A = map(int, input().split())", "map(int, input().split())", "N", "A = map(int, input().split())", "map(int, input().split())", "A", "ans = 0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 31, 13, 41, 28, 13, 13, 4, 2, 18, 13, 17, 13, 0, 13, 13, 0, 13, 2, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 13, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 40, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 114, 2 ], [ 114, 15 ], [ 20, 19 ], [ 19, 26 ], [ 123, 28 ], [ 117, 31 ], [ 115, 33 ], [ 40, 39 ], [ 115, 43 ], [ 118, 51 ], [ 120, 55 ], [ 63, 58 ], [ 121, 60 ], [ 66, 65 ], [ 115, 70 ], [ 74, 73 ], [ 118, 77 ], [ 118, 78 ], [ 85, 80 ], [ 121, 82 ], [ 65, 83 ], [ 73, 84 ], [ 121, 88 ], [ 65, 90 ], [ 73, 92 ], [ 121, 95 ], [ 65, 97 ], [ 73, 100 ], [ 124, 102 ], [ 65, 103 ], [ 121, 109 ], [ 115, 110 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "n,*x=map(int,open(0).read().split())\ny=[x[0]-i for i in x]\nm=n*max(x)\ndp=[[0]*(m*2+1) for _ in range(n+1)]\ndp[0][0]=1\nfor i in range(1,n+1):\n\tfor s in range(-m,m):\n\t\tdp[i][s]=dp[i-1][s]+dp[i-1][s-y[i]]\nprint(dp[n][0]-1)", "n,*x=map(int,open(0).read().split())", "n", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "*x", "x", "x[0]-i for i in x", "for i in x", "i", "x", "for i in x", "x[0]-i", "x[0]", "x", "0", "i", "y=[x[0]-i for i in x]", "y", "[x[0]-i for i in x]", "m=n*max(x)", "m", "n*max(x)", "n", "max(x)", "max", "x", "[0]*(m*2+1) for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0]*(m*2+1)", "[0]", "0", "m*2+1", "m*2", "m", "2", "1", "dp=[[0]*(m*2+1) for _ in range(n+1)]", "dp", "[[0]*(m*2+1) for _ in range(n+1)]", "dp[0][0]=1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(1,n+1):\n\tfor s in range(-m,m):\n\t\tdp[i][s]=dp[i-1][s]+dp[i-1][s-y[i]]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "for s in range(-m,m):\n\t\tdp[i][s]=dp[i-1][s]+dp[i-1][s-y[i]]", "s", "range(-m,m)", "range", "-m", "m", "m", "dp[i][s]=dp[i-1][s]+dp[i-1][s-y[i]]", "dp[i][s]", "[i]", "dp", "i", "s", "dp[i-1][s]+dp[i-1][s-y[i]]", "dp[i-1][s]", "[i-1]", "dp", "i-1", "i", "1", "s", "dp[i-1][s-y[i]]", "[i-1]", "dp", "i-1", "i", "1", "s-y[i]", "s", "y[i]", "y", "i", "print(dp[n][0]-1)", "print", "dp[n][0]-1", "dp[n][0]", "[n]", "dp", "n", "0", "1", "n,*x=map(int,open(0).read().split())", "map(int,open(0).read().split())", "n", "m=n*max(x)", "n*max(x)", "m", "dp=[[0]*(m*2+1) for _ in range(n+1)]", "[[0]*(m*2+1) for _ in range(n+1)]", "dp", "y=[x[0]-i for i in x]", "[x[0]-i for i in x]", "y" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 31, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 14, 40, 40, 17, 2, 13, 18, 13, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 2, 13, 18, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13, 10, 17, 13, 10, 18, 13, 10, 18, 13, 10, 2, 13 ]

[ [ 170, 4 ], [ 158, 11 ], [ 167, 18 ], [ 173, 32 ], [ 164, 37 ], [ 43, 42 ], [ 171, 49 ], [ 43, 51 ], [ 43, 52 ], [ 57, 56 ], [ 56, 60 ], [ 51, 61 ], [ 64, 63 ], [ 67, 66 ], [ 71, 70 ], [ 42, 74 ], [ 83, 82 ], [ 90, 85 ], [ 82, 87 ], [ 66, 89 ], [ 93, 92 ], [ 42, 95 ], [ 98, 97 ], [ 109, 102 ], [ 82, 104 ], [ 92, 106 ], [ 97, 108 ], [ 82, 111 ], [ 92, 112 ], [ 97, 113 ], [ 97, 119 ], [ 63, 121 ], [ 92, 122 ], [ 132, 125 ], [ 82, 127 ], [ 92, 129 ], [ 97, 131 ], [ 82, 134 ], [ 92, 135 ], [ 97, 137 ], [ 63, 139 ], [ 92, 140 ], [ 82, 146 ], [ 42, 147 ], [ 66, 148 ], [ 162, 156 ], [ 158, 159 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ] ]

[ "import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\nsys.setrecursionlimit(10 ** 9)\nINF = 1 << 60\nMOD = 1000000007\n\n\ndef main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "MOD = 1000000007", "MOD", "1000000007", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "main", "N, A, *X = map(int, read().split())", "N", "map(int, read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "A", "*X", "X", "x - A for x in X", "for x in X", "x", "X", "for x in X", "x - A", "x", "A", "X = [x - A for x in X]", "X", "[x - A for x in X]", "base = 2500", "base", "2500", "[0] * 5001 for _ in range(N + 1)", "for _ in range(N + 1)", "_", "range(N + 1)", "range", "N + 1", "N", "1", "for _ in range(N + 1)", "[0] * 5001", "[0]", "0", "5001", "dp = [[0] * 5001 for _ in range(N + 1)]", "dp", "[[0] * 5001 for _ in range(N + 1)]", "dp[0][base] = 1", "dp[0][base]", "[0]", "dp", "0", "base", "1", "for i in range(N):\n for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "i", "range(N)", "range", "N", "for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "s", "range(5001)", "range", "5001", "dp[i + 1][s] = dp[i][s]", "dp[i + 1][s]", "[i + 1]", "dp", "i + 1", "i", "1", "s", "dp[i][s]", "[i]", "dp", "i", "s", "if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n ", "0 <= s - X[i] <= 5000", "0 <= s - X[i]", "0", "s - X[i]", "s", "X[i]", "X", "i", "5000", "dp[i + 1][s] += dp[i][s - X[i]]", "dp[i + 1][s]", "[i + 1]", "dp", "i + 1", "i", "1", "s", "dp[i][s - X[i]]", "[i]", "dp", "i", "s - X[i]", "s", "X[i]", "X", "i", "print(dp[N][base] - 1)", "print", "dp[N][base] - 1", "dp[N][base]", "[N]", "dp", "N", "base", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n base = 2500\n dp = [[0] * 5001 for _ in range(N + 1)]\n dp[0][base] = 1\n\n for i in range(N):\n for s in range(5001):\n dp[i + 1][s] = dp[i][s]\n if 0 <= s - X[i] <= 5000:\n dp[i + 1][s] += dp[i][s - X[i]]\n\n print(dp[N][base] - 1)\n return", "main", "MOD = 1000000007", "1000000007", "MOD", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "read = sys.stdin.read", "sys.stdin.read", "read", "INF = 1 << 60", "1 << 60", "INF" ]

[ 7, 15, 13, 12, 13, 0, 13, 17, 0, 13, 4, 13, 17, 4, 18, 13, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 14, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 10, 9 ], [ 36, 35 ], [ 25, 37 ], [ 36, 38 ], [ 41, 40 ], [ 29, 42 ], [ 46, 45 ], [ 40, 45 ], [ 45, 49 ], [ 38, 50 ], [ 53, 52 ], [ 57, 56 ], [ 35, 60 ], [ 69, 68 ], [ 76, 71 ], [ 68, 73 ], [ 79, 78 ], [ 35, 81 ], [ 84, 83 ], [ 68, 90 ], [ 78, 91 ], [ 83, 92 ], [ 105, 94 ], [ 68, 96 ], [ 78, 98 ], [ 83, 101 ], [ 52, 103 ], [ 78, 104 ], [ 68, 107 ], [ 78, 108 ], [ 83, 109 ], [ 118, 111 ], [ 68, 113 ], [ 78, 115 ], [ 83, 117 ], [ 68, 120 ], [ 78, 121 ], [ 83, 122 ], [ 68, 128 ], [ 35, 129 ], [ 140, 137 ] ]

[ "#!/usr/bin/env python3\n\nimport sys\n# import math\n# from string import ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits\n# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)\n# from operator import itemgetter # itemgetter(1), itemgetter('key')\n# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()\n# from collections import defaultdict # subclass of dict. defaultdict(facroty)\n# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)\n# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).\n# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).\n# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])\n# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]\n# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]\n# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])\n# from itertools import combinations, combinations_with_replacement\n# from itertools import accumulate # accumulate(iter[, f])\n# from functools import reduce # reduce(f, iter[, init])\n# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)\n# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).\n# from copy import deepcopy # to copy multi-dimentional matrix without reference\n# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)\n\n\ndef main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, a = mi()\n L = lmi()\n diff = [elm - a for elm in L]\n # dp[i][num] = (diff から i 番目までを使用して和を num - 2500 にする場合の数)\n dp = [[0] * 5001 for _ in range(n + 1)]\n dp[0][2500] = 1\n\n for i in range(n):\n for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n print(dp[n][2500] - 1) # n 番目までを使用して和を 0 にするには？ 最初の何も選ばない 1 通りを除く\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, a = mi()\n L = lmi()\n diff = [elm - a for elm in L]\n # dp[i][num] = (diff から i 番目までを使用して和を num - 2500 にする場合の数)\n dp = [[0] * 5001 for _ in range(n + 1)]\n dp[0][2500] = 1\n\n for i in range(n):\n for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n print(dp[n][2500] - 1) # n 番目までを使用して和を 0 にするには？ 最初の何も選ばない 1 通りを除く", "main", "mod = 1000000007", "mod", "1000000007", "inf = float('inf')", "inf", "float('inf')", "float", "'inf'", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "def input(): return sys.stdin.readline().rstrip()\n ", "input", "def ii(): return int(input())\n ", "ii", "def mi(): return map(int, input().split())\n ", "mi", "def mi_0(): return map(lambda x: int(x)-1, input().split())\n ", "mi_0", "def lmi(): return list(map(int, input().split()))\n ", "lmi", "def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n ", "lmi_0", "def li(): return list(input())\n \n \n ", "li", "n, a = mi()", "n", "mi()", "mi", "a", "L = lmi()", "L", "lmi()", "lmi", "elm - a for elm in L", "for elm in L", "elm", "L", "for elm in L", "elm - a", "elm", "a", "diff = [elm - a for elm in L]", "diff", "[elm - a for elm in L]", "[0] * 5001 for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[0] * 5001", "[0]", "0", "5001", "dp = [[0] * 5001 for _ in range(n + 1)]", "dp", "[[0] * 5001 for _ in range(n + 1)]", "dp[0][2500] = 1", "dp[0][2500]", "[0]", "dp", "0", "2500", "1", "for i in range(n):\n for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n ", "i", "range(n)", "range", "n", "for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n ", "j", "range(5001)", "range", "5001", "if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n ", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i+1][j + diff[i]] += dp[i][j]", "dp[i+1][j + diff[i]]", "[i+1]", "dp", "i+1", "i", "1", "j + diff[i]", "j", "diff[i]", "diff", "i", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i+1][j] += dp[i][j]", "dp[i+1][j]", "[i+1]", "dp", "i+1", "i", "1", "j", "dp[i][j]", "[i]", "dp", "i", "j", "print(dp[n][2500] - 1)", "print", "dp[n][2500] - 1", "dp[n][2500]", "[n]", "dp", "n", "2500", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, a = mi()\n L = lmi()\n diff = [elm - a for elm in L]\n # dp[i][num] = (diff から i 番目までを使用して和を num - 2500 にする場合の数)\n dp = [[0] * 5001 for _ in range(n + 1)]\n dp[0][2500] = 1\n\n for i in range(n):\n for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n print(dp[n][2500] - 1) # n 番目までを使用して和を 0 にするには？ 最初の何も選ばない 1 通りを除く", "def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, a = mi()\n L = lmi()\n diff = [elm - a for elm in L]\n # dp[i][num] = (diff から i 番目までを使用して和を num - 2500 にする場合の数)\n dp = [[0] * 5001 for _ in range(n + 1)]\n dp[0][2500] = 1\n\n for i in range(n):\n for j in range(5001):\n if dp[i][j]:\n dp[i+1][j + diff[i]] += dp[i][j]\n dp[i+1][j] += dp[i][j]\n \n\n print(dp[n][2500] - 1) # n 番目までを使用して和を 0 にするには？ 最初の何も選ばない 1 通りを除く", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 17, 14, 40, 18, 18, 18, 13, 13, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 4, 13, 4, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 130, 2 ], [ 130, 11 ], [ 136, 13 ], [ 27, 26 ], [ 131, 30 ], [ 133, 35 ], [ 45, 38 ], [ 134, 41 ], [ 48, 47 ], [ 131, 50 ], [ 53, 52 ], [ 131, 56 ], [ 60, 59 ], [ 134, 68 ], [ 47, 69 ], [ 52, 70 ], [ 59, 71 ], [ 83, 74 ], [ 134, 77 ], [ 47, 79 ], [ 52, 81 ], [ 59, 82 ], [ 134, 86 ], [ 47, 87 ], [ 52, 88 ], [ 59, 89 ], [ 106, 91 ], [ 134, 94 ], [ 47, 96 ], [ 52, 99 ], [ 59, 102 ], [ 137, 104 ], [ 47, 105 ], [ 134, 109 ], [ 47, 110 ], [ 52, 111 ], [ 59, 112 ], [ 134, 120 ], [ 131, 121 ], [ 128, 125 ], [ 130, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ] ]

[ "N,A=map(int,input().split())\nx=list(map(int,input().split()))\ndp=[[[0]*2600 for j in range(N+10)] for i in range(N+10)]\ndp[0][0][0]=1\nfor i in range(N):\n for j in range(N+1):\n for k in range(2501):\n if(dp[i][j][k]!=0):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\nprint(sum(dp[N][i][i*A] for i in range(1,N+1)))", "N,A=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0]*2600 for j in range(N+10)] for i in range(N+10)", "for i in range(N+10)", "i", "range(N+10)", "range", "N+10", "N", "10", "for i in range(N+10)", "[[0]*2600 for j in range(N+10)]", "dp=[[[0]*2600 for j in range(N+10)] for i in range(N+10)]", "dp", "[[[0]*2600 for j in range(N+10)] for i in range(N+10)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(N+1):\n for k in range(2501):\n if(dp[i][j][k]!=0):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "i", "range(N)", "range", "N", "for j in range(N+1):\n for k in range(2501):\n if(dp[i][j][k]!=0):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "j", "range(N+1)", "range", "N+1", "N", "1", "for k in range(2501):\n if(dp[i][j][k]!=0):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "k", "range(2501)", "range", "2501", "if(dp[i][j][k]!=0):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "dp[i][j][k]!=0", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "0", "dp[i+1][j][k]+=dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "dp[i+1][j+1][k+x[i]]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k+x[i]", "k", "x[i]", "x", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "print(sum(dp[N][i][i*A] for i in range(1,N+1)))", "print", "sum(dp[N][i][i*A] for i in range(1,N+1))", "sum", "dp[N][i][i*A]", "[i]", "[N]", "dp", "N", "i", "i*A", "i", "A", "A=map(int,input().split())", "map(int,input().split())", "A", "N,A=map(int,input().split())", "map(int,input().split())", "N", "dp=[[[0]*2600 for j in range(N+10)] for i in range(N+10)]", "[[[0]*2600 for j in range(N+10)] for i in range(N+10)]", "dp", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 13, 4, 13, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 40, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 155, 2 ], [ 155, 11 ], [ 158, 13 ], [ 146, 25 ], [ 156, 27 ], [ 32, 31 ], [ 156, 35 ], [ 149, 40 ], [ 50, 43 ], [ 150, 46 ], [ 159, 56 ], [ 60, 59 ], [ 156, 63 ], [ 67, 66 ], [ 147, 70 ], [ 80, 73 ], [ 150, 76 ], [ 59, 78 ], [ 66, 79 ], [ 150, 83 ], [ 59, 87 ], [ 66, 88 ], [ 66, 92 ], [ 101, 94 ], [ 150, 97 ], [ 59, 99 ], [ 66, 100 ], [ 150, 104 ], [ 59, 109 ], [ 66, 112 ], [ 143, 115 ], [ 119, 118 ], [ 156, 123 ], [ 152, 126 ], [ 150, 130 ], [ 118, 132 ], [ 141, 134 ], [ 118, 135 ], [ 153, 138 ], [ 144, 138 ], [ 155, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ] ]

[ "N, A = map(int, input().split())\nX = list(map(int, input().split()))\nn = N * 50\ndp = [[[0]*(n+1) for j in range(N+1)] for i in range(N+1)]\ndp[0][0][0] = 1\n\nfor i, a in enumerate(X, 1):\n for j in range(N+1):\n for s in range(n+1):\n dp[i][j][s] = dp[i-1][j][s]\n if a <= s:\n dp[i][j][s] += dp[i-1][j-1][s-a]\n\nans = 0\nfor m in range(1, N+1):\n ans += dp[-1][m][A*m]\n\nprint(ans)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "n = N * 50", "n", "N * 50", "N", "50", "[[0]*(n+1) for j in range(N+1)] for i in range(N+1)", "for i in range(N+1)", "i", "range(N+1)", "range", "N+1", "N", "1", "for i in range(N+1)", "[[0]*(n+1) for j in range(N+1)]", "dp = [[[0]*(n+1) for j in range(N+1)] for i in range(N+1)]", "dp", "[[[0]*(n+1) for j in range(N+1)] for i in range(N+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i, a in enumerate(X, 1):\n for j in range(N+1):\n for s in range(n+1):\n dp[i][j][s] = dp[i-1][j][s]\n if a <= s:\n dp[i][j][s] += dp[i-1][j-1][s-a]", "i", "a", "enumerate(X, 1)", "enumerate", "X", "1", "for j in range(N+1):\n for s in range(n+1):\n dp[i][j][s] = dp[i-1][j][s]\n if a <= s:\n dp[i][j][s] += dp[i-1][j-1][s-a]", "j", "range(N+1)", "range", "N+1", "N", "1", "for s in range(n+1):\n dp[i][j][s] = dp[i-1][j][s]\n if a <= s:\n dp[i][j][s] += dp[i-1][j-1][s-a]", "s", "range(n+1)", "range", "n+1", "n", "1", "dp[i][j][s] = dp[i-1][j][s]", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "dp[i-1][j][s]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "s", "if a <= s:\n dp[i][j][s] += dp[i-1][j-1][s-a]", "a <= s", "a", "s", "dp[i][j][s] += dp[i-1][j-1][s-a]", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "dp[i-1][j-1][s-a]", "[j-1]", "[i-1]", "dp", "i-1", "i", "1", "j-1", "j", "1", "s-a", "s", "a", "ans = 0", "ans", "0", "for m in range(1, N+1):\n ans += dp[-1][m][A*m]", "m", "range(1, N+1)", "range", "1", "N+1", "N", "1", "ans += dp[-1][m][A*m]", "ans", "dp[-1][m][A*m]", "[m]", "[-1]", "dp", "-1", "m", "A*m", "A", "m", "print(ans)", "print", "ans", "A = map(int, input().split())", "map(int, input().split())", "A", "ans = 0", "0", "ans", "n = N * 50", "N * 50", "n", "dp = [[[0]*(n+1) for j in range(N+1)] for i in range(N+1)]", "[[[0]*(n+1) for j in range(N+1)] for i in range(N+1)]", "dp", "ans += dp[-1][m][A*m]", "dp[-1][m][A*m]", "ans", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X" ]

[ 7, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 0, 13, 4, 13, 39, 17, 28, 13, 13, 0, 13, 4, 13, 28, 13, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 13, 0, 13, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 77, 3 ], [ 77, 12 ], [ 83, 14 ], [ 75, 26 ], [ 71, 34 ], [ 41, 40 ], [ 84, 40 ], [ 80, 43 ], [ 72, 51 ], [ 87, 51 ], [ 59, 54 ], [ 81, 55 ], [ 40, 58 ], [ 86, 61 ], [ 81, 62 ], [ 87, 67 ], [ 72, 67 ], [ 71, 72 ], [ 77, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 81, 86 ], [ 86, 87 ] ]

[ "from collections import Counter\nn,a=map(int,input().split())\nX=sorted(list(map(lambda x:int(x)-a,input().split())))\nans=Counter([0])\nfor x in X:\n tmp=Counter()\n for i,j in ans.items():\n tmp[i+x]+=j\n ans+=tmp\nprint(ans[0]-1)\n", "from collections import Counter", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X=sorted(list(map(lambda x:int(x)-a,input().split())))", "X", "sorted(list(map(lambda x:int(x)-a,input().split())))", "sorted", "list(map(lambda x:int(x)-a,input().split()))", "list", "map(lambda x:int(x)-a,input().split())", "map", "lambda x:int(x)-a", "int(x)-a", "int(x)", "int", "x", "a", "x", "input().split()", "().split", "()", "input", "split", "ans=Counter([0])", "ans", "Counter([0])", "Counter", "[0]", "0", "for x in X:\n tmp=Counter()\n for i,j in ans.items():\n tmp[i+x]+=j\n ans+=tmp", "x", "X", "tmp=Counter()", "tmp", "Counter()", "Counter", "for i,j in ans.items():\n tmp[i+x]+=j\n ", "i", "j", "ans.items()", "ans.items", "ans", "items", "tmp[i+x]+=j", "tmp[i+x]", "tmp", "i+x", "i", "x", "j", "ans+=tmp", "ans", "tmp", "print(ans[0]-1)", "print", "ans[0]-1", "ans[0]", "ans", "0", "1", "ans=Counter([0])", "Counter([0])", "ans", "a=map(int,input().split())", "map(int,input().split())", "a", "n,a=map(int,input().split())", "map(int,input().split())", "n", "tmp=Counter()", "Counter()", "tmp", "X=sorted(list(map(lambda x:int(x)-a,input().split())))", "sorted(list(map(lambda x:int(x)-a,input().split())))", "X", "ans+=tmp", "tmp", "ans" ]

[ 7, 15, 13, 4, 18, 13, 13, 17, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 15, 28, 13, 13, 41, 28, 13, 13, 4, 18, 13, 39, 0, 13, 13, 28, 13, 13, 4, 13, 4, 13, 13, 4, 13, 2, 13, 17, 14, 40, 2, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 18, 18, 13, 13, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 40, 2, 13, 13, 13, 0, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 177, 9 ], [ 171, 14 ], [ 174, 21 ], [ 36, 35 ], [ 175, 42 ], [ 36, 44 ], [ 47, 46 ], [ 175, 55 ], [ 59, 58 ], [ 46, 61 ], [ 65, 64 ], [ 35, 68 ], [ 58, 75 ], [ 79, 78 ], [ 86, 81 ], [ 78, 83 ], [ 90, 89 ], [ 46, 89 ], [ 94, 93 ], [ 78, 93 ], [ 137, 93 ], [ 93, 97 ], [ 101, 100 ], [ 35, 109 ], [ 58, 113 ], [ 89, 119 ], [ 58, 120 ], [ 131, 122 ], [ 100, 124 ], [ 89, 130 ], [ 78, 133 ], [ 137, 133 ], [ 138, 137 ], [ 100, 138 ], [ 141, 140 ], [ 144, 143 ], [ 35, 148 ], [ 143, 153 ], [ 44, 154 ], [ 58, 155 ], [ 158, 157 ], [ 137, 160 ], [ 78, 160 ], [ 143, 161 ], [ 143, 163 ], [ 44, 164 ], [ 157, 167 ], [ 140, 167 ], [ 181, 169 ], [ 171, 172 ], [ 174, 175 ], [ 177, 178 ] ]

[ "import sys\nsys.setrecursionlimit(2147483647)\nINF=float(\"inf\")\nMOD=10**9+7\ninput=lambda :sys.stdin.readline().rstrip()\ndef resolve():\n n,a=map(int,input().split())\n X=list(map(int,input().split()))\n M=sum(X)\n dp=[[0]*(M+1) for _ in range(n+1)]\n dp[0][0]=1\n\n from itertools import product\n for x in X:\n ndp=[y[:] for y in dp]\n for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n dp=ndp\n\n ans=0\n for i in range(1,n+1):\n if(i*a<=M):\n ans+=dp[i][i*a]\n print(ans)\nresolve()", "import sys", "sys", "sys.setrecursionlimit(2147483647)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "2147483647", "INF=float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "MOD=10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "input=lambda :sys.stdin.readline().rstrip()", "input", "lambda :sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "def resolve():\n n,a=map(int,input().split())\n X=list(map(int,input().split()))\n M=sum(X)\n dp=[[0]*(M+1) for _ in range(n+1)]\n dp[0][0]=1\n\n from itertools import product\n for x in X:\n ndp=[y[:] for y in dp]\n for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n dp=ndp\n\n ans=0\n for i in range(1,n+1):\n if(i*a<=M):\n ans+=dp[i][i*a]\n print(ans)", "resolve", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X=list(map(int,input().split()))", "X", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M=sum(X)", "M", "sum(X)", "sum", "X", "[0]*(M+1) for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0]*(M+1)", "[0]", "0", "M+1", "M", "1", "dp=[[0]*(M+1) for _ in range(n+1)]", "dp", "[[0]*(M+1) for _ in range(n+1)]", "dp[0][0]=1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "from itertools import product", "for x in X:\n ndp=[y[:] for y in dp]\n for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n dp=ndp\n\n ", "x", "X", "y[:] for y in dp", "for y in dp", "y", "dp", "for y in dp", "y[:]", "y", ":", "ndp=[y[:] for y in dp]", "ndp", "[y[:] for y in dp]", "for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n ", "i", "m", "product(range(n),range(M+1))", "product", "range(n)", "range", "n", "range(M+1)", "range", "M+1", "M", "1", "if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n ", "m+x<=M", "m+x", "m", "x", "M", "ndp[i+1][m+x]+=dp[i][m]", "ndp[i+1][m+x]", "[i+1]", "ndp", "i+1", "i", "1", "m+x", "m", "x", "dp[i][m]", "[i]", "dp", "i", "m", "dp=ndp", "dp", "ndp", "ans=0", "ans", "0", "for i in range(1,n+1):\n if(i*a<=M):\n ans+=dp[i][i*a]\n ", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "if(i*a<=M):\n ans+=dp[i][i*a]\n ", "i*a<=M", "i*a", "i", "a", "M", "ans+=dp[i][i*a]", "ans", "dp[i][i*a]", "[i]", "dp", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "resolve()", "resolve", "MOD=10**9+7", "10**9+7", "MOD", "input=lambda :sys.stdin.readline().rstrip()", "lambda :sys.stdin.readline().rstrip()", "input", "INF=float(\"inf\")", "float(\"inf\")", "INF", "def resolve():\n n,a=map(int,input().split())\n X=list(map(int,input().split()))\n M=sum(X)\n dp=[[0]*(M+1) for _ in range(n+1)]\n dp[0][0]=1\n\n from itertools import product\n for x in X:\n ndp=[y[:] for y in dp]\n for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n dp=ndp\n\n ans=0\n for i in range(1,n+1):\n if(i*a<=M):\n ans+=dp[i][i*a]\n print(ans)", "def resolve():\n n,a=map(int,input().split())\n X=list(map(int,input().split()))\n M=sum(X)\n dp=[[0]*(M+1) for _ in range(n+1)]\n dp[0][0]=1\n\n from itertools import product\n for x in X:\n ndp=[y[:] for y in dp]\n for i,m in product(range(n),range(M+1)):\n if(m+x<=M):\n ndp[i+1][m+x]+=dp[i][m]\n dp=ndp\n\n ans=0\n for i in range(1,n+1):\n if(i*a<=M):\n ans+=dp[i][i*a]\n print(ans)", "resolve" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 13, 3, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 155, 2 ], [ 155, 11 ], [ 161, 13 ], [ 158, 25 ], [ 162, 29 ], [ 150, 30 ], [ 34, 33 ], [ 150, 37 ], [ 143, 42 ], [ 52, 45 ], [ 144, 48 ], [ 55, 54 ], [ 150, 57 ], [ 60, 59 ], [ 54, 63 ], [ 67, 66 ], [ 159, 69 ], [ 86, 71 ], [ 144, 74 ], [ 54, 76 ], [ 59, 79 ], [ 66, 82 ], [ 162, 84 ], [ 54, 85 ], [ 144, 89 ], [ 54, 90 ], [ 59, 91 ], [ 66, 92 ], [ 103, 94 ], [ 144, 97 ], [ 54, 99 ], [ 59, 101 ], [ 66, 102 ], [ 144, 106 ], [ 54, 107 ], [ 59, 108 ], [ 66, 109 ], [ 152, 111 ], [ 115, 114 ], [ 150, 119 ], [ 114, 124 ], [ 156, 125 ], [ 159, 126 ], [ 146, 129 ], [ 144, 133 ], [ 114, 135 ], [ 114, 137 ], [ 156, 138 ], [ 147, 141 ], [ 153, 141 ], [ 143, 144 ], [ 146, 147 ], [ 155, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ] ]

[ "# ABC044\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\n\n# 2 ** 50 -> 全探索は厳しい -> DP\n# dp[i][k][wa] = i枚まで見て、k枚選んだ時の合計値がwaとなるときの選び方の合計\n# max wa = max(X) * N\nmax_wa = max(X) * N\ndp = [[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)]\ndp[0][0][0] = 1\nfor i in range(N):\n for k in range(i+1):\n for wa in range(max_wa):\n # 選ぶとき\n dp[i+1][k+1][wa+X[i]] += dp[i][k][wa]\n # 選ばないとき\n dp[i+1][k][wa] += dp[i][k][wa]\n\nans = 0\nfor k in range(1, N+1):\n if k * A > max_wa:\n break\n ans += dp[-1][k][k*A]\n\nprint(ans)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_wa = max(X) * N", "max_wa", "max(X) * N", "max(X)", "max", "X", "N", "[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)", "for __ in range(N+1)", "__", "range(N+1)", "range", "N+1", "N", "1", "for __ in range(N+1)", "[[0] * (max(X) * (N+1)) for _ in range(N+1)]", "dp = [[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)]", "dp", "[[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for k in range(i+1):\n for wa in range(max_wa):\n # 選ぶとき\n dp[i+1][k+1][wa+X[i]] += dp[i][k][wa]\n # 選ばないとき\n dp[i+1][k][wa] += dp[i][k][wa]", "i", "range(N)", "range", "N", "for k in range(i+1):\n for wa in range(max_wa):\n # 選ぶとき\n dp[i+1][k+1][wa+X[i]] += dp[i][k][wa]\n # 選ばないとき\n dp[i+1][k][wa] += dp[i][k][wa]", "k", "range(i+1)", "range", "i+1", "i", "1", "for wa in range(max_wa):\n # 選ぶとき\n dp[i+1][k+1][wa+X[i]] += dp[i][k][wa]\n # 選ばないとき\n dp[i+1][k][wa] += dp[i][k][wa]", "wa", "range(max_wa)", "range", "max_wa", "dp[i+1][k+1][wa+X[i]] += dp[i][k][wa]", "dp[i+1][k+1][wa+X[i]]", "[k+1]", "[i+1]", "dp", "i+1", "i", "1", "k+1", "k", "1", "wa+X[i]", "wa", "X[i]", "X", "i", "dp[i][k][wa]", "[k]", "[i]", "dp", "i", "k", "wa", "dp[i+1][k][wa] += dp[i][k][wa]", "dp[i+1][k][wa]", "[k]", "[i+1]", "dp", "i+1", "i", "1", "k", "wa", "dp[i][k][wa]", "[k]", "[i]", "dp", "i", "k", "wa", "ans = 0", "ans", "0", "for k in range(1, N+1):\n if k * A > max_wa:\n break\n ans += dp[-1][k][k*A]", "k", "range(1, N+1)", "range", "1", "N+1", "N", "1", "if k * A > max_wa:\n break\n ", "k * A > max_wa", "k * A", "k", "A", "max_wa", "break", "ans += dp[-1][k][k*A]", "ans", "dp[-1][k][k*A]", "[k]", "[-1]", "dp", "-1", "k", "k*A", "k", "A", "print(ans)", "print", "ans", "dp = [[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)]", "[[[0] * (max(X) * (N+1)) for _ in range(N+1)] for __ in range(N+1)]", "dp", "ans += dp[-1][k][k*A]", "dp[-1][k][k*A]", "ans", "N, A = map(int, input().split())", "map(int, input().split())", "N", "ans = 0", "0", "ans", "A = map(int, input().split())", "map(int, input().split())", "A", "max_wa = max(X) * N", "max(X) * N", "max_wa", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 4, 13, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 13, 17, 14, 2, 2, 13, 13, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 157, 2 ], [ 157, 11 ], [ 151, 13 ], [ 27, 26 ], [ 145, 33 ], [ 43, 36 ], [ 146, 39 ], [ 46, 45 ], [ 149, 49 ], [ 52, 51 ], [ 149, 56 ], [ 60, 59 ], [ 149, 64 ], [ 152, 67 ], [ 79, 70 ], [ 146, 73 ], [ 45, 75 ], [ 51, 77 ], [ 59, 78 ], [ 146, 82 ], [ 45, 83 ], [ 51, 84 ], [ 59, 85 ], [ 102, 87 ], [ 146, 90 ], [ 45, 92 ], [ 51, 95 ], [ 59, 98 ], [ 152, 100 ], [ 45, 101 ], [ 146, 105 ], [ 45, 106 ], [ 51, 107 ], [ 59, 108 ], [ 160, 110 ], [ 114, 113 ], [ 149, 118 ], [ 122, 121 ], [ 158, 124 ], [ 113, 129 ], [ 158, 130 ], [ 121, 131 ], [ 154, 133 ], [ 146, 137 ], [ 149, 138 ], [ 113, 139 ], [ 121, 140 ], [ 155, 143 ], [ 161, 143 ], [ 145, 146 ], [ 157, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ] ]

[ "n, a = map(int, input().split())\nX = list(map(int, input().split()))\n\n# dp[i][j][k] i枚までj枚えらんで合計k\n# 答えはdp[n][1..n][a..ak]\ndp = [[[0] * 2700 for _ in range(52)]\n for __ in range(52)]\n\ndp[0][0][0] = 1\nfor i in range(0, n):\n for j in range(0, n + 1):\n for k in range(n * max(X) + 1):\n dp[i + 1][j][k] += dp[i][j][k] # 選ぶ\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k] # 選ばない\n\nans = 0\nfor i in range(1, n+1):\n for j in range(a, 2501):\n if i * a == j:\n ans += dp[n][i][j]\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * 2700 for _ in range(52)]\n for __ in range(52)", "for __ in range(52)", "__", "range(52)", "range", "52", "for __ in range(52)", "[[0] * 2700 for _ in range(52)]", "dp = [[[0] * 2700 for _ in range(52)]\n for __ in range(52)]", "dp", "[[[0] * 2700 for _ in range(52)]\n for __ in range(52)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(0, n):\n for j in range(0, n + 1):\n for k in range(n * max(X) + 1):\n dp[i + 1][j][k] += dp[i][j][k] # 選ぶ\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k] # 選ばない", "i", "range(0, n)", "range", "0", "n", "for j in range(0, n + 1):\n for k in range(n * max(X) + 1):\n dp[i + 1][j][k] += dp[i][j][k] # 選ぶ\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k] # 選ばない", "j", "range(0, n + 1)", "range", "0", "n + 1", "n", "1", "for k in range(n * max(X) + 1):\n dp[i + 1][j][k] += dp[i][j][k] # 選ぶ\n dp[i + 1][j + 1][k + X[i]] += dp[i][j][k] # 選ばない", "k", "range(n * max(X) + 1)", "range", "n * max(X) + 1", "n * max(X)", "n", "max(X)", "max", "X", "1", "dp[i + 1][j][k] += dp[i][j][k]", "dp[i + 1][j][k]", "[j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]", "dp[i + 1][j + 1][k + X[i]]", "[j + 1]", "[i + 1]", "dp", "i + 1", "i", "1", "j + 1", "j", "1", "k + X[i]", "k", "X[i]", "X", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans = 0", "ans", "0", "for i in range(1, n+1):\n for j in range(a, 2501):\n if i * a == j:\n ans += dp[n][i][j]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "for j in range(a, 2501):\n if i * a == j:\n ans += dp[n][i][j]", "j", "range(a, 2501)", "range", "a", "2501", "if i * a == j:\n ans += dp[n][i][j]", "i * a == j", "i * a", "i", "a", "j", "ans += dp[n][i][j]", "ans", "dp[n][i][j]", "[i]", "[n]", "dp", "n", "i", "j", "print(ans)", "print", "ans", "dp = [[[0] * 2700 for _ in range(52)]\n for __ in range(52)]", "[[[0] * 2700 for _ in range(52)]\n for __ in range(52)]", "dp", "n, a = map(int, input().split())", "map(int, input().split())", "n", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "ans += dp[n][i][j]", "dp[n][i][j]", "ans", "a = map(int, input().split())", "map(int, input().split())", "a", "ans = 0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 13, 4, 13, 0, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 28, 13, 4, 13, 13, 14, 2, 2, 13, 17, 2, 18, 13, 17, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 17, 18, 13, 17, 17, 17, 3, 14, 2, 13, 17, 14, 2, 2, 13, 17, 2, 18, 13, 13, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 13, 18, 13, 13, 17, 17, 9, 14, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 40, 2, 40, 17, 2, 13, 18, 13, 13, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 13, 2, 13, 18, 13, 13, 2, 13, 17, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 40, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 13, 13, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 234, 2 ], [ 234, 11 ], [ 237, 13 ], [ 27, 26 ], [ 235, 29 ], [ 225, 33 ], [ 37, 36 ], [ 235, 39 ], [ 42, 41 ], [ 235, 46 ], [ 220, 47 ], [ 51, 50 ], [ 235, 53 ], [ 36, 57 ], [ 238, 61 ], [ 235, 65 ], [ 220, 66 ], [ 78, 69 ], [ 226, 72 ], [ 238, 75 ], [ 41, 82 ], [ 50, 87 ], [ 238, 91 ], [ 36, 92 ], [ 235, 95 ], [ 220, 96 ], [ 108, 99 ], [ 226, 102 ], [ 36, 103 ], [ 238, 105 ], [ 36, 106 ], [ 226, 115 ], [ 36, 117 ], [ 41, 119 ], [ 50, 120 ], [ 130, 123 ], [ 226, 126 ], [ 36, 127 ], [ 41, 128 ], [ 50, 129 ], [ 226, 133 ], [ 36, 135 ], [ 41, 137 ], [ 50, 138 ], [ 41, 145 ], [ 238, 147 ], [ 36, 148 ], [ 235, 151 ], [ 220, 152 ], [ 168, 155 ], [ 226, 158 ], [ 36, 159 ], [ 41, 161 ], [ 238, 163 ], [ 36, 164 ], [ 50, 166 ], [ 226, 171 ], [ 36, 173 ], [ 41, 175 ], [ 50, 176 ], [ 228, 178 ], [ 182, 181 ], [ 235, 186 ], [ 220, 187 ], [ 181, 192 ], [ 181, 196 ], [ 220, 197 ], [ 231, 200 ], [ 181, 202 ], [ 220, 203 ], [ 222, 205 ], [ 226, 209 ], [ 181, 211 ], [ 232, 213 ], [ 223, 217 ], [ 229, 217 ], [ 234, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ], [ 237, 238 ] ]

[ "n, a = map(int,input().split())\nx = list(map(int,input().split()))\n\ndp = [[[0] * n for i in range(n * a + 1)] for i in range(n)]\nfor i in range(n):\n for j in range(n * a + 1):\n for k in range(n):\n if i == 0 and x[0] < n * a + 1:\n dp[0][x[0]][0] = 1\n break\n else:\n if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n if dp[i - 1][j][k] == 0:continue\n dp[i][j][k] += dp[i - 1][j][k]\n if not(0 <= j + x[i] < n * a + 1):continue\n dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]\ncnt = 0\nfor i in range(n * a + 1):\n if i != 0 and i % a == 0:\n temp = i // a\n cnt += dp[-1][i][temp - 1]\nprint(cnt)", "n, a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0] * n for i in range(n * a + 1)] for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "[[0] * n for i in range(n * a + 1)]", "dp = [[[0] * n for i in range(n * a + 1)] for i in range(n)]", "dp", "[[[0] * n for i in range(n * a + 1)] for i in range(n)]", "for i in range(n):\n for j in range(n * a + 1):\n for k in range(n):\n if i == 0 and x[0] < n * a + 1:\n dp[0][x[0]][0] = 1\n break\n else:\n if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n if dp[i - 1][j][k] == 0:continue\n dp[i][j][k] += dp[i - 1][j][k]\n if not(0 <= j + x[i] < n * a + 1):continue\n dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]", "i", "range(n)", "range", "n", "for j in range(n * a + 1):\n for k in range(n):\n if i == 0 and x[0] < n * a + 1:\n dp[0][x[0]][0] = 1\n break\n else:\n if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n if dp[i - 1][j][k] == 0:continue\n dp[i][j][k] += dp[i - 1][j][k]\n if not(0 <= j + x[i] < n * a + 1):continue\n dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]", "j", "range(n * a + 1)", "range", "n * a + 1", "n * a", "n", "a", "1", "for k in range(n):\n if i == 0 and x[0] < n * a + 1:\n dp[0][x[0]][0] = 1\n break\n else:\n if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n if dp[i - 1][j][k] == 0:continue\n dp[i][j][k] += dp[i - 1][j][k]\n if not(0 <= j + x[i] < n * a + 1):continue\n dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]", "k", "range(n)", "range", "n", "if i == 0 and x[0] < n * a + 1:\n dp[0][x[0]][0] = 1\n break\n else:\n if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n if dp[i - 1][j][k] == 0:continue\n dp[i][j][k] += dp[i - 1][j][k]\n if not(0 <= j + x[i] < n * a + 1):continue\n dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]", "i == 0 and x[0] < n * a + 1", "i == 0", "i", "0", "x[0] < n * a + 1", "x[0]", "x", "0", "n * a + 1", "n * a", "n", "a", "1", "dp[0][x[0]][0] = 1", "dp[0][x[0]][0]", "[x[0]]", "[0]", "dp", "0", "x[0]", "x", "0", "0", "1", "break", "if j == 0:\n if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n continue\n\n ", "j == 0", "j", "0", "if k == 0 and x[i] < n * a + 1:\n dp[i][x[i]][0] += 1\n ", "k == 0 and x[i] < n * a + 1", "k == 0", "k", "0", "x[i] < n * a + 1", "x[i]", "x", "i", "n * a + 1", "n * a", "n", "a", "1", "dp[i][x[i]][0] += 1", "dp[i][x[i]][0]", "[x[i]]", "[i]", "dp", "i", "x[i]", "x", "i", "0", "1", "continue", "if dp[i - 1][j][k] == 0:continue\n ", "dp[i - 1][j][k] == 0", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "0", "dp[i][j][k] += dp[i - 1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "if not(0 <= j + x[i] < n * a + 1):continue\n ", "not(0 <= j + x[i] < n * a + 1)", "0 <= j + x[i] < n * a + 1", "0 <= j + x[i]", "0", "j + x[i]", "j", "x[i]", "x", "i", "n * a + 1", "n * a", "n", "a", "1", "dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]", "dp[i][j + x[i]][k + 1]", "[j + x[i]]", "[i]", "dp", "i", "j + x[i]", "j", "x[i]", "x", "i", "k + 1", "k", "1", "dp[i - 1][j][k]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "k", "cnt = 0", "cnt", "0", "for i in range(n * a + 1):\n if i != 0 and i % a == 0:\n temp = i // a\n cnt += dp[-1][i][temp - 1]", "i", "range(n * a + 1)", "range", "n * a + 1", "n * a", "n", "a", "1", "if i != 0 and i % a == 0:\n temp = i // a\n cnt += dp[-1][i][temp - 1]", "i != 0 and i % a == 0", "i != 0", "i", "0", "i % a == 0", "i % a", "i", "a", "0", "temp = i // a", "temp", "i // a", "i", "a", "cnt += dp[-1][i][temp - 1]", "cnt", "dp[-1][i][temp - 1]", "[i]", "[-1]", "dp", "-1", "i", "temp - 1", "temp", "1", "print(cnt)", "print", "cnt", "a = map(int,input().split())", "map(int,input().split())", "a", "cnt += dp[-1][i][temp - 1]", "dp[-1][i][temp - 1]", "cnt", "dp = [[[0] * n for i in range(n * a + 1)] for i in range(n)]", "[[[0] * n for i in range(n * a + 1)] for i in range(n)]", "dp", "cnt = 0", "0", "cnt", "temp = i // a", "i // a", "temp", "n, a = map(int,input().split())", "map(int,input().split())", "n", "x = list(map(int,input().split()))", "list(map(int,input().split()))", "x" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 41, 28, 13, 13, 4, 2, 4, 13, 13, 13, 0, 13, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 2, 17, 13, 13, 17, 14, 2, 2, 2, 13, 18, 13, 2, 13, 17, 17, 2, 2, 13, 18, 13, 2, 13, 17, 2, 2, 17, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 4, 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 188, 14 ], [ 188, 16 ], [ 20, 19 ], [ 19, 28 ], [ 173, 30 ], [ 35, 34 ], [ 174, 34 ], [ 34, 40 ], [ 189, 41 ], [ 182, 43 ], [ 185, 46 ], [ 174, 49 ], [ 53, 52 ], [ 177, 56 ], [ 170, 61 ], [ 71, 64 ], [ 171, 66 ], [ 177, 69 ], [ 186, 70 ], [ 74, 73 ], [ 177, 78 ], [ 82, 81 ], [ 177, 88 ], [ 186, 89 ], [ 81, 95 ], [ 183, 97 ], [ 73, 99 ], [ 81, 104 ], [ 183, 106 ], [ 73, 108 ], [ 177, 113 ], [ 186, 114 ], [ 121, 116 ], [ 171, 118 ], [ 73, 119 ], [ 81, 120 ], [ 171, 123 ], [ 73, 125 ], [ 81, 127 ], [ 134, 129 ], [ 171, 131 ], [ 73, 132 ], [ 81, 133 ], [ 171, 137 ], [ 73, 139 ], [ 81, 141 ], [ 171, 144 ], [ 73, 146 ], [ 81, 149 ], [ 183, 151 ], [ 73, 153 ], [ 179, 156 ], [ 171, 160 ], [ 177, 161 ], [ 177, 163 ], [ 186, 164 ], [ 180, 168 ], [ 170, 171 ], [ 173, 174 ], [ 188, 177 ], [ 179, 180 ], [ 182, 183 ], [ 185, 186 ], [ 188, 189 ] ]

[ "n, a = [int(i) for i in input().split()]\n\nx = [int(i) for i in input().split()] \ny = [int(i)-a for i in x] \n\n\nmax = max(x)\n\ndp = [[0 for _ in range(2*n*max+1)] for _ in range(n+1)]\n\ndp[0][n*max] = 1 \n\nfor i in range(1, n+1):\n\tfor j in range(2*n*max+1):\n\t\tif j - y[i-1] < 0 or j - y[i-1] > 2*n*max:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\telse: \n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]\n\nresult = dp[n][n*max]-1\n\nprint(result)\n\n\n\n\n", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "n, a = [int(i) for i in input().split()]", "n", "[int(i) for i in input().split()]", "a", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "x = [int(i) for i in input().split()]", "x", "[int(i) for i in input().split()]", "int(i)-a for i in x", "for i in x", "i", "x", "for i in x", "int(i)-a", "int(i)", "int", "i", "a", "y = [int(i)-a for i in x]", "y", "[int(i)-a for i in x]", "max = max(x)", "max", "max(x)", "max", "x", "[0 for _ in range(2*n*max+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0 for _ in range(2*n*max+1)]", "dp = [[0 for _ in range(2*n*max+1)] for _ in range(n+1)]", "dp", "[[0 for _ in range(2*n*max+1)] for _ in range(n+1)]", "dp[0][n*max] = 1", "dp[0][n*max]", "[0]", "dp", "0", "n*max", "n", "max", "1", "for i in range(1, n+1):\n\tfor j in range(2*n*max+1):\n\t\tif j - y[i-1] < 0 or j - y[i-1] > 2*n*max:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\telse: \n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "for j in range(2*n*max+1):\n\t\tif j - y[i-1] < 0 or j - y[i-1] > 2*n*max:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\telse: \n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]", "j", "range(2*n*max+1)", "range", "2*n*max+1", "2*n*max", "2*n", "2", "n", "max", "1", "if j - y[i-1] < 0 or j - y[i-1] > 2*n*max:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\telse: \n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]", "j - y[i-1] < 0 or j - y[i-1] > 2*n*max", "j - y[i-1] < 0", "j - y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "0", "j - y[i-1] > 2*n*max", "j - y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "2*n*max", "2*n", "2", "n", "max", "dp[i][j] = dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i][j] = dp[i-1][j] + dp[i-1][j-y[i-1]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j] + dp[i-1][j-y[i-1]]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][j-y[i-1]]", "[i-1]", "dp", "i-1", "i", "1", "j-y[i-1]", "j", "y[i-1]", "y", "i-1", "i", "1", "result = dp[n][n*max]-1", "result", "dp[n][n*max]-1", "dp[n][n*max]", "[n]", "dp", "n", "n*max", "n", "max", "1", "print(result)", "print", "result", "dp = [[0 for _ in range(2*n*max+1)] for _ in range(n+1)]", "[[0 for _ in range(2*n*max+1)] for _ in range(n+1)]", "dp", "x = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "x", "n, a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "n", "result = dp[n][n*max]-1", "dp[n][n*max]-1", "result", "y = [int(i)-a for i in x]", "[int(i)-a for i in x]", "y", "max = max(x)", "max(x)", "max", "a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a" ]

[ 7, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 13, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 14, 2, 2, 2, 13, 18, 13, 13, 17, 2, 18, 18, 13, 13, 13, 17, 9, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 127, 2 ], [ 124, 5 ], [ 133, 8 ], [ 133, 17 ], [ 136, 19 ], [ 131, 29 ], [ 39, 38 ], [ 128, 41 ], [ 139, 48 ], [ 56, 51 ], [ 140, 53 ], [ 125, 55 ], [ 59, 58 ], [ 134, 61 ], [ 64, 63 ], [ 63, 71 ], [ 137, 73 ], [ 58, 74 ], [ 140, 79 ], [ 58, 80 ], [ 63, 81 ], [ 92, 85 ], [ 140, 87 ], [ 58, 89 ], [ 63, 91 ], [ 140, 94 ], [ 58, 95 ], [ 63, 96 ], [ 109, 98 ], [ 140, 100 ], [ 58, 102 ], [ 63, 105 ], [ 137, 107 ], [ 58, 108 ], [ 140, 111 ], [ 58, 112 ], [ 63, 113 ], [ 140, 119 ], [ 134, 120 ], [ 125, 121 ], [ 124, 125 ], [ 127, 128 ], [ 133, 131 ], [ 133, 134 ], [ 136, 137 ], [ 139, 140 ] ]

[ "\nNMAX = 55\nT = 2500\nN, A = map(int, input().split())\nX = list(map(lambda x: int(x) - A, input().split()))\n\ndp = [[0]*5001 for i in range(NMAX)] # i時点で総和がSになるものの個数\n\ndp[0][T] = 1\n\nfor i in range(N):\n for s in range(5001):\n if s+X[i] > 5001 or dp[i][s] == 0:\n continue\n dp[i+1][s] += dp[i][s]\n dp[i+1][s+X[i]] += dp[i][s]\n\nprint(dp[N][T]-1)\n", "NMAX = 55", "NMAX", "55", "T = 2500", "T", "2500", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(lambda x: int(x) - A, input().split()))", "X", "list(map(lambda x: int(x) - A, input().split()))", "list", "map(lambda x: int(x) - A, input().split())", "map", "lambda x: int(x) - A", "int(x) - A", "int(x)", "int", "x", "A", "x", "input().split()", "().split", "()", "input", "split", "[0]*5001 for i in range(NMAX)", "for i in range(NMAX)", "i", "range(NMAX)", "range", "NMAX", "for i in range(NMAX)", "[0]*5001", "[0]", "0", "5001", "dp = [[0]*5001 for i in range(NMAX)]", "dp", "[[0]*5001 for i in range(NMAX)]", "dp[0][T] = 1", "dp[0][T]", "[0]", "dp", "0", "T", "1", "for i in range(N):\n for s in range(5001):\n if s+X[i] > 5001 or dp[i][s] == 0:\n continue\n dp[i+1][s] += dp[i][s]\n dp[i+1][s+X[i]] += dp[i][s]", "i", "range(N)", "range", "N", "for s in range(5001):\n if s+X[i] > 5001 or dp[i][s] == 0:\n continue\n dp[i+1][s] += dp[i][s]\n dp[i+1][s+X[i]] += dp[i][s]", "s", "range(5001)", "range", "5001", "if s+X[i] > 5001 or dp[i][s] == 0:\n continue\n ", "s+X[i] > 5001 or dp[i][s] == 0", "s+X[i] > 5001", "s+X[i]", "s", "X[i]", "X", "i", "5001", "dp[i][s] == 0", "dp[i][s]", "[i]", "dp", "i", "s", "0", "continue", "dp[i+1][s] += dp[i][s]", "dp[i+1][s]", "[i+1]", "dp", "i+1", "i", "1", "s", "dp[i][s]", "[i]", "dp", "i", "s", "dp[i+1][s+X[i]] += dp[i][s]", "dp[i+1][s+X[i]]", "[i+1]", "dp", "i+1", "i", "1", "s+X[i]", "s", "X[i]", "X", "i", "dp[i][s]", "[i]", "dp", "i", "s", "print(dp[N][T]-1)", "print", "dp[N][T]-1", "dp[N][T]", "[N]", "dp", "N", "T", "1", "T = 2500", "2500", "T", "NMAX = 55", "55", "NMAX", "A = map(int, input().split())", "map(int, input().split())", "A", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = list(map(lambda x: int(x) - A, input().split()))", "list(map(lambda x: int(x) - A, input().split()))", "X", "dp = [[0]*5001 for i in range(NMAX)]", "[[0]*5001 for i in range(NMAX)]", "dp" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 31, 13, 0, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 2, 39, 17, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 40, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 2, 13, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 99, 2 ], [ 99, 15 ], [ 99, 16 ], [ 102, 19 ], [ 24, 23 ], [ 97, 27 ], [ 103, 34 ], [ 93, 37 ], [ 45, 40 ], [ 94, 42 ], [ 48, 47 ], [ 97, 50 ], [ 53, 52 ], [ 103, 56 ], [ 103, 57 ], [ 66, 59 ], [ 94, 61 ], [ 47, 63 ], [ 52, 65 ], [ 94, 69 ], [ 47, 70 ], [ 52, 71 ], [ 94, 74 ], [ 47, 75 ], [ 52, 78 ], [ 47, 81 ], [ 100, 82 ], [ 94, 88 ], [ 97, 89 ], [ 93, 94 ], [ 99, 97 ], [ 99, 100 ], [ 102, 103 ] ]

[ "n,a,*l=map(int,open(0).read().split())\nR=2500\ndp=[[0]*R*2 for _ in range(n+1)]\ndp[0][0]=1\nfor i in range(n):\n for s in range(-R,R):\n dp[i+1][s]=dp[i][s]+dp[i][s-l[i]+a]\nprint(dp[n][0]-1)", "n,a,*l=map(int,open(0).read().split())", "n", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "a", "*l", "l", "R=2500", "R", "2500", "[0]*R*2 for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0]*R*2", "[0]*R", "[0]", "0", "R", "2", "dp=[[0]*R*2 for _ in range(n+1)]", "dp", "[[0]*R*2 for _ in range(n+1)]", "dp[0][0]=1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(n):\n for s in range(-R,R):\n dp[i+1][s]=dp[i][s]+dp[i][s-l[i]+a]", "i", "range(n)", "range", "n", "for s in range(-R,R):\n dp[i+1][s]=dp[i][s]+dp[i][s-l[i]+a]", "s", "range(-R,R)", "range", "-R", "R", "R", "dp[i+1][s]=dp[i][s]+dp[i][s-l[i]+a]", "dp[i+1][s]", "[i+1]", "dp", "i+1", "i", "1", "s", "dp[i][s]+dp[i][s-l[i]+a]", "dp[i][s]", "[i]", "dp", "i", "s", "dp[i][s-l[i]+a]", "[i]", "dp", "i", "s-l[i]+a", "s-l[i]", "s", "l[i]", "l", "i", "a", "print(dp[n][0]-1)", "print", "dp[n][0]-1", "dp[n][0]", "[n]", "dp", "n", "0", "1", "dp=[[0]*R*2 for _ in range(n+1)]", "[[0]*R*2 for _ in range(n+1)]", "dp", "n,a,*l=map(int,open(0).read().split())", "map(int,open(0).read().split())", "n", "a,*l=map(int,open(0).read().split())", "map(int,open(0).read().split())", "a", "R=2500", "2500", "R" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 2, 13, 13, 17, 18, 13, 13, 14, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 40, 2, 13, 13, 2, 13, 13, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 179, 4 ], [ 20, 19 ], [ 27, 26 ], [ 171, 28 ], [ 27, 29 ], [ 32, 31 ], [ 183, 33 ], [ 36, 35 ], [ 31, 38 ], [ 42, 41 ], [ 26, 45 ], [ 51, 50 ], [ 60, 53 ], [ 50, 56 ], [ 63, 62 ], [ 26, 65 ], [ 68, 67 ], [ 62, 71 ], [ 75, 74 ], [ 26, 80 ], [ 35, 81 ], [ 31, 84 ], [ 62, 85 ], [ 50, 90 ], [ 62, 91 ], [ 67, 92 ], [ 74, 93 ], [ 104, 95 ], [ 50, 98 ], [ 62, 100 ], [ 67, 102 ], [ 74, 103 ], [ 50, 107 ], [ 62, 108 ], [ 67, 109 ], [ 74, 110 ], [ 127, 112 ], [ 50, 115 ], [ 62, 117 ], [ 67, 120 ], [ 74, 123 ], [ 31, 125 ], [ 62, 126 ], [ 50, 130 ], [ 62, 131 ], [ 67, 132 ], [ 74, 133 ], [ 136, 135 ], [ 139, 138 ], [ 26, 143 ], [ 138, 148 ], [ 29, 149 ], [ 26, 151 ], [ 35, 152 ], [ 155, 154 ], [ 50, 158 ], [ 138, 160 ], [ 138, 162 ], [ 29, 163 ], [ 154, 166 ], [ 135, 166 ], [ 177, 168 ], [ 179, 180 ] ]

[ "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LI(): return list(map(int, input().split()))\n\ndef main():\n mod=10**9+7\n N,A=MI()\n x=LI()\n M=max(x)\n \n #dp[i][j][k]はi番目まで，j枚で，和がkにできるか\n dp=[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n \n for i in range(N):\n for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ans=0\n for j in range(1,N+1):\n if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n print(ans)\n \n\n \n \n \n \n \n \n \n \n \n \n\nmain()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def I(): return int(input())", "I", "def MI(): return map(int, input().split())", "MI", "def LI(): return list(map(int, input().split()))", "LI", "def main():\n mod=10**9+7\n N,A=MI()\n x=LI()\n M=max(x)\n \n #dp[i][j][k]はi番目まで，j枚で，和がkにできるか\n dp=[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n \n for i in range(N):\n for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ans=0\n for j in range(1,N+1):\n if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n print(ans)\n \n\n \n \n \n \n \n \n \n \n \n ", "main", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "N,A=MI()", "N", "MI()", "MI", "A", "x=LI()", "x", "LI()", "LI", "M=max(x)", "M", "max(x)", "max", "x", "[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[[0]*(N*M+1) for j in range(N+1)]", "dp=[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]", "dp", "[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ", "i", "range(N)", "range", "N", "for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ", "k", "range(N*M+1-x[i])", "range", "N*M+1-x[i]", "N*M+1", "N*M", "N", "M", "1", "x[i]", "x", "i", "if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j][k]+=dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j+1][k+x[i]]+=dp[i][j][k]", "dp[i+1][j+1][k+x[i]]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k+x[i]", "k", "x[i]", "x", "i", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans=0", "ans", "0", "for j in range(1,N+1):\n if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n ", "j", "range(1,N+1)", "range", "1", "N+1", "N", "1", "if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n ", "j*A<=N*M", "j*A", "j", "A", "N*M", "N", "M", "ans+=dp[-1][j][j*A]", "ans", "dp[-1][j][j*A]", "[j]", "[-1]", "dp", "-1", "j", "j*A", "j", "A", "print(ans)", "print", "ans", "main()", "main", "def MI(): return map(int, input().split())", "def MI(): return map(int, input().split())", "MI", "def I(): return int(input())", "def I(): return int(input())", "I", "def main():\n mod=10**9+7\n N,A=MI()\n x=LI()\n M=max(x)\n \n #dp[i][j][k]はi番目まで，j枚で，和がkにできるか\n dp=[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n \n for i in range(N):\n for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ans=0\n for j in range(1,N+1):\n if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n print(ans)\n \n\n \n \n \n \n \n \n \n \n \n ", "def main():\n mod=10**9+7\n N,A=MI()\n x=LI()\n M=max(x)\n \n #dp[i][j][k]はi番目まで，j枚で，和がkにできるか\n dp=[[[0]*(N*M+1) for j in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n \n for i in range(N):\n for j in range(i+1):\n for k in range(N*M+1-x[i]):\n if dp[i][j][k]:\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x[i]]+=dp[i][j][k]\n \n\n \n ans=0\n for j in range(1,N+1):\n if j*A<=N*M: \n ans+=dp[-1][j][j*A]\n \n print(ans)\n \n\n \n \n \n \n \n \n \n \n \n ", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def LI(): return list(map(int, input().split()))", "def LI(): return list(map(int, input().split()))", "LI" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 14, 2, 18, 18, 18, 13, 13, 13, 13, 17, 9, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 2, 13, 17, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 145, 2 ], [ 145, 11 ], [ 151, 13 ], [ 27, 26 ], [ 140, 30 ], [ 148, 35 ], [ 45, 38 ], [ 149, 41 ], [ 48, 47 ], [ 140, 50 ], [ 53, 52 ], [ 140, 55 ], [ 58, 57 ], [ 149, 66 ], [ 47, 67 ], [ 52, 68 ], [ 57, 69 ], [ 82, 73 ], [ 149, 76 ], [ 47, 78 ], [ 52, 80 ], [ 57, 81 ], [ 149, 85 ], [ 47, 86 ], [ 52, 87 ], [ 57, 88 ], [ 105, 90 ], [ 149, 93 ], [ 47, 95 ], [ 52, 98 ], [ 57, 101 ], [ 152, 103 ], [ 47, 104 ], [ 149, 108 ], [ 47, 109 ], [ 52, 110 ], [ 57, 111 ], [ 154, 113 ], [ 117, 116 ], [ 140, 120 ], [ 142, 123 ], [ 149, 127 ], [ 140, 128 ], [ 116, 129 ], [ 116, 131 ], [ 146, 132 ], [ 143, 136 ], [ 155, 136 ], [ 145, 140 ], [ 142, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ] ]

[ "N,A=map(int,input().split())\nx=list(map(int,input().split()))\ndp=[[[0]*(2501) for i in range(N+1)] for k in range(N+1)]\ndp[0][0][0]=1\nfor j in range(N):\n for k in range(N):\n for i in range(2501):\n if dp[j][k][i]==0:\n continue\n dp[j+1][k][i]+=dp[j][k][i]\n dp[j+1][k+1][i+x[j]]+=dp[j][k][i]\nans=0\nfor j in range(N+1):\n ans+=dp[N][j][j*A]\nprint(ans-1)", "N,A=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0]*(2501) for i in range(N+1)] for k in range(N+1)", "for k in range(N+1)", "k", "range(N+1)", "range", "N+1", "N", "1", "for k in range(N+1)", "[[0]*(2501) for i in range(N+1)]", "dp=[[[0]*(2501) for i in range(N+1)] for k in range(N+1)]", "dp", "[[[0]*(2501) for i in range(N+1)] for k in range(N+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for j in range(N):\n for k in range(N):\n for i in range(2501):\n if dp[j][k][i]==0:\n continue\n dp[j+1][k][i]+=dp[j][k][i]\n dp[j+1][k+1][i+x[j]]+=dp[j][k][i]", "j", "range(N)", "range", "N", "for k in range(N):\n for i in range(2501):\n if dp[j][k][i]==0:\n continue\n dp[j+1][k][i]+=dp[j][k][i]\n dp[j+1][k+1][i+x[j]]+=dp[j][k][i]", "k", "range(N)", "range", "N", "for i in range(2501):\n if dp[j][k][i]==0:\n continue\n dp[j+1][k][i]+=dp[j][k][i]\n dp[j+1][k+1][i+x[j]]+=dp[j][k][i]", "i", "range(2501)", "range", "2501", "if dp[j][k][i]==0:\n continue\n ", "dp[j][k][i]==0", "dp[j][k][i]", "[k]", "[j]", "dp", "j", "k", "i", "0", "continue", "dp[j+1][k][i]+=dp[j][k][i]", "dp[j+1][k][i]", "[k]", "[j+1]", "dp", "j+1", "j", "1", "k", "i", "dp[j][k][i]", "[k]", "[j]", "dp", "j", "k", "i", "dp[j+1][k+1][i+x[j]]+=dp[j][k][i]", "dp[j+1][k+1][i+x[j]]", "[k+1]", "[j+1]", "dp", "j+1", "j", "1", "k+1", "k", "1", "i+x[j]", "i", "x[j]", "x", "j", "dp[j][k][i]", "[k]", "[j]", "dp", "j", "k", "i", "ans=0", "ans", "0", "for j in range(N+1):\n ans+=dp[N][j][j*A]", "j", "range(N+1)", "range", "N+1", "N", "1", "ans+=dp[N][j][j*A]", "ans", "dp[N][j][j*A]", "[j]", "[N]", "dp", "N", "j", "j*A", "j", "A", "print(ans-1)", "print", "ans-1", "ans", "1", "N,A=map(int,input().split())", "map(int,input().split())", "N", "ans+=dp[N][j][j*A]", "dp[N][j][j*A]", "ans", "A=map(int,input().split())", "map(int,input().split())", "A", "dp=[[[0]*(2501) for i in range(N+1)] for k in range(N+1)]", "[[[0]*(2501) for i in range(N+1)] for k in range(N+1)]", "dp", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "ans=0", "0", "ans" ]

[ 7, 15, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 18, 13, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 13, 13, 0, 13, 17, 0, 13, 4, 18, 13, 13, 39, 13, 13, 18, 13, 13, 0, 18, 18, 13, 17, 2, 2, 13, 17, 17, 17, 0, 18, 18, 13, 17, 2, 2, 2, 13, 17, 17, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 13, 14, 40, 40, 17, 2, 13, 18, 13, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 4, 13, 2, 18, 18, 13, 2, 13, 17, 2, 2, 13, 17, 17, 17, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 167, 6 ], [ 167, 15 ], [ 158, 17 ], [ 164, 33 ], [ 159, 35 ], [ 168, 36 ], [ 161, 38 ], [ 170, 41 ], [ 62, 53 ], [ 171, 55 ], [ 162, 59 ], [ 77, 64 ], [ 171, 66 ], [ 162, 71 ], [ 165, 75 ], [ 80, 79 ], [ 156, 83 ], [ 86, 85 ], [ 162, 88 ], [ 85, 94 ], [ 165, 96 ], [ 79, 97 ], [ 162, 99 ], [ 107, 102 ], [ 171, 104 ], [ 79, 105 ], [ 85, 106 ], [ 171, 110 ], [ 79, 112 ], [ 85, 114 ], [ 171, 117 ], [ 79, 119 ], [ 85, 122 ], [ 165, 124 ], [ 79, 125 ], [ 132, 127 ], [ 171, 129 ], [ 79, 130 ], [ 85, 131 ], [ 171, 134 ], [ 79, 136 ], [ 85, 138 ], [ 171, 144 ], [ 156, 146 ], [ 162, 150 ], [ 167, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ] ]

[ "import sys\nimport numpy as np\nN, A = map(int, input().split())\nX = np.array(list(map(int, input().split())))\nx = X - A\nR = 5001\ndp = np.zeros([N, R], np.int64)\ndp[0][(R-1)//2] += 1\ndp[0][(R-1)//2 + x[0]] += 1\n\nfor i in range(1,N):\n\tfor j in range(R):\n\t\tif 0 <= j-x[i] <= R-1:\n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-x[i]]\n\t\telse:\n\t\t\tdp[i][j] = dp[i-1][j]\nprint(dp[N-1][(R-1)//2]-1)", "import sys", "sys", "import numpy as np", "numpy", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = np.array(list(map(int, input().split())))", "X", "np.array(list(map(int, input().split())))", "np.array", "np", "array", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x = X - A", "x", "X - A", "X", "A", "R = 5001", "R", "5001", "dp = np.zeros([N, R], np.int64)", "dp", "np.zeros([N, R], np.int64)", "np.zeros", "np", "zeros", "[N, R]", "N", "R", "np.int64", "np", "int64", "dp[0][(R-1)//2] += 1", "dp[0][(R-1)//2]", "[0]", "dp", "0", "(R-1)//2", "R-1", "R", "1", "2", "1", "dp[0][(R-1)//2 + x[0]] += 1", "dp[0][(R-1)//2 + x[0]]", "[0]", "dp", "0", "(R-1)//2 + x[0]", "(R-1)//2", "R-1", "R", "1", "2", "x[0]", "x", "0", "1", "for i in range(1,N):\n\tfor j in range(R):\n\t\tif 0 <= j-x[i] <= R-1:\n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-x[i]]\n\t\telse:\n\t\t\tdp[i][j] = dp[i-1][j]", "i", "range(1,N)", "range", "1", "N", "for j in range(R):\n\t\tif 0 <= j-x[i] <= R-1:\n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-x[i]]\n\t\telse:\n\t\t\tdp[i][j] = dp[i-1][j]", "j", "range(R)", "range", "R", "if 0 <= j-x[i] <= R-1:\n\t\t\tdp[i][j] = dp[i-1][j] + dp[i-1][j-x[i]]\n\t\telse:\n\t\t\tdp[i][j] = dp[i-1][j]", "0 <= j-x[i] <= R-1", "0 <= j-x[i]", "0", "j-x[i]", "j", "x[i]", "x", "i", "R-1", "R", "1", "dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j] + dp[i-1][j-x[i]]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][j-x[i]]", "[i-1]", "dp", "i-1", "i", "1", "j-x[i]", "j", "x[i]", "x", "i", "dp[i][j] = dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "print(dp[N-1][(R-1)//2]-1)", "print", "dp[N-1][(R-1)//2]-1", "dp[N-1][(R-1)//2]", "[N-1]", "dp", "N-1", "N", "1", "(R-1)//2", "R-1", "R", "1", "2", "1", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X = np.array(list(map(int, input().split())))", "np.array(list(map(int, input().split())))", "X", "R = 5001", "5001", "R", "x = X - A", "X - A", "x", "A = map(int, input().split())", "map(int, input().split())", "A", "dp = np.zeros([N, R], np.int64)", "np.zeros([N, R], np.int64)", "dp" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 4, 13, 12, 2, 4, 13, 13, 13, 23, 4, 18, 4, 13, 13, 0, 13, 2, 4, 13, 4, 13, 18, 13, 17, 4, 13, 18, 13, 17, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 40, 13, 17, 2, 13, 17, 14, 2, 40, 40, 13, 2, 13, 18, 13, 13, 40, 2, 13, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 18, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 159, 2 ], [ 159, 11 ], [ 153, 13 ], [ 157, 25 ], [ 150, 33 ], [ 154, 40 ], [ 154, 45 ], [ 160, 47 ], [ 51, 50 ], [ 160, 54 ], [ 147, 59 ], [ 67, 62 ], [ 148, 64 ], [ 70, 69 ], [ 160, 72 ], [ 75, 74 ], [ 151, 79 ], [ 151, 82 ], [ 151, 88 ], [ 74, 90 ], [ 154, 92 ], [ 69, 93 ], [ 74, 96 ], [ 154, 98 ], [ 69, 99 ], [ 151, 100 ], [ 109, 102 ], [ 148, 104 ], [ 69, 106 ], [ 74, 108 ], [ 148, 112 ], [ 69, 113 ], [ 74, 114 ], [ 148, 117 ], [ 69, 118 ], [ 74, 120 ], [ 154, 122 ], [ 69, 123 ], [ 132, 125 ], [ 148, 127 ], [ 69, 129 ], [ 74, 131 ], [ 148, 134 ], [ 69, 135 ], [ 74, 136 ], [ 148, 142 ], [ 160, 143 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ], [ 159, 157 ], [ 159, 160 ] ]

[ "n,a = map(int,input().split())\nx = sorted(list(map(lambda y:int(y)-a,input().split())))\n\nsx = max(abs(x[0]),abs(x[-1]))*n\n\ndp = [[0 for _ in range(2*sx+2)] for _ in range(n+1)]\ndp[0][0] = 1\n\nfor j in range(n):\n for t in range(-sx-1,sx+1):\n if -sx <= t-x[j] and t-x[j] <= sx: \n dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]\n else:\n dp[j+1][t] = dp[j][t]\n\nprint(dp[n][0]-1)", "n,a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = sorted(list(map(lambda y:int(y)-a,input().split())))", "x", "sorted(list(map(lambda y:int(y)-a,input().split())))", "sorted", "list(map(lambda y:int(y)-a,input().split()))", "list", "map(lambda y:int(y)-a,input().split())", "map", "lambda y:int(y)-a", "int(y)-a", "int(y)", "int", "y", "a", "y", "input().split()", "().split", "()", "input", "split", "sx = max(abs(x[0]),abs(x[-1]))*n", "sx", "max(abs(x[0]),abs(x[-1]))*n", "max(abs(x[0]),abs(x[-1]))", "max", "abs(x[0])", "abs", "x[0]", "x", "0", "abs(x[-1])", "abs", "x[-1]", "x", "-1", "n", "[0 for _ in range(2*sx+2)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[0 for _ in range(2*sx+2)]", "dp = [[0 for _ in range(2*sx+2)] for _ in range(n+1)]", "dp", "[[0 for _ in range(2*sx+2)] for _ in range(n+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for j in range(n):\n for t in range(-sx-1,sx+1):\n if -sx <= t-x[j] and t-x[j] <= sx: \n dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]\n else:\n dp[j+1][t] = dp[j][t]", "j", "range(n)", "range", "n", "for t in range(-sx-1,sx+1):\n if -sx <= t-x[j] and t-x[j] <= sx: \n dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]\n else:\n dp[j+1][t] = dp[j][t]", "t", "range(-sx-1,sx+1)", "range", "-sx-1", "-sx", "sx", "1", "sx+1", "sx", "1", "if -sx <= t-x[j] and t-x[j] <= sx: \n dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]\n else:\n dp[j+1][t] = dp[j][t]", "-sx <= t-x[j] and t-x[j] <= sx", "-sx <= t-x[j]", "-sx", "sx", "t-x[j]", "t", "x[j]", "x", "j", "t-x[j] <= sx", "t-x[j]", "t", "x[j]", "x", "j", "sx", "dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]", "dp[j+1][t]", "[j+1]", "dp", "j+1", "j", "1", "t", "dp[j][t] + dp[j][t-x[j]]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j][t-x[j]]", "[j]", "dp", "j", "t-x[j]", "t", "x[j]", "x", "j", "dp[j+1][t] = dp[j][t]", "dp[j+1][t]", "[j+1]", "dp", "j+1", "j", "1", "t", "dp[j][t]", "[j]", "dp", "j", "t", "print(dp[n][0]-1)", "print", "dp[n][0]-1", "dp[n][0]", "[n]", "dp", "n", "0", "1", "dp = [[0 for _ in range(2*sx+2)] for _ in range(n+1)]", "[[0 for _ in range(2*sx+2)] for _ in range(n+1)]", "dp", "sx = max(abs(x[0]),abs(x[-1]))*n", "max(abs(x[0]),abs(x[-1]))*n", "sx", "x = sorted(list(map(lambda y:int(y)-a,input().split())))", "sorted(list(map(lambda y:int(y)-a,input().split())))", "x", "a = map(int,input().split())", "map(int,input().split())", "a", "n,a = map(int,input().split())", "map(int,input().split())", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 0, 13, 2, 39, 17, 17, 0, 13, 17, 28, 13, 13, 0, 13, 18, 13, 2, 40, 13, 17, 14, 2, 13, 17, 0, 13, 17, 14, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 40, 17, 2, 13, 13, 17, 0, 18, 13, 2, 13, 13, 18, 13, 13, 28, 13, 4, 13, 17, 17, 17, 14, 2, 40, 17, 2, 13, 13, 17, 0, 18, 13, 2, 13, 13, 18, 13, 13, 0, 18, 13, 2, 13, 17, 2, 18, 13, 2, 13, 17, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 140, 2 ], [ 140, 11 ], [ 134, 13 ], [ 26, 25 ], [ 141, 28 ], [ 33, 30 ], [ 135, 31 ], [ 25, 32 ], [ 129, 33 ], [ 143, 35 ], [ 146, 41 ], [ 45, 44 ], [ 135, 44 ], [ 137, 47 ], [ 144, 49 ], [ 44, 52 ], [ 44, 56 ], [ 131, 59 ], [ 44, 63 ], [ 67, 66 ], [ 66, 75 ], [ 44, 76 ], [ 84, 79 ], [ 144, 80 ], [ 66, 82 ], [ 44, 83 ], [ 144, 85 ], [ 66, 86 ], [ 89, 88 ], [ 88, 99 ], [ 44, 100 ], [ 108, 103 ], [ 144, 104 ], [ 88, 106 ], [ 44, 107 ], [ 144, 109 ], [ 88, 110 ], [ 117, 112 ], [ 144, 113 ], [ 44, 115 ], [ 144, 119 ], [ 44, 121 ], [ 132, 126 ], [ 138, 126 ], [ 147, 126 ], [ 140, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\nfor i in range(n):\n x[i] -= a\n\nd = [0] * 6000\nans = 0\nfor dif in x:\n ans += d[-dif+3000]\n if dif == 0:\n ans += 1\n if dif < 0:\n for i in range(6000):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n else:\n for i in range(5999, -1, -1):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n d[dif+3000] = d[dif+3000] + 1\n \nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n x[i] -= a", "i", "range(n)", "range", "n", "x[i] -= a", "x[i]", "x", "i", "a", "d = [0] * 6000", "d", "[0] * 6000", "[0]", "0", "6000", "ans = 0", "ans", "0", "for dif in x:\n ans += d[-dif+3000]\n if dif == 0:\n ans += 1\n if dif < 0:\n for i in range(6000):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n else:\n for i in range(5999, -1, -1):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n d[dif+3000] = d[dif+3000] + 1\n ", "dif", "x", "ans += d[-dif+3000]", "ans", "d[-dif+3000]", "d", "-dif+3000", "-dif", "dif", "3000", "if dif == 0:\n ans += 1\n ", "dif == 0", "dif", "0", "ans += 1", "ans", "1", "if dif < 0:\n for i in range(6000):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n else:\n for i in range(5999, -1, -1):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n ", "dif < 0", "dif", "0", "for i in range(6000):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n ", "i", "range(6000)", "range", "6000", "if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n ", "0 <= i+dif < 6000", "0 <= i+dif", "0", "i+dif", "i", "dif", "6000", "d[i+dif] += d[i]", "d[i+dif]", "d", "i+dif", "i", "dif", "d[i]", "d", "i", "for i in range(5999, -1, -1):\n if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n ", "i", "range(5999, -1, -1)", "range", "5999", "-1", "-1", "if 0 <= i+dif < 6000:\n d[i+dif] += d[i]\n ", "0 <= i+dif < 6000", "0 <= i+dif", "0", "i+dif", "i", "dif", "6000", "d[i+dif] += d[i]", "d[i+dif]", "d", "i+dif", "i", "dif", "d[i]", "d", "i", "d[dif+3000] = d[dif+3000] + 1", "d[dif+3000]", "d", "dif+3000", "dif", "3000", "d[dif+3000] + 1", "d[dif+3000]", "d", "dif+3000", "dif", "3000", "1", "print(ans)", "print", "ans", "a = map(int, input().split())", "map(int, input().split())", "a", "ans += 1", "1", "ans", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "ans += d[-dif+3000]", "d[-dif+3000]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "d = [0] * 6000", "[0] * 6000", "d", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 2, 39, 13, 13, 12, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 17, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 17, 12, 13, 12, 13, 12, 13, 12, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 4, 2, 13, 13, 0, 13, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 13, 14, 40, 40, 17, 2, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 18, 18, 13, 13, 13, 4, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 13, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 8, 7 ], [ 19, 19 ], [ 21, 21 ], [ 23, 23 ], [ 27, 26 ], [ 35, 35 ], [ 37, 37 ], [ 39, 39 ], [ 41, 41 ], [ 45, 44 ], [ 53, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 65, 65 ], [ 68, 67 ], [ 76, 75 ], [ 281, 81 ], [ 86, 85 ], [ 226, 103 ], [ 262, 108 ], [ 235, 115 ], [ 224, 117 ], [ 235, 118 ], [ 122, 121 ], [ 257, 123 ], [ 121, 126 ], [ 230, 127 ], [ 265, 129 ], [ 271, 132 ], [ 236, 135 ], [ 230, 136 ], [ 232, 139 ], [ 242, 141 ], [ 236, 143 ], [ 272, 146 ], [ 157, 150 ], [ 233, 152 ], [ 236, 155 ], [ 230, 156 ], [ 160, 159 ], [ 236, 162 ], [ 247, 164 ], [ 266, 166 ], [ 159, 167 ], [ 170, 169 ], [ 272, 173 ], [ 183, 176 ], [ 233, 178 ], [ 159, 180 ], [ 169, 182 ], [ 233, 185 ], [ 159, 186 ], [ 169, 187 ], [ 169, 193 ], [ 248, 194 ], [ 272, 195 ], [ 206, 197 ], [ 233, 199 ], [ 159, 201 ], [ 169, 204 ], [ 248, 205 ], [ 233, 208 ], [ 159, 209 ], [ 169, 210 ], [ 233, 216 ], [ 236, 217 ], [ 236, 219 ], [ 230, 220 ], [ 226, 227 ], [ 235, 230 ], [ 232, 233 ], [ 235, 236 ], [ 247, 248 ], [ 262, 263 ], [ 265, 266 ], [ 271, 272 ] ]

[ "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN, K = MAP()\n# 予め-Kした状態で用意しておく\nA = [a-K for a in LIST()]\n\nMAX = N * K * 2\n# dp[i][k] := i枚目までのカードで、合計をkにする通り数\ndp = list2d(N+1, MAX+1, 0)\n# 負の数を考慮して、N*K位置を0とする\ndp[0][N*K] = 1\nfor i in range(N):\n a = A[i]\n for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+a <= MAX:\n dp[i+1][k+a] += dp[i][k]\n# N回終わって合計が0になっている通り数 - 1枚も取らないケース\nprint(dp[N][N*K]-1)", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "[c] * b for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[c] * b", "[c]", "c", "b", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "a", "a", "b", "b", "c", "c", "[[d] * c for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[d] * c for j in range(b)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "a", "a", "b", "b", "c", "c", "d", "d", "[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[[e] * d for j in range(c)] for j in range(b)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "a", "a", "b", "b", "c", "c", "d", "d", "e", "e", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "x", "x", "y=1", "y", "1", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "INT() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "INT()", "INT", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "N=None", "N", "None", "def Yes(): print('Yes')", "Yes", "def No(): print('No')", "No", "def YES(): print('YES')", "YES", "def NO(): print('NO')", "NO", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "INF = 10 ** 18", "INF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, K = MAP()", "N", "MAP()", "MAP", "K", "a-K for a in LIST()", "for a in LIST()", "a", "LIST()", "LIST", "for a in LIST()", "a-K", "a", "K", "A = [a-K for a in LIST()]", "A", "[a-K for a in LIST()]", "MAX = N * K * 2", "MAX", "N * K * 2", "N * K", "N", "K", "2", "dp = list2d(N+1, MAX+1, 0)", "dp", "list2d(N+1, MAX+1, 0)", "list2d", "N+1", "N", "1", "MAX+1", "MAX", "1", "0", "dp[0][N*K] = 1", "dp[0][N*K]", "[0]", "dp", "0", "N*K", "N", "K", "1", "for i in range(N):\n a = A[i]\n for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+a <= MAX:\n dp[i+1][k+a] += dp[i][k]\n# N回終わって合計が0になっている通り数 - 1枚も取らないケース", "i", "range(N)", "range", "N", "a = A[i]", "a", "A[i]", "A", "i", "for k in range(MAX+1):\n dp[i+1][k] += dp[i][k]\n if 0 <= k+a <= MAX:\n dp[i+1][k+a] += dp[i][k]\n# N回終わって合計が0になっている通り数 - 1枚も取らないケース", "k", "range(MAX+1)", "range", "MAX+1", "MAX", "1", "dp[i+1][k] += dp[i][k]", "dp[i+1][k]", "[i+1]", "dp", "i+1", "i", "1", "k", "dp[i][k]", "[i]", "dp", "i", "k", "if 0 <= k+a <= MAX:\n dp[i+1][k+a] += dp[i][k]\n# N回終わって合計が0になっている通り数 - 1枚も取らないケース", "0 <= k+a <= MAX", "0 <= k+a", "0", "k+a", "k", "a", "MAX", "dp[i+1][k+a] += dp[i][k]", "dp[i+1][k+a]", "[i+1]", "dp", "i+1", "i", "1", "k+a", "k", "a", "dp[i][k]", "[i]", "dp", "i", "k", "print(dp[N][N*K]-1)", "print", "dp[N][N*K]-1", "dp[N][N*K]", "[N]", "dp", "N", "N*K", "N", "K", "1", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "INF = 10 ** 18", "10 ** 18", "INF", "K = MAP()", "MAP()", "K", "dp = list2d(N+1, MAX+1, 0)", "list2d(N+1, MAX+1, 0)", "dp", "N, K = MAP()", "MAP()", "N", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "def YES(): print('YES')", "def YES(): print('YES')", "YES", "a = A[i]", "A[i]", "a", "def No(): print('No')", "def No(): print('No')", "No", "def NO(): print('NO')", "def NO(): print('NO')", "NO", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "def ceil(x, y=1): return int(-(-x // y))", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "A = [a-K for a in LIST()]", "[a-K for a in LIST()]", "A", "def Yes(): print('Yes')", "def Yes(): print('Yes')", "Yes", "MAX = N * K * 2", "N * K * 2", "MAX", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "def INT(): return int(input())", "def INT(): return int(input())", "INT" ]

[ 7, 15, 13, 0, 13, 4, 18, 13, 13, 39, 17, 17, 18, 13, 13, 0, 18, 13, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 28, 13, 13, 0, 13, 4, 18, 13, 13, 0, 18, 13, 39, 13, 17, 18, 13, 39, 2, 17, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 2, 2, 13, 17, 13, 4, 13, 13, 10, 18, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 100, 4 ], [ 19, 16 ], [ 101, 17 ], [ 97, 21 ], [ 97, 30 ], [ 34, 33 ], [ 33, 42 ], [ 91, 44 ], [ 48, 47 ], [ 92, 47 ], [ 106, 50 ], [ 101, 53 ], [ 61, 56 ], [ 101, 57 ], [ 107, 62 ], [ 47, 66 ], [ 103, 68 ], [ 72, 71 ], [ 95, 74 ], [ 88, 76 ], [ 101, 78 ], [ 71, 81 ], [ 98, 83 ], [ 89, 86 ], [ 104, 86 ], [ 88, 89 ], [ 91, 92 ], [ 97, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "import numpy as np\nhi = np.zeros((5000,60),np.int64)\nhi[0,0]=1\nn,a = map(int, input().split())\nli = [int(it) for it in input().split()]\nfor i in li:\n hi_ = hi.copy()\n hi[i:-1,1:]+=hi_[:-1-i,:-1]\ns = 0\nfor i in range(n):\n s+=hi[(i+1)*a,i+1]\nprint (s)", "import numpy as np", "numpy", "hi = np.zeros((5000,60),np.int64)", "hi", "np.zeros((5000,60),np.int64)", "np.zeros", "np", "zeros", "(5000,60)", "5000", "60", "np.int64", "np", "int64", "hi[0,0]=1", "hi[0,0]", "hi", "0", "1", "n,a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "int(it) for it in input().split()", "for it in input().split()", "it", "input().split()", "().split", "()", "input", "split", "for it in input().split()", "int(it)", "int", "it", "li = [int(it) for it in input().split()]", "li", "[int(it) for it in input().split()]", "for i in li:\n hi_ = hi.copy()\n hi[i:-1,1:]+=hi_[:-1-i,:-1]", "i", "li", "hi_ = hi.copy()", "hi_", "hi.copy()", "hi.copy", "hi", "copy", "hi[i:-1,1:]+=hi_[:-1-i,:-1]", "hi[i:-1,1:]", "hi", "i:-1", "i", "-1", "hi_[:-1-i,:-1]", "hi_", ":-1-i", "-1-i", "-1", "i", "s = 0", "s", "0", "for i in range(n):\n s+=hi[(i+1)*a,i+1]", "i", "range(n)", "range", "n", "s+=hi[(i+1)*a,i+1]", "s", "hi[(i+1)*a,i+1]", "hi", "(i+1)*a", "i+1", "i", "1", "a", "print (s)", "print", "s", "s+=hi[(i+1)*a,i+1]", "hi[(i+1)*a,i+1]", "s", "li = [int(it) for it in input().split()]", "[int(it) for it in input().split()]", "li", "n,a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "hi = np.zeros((5000,60),np.int64)", "np.zeros((5000,60),np.int64)", "hi", "s = 0", "0", "s", "hi_ = hi.copy()", "hi.copy()", "hi_" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 2, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 147, 2 ], [ 147, 11 ], [ 141, 13 ], [ 27, 26 ], [ 153, 33 ], [ 43, 36 ], [ 154, 39 ], [ 46, 45 ], [ 145, 48 ], [ 51, 50 ], [ 145, 54 ], [ 58, 57 ], [ 57, 63 ], [ 142, 65 ], [ 45, 66 ], [ 77, 68 ], [ 154, 71 ], [ 45, 73 ], [ 50, 75 ], [ 57, 76 ], [ 154, 80 ], [ 45, 81 ], [ 50, 82 ], [ 57, 83 ], [ 94, 85 ], [ 154, 88 ], [ 45, 90 ], [ 50, 92 ], [ 57, 93 ], [ 154, 98 ], [ 45, 99 ], [ 50, 100 ], [ 57, 101 ], [ 154, 105 ], [ 45, 106 ], [ 50, 108 ], [ 57, 111 ], [ 142, 113 ], [ 45, 114 ], [ 156, 116 ], [ 120, 119 ], [ 145, 124 ], [ 150, 127 ], [ 154, 131 ], [ 145, 132 ], [ 119, 133 ], [ 119, 135 ], [ 148, 136 ], [ 151, 139 ], [ 157, 139 ], [ 141, 142 ], [ 147, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ] ]

[ "n,a=map(int,input().split())\nx=list(map(int,input().split()))\n# dp[j][k][s]=(x1,...,xjからk枚選んでx[i]の合計をsにするような選び方の総数)\ndp=[[[0]*2501 for i in range(51)] for j in range(51)]\ndp[0][0][0]=1\nfor i in range(n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i+1][j][k]=dp[i][j][k]\n else:\n dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]\nans=0\nfor i in range(1,n+1):\n ans+=dp[n][i][i*a]\nprint(ans)", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0]*2501 for i in range(51)] for j in range(51)", "for j in range(51)", "j", "range(51)", "range", "51", "for j in range(51)", "[[0]*2501 for i in range(51)]", "dp=[[[0]*2501 for i in range(51)] for j in range(51)]", "dp", "[[[0]*2501 for i in range(51)] for j in range(51)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i+1][j][k]=dp[i][j][k]\n else:\n dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]", "i", "range(n)", "range", "n", "for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i+1][j][k]=dp[i][j][k]\n else:\n dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]", "j", "range(n+1)", "range", "n+1", "n", "1", "for k in range(2501):\n if k<x[i]:\n dp[i+1][j][k]=dp[i][j][k]\n else:\n dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]", "k", "range(2501)", "range", "2501", "if k<x[i]:\n dp[i+1][j][k]=dp[i][j][k]\n else:\n dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]", "k<x[i]", "k", "x[i]", "x", "i", "dp[i+1][j][k]=dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j][k]=dp[i][j][k]+dp[i][j-1][k-x[i]]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]+dp[i][j-1][k-x[i]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i][j-1][k-x[i]]", "[j-1]", "[i]", "dp", "i", "j-1", "j", "1", "k-x[i]", "k", "x[i]", "x", "i", "ans=0", "ans", "0", "for i in range(1,n+1):\n ans+=dp[n][i][i*a]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "ans+=dp[n][i][i*a]", "ans", "dp[n][i][i*a]", "[i]", "[n]", "dp", "n", "i", "i*a", "i", "a", "print(ans)", "print", "ans", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "n,a=map(int,input().split())", "map(int,input().split())", "n", "a=map(int,input().split())", "map(int,input().split())", "a", "ans+=dp[n][i][i*a]", "dp[n][i][i*a]", "ans", "dp=[[[0]*2501 for i in range(51)] for j in range(51)]", "[[[0]*2501 for i in range(51)] for j in range(51)]", "dp", "ans=0", "0", "ans" ]

[ 7, 15, 12, 13, 0, 13, 18, 13, 13, 0, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 17, 17, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 13, 2, 13, 17, 18, 18, 18, 13, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 2, 13, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 11, 10 ], [ 14, 13 ], [ 5, 20 ], [ 14, 22 ], [ 25, 24 ], [ 5, 33 ], [ 38, 37 ], [ 13, 41 ], [ 47, 46 ], [ 56, 49 ], [ 46, 52 ], [ 59, 58 ], [ 13, 61 ], [ 64, 63 ], [ 13, 66 ], [ 69, 68 ], [ 10, 73 ], [ 92, 77 ], [ 46, 80 ], [ 58, 82 ], [ 68, 85 ], [ 24, 87 ], [ 58, 88 ], [ 63, 90 ], [ 46, 95 ], [ 58, 96 ], [ 68, 97 ], [ 63, 98 ], [ 109, 100 ], [ 46, 103 ], [ 58, 105 ], [ 68, 107 ], [ 63, 108 ], [ 46, 112 ], [ 58, 113 ], [ 68, 114 ], [ 63, 115 ], [ 118, 117 ], [ 121, 120 ], [ 13, 125 ], [ 129, 128 ], [ 46, 132 ], [ 13, 133 ], [ 120, 135 ], [ 22, 136 ], [ 120, 137 ], [ 128, 140 ], [ 117, 140 ], [ 149, 146 ] ]

[ "from sys import stdin\ndef main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n print(ans)\n\nif __name__==\"__main__\":\n main()", "from sys import stdin", "def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n print(ans)", "main", "readline=stdin.readline", "readline", "stdin.readline", "stdin", "readline", "con=2500", "con", "2500", "n,a=map(int,readline().split())", "n", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "a", "x=list(map(int,readline().split()))", "x", "list(map(int,readline().split()))", "list", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[[0]*(n+1) for _ in range(con+1)]", "dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]", "dp", "[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ", "i", "range(n)", "range", "n", "for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ", "k", "range(n)", "range", "n", "for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ", "j", "range(con+1-50)", "range", "con+1-50", "con+1", "con", "1", "50", "dp[i+1][j+x[i]][k+1]+=dp[i][j][k]", "dp[i+1][j+x[i]][k+1]", "[j+x[i]]", "[i+1]", "dp", "i+1", "i", "1", "j+x[i]", "j", "x[i]", "x", "i", "k+1", "k", "1", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i+1][j][k]+=dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans=0", "ans", "0", "for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n ", "k", "range(1,n+1)", "range", "1", "n+1", "n", "1", "ans+=dp[n][k*a][k]", "ans", "dp[n][k*a][k]", "[k*a]", "[n]", "dp", "n", "k*a", "k", "a", "k", "print(ans)", "print", "ans", "if __name__==\"__main__\":\n main()", "__name__==\"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n print(ans)", "def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n print(ans)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 0, 18, 18, 13, 17, 17, 17, 0, 18, 18, 13, 17, 2, 18, 13, 17, 17, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 14, 2, 40, 17, 2, 13, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 155, 2 ], [ 155, 11 ], [ 140, 13 ], [ 149, 23 ], [ 156, 28 ], [ 32, 31 ], [ 147, 35 ], [ 143, 40 ], [ 48, 43 ], [ 144, 45 ], [ 55, 50 ], [ 144, 52 ], [ 66, 57 ], [ 144, 59 ], [ 150, 63 ], [ 69, 68 ], [ 147, 72 ], [ 68, 77 ], [ 68, 80 ], [ 152, 83 ], [ 150, 85 ], [ 68, 87 ], [ 91, 90 ], [ 100, 95 ], [ 144, 97 ], [ 68, 98 ], [ 90, 99 ], [ 144, 102 ], [ 68, 104 ], [ 90, 106 ], [ 90, 112 ], [ 153, 113 ], [ 121, 116 ], [ 144, 118 ], [ 68, 119 ], [ 90, 120 ], [ 144, 123 ], [ 68, 125 ], [ 90, 128 ], [ 153, 129 ], [ 144, 135 ], [ 147, 136 ], [ 140, 141 ], [ 143, 144 ], [ 155, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ] ]

[ "n, a = map(int, input().split())\nx_i = map(int, input().split())\nlist = list(i - a for i in x_i)\nanslist = [[0 for i in range(5001)] for j in range(n + 1)]\nanslist[0][2500] += 1\nanslist[1][2500] += 1\nanslist[1][list[0] + 2500] += 1\nfor id in range(n + 1):\n if id == 0 or id == 1: continue\n num = list[id - 1]\n for x in range(5001):\n anslist[id][x] += anslist[id - 1][x]\n if 0 <= x - num < 5001:\n anslist[id][x] += anslist[id - 1][x - num]\nprint(anslist[n][2500] - 1)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x_i = map(int, input().split())", "x_i", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "list = list(i - a for i in x_i)", "list", "list(i - a for i in x_i)", "list", "i - a", "i", "a", "[0 for i in range(5001)] for j in range(n + 1)", "for j in range(n + 1)", "j", "range(n + 1)", "range", "n + 1", "n", "1", "for j in range(n + 1)", "[0 for i in range(5001)]", "anslist = [[0 for i in range(5001)] for j in range(n + 1)]", "anslist", "[[0 for i in range(5001)] for j in range(n + 1)]", "anslist[0][2500] += 1", "anslist[0][2500]", "[0]", "anslist", "0", "2500", "1", "anslist[1][2500] += 1", "anslist[1][2500]", "[1]", "anslist", "1", "2500", "1", "anslist[1][list[0] + 2500] += 1", "anslist[1][list[0] + 2500]", "[1]", "anslist", "1", "list[0] + 2500", "list[0]", "list", "0", "2500", "1", "for id in range(n + 1):\n if id == 0 or id == 1: continue\n num = list[id - 1]\n for x in range(5001):\n anslist[id][x] += anslist[id - 1][x]\n if 0 <= x - num < 5001:\n anslist[id][x] += anslist[id - 1][x - num]", "id", "range(n + 1)", "range", "n + 1", "n", "1", "if id == 0 or id == 1: continue\n ", "id == 0 or id == 1", "id == 0", "id", "0", "id == 1", "id", "1", "num = list[id - 1]", "num", "list[id - 1]", "list", "id - 1", "id", "1", "for x in range(5001):\n anslist[id][x] += anslist[id - 1][x]\n if 0 <= x - num < 5001:\n anslist[id][x] += anslist[id - 1][x - num]", "x", "range(5001)", "range", "5001", "anslist[id][x] += anslist[id - 1][x]", "anslist[id][x]", "[id]", "anslist", "id", "x", "anslist[id - 1][x]", "[id - 1]", "anslist", "id - 1", "id", "1", "x", "if 0 <= x - num < 5001:\n anslist[id][x] += anslist[id - 1][x - num]", "0 <= x - num < 5001", "0 <= x - num", "0", "x - num", "x", "num", "5001", "anslist[id][x] += anslist[id - 1][x - num]", "anslist[id][x]", "[id]", "anslist", "id", "x", "anslist[id - 1][x - num]", "[id - 1]", "anslist", "id - 1", "id", "1", "x - num", "x", "num", "print(anslist[n][2500] - 1)", "print", "anslist[n][2500] - 1", "anslist[n][2500]", "[n]", "anslist", "n", "2500", "1", "x_i = map(int, input().split())", "map(int, input().split())", "x_i", "anslist = [[0 for i in range(5001)] for j in range(n + 1)]", "[[0 for i in range(5001)] for j in range(n + 1)]", "anslist", "n, a = map(int, input().split())", "map(int, input().split())", "n", "list = list(i - a for i in x_i)", "list(i - a for i in x_i)", "list", "num = list[id - 1]", "list[id - 1]", "num", "a = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 17, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 13, 4, 13, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 4, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 172, 2 ], [ 172, 11 ], [ 157, 13 ], [ 166, 25 ], [ 155, 28 ], [ 32, 31 ], [ 155, 35 ], [ 160, 40 ], [ 50, 43 ], [ 161, 46 ], [ 158, 56 ], [ 60, 59 ], [ 65, 64 ], [ 167, 68 ], [ 78, 71 ], [ 161, 74 ], [ 59, 76 ], [ 64, 77 ], [ 161, 81 ], [ 59, 85 ], [ 64, 86 ], [ 89, 88 ], [ 94, 93 ], [ 167, 98 ], [ 113, 102 ], [ 161, 105 ], [ 88, 108 ], [ 93, 111 ], [ 161, 116 ], [ 88, 120 ], [ 93, 121 ], [ 163, 123 ], [ 127, 126 ], [ 155, 131 ], [ 169, 134 ], [ 126, 136 ], [ 173, 137 ], [ 151, 139 ], [ 161, 143 ], [ 155, 144 ], [ 126, 145 ], [ 170, 146 ], [ 152, 149 ], [ 164, 149 ], [ 151, 152 ], [ 172, 155 ], [ 157, 158 ], [ 160, 161 ], [ 163, 164 ], [ 166, 167 ], [ 169, 170 ], [ 172, 173 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\nMAX = 50 * n\n\ndp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]\ndp[0][0][0] = 1\n\nfor i, e in enumerate(x, 1):\n for j in range(i):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i-1][j][k]\n\n for j in range(i):\n for k in range(MAX - e + 1):\n dp[i][j+1][k+e] += dp[i-1][j][k]\n\nans = 0\nfor cnt in range(1, n + 1):\n sm = cnt * a\n ans += dp[n][cnt][sm]\n\nprint(ans)", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = list(map(int, input().split()))", "x", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "MAX = 50 * n", "MAX", "50 * n", "50", "n", "[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[[0] * (MAX + 1) for _ in range(n + 1)]", "dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "[[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i, e in enumerate(x, 1):\n for j in range(i):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i-1][j][k]\n\n for j in range(i):\n for k in range(MAX - e + 1):\n dp[i][j+1][k+e] += dp[i-1][j][k]", "i", "e", "enumerate(x, 1)", "enumerate", "x", "1", "for j in range(i):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i-1][j][k]\n\n ", "j", "range(i)", "range", "i", "for k in range(MAX + 1):\n dp[i][j][k] += dp[i-1][j][k]\n\n ", "k", "range(MAX + 1)", "range", "MAX + 1", "MAX", "1", "dp[i][j][k] += dp[i-1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "for j in range(i):\n for k in range(MAX - e + 1):\n dp[i][j+1][k+e] += dp[i-1][j][k]", "j", "range(i)", "range", "i", "for k in range(MAX - e + 1):\n dp[i][j+1][k+e] += dp[i-1][j][k]", "k", "range(MAX - e + 1)", "range", "MAX - e + 1", "MAX - e", "MAX", "e", "1", "dp[i][j+1][k+e] += dp[i-1][j][k]", "dp[i][j+1][k+e]", "[j+1]", "[i]", "dp", "i", "j+1", "j", "1", "k+e", "k", "e", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "ans = 0", "ans", "0", "for cnt in range(1, n + 1):\n sm = cnt * a\n ans += dp[n][cnt][sm]", "cnt", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "sm = cnt * a", "sm", "cnt * a", "cnt", "a", "ans += dp[n][cnt][sm]", "ans", "dp[n][cnt][sm]", "[cnt]", "[n]", "dp", "n", "cnt", "sm", "print(ans)", "print", "ans", "ans += dp[n][cnt][sm]", "dp[n][cnt][sm]", "ans", "n, a = map(int, input().split())", "map(int, input().split())", "n", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "[[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "dp", "ans = 0", "0", "ans", "MAX = 50 * n", "50 * n", "MAX", "sm = cnt * a", "cnt * a", "sm", "a = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 28, 13, 4, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 13, 13, 9, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 13, 4, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 122, 2 ], [ 122, 11 ], [ 15, 14 ], [ 14, 23 ], [ 125, 25 ], [ 30, 29 ], [ 123, 33 ], [ 123, 41 ], [ 117, 42 ], [ 113, 45 ], [ 53, 48 ], [ 114, 50 ], [ 56, 55 ], [ 126, 55 ], [ 59, 58 ], [ 123, 65 ], [ 69, 68 ], [ 123, 75 ], [ 117, 76 ], [ 68, 80 ], [ 55, 81 ], [ 89, 84 ], [ 114, 86 ], [ 58, 87 ], [ 68, 88 ], [ 114, 91 ], [ 58, 93 ], [ 68, 96 ], [ 55, 97 ], [ 119, 99 ], [ 114, 104 ], [ 117, 108 ], [ 120, 111 ], [ 113, 114 ], [ 122, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "N, A = map(int,input().split())\nX = [int(x) for x in input().split()]\n\ndp = [[0]*(N*A+1) for _ in range(N+1)] #dp[i][j]:i枚の和がjとなるようなカードの選び方\ndp[0][0] = 1 \nfor x in X:\n for i in reversed(range(1,N+1)):\n for j in reversed(range(N*A+1)):\n if j < x:\n continue\n dp[i][j] += dp[i-1][j-x]\nans = sum(dp[k][k*A] for k in range(1,N+1)) \nprint(ans) ", "N, A = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "X = [int(x) for x in input().split()]", "X", "[int(x) for x in input().split()]", "[0]*(N*A+1) for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0]*(N*A+1)", "[0]", "0", "N*A+1", "N*A", "N", "A", "1", "dp = [[0]*(N*A+1) for _ in range(N+1)]", "dp", "[[0]*(N*A+1) for _ in range(N+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for x in X:\n for i in reversed(range(1,N+1)):\n for j in reversed(range(N*A+1)):\n if j < x:\n continue\n dp[i][j] += dp[i-1][j-x]", "x", "X", "for i in reversed(range(1,N+1)):\n for j in reversed(range(N*A+1)):\n if j < x:\n continue\n dp[i][j] += dp[i-1][j-x]", "i", "reversed(range(1,N+1))", "reversed", "range(1,N+1)", "range", "1", "N+1", "N", "1", "for j in reversed(range(N*A+1)):\n if j < x:\n continue\n dp[i][j] += dp[i-1][j-x]", "j", "reversed(range(N*A+1))", "reversed", "range(N*A+1)", "range", "N*A+1", "N*A", "N", "A", "1", "if j < x:\n continue\n ", "j < x", "j", "x", "continue", "dp[i][j] += dp[i-1][j-x]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j-x]", "[i-1]", "dp", "i-1", "i", "1", "j-x", "j", "x", "ans = sum(dp[k][k*A] for k in range(1,N+1))", "ans", "sum(dp[k][k*A] for k in range(1,N+1))", "sum", "dp[k][k*A]", "[k]", "dp", "k", "k*A", "k", "A", "print(ans)", "print", "ans", "dp = [[0]*(N*A+1) for _ in range(N+1)]", "[[0]*(N*A+1) for _ in range(N+1)]", "dp", "A = map(int,input().split())", "map(int,input().split())", "A", "ans = sum(dp[k][k*A] for k in range(1,N+1))", "sum(dp[k][k*A] for k in range(1,N+1))", "ans", "N, A = map(int,input().split())", "map(int,input().split())", "N", "X = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "X" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 0, 13, 2, 4, 13, 13, 13, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 17, 13, 0, 13, 13, 0, 18, 18, 13, 17, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 2, 17, 13, 14, 2, 40, 17, 2, 13, 13, 2, 17, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 4, 13, 2, 18, 18, 13, 13, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 18, 13 ]

[ [ 171, 4 ], [ 14, 13 ], [ 172, 22 ], [ 14, 25 ], [ 28, 27 ], [ 172, 38 ], [ 43, 42 ], [ 27, 46 ], [ 13, 47 ], [ 51, 50 ], [ 27, 50 ], [ 50, 54 ], [ 25, 55 ], [ 58, 57 ], [ 62, 61 ], [ 13, 65 ], [ 42, 73 ], [ 76, 75 ], [ 83, 78 ], [ 75, 80 ], [ 42, 82 ], [ 86, 85 ], [ 13, 90 ], [ 94, 93 ], [ 57, 95 ], [ 27, 95 ], [ 85, 97 ], [ 101, 100 ], [ 42, 105 ], [ 100, 111 ], [ 93, 112 ], [ 42, 115 ], [ 122, 117 ], [ 75, 119 ], [ 85, 120 ], [ 100, 121 ], [ 75, 125 ], [ 85, 127 ], [ 100, 129 ], [ 75, 132 ], [ 85, 134 ], [ 100, 137 ], [ 93, 138 ], [ 145, 140 ], [ 75, 142 ], [ 85, 143 ], [ 100, 144 ], [ 75, 147 ], [ 85, 149 ], [ 100, 151 ], [ 75, 157 ], [ 13, 158 ], [ 42, 159 ], [ 169, 166 ], [ 171, 172 ] ]

[ "import sys\nreadline = sys.stdin.readline\n\ndef main():\n N, A = map(int, readline().rstrip().split())\n X = list(map(int, readline().rstrip().split()))\n lim = max(X) * N\n X = [x-A for x in X]\n dp = [[0]*(2*lim) for _ in range(N+1)]\n dp[0][lim] = 1\n for i in range(1, N+1):\n x = X[i-1]\n for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n print(dp[N][lim] - 1)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n N, A = map(int, readline().rstrip().split())\n X = list(map(int, readline().rstrip().split()))\n lim = max(X) * N\n X = [x-A for x in X]\n dp = [[0]*(2*lim) for _ in range(N+1)]\n dp[0][lim] = 1\n for i in range(1, N+1):\n x = X[i-1]\n for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n print(dp[N][lim] - 1)", "main", "N, A = map(int, readline().rstrip().split())", "N", "map(int, readline().rstrip().split())", "map", "int", "readline().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "readline", "rstrip", "split", "A", "X = list(map(int, readline().rstrip().split()))", "X", "list(map(int, readline().rstrip().split()))", "list", "map(int, readline().rstrip().split())", "map", "int", "readline().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "readline", "rstrip", "split", "lim = max(X) * N", "lim", "max(X) * N", "max(X)", "max", "X", "N", "x-A for x in X", "for x in X", "x", "X", "for x in X", "x-A", "x", "A", "X = [x-A for x in X]", "X", "[x-A for x in X]", "[0]*(2*lim) for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0]*(2*lim)", "[0]", "0", "2*lim", "2", "lim", "dp = [[0]*(2*lim) for _ in range(N+1)]", "dp", "[[0]*(2*lim) for _ in range(N+1)]", "dp[0][lim] = 1", "dp[0][lim]", "[0]", "dp", "0", "lim", "1", "for i in range(1, N+1):\n x = X[i-1]\n for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n ", "i", "range(1, N+1)", "range", "1", "N+1", "N", "1", "x = X[i-1]", "x", "X[i-1]", "X", "i-1", "i", "1", "for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n ", "j", "range(2*lim)", "range", "2*lim", "2", "lim", "if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n ", "0 <= j - x < 2 * lim", "0 <= j - x", "0", "j - x", "j", "x", "2 * lim", "2", "lim", "dp[i][j] = dp[i-1][j] + dp[i-1][j-x]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j] + dp[i-1][j-x]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][j-x]", "[i-1]", "dp", "i-1", "i", "1", "j-x", "j", "x", "dp[i][j] = dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "print(dp[N][lim] - 1)", "print", "dp[N][lim] - 1", "dp[N][lim]", "[N]", "dp", "N", "lim", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, A = map(int, readline().rstrip().split())\n X = list(map(int, readline().rstrip().split()))\n lim = max(X) * N\n X = [x-A for x in X]\n dp = [[0]*(2*lim) for _ in range(N+1)]\n dp[0][lim] = 1\n for i in range(1, N+1):\n x = X[i-1]\n for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n print(dp[N][lim] - 1)", "def main():\n N, A = map(int, readline().rstrip().split())\n X = list(map(int, readline().rstrip().split()))\n lim = max(X) * N\n X = [x-A for x in X]\n dp = [[0]*(2*lim) for _ in range(N+1)]\n dp[0][lim] = 1\n for i in range(1, N+1):\n x = X[i-1]\n for j in range(2*lim):\n if 0 <= j - x < 2 * lim:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x]\n else:\n dp[i][j] = dp[i-1][j]\n \n print(dp[N][lim] - 1)", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 13, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 0, 18, 18, 18, 13, 17, 17, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 17, 16 ], [ 16, 25 ], [ 28, 27 ], [ 32, 31 ], [ 4, 34 ], [ 39, 38 ], [ 48, 41 ], [ 38, 44 ], [ 59, 50 ], [ 38, 53 ], [ 27, 57 ], [ 62, 61 ], [ 4, 65 ], [ 68, 67 ], [ 4, 71 ], [ 75, 74 ], [ 74, 80 ], [ 27, 82 ], [ 61, 83 ], [ 92, 85 ], [ 38, 88 ], [ 61, 89 ], [ 67, 90 ], [ 74, 91 ], [ 38, 95 ], [ 61, 97 ], [ 67, 99 ], [ 74, 100 ], [ 109, 102 ], [ 38, 105 ], [ 61, 106 ], [ 67, 107 ], [ 74, 108 ], [ 38, 113 ], [ 61, 115 ], [ 67, 117 ], [ 74, 118 ], [ 38, 122 ], [ 61, 124 ], [ 67, 127 ], [ 74, 130 ], [ 27, 132 ], [ 61, 133 ], [ 136, 135 ], [ 139, 138 ], [ 4, 143 ], [ 147, 146 ], [ 38, 150 ], [ 138, 152 ], [ 13, 154 ], [ 138, 155 ], [ 146, 158 ], [ 135, 158 ], [ 167, 164 ] ]

[ "def main():\n n,a = map(int,input().split())\n x = [int(x) for x in input().split()]\n dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]\n\n dp[0][0][0] = 1\n dp[0][1][x[0]] = 1\n\n for i in range(1,n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ans = 0\n for i in range(1,n+1):\n ans += dp[-1][i][a*i]\n print(ans)\n \nif __name__ == \"__main__\":\n main()", "def main():\n n,a = map(int,input().split())\n x = [int(x) for x in input().split()]\n dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]\n\n dp[0][0][0] = 1\n dp[0][1][x[0]] = 1\n\n for i in range(1,n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ans = 0\n for i in range(1,n+1):\n ans += dp[-1][i][a*i]\n print(ans)\n ", "main", "n,a = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "x = [int(x) for x in input().split()]", "x", "[int(x) for x in input().split()]", "[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "[[0 for _ in range(2501)] for _ in range(n+1)]", "dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]", "dp", "[[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "dp[0][1][x[0]] = 1", "dp[0][1][x[0]]", "[1]", "[0]", "dp", "0", "1", "x[0]", "x", "0", "1", "for i in range(1,n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ", "i", "range(1,n)", "range", "1", "n", "for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ", "j", "range(n+1)", "range", "n+1", "n", "1", "for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ", "k", "range(2501)", "range", "2501", "if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ", "k<x[i]", "k", "x[i]", "x", "i", "dp[i][j][k] = dp[i-1][j][k]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]", "dp[i-1][j][k]", "[j]", "[i-1]", "dp", "i-1", "i", "1", "j", "k", "dp[i-1][j-1][k-x[i]]", "[j-1]", "[i-1]", "dp", "i-1", "i", "1", "j-1", "j", "1", "k-x[i]", "k", "x[i]", "x", "i", "ans = 0", "ans", "0", "for i in range(1,n+1):\n ans += dp[-1][i][a*i]\n ", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "ans += dp[-1][i][a*i]", "ans", "dp[-1][i][a*i]", "[i]", "[-1]", "dp", "-1", "i", "a*i", "a", "i", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n,a = map(int,input().split())\n x = [int(x) for x in input().split()]\n dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]\n\n dp[0][0][0] = 1\n dp[0][1][x[0]] = 1\n\n for i in range(1,n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ans = 0\n for i in range(1,n+1):\n ans += dp[-1][i][a*i]\n print(ans)\n ", "def main():\n n,a = map(int,input().split())\n x = [int(x) for x in input().split()]\n dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]\n\n dp[0][0][0] = 1\n dp[0][1][x[0]] = 1\n\n for i in range(1,n):\n for j in range(n+1):\n for k in range(2501):\n if k<x[i]:\n dp[i][j][k] = dp[i-1][j][k]\n else:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]\n ans = 0\n for i in range(1,n+1):\n ans += dp[-1][i][a*i]\n print(ans)\n ", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 17, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 14, 2, 13, 13, 0, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 13, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 18, 13, 2, 13, 17, 2, 2, 13, 17, 13, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 138, 2 ], [ 138, 11 ], [ 117, 13 ], [ 123, 25 ], [ 32, 31 ], [ 139, 35 ], [ 120, 40 ], [ 48, 43 ], [ 121, 45 ], [ 51, 50 ], [ 139, 53 ], [ 129, 55 ], [ 118, 57 ], [ 50, 58 ], [ 61, 60 ], [ 139, 65 ], [ 68, 67 ], [ 124, 71 ], [ 67, 75 ], [ 130, 76 ], [ 85, 78 ], [ 121, 80 ], [ 60, 82 ], [ 67, 84 ], [ 121, 87 ], [ 60, 88 ], [ 67, 90 ], [ 130, 91 ], [ 132, 93 ], [ 97, 96 ], [ 139, 99 ], [ 135, 101 ], [ 121, 104 ], [ 96, 106 ], [ 96, 110 ], [ 127, 112 ], [ 136, 115 ], [ 133, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 138, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ] ]

[ "N, K = map(int, input().split())\nA = list(map(int, input().split()))\n\nL = 50*50\ndp = [[0 for _ in range(L+1)] for _ in range(N+1)]\ndp[0][0] = 1\n\nfor i in range(N):\n a = A[i]\n for j in reversed(range(N)):\n for l in range(L+1):\n if l < a: continue\n dp[j+1][l] += dp[j][l-a]\n\nans = 0\nfor j in range(N):\n ans += dp[j+1][(j+1)*K]\nprint(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L = 50*50", "L", "50*50", "50", "50", "[0 for _ in range(L+1)] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0 for _ in range(L+1)]", "dp = [[0 for _ in range(L+1)] for _ in range(N+1)]", "dp", "[[0 for _ in range(L+1)] for _ in range(N+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i in range(N):\n a = A[i]\n for j in reversed(range(N)):\n for l in range(L+1):\n if l < a: continue\n dp[j+1][l] += dp[j][l-a]", "i", "range(N)", "range", "N", "a = A[i]", "a", "A[i]", "A", "i", "for j in reversed(range(N)):\n for l in range(L+1):\n if l < a: continue\n dp[j+1][l] += dp[j][l-a]", "j", "reversed(range(N))", "reversed", "range(N)", "range", "N", "for l in range(L+1):\n if l < a: continue\n dp[j+1][l] += dp[j][l-a]", "l", "range(L+1)", "range", "L+1", "L", "1", "if l < a: continue\n ", "l < a", "l", "a", "dp[j+1][l] += dp[j][l-a]", "dp[j+1][l]", "[j+1]", "dp", "j+1", "j", "1", "l", "dp[j][l-a]", "[j]", "dp", "j", "l-a", "l", "a", "ans = 0", "ans", "0", "for j in range(N):\n ans += dp[j+1][(j+1)*K]", "j", "range(N)", "range", "N", "ans += dp[j+1][(j+1)*K]", "ans", "dp[j+1][(j+1)*K]", "[j+1]", "dp", "j+1", "j", "1", "(j+1)*K", "j+1", "j", "1", "K", "print(ans)", "print", "ans", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "dp = [[0 for _ in range(L+1)] for _ in range(N+1)]", "[[0 for _ in range(L+1)] for _ in range(N+1)]", "dp", "L = 50*50", "50*50", "L", "K = map(int, input().split())", "map(int, input().split())", "K", "a = A[i]", "A[i]", "a", "ans = 0", "0", "ans", "ans += dp[j+1][(j+1)*K]", "dp[j+1][(j+1)*K]", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 39, 17, 0, 13, 39, 17, 0, 13, 17, 28, 13, 13, 14, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 13, 13, 14, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 13, 13, 0, 13, 17, 41, 28, 13, 4, 13, 4, 13, 13, 4, 13, 0, 13, 13, 41, 28, 13, 4, 13, 4, 13, 13, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 17, 14, 40, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 28, 13, 4, 13, 17, 4, 13, 13, 0, 13, 40, 18, 13, 13, 28, 13, 4, 13, 17, 14, 40, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 17, 17, 0, 13, 2, 18, 18, 13, 2, 4, 13, 13, 17, 13, 18, 18, 13, 2, 4, 13, 13, 17, 13, 0, 13, 2, 2, 13, 4, 13, 17, 13, 17, 4, 13, 13, 10, 17, 13, 10, 39, 13, 10, 4, 13, 10, 40, 13, 10, 2, 13, 10, 18, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 39, 13, 10, 17, 13 ]

[ [ 301, 2 ], [ 301, 11 ], [ 274, 13 ], [ 271, 25 ], [ 304, 29 ], [ 286, 33 ], [ 37, 36 ], [ 275, 36 ], [ 36, 41 ], [ 302, 42 ], [ 272, 46 ], [ 36, 49 ], [ 302, 50 ], [ 36, 54 ], [ 302, 55 ], [ 305, 59 ], [ 36, 62 ], [ 302, 63 ], [ 307, 65 ], [ 70, 69 ], [ 272, 74 ], [ 295, 78 ], [ 83, 82 ], [ 305, 87 ], [ 298, 91 ], [ 99, 94 ], [ 296, 96 ], [ 106, 101 ], [ 299, 103 ], [ 109, 108 ], [ 296, 114 ], [ 283, 116 ], [ 272, 118 ], [ 108, 119 ], [ 122, 121 ], [ 121, 127 ], [ 284, 128 ], [ 135, 130 ], [ 296, 132 ], [ 108, 133 ], [ 121, 134 ], [ 296, 138 ], [ 108, 140 ], [ 121, 142 ], [ 296, 145 ], [ 108, 147 ], [ 121, 150 ], [ 284, 151 ], [ 158, 153 ], [ 296, 155 ], [ 108, 156 ], [ 121, 157 ], [ 296, 160 ], [ 108, 162 ], [ 121, 164 ], [ 167, 166 ], [ 299, 172 ], [ 277, 174 ], [ 305, 177 ], [ 166, 178 ], [ 181, 180 ], [ 180, 186 ], [ 278, 187 ], [ 284, 187 ], [ 194, 189 ], [ 299, 191 ], [ 166, 192 ], [ 180, 193 ], [ 299, 197 ], [ 166, 199 ], [ 180, 201 ], [ 299, 204 ], [ 166, 206 ], [ 180, 209 ], [ 278, 210 ], [ 284, 210 ], [ 217, 212 ], [ 299, 214 ], [ 166, 215 ], [ 180, 216 ], [ 299, 219 ], [ 166, 221 ], [ 180, 223 ], [ 268, 225 ], [ 229, 228 ], [ 289, 234 ], [ 296, 238 ], [ 296, 242 ], [ 228, 244 ], [ 299, 247 ], [ 299, 251 ], [ 228, 253 ], [ 280, 255 ], [ 290, 258 ], [ 269, 258 ], [ 308, 262 ], [ 287, 262 ], [ 281, 266 ], [ 290, 266 ], [ 269, 266 ], [ 268, 269 ], [ 271, 272 ], [ 274, 275 ], [ 277, 278 ], [ 280, 281 ], [ 283, 284 ], [ 286, 287 ], [ 289, 290 ], [ 301, 293 ], [ 295, 296 ], [ 298, 299 ], [ 301, 302 ], [ 304, 305 ], [ 307, 308 ] ]

[ "N,A = map(int,input().split())\nX = list(map(int,input().split()))\n\nXp = [0]\nXm = [0]\nXz = 0\nfor x in X:\n if x-A > 0:\n Xp.append(x-A)\n elif x-A < 0:\n Xm.append(x-A)\n else:\n Xz += 1\n\nDPp = [[0 for j in range(2501)] for i in range(len(Xp))]\nDPm = [[0 for j in range(2501)] for i in range(len(Xm))]\n\nDPp[0][0] = 1\nDPm[0][0] = 1\n\nfor i in range(1,len(DPp)):\n x = Xp[i]\n for j in range(2501):\n if j >= x:\n DPp[i][j] = DPp[i-1][j] + DPp[i-1][j-x]\n else:\n DPp[i][j] = DPp[i-1][j]\n\nfor i in range(1,len(DPm)):\n x = -Xm[i]\n for j in range(2501):\n if j >= x:\n DPm[i][j] = DPm[i-1][j] + DPm[i-1][j-x]\n else:\n DPm[i][j] = DPm[i-1][j]\n\nans = 1\n\nfor j in range(1,2501):\n ans += DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]\nans = ans*pow(2,Xz) - 1\nprint(ans)", "N,A = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int,input().split()))", "X", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Xp = [0]", "Xp", "[0]", "0", "Xm = [0]", "Xm", "[0]", "0", "Xz = 0", "Xz", "0", "for x in X:\n if x-A > 0:\n Xp.append(x-A)\n elif x-A < 0:\n Xm.append(x-A)\n else:\n Xz += 1", "x", "X", "if x-A > 0:\n Xp.append(x-A)\n elif x-A < 0:\n Xm.append(x-A)\n else:\n Xz += 1", "x-A > 0", "x-A", "x", "A", "0", "Xp.append(x-A)", "Xp.append", "Xp", "append", "x-A", "x", "A", "elif x-A < 0:\n Xm.append(x-A)\n ", "x-A < 0", "x-A", "x", "A", "0", "Xm.append(x-A)", "Xm.append", "Xm", "append", "x-A", "x", "A", "Xz += 1", "Xz", "1", "[0 for j in range(2501)] for i in range(len(Xp))", "for i in range(len(Xp))", "i", "range(len(Xp))", "range", "len(Xp)", "len", "Xp", "for i in range(len(Xp))", "[0 for j in range(2501)]", "DPp = [[0 for j in range(2501)] for i in range(len(Xp))]", "DPp", "[[0 for j in range(2501)] for i in range(len(Xp))]", "[0 for j in range(2501)] for i in range(len(Xm))", "for i in range(len(Xm))", "i", "range(len(Xm))", "range", "len(Xm)", "len", "Xm", "for i in range(len(Xm))", "[0 for j in range(2501)]", "DPm = [[0 for j in range(2501)] for i in range(len(Xm))]", "DPm", "[[0 for j in range(2501)] for i in range(len(Xm))]", "DPp[0][0] = 1", "DPp[0][0]", "[0]", "DPp", "0", "0", "1", "DPm[0][0] = 1", "DPm[0][0]", "[0]", "DPm", "0", "0", "1", "for i in range(1,len(DPp)):\n x = Xp[i]\n for j in range(2501):\n if j >= x:\n DPp[i][j] = DPp[i-1][j] + DPp[i-1][j-x]\n else:\n DPp[i][j] = DPp[i-1][j]", "i", "range(1,len(DPp))", "range", "1", "len(DPp)", "len", "DPp", "x = Xp[i]", "x", "Xp[i]", "Xp", "i", "for j in range(2501):\n if j >= x:\n DPp[i][j] = DPp[i-1][j] + DPp[i-1][j-x]\n else:\n DPp[i][j] = DPp[i-1][j]", "j", "range(2501)", "range", "2501", "if j >= x:\n DPp[i][j] = DPp[i-1][j] + DPp[i-1][j-x]\n else:\n DPp[i][j] = DPp[i-1][j]", "j >= x", "j", "x", "DPp[i][j] = DPp[i-1][j] + DPp[i-1][j-x]", "DPp[i][j]", "[i]", "DPp", "i", "j", "DPp[i-1][j] + DPp[i-1][j-x]", "DPp[i-1][j]", "[i-1]", "DPp", "i-1", "i", "1", "j", "DPp[i-1][j-x]", "[i-1]", "DPp", "i-1", "i", "1", "j-x", "j", "x", "DPp[i][j] = DPp[i-1][j]", "DPp[i][j]", "[i]", "DPp", "i", "j", "DPp[i-1][j]", "[i-1]", "DPp", "i-1", "i", "1", "j", "for i in range(1,len(DPm)):\n x = -Xm[i]\n for j in range(2501):\n if j >= x:\n DPm[i][j] = DPm[i-1][j] + DPm[i-1][j-x]\n else:\n DPm[i][j] = DPm[i-1][j]", "i", "range(1,len(DPm))", "range", "1", "len(DPm)", "len", "DPm", "x = -Xm[i]", "x", "-Xm[i]", "Xm[i]", "Xm", "i", "for j in range(2501):\n if j >= x:\n DPm[i][j] = DPm[i-1][j] + DPm[i-1][j-x]\n else:\n DPm[i][j] = DPm[i-1][j]", "j", "range(2501)", "range", "2501", "if j >= x:\n DPm[i][j] = DPm[i-1][j] + DPm[i-1][j-x]\n else:\n DPm[i][j] = DPm[i-1][j]", "j >= x", "j", "x", "DPm[i][j] = DPm[i-1][j] + DPm[i-1][j-x]", "DPm[i][j]", "[i]", "DPm", "i", "j", "DPm[i-1][j] + DPm[i-1][j-x]", "DPm[i-1][j]", "[i-1]", "DPm", "i-1", "i", "1", "j", "DPm[i-1][j-x]", "[i-1]", "DPm", "i-1", "i", "1", "j-x", "j", "x", "DPm[i][j] = DPm[i-1][j]", "DPm[i][j]", "[i]", "DPm", "i", "j", "DPm[i-1][j]", "[i-1]", "DPm", "i-1", "i", "1", "j", "ans = 1", "ans", "1", "for j in range(1,2501):\n ans += DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]", "j", "range(1,2501)", "range", "1", "2501", "ans += DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]", "ans", "DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]", "DPp[len(DPp)-1][j]", "[len(DPp)-1]", "DPp", "len(DPp)-1", "len(DPp)", "len", "DPp", "1", "j", "DPm[len(DPm)-1][j]", "[len(DPm)-1]", "DPm", "len(DPm)-1", "len(DPm)", "len", "DPm", "1", "j", "ans = ans*pow(2,Xz) - 1", "ans", "ans*pow(2,Xz) - 1", "ans*pow(2,Xz)", "ans", "pow(2,Xz)", "pow", "2", "Xz", "1", "print(ans)", "print", "ans", "ans = 1", "1", "ans", "Xp = [0]", "[0]", "Xp", "X = list(map(int,input().split()))", "list(map(int,input().split()))", "X", "x = -Xm[i]", "-Xm[i]", "x", "ans = ans*pow(2,Xz) - 1", "ans*pow(2,Xz) - 1", "ans", "x = Xp[i]", "Xp[i]", "x", "Xz = 0", "0", "Xz", "ans += DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]", "DPp[len(DPp)-1][j]*DPm[len(DPm)-1][j]", "ans", "N,A = map(int,input().split())", "map(int,input().split())", "N", "DPp = [[0 for j in range(2501)] for i in range(len(Xp))]", "[[0 for j in range(2501)] for i in range(len(Xp))]", "DPp", "DPm = [[0 for j in range(2501)] for i in range(len(Xm))]", "[[0 for j in range(2501)] for i in range(len(Xm))]", "DPm", "A = map(int,input().split())", "map(int,input().split())", "A", "Xm = [0]", "[0]", "Xm", "Xz += 1", "1", "Xz" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 31, 13, 12, 13, 0, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 14, 40, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 2, 13, 17, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 29, 13, 14, 2, 13, 17, 0, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 154, 4 ], [ 154, 17 ], [ 154, 18 ], [ 24, 23 ], [ 152, 25 ], [ 155, 26 ], [ 30, 29 ], [ 155, 33 ], [ 39, 38 ], [ 48, 41 ], [ 38, 44 ], [ 51, 50 ], [ 155, 53 ], [ 56, 55 ], [ 50, 58 ], [ 61, 60 ], [ 50, 64 ], [ 68, 67 ], [ 23, 71 ], [ 83, 74 ], [ 38, 77 ], [ 50, 79 ], [ 60, 81 ], [ 67, 82 ], [ 38, 86 ], [ 50, 87 ], [ 60, 88 ], [ 67, 89 ], [ 67, 92 ], [ 55, 93 ], [ 104, 95 ], [ 38, 98 ], [ 50, 100 ], [ 60, 102 ], [ 67, 103 ], [ 38, 107 ], [ 50, 108 ], [ 60, 110 ], [ 67, 113 ], [ 55, 114 ], [ 117, 116 ], [ 120, 119 ], [ 155, 124 ], [ 128, 127 ], [ 38, 131 ], [ 155, 132 ], [ 119, 133 ], [ 119, 135 ], [ 152, 136 ], [ 127, 138 ], [ 116, 138 ], [ 157, 144 ], [ 161, 146 ], [ 158, 149 ], [ 154, 152 ], [ 154, 155 ], [ 157, 158 ] ]

[ "import sys\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n ma = a * n\n res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n res[0][0][0] = 1\n for i in range(n):\n cur = x[i]\n for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ans = 0\n for j in range(1, n+1):\n ans += res[n][j][j*a]\n\n return ans\n\nif __name__ == '__main__':\n ans = main()\n print(ans)", "import sys", "sys", "n, a, *x = map(int, sys.stdin.read().split())", "n", "map(int, sys.stdin.read().split())", "map", "int", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "a", "*x", "x", "def main():\n ma = a * n\n res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n res[0][0][0] = 1\n for i in range(n):\n cur = x[i]\n for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ans = 0\n for j in range(1, n+1):\n ans += res[n][j][j*a]\n\n return ans", "main", "ma = a * n", "ma", "a * n", "a", "n", "[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)", "for _ in range(n + 1)", "_", "range(n + 1)", "range", "n + 1", "n", "1", "for _ in range(n + 1)", "[[0] * (ma + 1) for _ in range(n + 1)]", "res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "res", "[[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]", "res[0][0][0] = 1", "res[0][0][0]", "[0]", "[0]", "res", "0", "0", "0", "1", "for i in range(n):\n cur = x[i]\n for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ", "i", "range(n)", "range", "n", "cur = x[i]", "cur", "x[i]", "x", "i", "for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ", "j", "range(i+2)", "range", "i+2", "i", "2", "for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ", "k", "range(ma + 1)", "range", "ma + 1", "ma", "1", "res[i+1][j][k] += res[i][j][k]", "res[i+1][j][k]", "[j]", "[i+1]", "res", "i+1", "i", "1", "j", "k", "res[i][j][k]", "[j]", "[i]", "res", "i", "j", "k", "if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ", "k >= cur", "k", "cur", "res[i+1][j][k] += res[i][j-1][k-cur]", "res[i+1][j][k]", "[j]", "[i+1]", "res", "i+1", "i", "1", "j", "k", "res[i][j-1][k-cur]", "[j-1]", "[i]", "res", "i", "j-1", "j", "1", "k-cur", "k", "cur", "ans = 0", "ans", "0", "for j in range(1, n+1):\n ans += res[n][j][j*a]\n\n ", "j", "range(1, n+1)", "range", "1", "n+1", "n", "1", "ans += res[n][j][j*a]", "ans", "res[n][j][j*a]", "[j]", "[n]", "res", "n", "j", "j*a", "j", "a", "return ans", "ans", "if __name__ == '__main__':\n ans = main()\n print(ans)", "__name__ == '__main__'", "__name__", "'__main__'", "ans = main()", "ans", "main()", "main", "print(ans)", "print", "ans", "a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "a", "n, a, *x = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "n", "ans = main()", "main()", "ans", "def main():\n ma = a * n\n res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n res[0][0][0] = 1\n for i in range(n):\n cur = x[i]\n for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ans = 0\n for j in range(1, n+1):\n ans += res[n][j][j*a]\n\n return ans", "def main():\n ma = a * n\n res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n res[0][0][0] = 1\n for i in range(n):\n cur = x[i]\n for j in range(i+2):\n for k in range(ma + 1):\n res[i+1][j][k] += res[i][j][k]\n if k >= cur:\n res[i+1][j][k] += res[i][j-1][k-cur]\n \n ans = 0\n for j in range(1, n+1):\n ans += res[n][j][j*a]\n\n return ans", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 2, 2, 4, 13, 13, 13, 17, 2, 2, 13, 13, 17, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 144, 2 ], [ 144, 11 ], [ 129, 13 ], [ 138, 25 ], [ 130, 32 ], [ 145, 33 ], [ 127, 37 ], [ 145, 38 ], [ 43, 42 ], [ 145, 46 ], [ 135, 51 ], [ 61, 54 ], [ 136, 57 ], [ 64, 63 ], [ 145, 68 ], [ 72, 71 ], [ 63, 75 ], [ 79, 78 ], [ 139, 81 ], [ 84, 83 ], [ 63, 88 ], [ 92, 91 ], [ 130, 95 ], [ 63, 97 ], [ 139, 99 ], [ 132, 101 ], [ 105, 104 ], [ 145, 109 ], [ 141, 112 ], [ 136, 116 ], [ 104, 118 ], [ 104, 120 ], [ 127, 121 ], [ 142, 124 ], [ 133, 124 ], [ 144, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ] ]

[ "n,a=map(int,input().split())\nx=list(map(int,input().split()))\nl=max(max(x)*n+3,a*n+3)\ndp=[[l*[0]for _ in range(n+1)]for _ in range(n+1)]\ndp[0][0][0]=1\nfor i in range(1,n+1):\n for j in range(i+1):\n for k in range(l):dp[i][j][k]=dp[i-1][j][k]\n for j in range(1,i+1):\n for k in range(x[i-1],l):dp[i][j][k]+=dp[i-1][j-1][k-x[i-1]]\nans=0\nfor j in range(1,n+1):\n ans+=dp[-1][j][j*a]\nprint(ans)", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l=max(max(x)*n+3,a*n+3)", "l", "max(max(x)*n+3,a*n+3)", "max", "max(x)*n+3", "max(x)*n", "max(x)", "max", "x", "n", "3", "a*n+3", "a*n", "a", "n", "3", "[l*[0]for _ in range(n+1)]for _ in range(n+1)", "for _ in range(n+1)", "_", "range(n+1)", "range", "n+1", "n", "1", "for _ in range(n+1)", "[l*[0]for _ in range(n+1)]", "dp=[[l*[0]for _ in range(n+1)]for _ in range(n+1)]", "dp", "[[l*[0]for _ in range(n+1)]for _ in range(n+1)]", "dp[0][0][0]=1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(1,n+1):\n for j in range(i+1):\n for k in range(l):dp[i][j][k]=dp[i-1][j][k]\n for j in range(1,i+1):\n for k in range(x[i-1],l):dp[i][j][k]+=dp[i-1][j-1][k-x[i-1]]", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "for j in range(i+1):\n for k in range(l):dp[i][j][k]=dp[i-1][j][k]\n ", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(l):dp[i][j][k]=dp[i-1][j][k]\n ", "k", "range(l)", "range", "l", "for j in range(1,i+1):\n for k in range(x[i-1],l):dp[i][j][k]+=dp[i-1][j-1][k-x[i-1]]", "j", "range(1,i+1)", "range", "1", "i+1", "i", "1", "for k in range(x[i-1],l):dp[i][j][k]+=dp[i-1][j-1][k-x[i", "k", "range(x[i-1],l)", "range", "x[i-1]", "x", "i-1", "i", "1", "l", "ans=0", "ans", "0", "for j in range(1,n+1):\n ans+=dp[-1][j][j*a]", "j", "range(1,n+1)", "range", "1", "n+1", "n", "1", "ans+=dp[-1][j][j*a]", "ans", "dp[-1][j][j*a]", "[j]", "[-1]", "dp", "-1", "j", "j*a", "j", "a", "print(ans)", "print", "ans", "a=map(int,input().split())", "map(int,input().split())", "a", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "ans=0", "0", "ans", "dp=[[l*[0]for _ in range(n+1)]for _ in range(n+1)]", "[[l*[0]for _ in range(n+1)]for _ in range(n+1)]", "dp", "l=max(max(x)*n+3,a*n+3)", "max(max(x)*n+3,a*n+3)", "l", "ans+=dp[-1][j][j*a]", "dp[-1][j][j*a]", "ans", "n,a=map(int,input().split())", "map(int,input().split())", "n" ]

[ 7, 15, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 2, 18, 13, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 40, 2, 13, 18, 13, 2, 13, 17, 17, 2, 2, 13, 18, 13, 2, 13, 17, 17, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 4, 13, 2, 18, 18, 13, 13, 17, 17, 29, 23, 13, 23, 13, 23, 13, 12, 13, 12, 13, 28, 13, 18, 13, 13, 28, 13, 4, 18, 13, 13, 27, 13, 0, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 0, 13, 13, 4, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 8, 7 ], [ 127, 10 ], [ 131, 14 ], [ 7, 15 ], [ 129, 16 ], [ 19, 18 ], [ 23, 22 ], [ 127, 26 ], [ 35, 34 ], [ 42, 37 ], [ 34, 39 ], [ 45, 44 ], [ 127, 49 ], [ 53, 52 ], [ 52, 60 ], [ 18, 62 ], [ 131, 62 ], [ 44, 64 ], [ 52, 69 ], [ 18, 71 ], [ 131, 71 ], [ 44, 73 ], [ 82, 77 ], [ 34, 79 ], [ 44, 80 ], [ 52, 81 ], [ 34, 85 ], [ 44, 87 ], [ 52, 89 ], [ 34, 92 ], [ 44, 94 ], [ 52, 97 ], [ 18, 99 ], [ 131, 99 ], [ 44, 101 ], [ 109, 104 ], [ 34, 106 ], [ 44, 107 ], [ 52, 108 ], [ 34, 111 ], [ 44, 113 ], [ 52, 115 ], [ 34, 121 ], [ 127, 122 ], [ 127, 127 ], [ 129, 129 ], [ 131, 131 ], [ 138, 137 ], [ 143, 142 ], [ 137, 145 ], [ 142, 148 ], [ 151, 150 ], [ 135, 152 ], [ 155, 154 ], [ 150, 159 ], [ 162, 161 ], [ 150, 166 ], [ 170, 169 ], [ 154, 172 ], [ 150, 178 ], [ 181, 180 ], [ 195, 183 ], [ 154, 184 ], [ 161, 185 ], [ 180, 186 ], [ 198, 192 ] ]

[ "#!/usr/bin/env python3\nimport sys\n# dp[j][t]=(y1,...,yj から 0 枚以上選んで yi の合計を t − 1250 にするような選び方の総数)\n\ndef solve(N: int, A: int, x: \"List[int]\"):\n x = [x[i]-A for i in range(N)]\n dp = [[0]*2500 for _ in range(N+1)]\n dp[0][1250] = 1\n\n for j in range(1,N+1):\n for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n print(dp[N][1250]-1)\n \n return\n\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "def solve(N: int, A: int, x: \"List[int]\"):\n x = [x[i]-A for i in range(N)]\n dp = [[0]*2500 for _ in range(N+1)]\n dp[0][1250] = 1\n\n for j in range(1,N+1):\n for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n print(dp[N][1250]-1)\n \n return", "solve", "x[i]-A for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "x[i]-A", "x[i]", "x", "i", "A", "x = [x[i]-A for i in range(N)]", "x", "[x[i]-A for i in range(N)]", "[0]*2500 for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[0]*2500", "[0]", "0", "2500", "dp = [[0]*2500 for _ in range(N+1)]", "dp", "[[0]*2500 for _ in range(N+1)]", "dp[0][1250] = 1", "dp[0][1250]", "[0]", "dp", "0", "1250", "1", "for j in range(1,N+1):\n for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n ", "j", "range(1,N+1)", "range", "1", "N+1", "N", "1", "for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n ", "t", "range(2500)", "range", "2500", "if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n ", "t-x[j-1]>=0 and t-x[j-1]<2500", "t-x[j-1]>=0", "t-x[j-1]", "t", "x[j-1]", "x", "j-1", "j", "1", "0", "t-x[j-1]<2500", "t-x[j-1]", "t", "x[j-1]", "x", "j-1", "j", "1", "2500", "dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j-1][t] + dp[j-1][t-x[j-1]]", "dp[j-1][t]", "[j-1]", "dp", "j-1", "j", "1", "t", "dp[j-1][t-x[j-1]]", "[j-1]", "dp", "j-1", "j", "1", "t-x[j-1]", "t", "x[j-1]", "x", "j-1", "j", "1", "dp[j][t] = dp[j-1][t]", "dp[j][t]", "[j]", "dp", "j", "t", "dp[j-1][t]", "[j-1]", "dp", "j-1", "j", "1", "t", "print(dp[N][1250]-1)", "print", "dp[N][1250]-1", "dp[N][1250]", "[N]", "dp", "N", "1250", "1", "return", "N: int", "N", "A: int", "A", "x: \"List[int]\"", "x", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)", "main", "def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ", "iterate_tokens", "for line in sys.stdin:\n for word in line.split():\n yield word\n ", "line", "sys.stdin", "sys", "stdin", "for word in line.split():\n yield word\n ", "word", "line.split()", "line.split", "line", "split", "yield word", "word", "tokens = iterate_tokens()", "tokens", "iterate_tokens()", "iterate_tokens", "N = int(next(tokens))", "N", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "A = int(next(tokens))", "A", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "int(next(tokens)) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "x = [int(next(tokens)) for _ in range(N)]", "x", "[int(next(tokens)) for _ in range(N)]", "solve(N, A, x)", "solve", "N", "A", "x", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def solve(N: int, A: int, x: \"List[int]\"):\n x = [x[i]-A for i in range(N)]\n dp = [[0]*2500 for _ in range(N+1)]\n dp[0][1250] = 1\n\n for j in range(1,N+1):\n for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n print(dp[N][1250]-1)\n \n return", "def solve(N: int, A: int, x: \"List[int]\"):\n x = [x[i]-A for i in range(N)]\n dp = [[0]*2500 for _ in range(N+1)]\n dp[0][1250] = 1\n\n for j in range(1,N+1):\n for t in range(2500):\n if t-x[j-1]>=0 and t-x[j-1]<2500:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = dp[j-1][t]\n print(dp[N][1250]-1)\n \n return", "solve", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 39, 17, 2, 2, 2, 17, 13, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 2, 17, 13, 13, 17, 14, 40, 40, 17, 2, 13, 18, 13, 2, 13, 17, 2, 2, 17, 13, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 4, 13, 2, 18, 18, 13, 13, 2, 13, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 168, 2 ], [ 168, 11 ], [ 171, 13 ], [ 180, 27 ], [ 172, 30 ], [ 177, 32 ], [ 181, 35 ], [ 169, 36 ], [ 39, 38 ], [ 166, 41 ], [ 46, 43 ], [ 172, 44 ], [ 38, 45 ], [ 169, 46 ], [ 50, 49 ], [ 166, 53 ], [ 166, 63 ], [ 178, 64 ], [ 181, 64 ], [ 174, 67 ], [ 77, 70 ], [ 175, 72 ], [ 166, 75 ], [ 178, 76 ], [ 181, 76 ], [ 80, 79 ], [ 166, 84 ], [ 88, 87 ], [ 166, 94 ], [ 178, 95 ], [ 181, 95 ], [ 87, 102 ], [ 172, 104 ], [ 79, 106 ], [ 166, 111 ], [ 178, 112 ], [ 181, 112 ], [ 119, 114 ], [ 175, 116 ], [ 79, 117 ], [ 87, 118 ], [ 175, 122 ], [ 79, 124 ], [ 87, 126 ], [ 175, 129 ], [ 79, 131 ], [ 87, 134 ], [ 172, 136 ], [ 79, 138 ], [ 146, 141 ], [ 175, 143 ], [ 79, 144 ], [ 87, 145 ], [ 175, 148 ], [ 79, 150 ], [ 87, 152 ], [ 175, 158 ], [ 166, 159 ], [ 166, 161 ], [ 178, 162 ], [ 181, 162 ], [ 168, 166 ], [ 168, 169 ], [ 171, 172 ], [ 174, 175 ], [ 177, 178 ], [ 180, 181 ] ]

[ "#想定解法\nN, A = map(int, input().split())\nX = sorted(list(map(int, input().split())))\nxm = max(X)\nxm = max(xm, A)\nfor i in range(N):\n X[i] -= A \n#print(X, xm)\ndp = [[0] * (2 * N * xm + 1) for i in range(N + 1)]\ndp[0][N * xm] = 1\n\nfor i in range(1, N + 1):\n for j in range(2 * N * xm + 1):\n if 0 <= j - X[i - 1] <= 2 * N * xm:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - X[i - 1]]\n else:\n dp[i][j] = dp[i - 1][j]\n\nprint(dp[N][N * xm] - 1)", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = sorted(list(map(int, input().split())))", "X", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "xm = max(X)", "xm", "max(X)", "max", "X", "xm = max(xm, A)", "xm", "max(xm, A)", "max", "xm", "A", "for i in range(N):\n X[i] -= A \n#print(X, xm)", "i", "range(N)", "range", "N", "X[i] -= A", "X[i]", "X", "i", "A", "[0] * (2 * N * xm + 1) for i in range(N + 1)", "for i in range(N + 1)", "i", "range(N + 1)", "range", "N + 1", "N", "1", "for i in range(N + 1)", "[0] * (2 * N * xm + 1)", "[0]", "0", "2 * N * xm + 1", "2 * N * xm", "2 * N", "2", "N", "xm", "1", "dp = [[0] * (2 * N * xm + 1) for i in range(N + 1)]", "dp", "[[0] * (2 * N * xm + 1) for i in range(N + 1)]", "dp[0][N * xm] = 1", "dp[0][N * xm]", "[0]", "dp", "0", "N * xm", "N", "xm", "1", "for i in range(1, N + 1):\n for j in range(2 * N * xm + 1):\n if 0 <= j - X[i - 1] <= 2 * N * xm:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - X[i - 1]]\n else:\n dp[i][j] = dp[i - 1][j]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "for j in range(2 * N * xm + 1):\n if 0 <= j - X[i - 1] <= 2 * N * xm:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - X[i - 1]]\n else:\n dp[i][j] = dp[i - 1][j]", "j", "range(2 * N * xm + 1)", "range", "2 * N * xm + 1", "2 * N * xm", "2 * N", "2", "N", "xm", "1", "if 0 <= j - X[i - 1] <= 2 * N * xm:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - X[i - 1]]\n else:\n dp[i][j] = dp[i - 1][j]", "0 <= j - X[i - 1] <= 2 * N * xm", "0 <= j - X[i - 1]", "0", "j - X[i - 1]", "j", "X[i - 1]", "X", "i - 1", "i", "1", "2 * N * xm", "2 * N", "2", "N", "xm", "dp[i][j] = dp[i - 1][j] + dp[i - 1][j - X[i - 1]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i - 1][j] + dp[i - 1][j - X[i - 1]]", "dp[i - 1][j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "dp[i - 1][j - X[i - 1]]", "[i - 1]", "dp", "i - 1", "i", "1", "j - X[i - 1]", "j", "X[i - 1]", "X", "i - 1", "i", "1", "dp[i][j] = dp[i - 1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i - 1][j]", "[i - 1]", "dp", "i - 1", "i", "1", "j", "print(dp[N][N * xm] - 1)", "print", "dp[N][N * xm] - 1", "dp[N][N * xm]", "[N]", "dp", "N", "N * xm", "N", "xm", "1", "N, A = map(int, input().split())", "map(int, input().split())", "N", "A = map(int, input().split())", "map(int, input().split())", "A", "X = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "X", "dp = [[0] * (2 * N * xm + 1) for i in range(N + 1)]", "[[0] * (2 * N * xm + 1) for i in range(N + 1)]", "dp", "xm = max(xm, A)", "max(xm, A)", "xm", "xm = max(X)", "max(X)", "xm" ]

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 13, 13, 14, 2, 40, 13, 17, 40, 2, 13, 18, 13, 2, 13, 17, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 22, 21 ], [ 21, 30 ], [ 33, 32 ], [ 37, 36 ], [ 16, 40 ], [ 46, 45 ], [ 55, 48 ], [ 45, 51 ], [ 58, 57 ], [ 16, 62 ], [ 66, 65 ], [ 16, 70 ], [ 74, 73 ], [ 16, 78 ], [ 18, 79 ], [ 89, 82 ], [ 45, 85 ], [ 57, 86 ], [ 65, 87 ], [ 73, 88 ], [ 45, 92 ], [ 57, 94 ], [ 65, 96 ], [ 73, 97 ], [ 65, 101 ], [ 73, 105 ], [ 32, 107 ], [ 57, 109 ], [ 120, 113 ], [ 45, 116 ], [ 57, 117 ], [ 65, 118 ], [ 73, 119 ], [ 45, 123 ], [ 57, 125 ], [ 65, 128 ], [ 73, 131 ], [ 32, 133 ], [ 57, 135 ], [ 139, 138 ], [ 142, 141 ], [ 16, 146 ], [ 150, 149 ], [ 45, 153 ], [ 16, 154 ], [ 141, 155 ], [ 141, 157 ], [ 18, 158 ], [ 149, 161 ], [ 138, 161 ], [ 170, 167 ] ]

[ "def main():\n N, A = (int(i) for i in input().split())\n X = [int(i) for i in input().split()]\n dp = [[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]\n dp[0][0][0] = 1\n for j in range(1, N+1):\n for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ans = 0\n for k in range(1, N+1):\n ans += dp[N][k][k*A]\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "def main():\n N, A = (int(i) for i in input().split())\n X = [int(i) for i in input().split()]\n dp = [[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]\n dp[0][0][0] = 1\n for j in range(1, N+1):\n for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ans = 0\n for k in range(1, N+1):\n ans += dp[N][k][k*A]\n print(ans)", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N, A = (int(i) for i in input().split())", "N", "(int(i) for i in input().split())", "A", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "X = [int(i) for i in input().split()]", "X", "[int(i) for i in input().split()]", "[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)", "for j in range(N + 1)", "j", "range(N + 1)", "range", "N + 1", "N", "1", "for j in range(N + 1)", "[[0 for s in range(N*A + 1)] for k in range(N + 1)]", "dp = [[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]", "dp", "[[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for j in range(1, N+1):\n for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ", "j", "range(1, N+1)", "range", "1", "N+1", "N", "1", "for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ", "k", "range(0, N+1)", "range", "0", "N+1", "N", "1", "for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ", "s", "range(N*A + 1)", "range", "N*A + 1", "N*A", "N", "A", "1", "dp[j][k][s] = dp[j-1][k][s]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "s", "if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ", "k >= 1 and s - X[j-1] >= 0", "k >= 1", "k", "1", "s - X[j-1] >= 0", "s - X[j-1]", "s", "X[j-1]", "X", "j-1", "j", "1", "0", "dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k-1][s-X[j-1]]", "[k-1]", "[j-1]", "dp", "j-1", "j", "1", "k-1", "k", "1", "s-X[j-1]", "s", "X[j-1]", "X", "j-1", "j", "1", "ans = 0", "ans", "0", "for k in range(1, N+1):\n ans += dp[N][k][k*A]\n ", "k", "range(1, N+1)", "range", "1", "N+1", "N", "1", "ans += dp[N][k][k*A]", "ans", "dp[N][k][k*A]", "[k]", "[N]", "dp", "N", "k", "k*A", "k", "A", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, A = (int(i) for i in input().split())\n X = [int(i) for i in input().split()]\n dp = [[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]\n dp[0][0][0] = 1\n for j in range(1, N+1):\n for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ans = 0\n for k in range(1, N+1):\n ans += dp[N][k][k*A]\n print(ans)", "def main():\n N, A = (int(i) for i in input().split())\n X = [int(i) for i in input().split()]\n dp = [[[0 for s in range(N*A + 1)] for k in range(N + 1)]\n for j in range(N + 1)]\n dp[0][0][0] = 1\n for j in range(1, N+1):\n for k in range(0, N+1):\n for s in range(N*A + 1):\n dp[j][k][s] = dp[j-1][k][s]\n if k >= 1 and s - X[j-1] >= 0:\n dp[j][k][s] += dp[j-1][k-1][s-X[j-1]]\n ans = 0\n for k in range(1, N+1):\n ans += dp[N][k][k*A]\n print(ans)", "main" ]

[ 7, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 2, 18, 13, 13, 13, 0, 13, 4, 13, 39, 17, 18, 13, 17, 28, 13, 18, 13, 39, 17, 0, 13, 4, 13, 28, 13, 13, 4, 18, 13, 13, 0, 18, 13, 2, 13, 13, 13, 0, 13, 13, 4, 13, 2, 18, 13, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 104, 3 ], [ 104, 12 ], [ 95, 14 ], [ 107, 26 ], [ 105, 30 ], [ 33, 32 ], [ 105, 35 ], [ 40, 37 ], [ 108, 38 ], [ 32, 39 ], [ 96, 42 ], [ 32, 43 ], [ 93, 44 ], [ 89, 46 ], [ 108, 52 ], [ 56, 55 ], [ 108, 57 ], [ 98, 61 ], [ 90, 69 ], [ 102, 69 ], [ 77, 72 ], [ 99, 73 ], [ 55, 76 ], [ 101, 79 ], [ 99, 80 ], [ 102, 85 ], [ 90, 85 ], [ 89, 90 ], [ 104, 93 ], [ 95, 96 ], [ 98, 99 ], [ 99, 101 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "from collections import Counter\n\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\n\nX2 = [0]*N\n\nfor i in range(N):\n X2[i] = X[i] - A\n\nC = Counter([0, X2[0]])\n\nfor x in X2[1:]:\n C2 = Counter()\n for s, c in C.items():\n C2[s+x] += c\n C += C2\n\nprint(C[0]-1)", "from collections import Counter", "N, A = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "X = list(map(int, input().split()))", "X", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X2 = [0]*N", "X2", "[0]*N", "[0]", "0", "N", "for i in range(N):\n X2[i] = X[i] - A", "i", "range(N)", "range", "N", "X2[i] = X[i] - A", "X2[i]", "X2", "i", "X[i] - A", "X[i]", "X", "i", "A", "C = Counter([0, X2[0]])", "C", "Counter([0, X2[0]])", "Counter", "[0, X2[0]]", "0", "X2[0]", "X2", "0", "for x in X2[1:]:\n C2 = Counter()\n for s, c in C.items():\n C2[s+x] += c\n C += C2", "x", "X2[1:]", "X2", "1:", "1", "C2 = Counter()", "C2", "Counter()", "Counter", "for s, c in C.items():\n C2[s+x] += c\n ", "s", "c", "C.items()", "C.items", "C", "items", "C2[s+x] += c", "C2[s+x]", "C2", "s+x", "s", "x", "c", "C += C2", "C", "C2", "print(C[0]-1)", "print", "C[0]-1", "C[0]", "C", "0", "1", "C = Counter([0, X2[0]])", "Counter([0, X2[0]])", "C", "A = map(int, input().split())", "map(int, input().split())", "A", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "C2 = Counter()", "Counter()", "C2", "C += C2", "C2", "C", "N, A = map(int, input().split())", "map(int, input().split())", "N", "X2 = [0]*N", "[0]*N", "X2" ]

[ 7, 15, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 2, 39, 13, 13, 12, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 17, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 17, 12, 13, 12, 13, 12, 13, 12, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 2, 13, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 2, 13, 17, 17, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 14, 2, 40, 2, 13, 17, 13, 40, 2, 13, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 12, 13, 10, 18, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 18, 13 ]

[ [ 8, 7 ], [ 19, 19 ], [ 21, 21 ], [ 23, 23 ], [ 27, 26 ], [ 35, 35 ], [ 37, 37 ], [ 39, 39 ], [ 41, 41 ], [ 45, 44 ], [ 53, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 65, 65 ], [ 68, 67 ], [ 76, 75 ], [ 285, 81 ], [ 86, 85 ], [ 311, 103 ], [ 281, 108 ], [ 263, 115 ], [ 261, 117 ], [ 263, 118 ], [ 296, 120 ], [ 303, 122 ], [ 272, 124 ], [ 264, 126 ], [ 258, 127 ], [ 266, 129 ], [ 306, 131 ], [ 264, 133 ], [ 264, 136 ], [ 273, 139 ], [ 150, 143 ], [ 267, 146 ], [ 153, 152 ], [ 264, 155 ], [ 254, 157 ], [ 297, 159 ], [ 152, 160 ], [ 163, 162 ], [ 152, 166 ], [ 170, 169 ], [ 273, 173 ], [ 185, 176 ], [ 267, 179 ], [ 152, 181 ], [ 162, 183 ], [ 169, 184 ], [ 267, 188 ], [ 152, 189 ], [ 162, 190 ], [ 169, 191 ], [ 162, 196 ], [ 264, 198 ], [ 169, 201 ], [ 255, 202 ], [ 273, 203 ], [ 218, 205 ], [ 267, 208 ], [ 152, 210 ], [ 162, 213 ], [ 169, 216 ], [ 255, 217 ], [ 267, 221 ], [ 152, 222 ], [ 162, 223 ], [ 169, 224 ], [ 287, 226 ], [ 230, 229 ], [ 264, 234 ], [ 314, 237 ], [ 267, 241 ], [ 264, 242 ], [ 229, 243 ], [ 229, 245 ], [ 258, 246 ], [ 315, 249 ], [ 288, 249 ], [ 254, 255 ], [ 263, 258 ], [ 263, 264 ], [ 266, 267 ], [ 272, 273 ], [ 281, 282 ], [ 287, 288 ], [ 296, 297 ], [ 311, 312 ], [ 314, 315 ] ]

[ "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN, K = MAP()\nA = LIST()\n\nMAX = N * K\n# dp[i][j][k] := i枚目までからj枚取って、合計をkにする通り数\ndp = list3d(N+1, N+1, MAX+1, 0)\ndp[0][0][0] = 1\nfor i in range(N):\n a = A[i]\n for j in range(i+1):\n for k in range(MAX+1):\n dp[i+1][j][k] += dp[i][j][k]\n if j+1 <= N and k+a <= MAX:\n dp[i+1][j+1][k+a] += dp[i][j][k]\nans = 0\nfor j in range(1, N+1):\n # 1枚以上取った時の、平均がKになる所 → j枚取って合計がj*Kの所 を合計する\n ans += dp[N][j][j*K]\nprint(ans)", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "[c] * b for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[c] * b", "[c]", "c", "b", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "a", "a", "b", "b", "c", "c", "[[d] * c for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[d] * c for j in range(b)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "a", "a", "b", "b", "c", "c", "d", "d", "[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[[e] * d for j in range(c)] for j in range(b)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "a", "a", "b", "b", "c", "c", "d", "d", "e", "e", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "x", "x", "y=1", "y", "1", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "INT() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "INT()", "INT", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "N=None", "N", "None", "def Yes(): print('Yes')", "Yes", "def No(): print('No')", "No", "def YES(): print('YES')", "YES", "def NO(): print('NO')", "NO", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "INF = 10 ** 18", "INF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, K = MAP()", "N", "MAP()", "MAP", "K", "A = LIST()", "A", "LIST()", "LIST", "MAX = N * K", "MAX", "N * K", "N", "K", "dp = list3d(N+1, N+1, MAX+1, 0)", "dp", "list3d(N+1, N+1, MAX+1, 0)", "list3d", "N+1", "N", "1", "N+1", "N", "1", "MAX+1", "MAX", "1", "0", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(N):\n a = A[i]\n for j in range(i+1):\n for k in range(MAX+1):\n dp[i+1][j][k] += dp[i][j][k]\n if j+1 <= N and k+a <= MAX:\n dp[i+1][j+1][k+a] += dp[i][j][k]", "i", "range(N)", "range", "N", "a = A[i]", "a", "A[i]", "A", "i", "for j in range(i+1):\n for k in range(MAX+1):\n dp[i+1][j][k] += dp[i][j][k]\n if j+1 <= N and k+a <= MAX:\n dp[i+1][j+1][k+a] += dp[i][j][k]", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(MAX+1):\n dp[i+1][j][k] += dp[i][j][k]\n if j+1 <= N and k+a <= MAX:\n dp[i+1][j+1][k+a] += dp[i][j][k]", "k", "range(MAX+1)", "range", "MAX+1", "MAX", "1", "dp[i+1][j][k] += dp[i][j][k]", "dp[i+1][j][k]", "[j]", "[i+1]", "dp", "i+1", "i", "1", "j", "k", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "if j+1 <= N and k+a <= MAX:\n dp[i+1][j+1][k+a] += dp[i][j][k]", "j+1 <= N and k+a <= MAX", "j+1 <= N", "j+1", "j", "1", "N", "k+a <= MAX", "k+a", "k", "a", "MAX", "dp[i+1][j+1][k+a] += dp[i][j][k]", "dp[i+1][j+1][k+a]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k+a", "k", "a", "dp[i][j][k]", "[j]", "[i]", "dp", "i", "j", "k", "ans = 0", "ans", "0", "for j in range(1, N+1):\n # 1枚以上取った時の、平均がKになる所 → j枚取って合計がj*Kの所 を合計する\n ans += dp[N][j][j*K]", "j", "range(1, N+1)", "range", "1", "N+1", "N", "1", "ans += dp[N][j][j*K]", "ans", "dp[N][j][j*K]", "[j]", "[N]", "dp", "N", "j", "j*K", "j", "K", "print(ans)", "print", "ans", "def ceil(x, y=1): return int(-(-x // y))", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "a = A[i]", "A[i]", "a", "K = MAP()", "MAP()", "K", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "N, K = MAP()", "MAP()", "N", "dp = list3d(N+1, N+1, MAX+1, 0)", "list3d(N+1, N+1, MAX+1, 0)", "dp", "def Yes(): print('Yes')", "def Yes(): print('Yes')", "Yes", "MAX = N * K", "N * K", "MAX", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def No(): print('No')", "def No(): print('No')", "No", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "ans = 0", "0", "ans", "def YES(): print('YES')", "def YES(): print('YES')", "YES", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "A = LIST()", "LIST()", "A", "def NO(): print('NO')", "def NO(): print('NO')", "NO", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "INF = 10 ** 18", "10 ** 18", "INF", "ans += dp[N][j][j*K]", "dp[N][j][j*K]", "ans" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 2, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 18, 13, 17, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 13, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 13, 0, 13, 4, 13, 17, 28, 13, 4, 13, 17, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 15, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 7 ], [ 10, 9 ], [ 14, 13 ], [ 9, 17 ], [ 4, 18 ], [ 22, 21 ], [ 4, 25 ], [ 31, 30 ], [ 40, 33 ], [ 30, 36 ], [ 43, 42 ], [ 4, 47 ], [ 51, 50 ], [ 9, 52 ], [ 42, 54 ], [ 58, 57 ], [ 4, 61 ], [ 65, 64 ], [ 13, 68 ], [ 78, 71 ], [ 30, 74 ], [ 57, 75 ], [ 42, 76 ], [ 64, 77 ], [ 30, 81 ], [ 57, 82 ], [ 42, 84 ], [ 64, 86 ], [ 89, 88 ], [ 4, 93 ], [ 97, 96 ], [ 50, 99 ], [ 13, 101 ], [ 111, 104 ], [ 30, 107 ], [ 88, 108 ], [ 42, 109 ], [ 96, 110 ], [ 30, 114 ], [ 88, 116 ], [ 42, 119 ], [ 96, 122 ], [ 50, 123 ], [ 126, 125 ], [ 131, 130 ], [ 13, 138 ], [ 7, 139 ], [ 4, 142 ], [ 146, 145 ], [ 30, 149 ], [ 130, 150 ], [ 4, 151 ], [ 130, 153 ], [ 7, 154 ], [ 145, 157 ], [ 125, 157 ], [ 183, 169 ], [ 195, 176 ], [ 199, 181 ], [ 183, 184 ], [ 195, 196 ] ]

[ "def examC():\n N, A = LI()\n x = LI()\n maxNX = max(x)*N\n dp = [[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(1,N+1):\n cur = x[i-1]\n for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ans = int(0)\n for i in range(1,min(maxNX//A+1,N+1)):\n ans += dp[i][N][i*A]\n print(ans)\n\n\nimport sys\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\nmod = 10**9 + 7\ninf = float('inf')\n\nexamC()", "def examC():\n N, A = LI()\n x = LI()\n maxNX = max(x)*N\n dp = [[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(1,N+1):\n cur = x[i-1]\n for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ans = int(0)\n for i in range(1,min(maxNX//A+1,N+1)):\n ans += dp[i][N][i*A]\n print(ans)", "examC", "N, A = LI()", "N", "LI()", "LI", "A", "x = LI()", "x", "LI()", "LI", "maxNX = max(x)*N", "maxNX", "max(x)*N", "max(x)", "max", "x", "N", "[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[[0]*(maxNX+1) for _ in range(N+1)]", "dp = [[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]", "dp", "[[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]", "dp[0][0][0] = 1", "dp[0][0][0]", "[0]", "[0]", "dp", "0", "0", "0", "1", "for i in range(1,N+1):\n cur = x[i-1]\n for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ", "i", "range(1,N+1)", "range", "1", "N+1", "N", "1", "cur = x[i-1]", "cur", "x[i-1]", "x", "i-1", "i", "1", "for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n ", "l", "range(N+1)", "range", "N+1", "N", "1", "for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n ", "j", "range(maxNX + 1)", "range", "maxNX + 1", "maxNX", "1", "dp[l][i][j] += dp[l][i - 1][j]", "dp[l][i][j]", "[i]", "[l]", "dp", "l", "i", "j", "dp[l][i - 1][j]", "[i - 1]", "[l]", "dp", "l", "i - 1", "i", "1", "j", "for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ", "l", "range(1,N + 1)", "range", "1", "N + 1", "N", "1", "for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ", "j", "range(cur, maxNX + 1)", "range", "cur", "maxNX + 1", "maxNX", "1", "dp[l][i][j] += dp[l-1][i - 1][j - cur]", "dp[l][i][j]", "[i]", "[l]", "dp", "l", "i", "j", "dp[l-1][i - 1][j - cur]", "[i - 1]", "[l-1]", "dp", "l-1", "l", "1", "i - 1", "i", "1", "j - cur", "j", "cur", "ans = int(0)", "ans", "int(0)", "int", "0", "for i in range(1,min(maxNX//A+1,N+1)):\n ans += dp[i][N][i*A]\n ", "i", "range(1,min(maxNX//A+1,N+1))", "range", "1", "min(maxNX//A+1,N+1)", "min", "maxNX//A+1", "maxNX//A", "maxNX", "A", "1", "N+1", "N", "1", "ans += dp[i][N][i*A]", "ans", "dp[i][N][i*A]", "[N]", "[i]", "dp", "i", "N", "i*A", "i", "A", "print(ans)", "print", "ans", "import sys", "sys", "def I(): return int(sys.stdin.readline())", "I", "def LI(): return list(map(int,sys.stdin.readline().split()))", "LI", "def LS(): return sys.stdin.readline().split()", "LS", "def S(): return sys.stdin.readline().strip()", "S", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "inf = float('inf')", "inf", "float('inf')", "float", "'inf'", "examC()", "examC", "mod = 10**9 + 7", "10**9 + 7", "mod", "def LI(): return list(map(int,sys.stdin.readline().split()))", "def LI(): return list(map(int,sys.stdin.readline().split()))", "LI", "def LS(): return sys.stdin.readline().split()", "def LS(): return sys.stdin.readline().split()", "LS", "def S(): return sys.stdin.readline().strip()", "def S(): return sys.stdin.readline().strip()", "S", "inf = float('inf')", "float('inf')", "inf", "def examC():\n N, A = LI()\n x = LI()\n maxNX = max(x)*N\n dp = [[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(1,N+1):\n cur = x[i-1]\n for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ans = int(0)\n for i in range(1,min(maxNX//A+1,N+1)):\n ans += dp[i][N][i*A]\n print(ans)", "def examC():\n N, A = LI()\n x = LI()\n maxNX = max(x)*N\n dp = [[[0]*(maxNX+1) for _ in range(N+1)]for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(1,N+1):\n cur = x[i-1]\n for l in range(N+1):\n for j in range(maxNX + 1):\n dp[l][i][j] += dp[l][i - 1][j]\n for l in range(1,N + 1):\n for j in range(cur, maxNX + 1):\n dp[l][i][j] += dp[l-1][i - 1][j - cur]\n# print(dp)\n ans = int(0)\n for i in range(1,min(maxNX//A+1,N+1)):\n ans += dp[i][N][i*A]\n print(ans)", "examC", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I" ]