Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 61, 2 ], [ 58, 6 ], [ 10, 9 ], [ 62, 14 ], [ 59, 17 ], [ 62, 20 ], [ 9, 21 ], [ 64, 23 ], [ 59, 28 ], [ 55, 30 ], [ 34, 33 ], [ 65, 33 ], [ 59, 40 ], [ 33, 42 ], [ 52, 46 ], [ 53, 50 ], [ 56, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "s = input()\n\nlst = []\n\nfor i in range(len(s)):\n lst.append(s[i])\n\nlst2 = list(set(lst))\n\nresult = 'Yes'\n\nfor i in lst2:\n if lst.count(i) % 2 != 0:\n result = 'No'\n\nprint(result)", "s = input()", "s", "input()", "input", "lst = []", "lst", "[]", "for i in range(len(s)):\n lst.append(s[i])", "i", "range(len(s))", "range", "len(s)", "len", "s", "lst.append(s[i])", "lst.append", "lst", "append", "s[i]", "s", "i", "lst2 = list(set(lst))", "lst2", "list(set(lst))", "list", "set(lst)", "set", "lst", "result = 'Yes'", "result", "'Yes'", "for i in lst2:\n if lst.count(i) % 2 != 0:\n result = 'No'", "i", "lst2", "if lst.count(i) % 2 != 0:\n result = 'No'", "lst.count(i) % 2 != 0", "lst.count(i) % 2", "lst.count(i)", "lst.count", "lst", "count", "i", "2", "0", "result = 'No'", "result", "'No'", "print(result)", "print", "result", "result = 'No'", "'No'", "result", "result = 'Yes'", "'Yes'", "result", "lst = []", "[]", "lst", "s = input()", "input()", "s", "lst2 = list(set(lst))", "list(set(lst))", "lst2" ]

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

[ [ 40, 4 ], [ 43, 10 ], [ 41, 15 ], [ 46, 17 ], [ 44, 20 ], [ 24, 23 ], [ 47, 23 ], [ 23, 28 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "import collections\nS=list(input())\nc = collections.Counter(S)\nL=c.values()\nfor i in L:\n if i%2==1:\n print(\"No\")\n exit()\nprint(\"Yes\")", "import collections", "collections", "S=list(input())", "S", "list(input())", "list", "input()", "input", "c = collections.Counter(S)", "c", "collections.Counter(S)", "collections.Counter", "collections", "Counter", "S", "L=c.values()", "L", "c.values()", "c.values", "c", "values", "for i in L:\n if i%2==1:\n print(\"No\")\n exit()", "i", "L", "if i%2==1:\n print(\"No\")\n exit()", "i%2==1", "i%2", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "S=list(input())", "list(input())", "S", "c = collections.Counter(S)", "collections.Counter(S)", "c", "L=c.values()", "c.values()", "L" ]

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

[ [ 59, 2 ], [ 56, 6 ], [ 10, 9 ], [ 60, 9 ], [ 9, 13 ], [ 57, 16 ], [ 22, 19 ], [ 57, 20 ], [ 9, 21 ], [ 27, 24 ], [ 57, 25 ], [ 9, 26 ], [ 53, 29 ], [ 33, 32 ], [ 57, 35 ], [ 24, 40 ], [ 19, 40 ], [ 57, 41 ], [ 32, 42 ], [ 62, 46 ], [ 63, 51 ], [ 54, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ] ]

[ "w = input()\n\ncnt_dict = {}\nfor c in w:\n if c not in cnt_dict.keys():\n cnt_dict[c] = 0\n cnt_dict[c] += 1\n\nans = \"Yes\"\nfor c in cnt_dict.keys():\n if cnt_dict[c] % 2 == 1:\n ans = \"No\"\n break\nprint(ans)", "w = input()", "w", "input()", "input", "cnt_dict = {}", "cnt_dict", "{}", "for c in w:\n if c not in cnt_dict.keys():\n cnt_dict[c] = 0\n cnt_dict[c] += 1", "c", "w", "if c not in cnt_dict.keys():\n cnt_dict[c] = 0\n ", "c not in cnt_dict.keys()", "c", "cnt_dict.keys()", "cnt_dict.keys", "cnt_dict", "keys", "cnt_dict[c] = 0", "cnt_dict[c]", "cnt_dict", "c", "0", "cnt_dict[c] += 1", "cnt_dict[c]", "cnt_dict", "c", "1", "ans = \"Yes\"", "ans", "\"Yes\"", "for c in cnt_dict.keys():\n if cnt_dict[c] % 2 == 1:\n ans = \"No\"\n break", "c", "cnt_dict.keys()", "cnt_dict.keys", "cnt_dict", "keys", "if cnt_dict[c] % 2 == 1:\n ans = \"No\"\n break", "cnt_dict[c] % 2 == 1", "cnt_dict[c] % 2", "cnt_dict[c]", "cnt_dict", "c", "2", "1", "ans = \"No\"", "ans", "\"No\"", "break", "print(ans)", "print", "ans", "ans = \"Yes\"", "\"Yes\"", "ans", "cnt_dict = {}", "{}", "cnt_dict", "w = input()", "input()", "w", "ans = \"No\"", "\"No\"", "ans" ]

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

[ [ 89, 4 ], [ 83, 13 ], [ 92, 22 ], [ 80, 38 ], [ 77, 43 ], [ 86, 49 ], [ 78, 54 ], [ 87, 60 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ] ]

[ "import sys\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nread = sys.stdin.buffer.read\nsys.setrecursionlimit(10 ** 7)\nINF = float('inf')\n\nw = input()\nimport collections\nc = collections.Counter(w)\nfor k, v in c.items():\n if v % 2 != 0:\n print('No')\n quit()\nprint('Yes')", "import sys", "sys", "readline = sys.stdin.buffer.readline", "readline", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "readlines = sys.stdin.buffer.readlines", "readlines", "sys.stdin.buffer.readlines", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readlines", "read = sys.stdin.buffer.read", "read", "sys.stdin.buffer.read", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "read", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "w = input()", "w", "input()", "input", "import collections", "collections", "c = collections.Counter(w)", "c", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "for k, v in c.items():\n if v % 2 != 0:\n print('No')\n quit()", "k", "v", "c.items()", "c.items", "c", "items", "if v % 2 != 0:\n print('No')\n quit()", "v % 2 != 0", "v % 2", "v", "2", "0", "print('No')", "print", "'No'", "quit()", "quit", "print('Yes')", "print", "'Yes'", "w = input()", "input()", "w", "INF = float('inf')", "float('inf')", "INF", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "c = collections.Counter(w)", "collections.Counter(w)", "c", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read" ]

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

[ [ 77, 2 ], [ 78, 10 ], [ 74, 19 ], [ 26, 25 ], [ 78, 30 ], [ 71, 32 ], [ 78, 37 ], [ 25, 38 ], [ 46, 43 ], [ 75, 44 ], [ 72, 45 ], [ 49, 48 ], [ 75, 53 ], [ 75, 58 ], [ 48, 59 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "w = input()\n\nif len(w) % 2 != 0:\n print('No')\n exit()\n\ncnt = [0]*30\nfor i in range(len(w)):\n a = ord(w[i]) - ord('a')\n cnt[a] += 1\n\nfor i in range(len(cnt)):\n if cnt[i] % 2 != 0:\n print('No')\n exit()\n\nprint('Yes')", "w = input()", "w", "input()", "input", "if len(w) % 2 != 0:\n print('No')\n exit()", "len(w) % 2 != 0", "len(w) % 2", "len(w)", "len", "w", "2", "0", "print('No')", "print", "'No'", "exit()", "exit", "cnt = [0]*30", "cnt", "[0]*30", "[0]", "0", "30", "for i in range(len(w)):\n a = ord(w[i]) - ord('a')\n cnt[a] += 1", "i", "range(len(w))", "range", "len(w)", "len", "w", "a = ord(w[i]) - ord('a')", "a", "ord(w[i]) - ord('a')", "ord(w[i])", "ord", "w[i]", "w", "i", "ord('a')", "ord", "'a'", "cnt[a] += 1", "cnt[a]", "cnt", "a", "1", "for i in range(len(cnt)):\n if cnt[i] % 2 != 0:\n print('No')\n exit()", "i", "range(len(cnt))", "range", "len(cnt)", "len", "cnt", "if cnt[i] % 2 != 0:\n print('No')\n exit()", "cnt[i] % 2 != 0", "cnt[i] % 2", "cnt[i]", "cnt", "i", "2", "0", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "a = ord(w[i]) - ord('a')", "ord(w[i]) - ord('a')", "a", "cnt = [0]*30", "[0]*30", "cnt", "w = input()", "input()", "w" ]

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

[ [ 72, 2 ], [ 69, 8 ], [ 78, 11 ], [ 73, 18 ], [ 26, 25 ], [ 73, 30 ], [ 75, 32 ], [ 73, 35 ], [ 73, 38 ], [ 25, 39 ], [ 76, 44 ], [ 70, 44 ], [ 25, 48 ], [ 73, 52 ], [ 76, 61 ], [ 70, 61 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ] ]

[ "w = list(input())\nj = 0\nans = 0\n\nif(len(w)%2 != 0):\n print('No')\nelse:\n for i in range(len(w)):\n j = w.count(w[i])\n if(j%2 == 0 and i == len(w)-1):\n print('Yes')\n break\n elif(j%2 != 0):\n print('No')\n break", "w = list(input())", "w", "list(input())", "list", "input()", "input", "j = 0", "j", "0", "ans = 0", "ans", "0", "if(len(w)%2 != 0):\n print('No')\nelse:\n for i in range(len(w)):\n j = w.count(w[i])\n if(j%2 == 0 and i == len(w)-1):\n print('Yes')\n break\n elif(j%2 != 0):\n print('No')\n break", "len(w)%2 != 0", "len(w)%2", "len(w)", "len", "w", "2", "0", "print('No')", "print", "'No'", "for i in range(len(w)):\n j = w.count(w[i])\n if(j%2 == 0 and i == len(w)-1):\n print('Yes')\n break\n elif(j%2 != 0):\n print('No')\n break", "i", "range(len(w))", "range", "len(w)", "len", "w", "j = w.count(w[i])", "j", "w.count(w[i])", "w.count", "w", "count", "w[i]", "w", "i", "if(j%2 == 0 and i == len(w)-1):\n print('Yes')\n break\n elif(j%2 != 0):\n print('No')\n break", "j%2 == 0 and i == len(w)-1", "j%2 == 0", "j%2", "j", "2", "0", "i == len(w)-1", "i", "len(w)-1", "len(w)", "len", "w", "1", "print('Yes')", "print", "'Yes'", "break", "elif(j%2 != 0):\n print('No')\n break", "j%2 != 0", "j%2", "j", "2", "0", "print('No')", "print", "'No'", "break", "j = 0", "0", "j", "w = list(input())", "list(input())", "w", "j = w.count(w[i])", "w.count(w[i])", "j", "ans = 0", "0", "ans" ]

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

[ [ 39, 4 ], [ 45, 10 ], [ 40, 15 ], [ 42, 17 ], [ 21, 20 ], [ 46, 23 ], [ 20, 28 ], [ 48, 32 ], [ 49, 37 ], [ 43, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "import collections\nw=list(input())\nW=collections.Counter(w)\nans=\"Yes\"\nfor i in W.values():\n if i%2!=0:\n ans=\"No\"\n break\n\nprint(ans)", "import collections", "collections", "w=list(input())", "w", "list(input())", "list", "input()", "input", "W=collections.Counter(w)", "W", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "ans=\"Yes\"", "ans", "\"Yes\"", "for i in W.values():\n if i%2!=0:\n ans=\"No\"\n break", "i", "W.values()", "W.values", "W", "values", "if i%2!=0:\n ans=\"No\"\n break", "i%2!=0", "i%2", "i", "2", "0", "ans=\"No\"", "ans", "\"No\"", "break", "print(ans)", "print", "ans", "w=list(input())", "list(input())", "w", "ans=\"Yes\"", "\"Yes\"", "ans", "W=collections.Counter(w)", "collections.Counter(w)", "W", "ans=\"No\"", "\"No\"", "ans" ]

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

[ [ 30, 3 ], [ 33, 7 ], [ 31, 10 ], [ 13, 12 ], [ 34, 15 ], [ 12, 19 ], [ 30, 31 ], [ 33, 34 ] ]

[ "from collections import Counter\n\nW = input()\nC = Counter(W)\n\nfor v in C.values():\n if v % 2:\n print(\"No\")\n exit()\nprint(\"Yes\")", "from collections import Counter", "W = input()", "W", "input()", "input", "C = Counter(W)", "C", "Counter(W)", "Counter", "W", "for v in C.values():\n if v % 2:\n print(\"No\")\n exit()", "v", "C.values()", "C.values", "C", "values", "if v % 2:\n print(\"No\")\n exit()", "v % 2", "v", "2", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "W = input()", "input()", "W", "C = Counter(W)", "Counter(W)", "C" ]

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

[ [ 46, 4 ], [ 49, 10 ], [ 47, 15 ], [ 52, 17 ], [ 21, 20 ], [ 50, 23 ], [ 20, 28 ], [ 43, 32 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "import collections\n\nw = list(input())\nw_count = collections.Counter(w)\nflag = True\nfor i in w_count.values():\n if i % 2 != 0:\n flag = False\nif flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "import collections", "collections", "w = list(input())", "w", "list(input())", "list", "input()", "input", "w_count = collections.Counter(w)", "w_count", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "flag = True", "flag", "True", "for i in w_count.values():\n if i % 2 != 0:\n flag = False", "i", "w_count.values()", "w_count.values", "w_count", "values", "if i % 2 != 0:\n flag = False", "i % 2 != 0", "i % 2", "i", "2", "0", "flag = False", "flag", "False", "if flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "flag", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "flag = False", "False", "flag", "w = list(input())", "list(input())", "w", "w_count = collections.Counter(w)", "collections.Counter(w)", "w_count", "flag = True", "True", "flag" ]

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

[ [ 109, 2 ], [ 100, 6 ], [ 10, 9 ], [ 110, 9 ], [ 101, 13 ], [ 9, 15 ], [ 97, 17 ], [ 101, 20 ], [ 101, 23 ], [ 106, 26 ], [ 103, 29 ], [ 33, 32 ], [ 101, 38 ], [ 101, 43 ], [ 32, 44 ], [ 101, 46 ], [ 32, 48 ], [ 112, 51 ], [ 107, 56 ], [ 116, 56 ], [ 113, 56 ], [ 104, 61 ], [ 101, 64 ], [ 32, 65 ], [ 115, 67 ], [ 116, 72 ], [ 113, 72 ], [ 107, 72 ], [ 104, 77 ], [ 101, 80 ], [ 104, 86 ], [ 98, 89 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ] ]

[ "# import math\n# import statistics\na=input()\n#b,c=int(input()),int(input())\nc=[]\nfor i in a:\n c.append(i)\n#e1,e2 = map(int,input().split())\n# f = list(map(int,input().split()))\n#g = [input() for _ in range(a)]\n# h = []\n# for i in range(e1):\n# h.append(list(map(int,input().split())))\nse=set(c)\nc.sort()\ncount=1\nres=[]\nfor i in range(len(c)-1):\n if c[i]==c[i+1]:\n count+=1\n else:\n if count%2==0:\n res.append(c[i])\n count=1\nif count%2==0:\n res.append(c[-1])\nif len(res)==len(se):\n print(\"Yes\")\nelse:\n print(\"No\")", "a=input()", "a", "input()", "input", "c=[]", "c", "[]", "for i in a:\n c.append(i)\n#e1,e2 = map(int,input().split())\n# f = list(map(int,input().split()))\n#g = [input() for _ in range(a)]\n# h = []\n# for i in range(e1):\n# h.append(list(map(int,input().split())))", "i", "a", "c.append(i)", "c.append", "c", "append", "i", "se=set(c)", "se", "set(c)", "set", "c", "c.sort()", "c.sort", "c", "sort", "count=1", "count", "1", "res=[]", "res", "[]", "for i in range(len(c)-1):\n if c[i]==c[i+1]:\n count+=1\n else:\n if count%2==0:\n res.append(c[i])\n count=1", "i", "range(len(c)-1)", "range", "len(c)-1", "len(c)", "len", "c", "1", "if c[i]==c[i+1]:\n count+=1\n else:\n if count%2==0:\n res.append(c[i])\n count=1", "c[i]==c[i+1]", "c[i]", "c", "i", "c[i+1]", "c", "i+1", "i", "1", "count+=1", "count", "1", "if count%2==0:\n res.append(c[i])\n ", "count%2==0", "count%2", "count", "2", "0", "res.append(c[i])", "res.append", "res", "append", "c[i]", "c", "i", "count=1", "count", "1", "if count%2==0:\n res.append(c[-1])", "count%2==0", "count%2", "count", "2", "0", "res.append(c[-1])", "res.append", "res", "append", "c[-1]", "c", "-1", "if len(res)==len(se):\n print(\"Yes\")\nelse:\n print(\"No\")", "len(res)==len(se)", "len(res)", "len", "res", "len(se)", "len", "se", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "se=set(c)", "set(c)", "se", "c=[]", "[]", "c", "res=[]", "[]", "res", "count=1", "1", "count", "a=input()", "input()", "a", "count+=1", "1", "count", "count=1", "1", "count" ]

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

[ [ 63, 2 ], [ 57, 6 ], [ 64, 9 ], [ 51, 11 ], [ 15, 14 ], [ 58, 14 ], [ 52, 18 ], [ 64, 22 ], [ 52, 23 ], [ 14, 24 ], [ 54, 26 ], [ 30, 29 ], [ 52, 29 ], [ 29, 34 ], [ 60, 38 ], [ 61, 42 ], [ 55, 42 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "w = input()\n\ngroup = set(w)\n\ncount = []\nfor i in group:\n count.append(w.count(i))\n\nans = 0\n\nfor j in count:\n if j % 2 == 1:\n ans = 1\n else:\n pass\n\nif ans == 0:\n print(\"Yes\")\nelse:\n print(\"No\")", "w = input()", "w", "input()", "input", "group = set(w)", "group", "set(w)", "set", "w", "count = []", "count", "[]", "for i in group:\n count.append(w.count(i))", "i", "group", "count.append(w.count(i))", "count.append", "count", "append", "w.count(i)", "w.count", "w", "count", "i", "ans = 0", "ans", "0", "for j in count:\n if j % 2 == 1:\n ans = 1\n else:\n pass", "j", "count", "if j % 2 == 1:\n ans = 1\n else:\n pass", "j % 2 == 1", "j % 2", "j", "2", "1", "ans = 1", "ans", "1", "if ans == 0:\n print(\"Yes\")\nelse:\n print(\"No\")", "ans == 0", "ans", "0", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "count = []", "[]", "count", "ans = 0", "0", "ans", "group = set(w)", "set(w)", "group", "ans = 1", "1", "ans", "w = input()", "input()", "w" ]

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

[ [ 28, 2 ], [ 7, 6 ], [ 29, 9 ], [ 29, 15 ], [ 6, 17 ], [ 28, 29 ] ]

[ "s = input()\n\nfor i in set(s):\n if s.count(i) % 2 != 0:\n print('No')\n break\nelse:\n print('Yes')", "s = input()", "s", "input()", "input", "for i in set(s):\n if s.count(i) % 2 != 0:\n print('No')\n break\nelse:\n print('Yes')", "i", "set(s)", "set", "s", "if s.count(i) % 2 != 0:\n print('No')\n break", "s.count(i) % 2 != 0", "s.count(i) % 2", "s.count(i)", "s.count", "s", "count", "i", "2", "0", "print('No')", "print", "'No'", "break", "print('Yes')", "print", "'Yes'", "s = input()", "input()", "s" ]

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

[ [ 32, 3 ], [ 35, 7 ], [ 33, 10 ], [ 13, 12 ], [ 36, 15 ], [ 12, 20 ], [ 32, 33 ], [ 35, 36 ] ]

[ "from collections import Counter\n\nw = input()\n\ncountAlphabets = Counter(w)\nfor count in countAlphabets.values():\n if count % 2 != 0:\n print(\"No\")\n exit()\n\nprint(\"Yes\")", "from collections import Counter", "w = input()", "w", "input()", "input", "countAlphabets = Counter(w)", "countAlphabets", "Counter(w)", "Counter", "w", "for count in countAlphabets.values():\n if count % 2 != 0:\n print(\"No\")\n exit()", "count", "countAlphabets.values()", "countAlphabets.values", "countAlphabets", "values", "if count % 2 != 0:\n print(\"No\")\n exit()", "count % 2 != 0", "count % 2", "count", "2", "0", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w", "countAlphabets = Counter(w)", "Counter(w)", "countAlphabets" ]

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

[ [ 50, 2 ], [ 53, 6 ], [ 10, 9 ], [ 51, 9 ], [ 54, 13 ], [ 9, 15 ], [ 21, 18 ], [ 54, 19 ], [ 9, 20 ], [ 59, 23 ], [ 27, 26 ], [ 54, 29 ], [ 26, 34 ], [ 56, 38 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "w = input()\n\ndict_ = {}\n\nfor i in w:\n dict_.setdefault(i, 0)\n dict_[i] +=1\n\nflg = True\n\nfor v in dict_.values():\n if v % 2 != 0:\n flg = False\n break\nif flg:\n print(\"Yes\")\nelse:\n print(\"No\")", "w = input()", "w", "input()", "input", "dict_ = {}", "dict_", "{}", "for i in w:\n dict_.setdefault(i, 0)\n dict_[i] +=1", "i", "w", "dict_.setdefault(i, 0)", "dict_.setdefault", "dict_", "setdefault", "i", "0", "dict_[i] +=1", "dict_[i]", "dict_", "i", "1", "flg = True", "flg", "True", "for v in dict_.values():\n if v % 2 != 0:\n flg = False\n break", "v", "dict_.values()", "dict_.values", "dict_", "values", "if v % 2 != 0:\n flg = False\n break", "v % 2 != 0", "v % 2", "v", "2", "0", "flg = False", "flg", "False", "break", "if flg:\n print(\"Yes\")\nelse:\n print(\"No\")", "flg", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "w = input()", "input()", "w", "dict_ = {}", "{}", "dict_", "flg = False", "False", "flg", "flg = True", "True", "flg" ]

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

[ [ 146, 17 ], [ 131, 29 ], [ 137, 41 ], [ 143, 52 ], [ 149, 67 ], [ 134, 84 ], [ 125, 89 ], [ 140, 96 ], [ 147, 98 ], [ 128, 100 ], [ 141, 105 ], [ 108, 107 ], [ 129, 110 ], [ 107, 114 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ] ]

[ "import sys\nimport math\nimport itertools\nimport collections\nimport heapq\nimport re\nimport numpy as np\nfrom functools import reduce\n\nrr = lambda: sys.stdin.readline().rstrip()\nrs = lambda: sys.stdin.readline().split()\nri = lambda: int(sys.stdin.readline())\nrm = lambda: map(int, sys.stdin.readline().split())\nrl = lambda: list(map(int, sys.stdin.readline().split()))\ninf = float('inf')\nmod = 10**9 + 7\n\ns = rr()\nc = collections.Counter(s)\nfor i in c.values():\n if i & 1:\n print('No')\n exit()\nprint('Yes')\n\n\n\n\n", "import sys", "sys", "import math", "math", "import itertools", "itertools", "import collections", "collections", "import heapq", "heapq", "import re", "re", "import numpy as np", "numpy", "from functools import reduce", "rr = lambda: sys.stdin.readline().rstrip()", "rr", "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", "rs = lambda: sys.stdin.readline().split()", "rs", "lambda: sys.stdin.readline().split()", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "ri = lambda: int(sys.stdin.readline())", "ri", "lambda: int(sys.stdin.readline())", "int(sys.stdin.readline())", "int", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rm = lambda: map(int, sys.stdin.readline().split())", "rm", "lambda: map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "rl = lambda: list(map(int, sys.stdin.readline().split()))", "rl", "lambda: list(map(int, sys.stdin.readline().split()))", "list(map(int, sys.stdin.readline().split()))", "list", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "inf = float('inf')", "inf", "float('inf')", "float", "'inf'", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "s = rr()", "s", "rr()", "rr", "c = collections.Counter(s)", "c", "collections.Counter(s)", "collections.Counter", "collections", "Counter", "s", "for i in c.values():\n if i & 1:\n print('No')\n exit()", "i", "c.values()", "c.values", "c", "values", "if i & 1:\n print('No')\n exit()", "i & 1", "i", "1", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "mod = 10**9 + 7", "10**9 + 7", "mod", "c = collections.Counter(s)", "collections.Counter(s)", "c", "rs = lambda: sys.stdin.readline().split()", "lambda: sys.stdin.readline().split()", "rs", "inf = float('inf')", "float('inf')", "inf", "ri = lambda: int(sys.stdin.readline())", "lambda: int(sys.stdin.readline())", "ri", "s = rr()", "rr()", "s", "rm = lambda: map(int, sys.stdin.readline().split())", "lambda: map(int, sys.stdin.readline().split())", "rm", "rr = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "rr", "rl = lambda: list(map(int, sys.stdin.readline().split()))", "lambda: list(map(int, sys.stdin.readline().split()))", "rl" ]

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

[ [ 47, 2 ], [ 10, 9 ], [ 9, 19 ], [ 44, 21 ], [ 25, 24 ], [ 45, 24 ], [ 48, 31 ], [ 24, 33 ], [ 44, 45 ], [ 47, 48 ] ]

[ "w = list(input())\nS = [chr(i) for i in range(97, 97 + 26)]\n\nfor S in S:\n if w.count(S) % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "w = list(input())", "w", "list(input())", "list", "input()", "input", "chr(i) for i in range(97, 97 + 26)", "for i in range(97, 97 + 26)", "i", "range(97, 97 + 26)", "range", "97", "97 + 26", "97", "26", "for i in range(97, 97 + 26)", "chr(i)", "chr", "i", "S = [chr(i) for i in range(97, 97 + 26)]", "S", "[chr(i) for i in range(97, 97 + 26)]", "for S in S:\n if w.count(S) % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "S", "S", "if w.count(S) % 2 != 0:\n print(\"No\")\n break", "w.count(S) % 2 != 0", "w.count(S) % 2", "w.count(S)", "w.count", "w", "count", "S", "2", "0", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "S = [chr(i) for i in range(97, 97 + 26)]", "[chr(i) for i in range(97, 97 + 26)]", "S", "w = list(input())", "list(input())", "w" ]

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

[ [ 42, 4 ], [ 45, 10 ], [ 43, 15 ], [ 48, 17 ], [ 21, 20 ], [ 46, 23 ], [ 20, 28 ], [ 39, 32 ], [ 40, 37 ], [ 49, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "import collections\nw = list(input())\n\ncnt = collections.Counter(w)\nans = \"Yes\"\nfor v in cnt.values():\n if v%2!=0:\n ans = \"No\"\n break\n \nprint(ans)", "import collections", "collections", "w = list(input())", "w", "list(input())", "list", "input()", "input", "cnt = collections.Counter(w)", "cnt", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "ans = \"Yes\"", "ans", "\"Yes\"", "for v in cnt.values():\n if v%2!=0:\n ans = \"No\"\n break\n ", "v", "cnt.values()", "cnt.values", "cnt", "values", "if v%2!=0:\n ans = \"No\"\n break\n ", "v%2!=0", "v%2", "v", "2", "0", "ans = \"No\"", "ans", "\"No\"", "break", "print(ans)", "print", "ans", "ans = \"No\"", "\"No\"", "ans", "w = list(input())", "list(input())", "w", "cnt = collections.Counter(w)", "collections.Counter(w)", "cnt", "ans = \"Yes\"", "\"Yes\"", "ans" ]

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

[ [ 40, 12 ], [ 17, 16 ], [ 41, 23 ], [ 16, 25 ], [ 40, 41 ] ]

[ "import sys\nimport copy\nimport math\nimport itertools\nimport numpy as np\nw = input()\nfor i in \"abcdefghijklmnopqrstuvwxyz\":\n if w.count(i)%2==1:\n print(\"No\")\n sys.exit(0)\n\nprint(\"Yes\")", "import sys", "sys", "import copy", "copy", "import math", "math", "import itertools", "itertools", "import numpy as np", "numpy", "w = input()", "w", "input()", "input", "for i in \"abcdefghijklmnopqrstuvwxyz\":\n if w.count(i)%2==1:\n print(\"No\")\n sys.exit(0)", "i", "\"abcdefghijklmnopqrstuvwxyz\"", "if w.count(i)%2==1:\n print(\"No\")\n sys.exit(0)", "w.count(i)%2==1", "w.count(i)%2", "w.count(i)", "w.count", "w", "count", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "sys.exit(0)", "sys.exit", "sys", "exit", "0", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w" ]

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

[ [ 42, 2 ], [ 45, 6 ], [ 36, 9 ], [ 13, 12 ], [ 46, 12 ], [ 43, 19 ], [ 12, 21 ], [ 39, 25 ], [ 36, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ] ]

[ "w=input()\nS=\"abcdefghijklmnopqrstuvwxyz\"\n\nflag=True\nfor c in S:\n if w.count(c)%2==1:\n flag=False\nif flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "w=input()", "w", "input()", "input", "S=\"abcdefghijklmnopqrstuvwxyz\"", "S", "\"abcdefghijklmnopqrstuvwxyz\"", "flag=True", "flag", "True", "for c in S:\n if w.count(c)%2==1:\n flag=False", "c", "S", "if w.count(c)%2==1:\n flag=False", "w.count(c)%2==1", "w.count(c)%2", "w.count(c)", "w.count", "w", "count", "c", "2", "1", "flag=False", "flag", "False", "if flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "flag", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "flag=True", "True", "flag", "flag=False", "False", "flag", "w=input()", "input()", "w", "S=\"abcdefghijklmnopqrstuvwxyz\"", "\"abcdefghijklmnopqrstuvwxyz\"", "S" ]

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

[ [ 53, 2 ], [ 56, 6 ], [ 13, 12 ], [ 54, 17 ], [ 28, 19 ], [ 57, 20 ], [ 54, 25 ], [ 12, 26 ], [ 31, 30 ], [ 57, 35 ], [ 57, 40 ], [ 30, 41 ], [ 53, 54 ], [ 56, 57 ] ]

[ "w = input()\ncount = [0] * 27\n\nfor i in range(len(w)):\n\tcount[ord(w[i])-97] += 1\n\nfor i in range(len(count)):\n\tif count[i] % 2 != 0:\n\t\tprint(\"No\")\n\t\texit()\n\nprint(\"Yes\")", "w = input()", "w", "input()", "input", "count = [0] * 27", "count", "[0] * 27", "[0]", "0", "27", "for i in range(len(w)):\n\tcount[ord(w[i])-97] += 1", "i", "range(len(w))", "range", "len(w)", "len", "w", "count[ord(w[i])-97] += 1", "count[ord(w[i])-97]", "count", "ord(w[i])-97", "ord(w[i])", "ord", "w[i]", "w", "i", "97", "1", "for i in range(len(count)):\n\tif count[i] % 2 != 0:\n\t\tprint(\"No\")\n\t\texit()", "i", "range(len(count))", "range", "len(count)", "len", "count", "if count[i] % 2 != 0:\n\t\tprint(\"No\")\n\t\texit()", "count[i] % 2 != 0", "count[i] % 2", "count[i]", "count", "i", "2", "0", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w", "count = [0] * 27", "[0] * 27", "count" ]

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

[ [ 35, 4 ], [ 38, 8 ], [ 36, 15 ], [ 19, 18 ], [ 39, 18 ], [ 18, 23 ], [ 35, 36 ], [ 38, 39 ] ]

[ "import collections\n\nw = input()\nC = collections.Counter(w).values()\n\nfor c in C:\n if c%2==0:\n pass\n else:\n print(\"No\")\n exit()\n \nprint(\"Yes\")", "import collections", "collections", "w = input()", "w", "input()", "input", "C = collections.Counter(w).values()", "C", "collections.Counter(w).values()", "collections.Counter(w).values", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "values", "for c in C:\n if c%2==0:\n pass\n else:\n print(\"No\")\n exit()\n ", "c", "C", "if c%2==0:\n pass\n else:\n print(\"No\")\n exit()\n ", "c%2==0", "c%2", "c", "2", "0", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w", "C = collections.Counter(w).values()", "collections.Counter(w).values()", "C" ]

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

[ [ 50, 2 ], [ 47, 8 ], [ 51, 13 ], [ 16, 15 ], [ 48, 20 ], [ 44, 22 ], [ 51, 25 ], [ 48, 28 ], [ 15, 29 ], [ 45, 33 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ] ]

[ "w = list(input())\nww = list(set(w))\n\nfor i in range(len(ww)):\n num = w.count(ww[i])\n if num % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "w = list(input())", "w", "list(input())", "list", "input()", "input", "ww = list(set(w))", "ww", "list(set(w))", "list", "set(w)", "set", "w", "for i in range(len(ww)):\n num = w.count(ww[i])\n if num % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "i", "range(len(ww))", "range", "len(ww)", "len", "ww", "num = w.count(ww[i])", "num", "w.count(ww[i])", "w.count", "w", "count", "ww[i]", "ww", "i", "if num % 2 != 0:\n print(\"No\")\n break", "num % 2 != 0", "num % 2", "num", "2", "0", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "num = w.count(ww[i])", "w.count(ww[i])", "num", "ww = list(set(w))", "list(set(w))", "ww", "w = list(input())", "list(input())", "w" ]

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

[ [ 52, 2 ], [ 43, 6 ], [ 10, 9 ], [ 53, 9 ], [ 55, 12 ], [ 16, 15 ], [ 53, 15 ], [ 9, 19 ], [ 15, 20 ], [ 46, 22 ], [ 47, 27 ], [ 56, 27 ], [ 49, 31 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "w = input()\nans = True\nfor i in w:\n cnt = 0\n for j in w:\n if i == j:\n cnt += 1\n if cnt % 2 != 0:\n ans = False\n break\n \nif ans:\n print(\"Yes\")\nelse:\n print(\"No\")", "w = input()", "w", "input()", "input", "ans = True", "ans", "True", "for i in w:\n cnt = 0\n for j in w:\n if i == j:\n cnt += 1\n if cnt % 2 != 0:\n ans = False\n break\n ", "i", "w", "cnt = 0", "cnt", "0", "for j in w:\n if i == j:\n cnt += 1\n ", "j", "w", "if i == j:\n cnt += 1\n ", "i == j", "i", "j", "cnt += 1", "cnt", "1", "if cnt % 2 != 0:\n ans = False\n break\n ", "cnt % 2 != 0", "cnt % 2", "cnt", "2", "0", "ans = False", "ans", "False", "break", "if ans:\n print(\"Yes\")\nelse:\n print(\"No\")", "ans", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "ans = True", "True", "ans", "cnt += 1", "1", "cnt", "ans = False", "False", "ans", "w = input()", "input()", "w", "cnt = 0", "0", "cnt" ]

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

[ [ 57, 2 ], [ 60, 6 ], [ 11, 10 ], [ 58, 10 ], [ 10, 14 ], [ 61, 15 ], [ 20, 17 ], [ 61, 18 ], [ 10, 19 ], [ 25, 22 ], [ 61, 23 ], [ 10, 24 ], [ 54, 27 ], [ 31, 30 ], [ 61, 33 ], [ 30, 38 ], [ 63, 42 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "S = input()\ncount = dict()\nfor c in S:\n if c in count:\n count[c] += 1\n else:\n count[c] = 1\n\nyes = True\nfor e in count.values():\n if e % 2 != 0:\n yes = False\n break\n \nif yes:\n print(\"Yes\")\nelse:\n print(\"No\")", "S = input()", "S", "input()", "input", "count = dict()", "count", "dict()", "dict", "for c in S:\n if c in count:\n count[c] += 1\n else:\n count[c] = 1", "c", "S", "if c in count:\n count[c] += 1\n else:\n count[c] = 1", "c in count", "c", "count", "count[c] += 1", "count[c]", "count", "c", "1", "count[c] = 1", "count[c]", "count", "c", "1", "yes = True", "yes", "True", "for e in count.values():\n if e % 2 != 0:\n yes = False\n break\n ", "e", "count.values()", "count.values", "count", "values", "if e % 2 != 0:\n yes = False\n break\n ", "e % 2 != 0", "e % 2", "e", "2", "0", "yes = False", "yes", "False", "break", "if yes:\n print(\"Yes\")\nelse:\n print(\"No\")", "yes", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "yes = True", "True", "yes", "S = input()", "input()", "S", "count = dict()", "dict()", "count", "yes = False", "False", "yes" ]

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

[ [ 31, 4 ], [ 32, 15 ], [ 31, 32 ] ]

[ "import collections\nW=collections.Counter(x for x in input())\n\nfor i,v in W.items():\n if v%2!=0:\n print('No')\n break\nelse:\n print('Yes')", "import collections", "collections", "W=collections.Counter(x for x in input())", "W", "collections.Counter(x for x in input())", "collections.Counter", "collections", "Counter", "x", "for i,v in W.items():\n if v%2!=0:\n print('No')\n break\nelse:\n print('Yes')", "i", "v", "W.items()", "W.items", "W", "items", "if v%2!=0:\n print('No')\n break", "v%2!=0", "v%2", "v", "2", "0", "print('No')", "print", "'No'", "break", "print('Yes')", "print", "'Yes'", "W=collections.Counter(x for x in input())", "collections.Counter(x for x in input())", "W" ]

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

[ [ 46, 2 ], [ 47, 9 ], [ 50, 9 ], [ 43, 12 ], [ 47, 14 ], [ 50, 14 ], [ 47, 21 ], [ 50, 21 ], [ 44, 23 ], [ 49, 32 ], [ 47, 35 ], [ 50, 35 ], [ 44, 37 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "w = input()\nwhile len(w) > 0:\n a = w[0]\n if w.count(a)%2 != 0:\n print(\"No\")\n exit()\n w = w.replace(a,\"\")\nprint(\"Yes\")", "w = input()", "w", "input()", "input", "while len(w) > 0:\n a = w[0]\n if w.count(a)%2 != 0:\n print(\"No\")\n exit()\n w = w.replace(a,\"\")", "len(w) > 0", "len(w)", "len", "w", "0", "a = w[0]", "a", "w[0]", "w", "0", "if w.count(a)%2 != 0:\n print(\"No\")\n exit()\n ", "w.count(a)%2 != 0", "w.count(a)%2", "w.count(a)", "w.count", "w", "count", "a", "2", "0", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "w = w.replace(a,\"\")", "w", "w.replace(a,\"\")", "w.replace", "w", "replace", "a", "\"\"", "print(\"Yes\")", "print", "\"Yes\"", "a = w[0]", "w[0]", "a", "w = input()", "input()", "w", "w = w.replace(a,\"\")", "w.replace(a,\"\")", "w" ]

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

[ [ 44, 2 ], [ 41, 6 ], [ 50, 13 ], [ 17, 16 ], [ 42, 16 ], [ 45, 23 ], [ 16, 25 ], [ 47, 29 ], [ 41, 42 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ] ]

[ "W = input()\nW_list = set(list(s for s in W))\nans = True \nfor s in W_list:\n if W.count(s) % 2 != 0:\n ans = False\n break\n\n\nif ans:\n print(\"Yes\")\nelse:\n print(\"No\")", "W = input()", "W", "input()", "input", "W_list = set(list(s for s in W))", "W_list", "set(list(s for s in W))", "set", "list(s for s in W)", "list", "s", "ans = True", "ans", "True", "for s in W_list:\n if W.count(s) % 2 != 0:\n ans = False\n break", "s", "W_list", "if W.count(s) % 2 != 0:\n ans = False\n break", "W.count(s) % 2 != 0", "W.count(s) % 2", "W.count(s)", "W.count", "W", "count", "s", "2", "0", "ans = False", "ans", "False", "break", "if ans:\n print(\"Yes\")\nelse:\n print(\"No\")", "ans", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "W_list = set(list(s for s in W))", "set(list(s for s in W))", "W_list", "W = input()", "input()", "W", "ans = False", "False", "ans", "ans = True", "True", "ans" ]

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

[ [ 42, 3 ], [ 36, 11 ], [ 43, 18 ], [ 39, 27 ], [ 40, 32 ], [ 37, 32 ], [ 36, 37 ], [ 39, 40 ], [ 42, 43 ] ]

[ "from collections import Counter\nw = Counter(list(input()))\nf = True\nfor k, v in w.items():\n if v % 2 == 1:\n f = False\nprint(\"Yes\" if f else \"No\")", "from collections import Counter", "w = Counter(list(input()))", "w", "Counter(list(input()))", "Counter", "list(input())", "list", "input()", "input", "f = True", "f", "True", "for k, v in w.items():\n if v % 2 == 1:\n f = False", "k", "v", "w.items()", "w.items", "w", "items", "if v % 2 == 1:\n f = False", "v % 2 == 1", "v % 2", "v", "2", "1", "f = False", "f", "False", "print(\"Yes\" if f else \"No\")", "print", "\"Yes\" if f else \"No\"", "f", "\"Yes\"", "\"No\"", "f = True", "True", "f", "f = False", "False", "f", "w = Counter(list(input()))", "Counter(list(input()))", "w" ]

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

[ [ 33, 3 ], [ 39, 6 ], [ 13, 12 ], [ 40, 15 ], [ 36, 18 ], [ 34, 20 ], [ 37, 20 ], [ 12, 23 ], [ 37, 29 ], [ 34, 29 ], [ 33, 34 ], [ 36, 37 ], [ 39, 40 ] ]

[ "from collections import Counter\nflg = True\nc = Counter(input())\n\nfor v in c.values():\n flg = flg and v % 2 == 0\n\nprint('Yes' if flg else 'No')", "from collections import Counter", "flg = True", "flg", "True", "c = Counter(input())", "c", "Counter(input())", "Counter", "input()", "input", "for v in c.values():\n flg = flg and v % 2 == 0", "v", "c.values()", "c.values", "c", "values", "flg = flg and v % 2 == 0", "flg", "flg and v % 2 == 0", "flg", "v % 2 == 0", "v % 2", "v", "2", "0", "print('Yes' if flg else 'No')", "print", "'Yes' if flg else 'No'", "flg", "'Yes'", "'No'", "flg = True", "True", "flg", "flg = flg and v % 2 == 0", "flg and v % 2 == 0", "flg", "c = Counter(input())", "Counter(input())", "c" ]

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

[ [ 76, 2 ], [ 70, 6 ], [ 77, 9 ], [ 13, 12 ], [ 73, 19 ], [ 23, 22 ], [ 71, 27 ], [ 38, 29 ], [ 74, 30 ], [ 71, 35 ], [ 22, 36 ], [ 79, 40 ], [ 44, 43 ], [ 74, 51 ], [ 43, 52 ], [ 67, 56 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "str1 = input()\nwo = list(str1)\nli = [0 for i in range(26)]\nfor i in range(len(wo)):\n li[ord(wo[i])-97] += 1\nflag = True\nfor i in range(26):\n if li[i] % 2 != 0:\n flag = False\nif flag:\n print('Yes')\nelse:\n print('No')", "str1 = input()", "str1", "input()", "input", "wo = list(str1)", "wo", "list(str1)", "list", "str1", "0 for i in range(26)", "for i in range(26)", "i", "range(26)", "range", "26", "for i in range(26)", "0", "li = [0 for i in range(26)]", "li", "[0 for i in range(26)]", "for i in range(len(wo)):\n li[ord(wo[i])-97] += 1", "i", "range(len(wo))", "range", "len(wo)", "len", "wo", "li[ord(wo[i])-97] += 1", "li[ord(wo[i])-97]", "li", "ord(wo[i])-97", "ord(wo[i])", "ord", "wo[i]", "wo", "i", "97", "1", "flag = True", "flag", "True", "for i in range(26):\n if li[i] % 2 != 0:\n flag = False", "i", "range(26)", "range", "26", "if li[i] % 2 != 0:\n flag = False", "li[i] % 2 != 0", "li[i] % 2", "li[i]", "li", "i", "2", "0", "flag = False", "flag", "False", "if flag:\n print('Yes')\nelse:\n print('No')", "flag", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "flag = False", "False", "flag", "wo = list(str1)", "list(str1)", "wo", "li = [0 for i in range(26)]", "[0 for i in range(26)]", "li", "str1 = input()", "input()", "str1", "flag = True", "True", "flag" ]

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

[ [ 74, 2 ], [ 10, 9 ], [ 68, 16 ], [ 77, 19 ], [ 23, 22 ], [ 75, 27 ], [ 30, 29 ], [ 75, 38 ], [ 22, 39 ], [ 29, 42 ], [ 47, 44 ], [ 69, 45 ], [ 29, 46 ], [ 50, 49 ], [ 69, 57 ], [ 49, 58 ], [ 71, 62 ], [ 72, 66 ], [ 78, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "W=str(input())\ncnt=[0 for i in range(26)]\nans=\"Yes\"\nfor i in range(len(W)):\n for j in range(26):\n if ord(W[i])==97+j:\n cnt[j]+=1\n\nfor s in range(26):\n if cnt[s]%2!=0:\n ans=\"No\"\nprint(ans)", "W=str(input())", "W", "str(input())", "str", "input()", "input", "0 for i in range(26)", "for i in range(26)", "i", "range(26)", "range", "26", "for i in range(26)", "0", "cnt=[0 for i in range(26)]", "cnt", "[0 for i in range(26)]", "ans=\"Yes\"", "ans", "\"Yes\"", "for i in range(len(W)):\n for j in range(26):\n if ord(W[i])==97+j:\n cnt[j]+=1", "i", "range(len(W))", "range", "len(W)", "len", "W", "for j in range(26):\n if ord(W[i])==97+j:\n cnt[j]+=1", "j", "range(26)", "range", "26", "if ord(W[i])==97+j:\n cnt[j]+=1", "ord(W[i])==97+j", "ord(W[i])", "ord", "W[i]", "W", "i", "97+j", "97", "j", "cnt[j]+=1", "cnt[j]", "cnt", "j", "1", "for s in range(26):\n if cnt[s]%2!=0:\n ans=\"No\"", "s", "range(26)", "range", "26", "if cnt[s]%2!=0:\n ans=\"No\"", "cnt[s]%2!=0", "cnt[s]%2", "cnt[s]", "cnt", "s", "2", "0", "ans=\"No\"", "ans", "\"No\"", "print(ans)", "print", "ans", "cnt=[0 for i in range(26)]", "[0 for i in range(26)]", "cnt", "ans=\"No\"", "\"No\"", "ans", "W=str(input())", "str(input())", "W", "ans=\"Yes\"", "\"Yes\"", "ans" ]

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

[ [ 43, 4 ], [ 40, 10 ], [ 44, 15 ], [ 18, 17 ], [ 41, 17 ], [ 44, 24 ], [ 17, 26 ], [ 40, 41 ], [ 43, 44 ] ]

[ "import sys\nw = list(input())\ns = list(set(w))\nfor i in s:\n if w.count(i) % 2 == 1:\n print(\"No\")\n sys.exit()\nprint(\"Yes\") ", "import sys", "sys", "w = list(input())", "w", "list(input())", "list", "input()", "input", "s = list(set(w))", "s", "list(set(w))", "list", "set(w)", "set", "w", "for i in s:\n if w.count(i) % 2 == 1:\n print(\"No\")\n sys.exit()", "i", "s", "if w.count(i) % 2 == 1:\n print(\"No\")\n sys.exit()", "w.count(i) % 2 == 1", "w.count(i) % 2", "w.count(i)", "w.count", "w", "count", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "sys.exit()", "sys.exit", "sys", "exit", "print(\"Yes\")", "print", "\"Yes\"", "s = list(set(w))", "list(set(w))", "s", "w = list(input())", "list(input())", "w" ]

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

[ [ 53, 2 ], [ 44, 6 ], [ 50, 9 ], [ 54, 14 ], [ 17, 16 ], [ 51, 16 ], [ 54, 23 ], [ 16, 25 ], [ 47, 29 ], [ 48, 35 ], [ 45, 35 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "N = input()\nans_num = 0\n# 重複を消して抽出する\nset_N = list(set(N))\nfor i in set_N:\n if N.count(i) % 2 == 1:\n ans_num = 1\n break\n else:\n continue\nif ans_num == 0:\n print('Yes')\nelse :\n print('No')", "N = input()", "N", "input()", "input", "ans_num = 0", "ans_num", "0", "set_N = list(set(N))", "set_N", "list(set(N))", "list", "set(N)", "set", "N", "for i in set_N:\n if N.count(i) % 2 == 1:\n ans_num = 1\n break\n else:\n continue", "i", "set_N", "if N.count(i) % 2 == 1:\n ans_num = 1\n break\n else:\n continue", "N.count(i) % 2 == 1", "N.count(i) % 2", "N.count(i)", "N.count", "N", "count", "i", "2", "1", "ans_num = 1", "ans_num", "1", "break", "continue", "if ans_num == 0:\n print('Yes')\nelse :\n print('No')", "ans_num == 0", "ans_num", "0", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "ans_num = 0", "0", "ans_num", "ans_num = 1", "1", "ans_num", "set_N = list(set(N))", "list(set(N))", "set_N", "N = input()", "input()", "N" ]

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

[ [ 46, 2 ], [ 43, 6 ], [ 47, 9 ], [ 52, 13 ], [ 44, 18 ], [ 47, 18 ], [ 49, 20 ], [ 53, 23 ], [ 27, 26 ], [ 50, 26 ], [ 26, 31 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "w = input()\nw = list(w)\nimport collections\nco = collections.Counter(w)\nli = co.values()\nfor i in li:\n if i % 2 == 1:\n print('No')\n exit()\nprint('Yes')", "w = input()", "w", "input()", "input", "w = list(w)", "w", "list(w)", "list", "w", "import collections", "collections", "co = collections.Counter(w)", "co", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "li = co.values()", "li", "co.values()", "co.values", "co", "values", "for i in li:\n if i % 2 == 1:\n print('No')\n exit()", "i", "li", "if i % 2 == 1:\n print('No')\n exit()", "i % 2 == 1", "i % 2", "i", "2", "1", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "w = list(w)", "list(w)", "w", "w = input()", "input()", "w", "li = co.values()", "co.values()", "li", "co = collections.Counter(w)", "collections.Counter(w)", "co" ]

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

[ [ 47, 4 ], [ 50, 12 ], [ 48, 17 ], [ 44, 19 ], [ 48, 22 ], [ 25, 24 ], [ 45, 24 ], [ 51, 32 ], [ 24, 33 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ] ]

[ "import collections\nw = list(str(input()))\nl = collections.Counter(w)\ns = set(w)\n\nfor i in s:\n if int(l[i])%2 != 0:\n print('No')\n break\nelse:\n print('Yes')", "import collections", "collections", "w = list(str(input()))", "w", "list(str(input()))", "list", "str(input())", "str", "input()", "input", "l = collections.Counter(w)", "l", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "s = set(w)", "s", "set(w)", "set", "w", "for i in s:\n if int(l[i])%2 != 0:\n print('No')\n break\nelse:\n print('Yes')", "i", "s", "if int(l[i])%2 != 0:\n print('No')\n break", "int(l[i])%2 != 0", "int(l[i])%2", "int(l[i])", "int", "l[i]", "l", "i", "2", "0", "print('No')", "print", "'No'", "break", "print('Yes')", "print", "'Yes'", "s = set(w)", "set(w)", "s", "w = list(str(input()))", "list(str(input()))", "w", "l = collections.Counter(w)", "collections.Counter(w)", "l" ]

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

[ [ 53, 2 ], [ 56, 6 ], [ 10, 9 ], [ 54, 9 ], [ 57, 13 ], [ 9, 15 ], [ 59, 17 ], [ 57, 20 ], [ 62, 22 ], [ 26, 25 ], [ 60, 25 ], [ 57, 32 ], [ 25, 34 ], [ 50, 38 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ] ]

[ "w = input()\nchars = []\nfor c in w:\n chars.append(c)\n\ncset = set(chars)\n\nbeautiful = True\nfor c in cset:\n if chars.count(c) % 2 != 0:\n beautiful = False\n break\n\nif beautiful:\n print('Yes')\nelse:\n print('No')", "w = input()", "w", "input()", "input", "chars = []", "chars", "[]", "for c in w:\n chars.append(c)", "c", "w", "chars.append(c)", "chars.append", "chars", "append", "c", "cset = set(chars)", "cset", "set(chars)", "set", "chars", "beautiful = True", "beautiful", "True", "for c in cset:\n if chars.count(c) % 2 != 0:\n beautiful = False\n break", "c", "cset", "if chars.count(c) % 2 != 0:\n beautiful = False\n break", "chars.count(c) % 2 != 0", "chars.count(c) % 2", "chars.count(c)", "chars.count", "chars", "count", "c", "2", "0", "beautiful = False", "beautiful", "False", "break", "if beautiful:\n print('Yes')\nelse:\n print('No')", "beautiful", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "beautiful = False", "False", "beautiful", "w = input()", "input()", "w", "chars = []", "[]", "chars", "cset = set(chars)", "set(chars)", "cset", "beautiful = True", "True", "beautiful" ]

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

[ [ 45, 2 ], [ 48, 6 ], [ 10, 9 ], [ 46, 9 ], [ 9, 13 ], [ 49, 14 ], [ 19, 16 ], [ 49, 17 ], [ 9, 18 ], [ 24, 21 ], [ 49, 22 ], [ 9, 23 ], [ 27, 26 ], [ 49, 29 ], [ 26, 34 ], [ 45, 46 ], [ 48, 49 ] ]

[ "w = input()\n\ncher_count = {}\n\nfor c in w:\n if c in cher_count:\n cher_count[c] += 1\n else:\n cher_count[c] = 1\n\nfor num in cher_count.values():\n if num % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "w = input()", "w", "input()", "input", "cher_count = {}", "cher_count", "{}", "for c in w:\n if c in cher_count:\n cher_count[c] += 1\n else:\n cher_count[c] = 1", "c", "w", "if c in cher_count:\n cher_count[c] += 1\n else:\n cher_count[c] = 1", "c in cher_count", "c", "cher_count", "cher_count[c] += 1", "cher_count[c]", "cher_count", "c", "1", "cher_count[c] = 1", "cher_count[c]", "cher_count", "c", "1", "for num in cher_count.values():\n if num % 2 != 0:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "num", "cher_count.values()", "cher_count.values", "cher_count", "values", "if num % 2 != 0:\n print(\"No\")\n break", "num % 2 != 0", "num % 2", "num", "2", "0", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w", "cher_count = {}", "{}", "cher_count" ]

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

[ [ 40, 4 ], [ 37, 10 ], [ 41, 15 ], [ 18, 17 ], [ 38, 20 ], [ 17, 25 ], [ 37, 38 ], [ 40, 41 ] ]

[ "import collections\ns = list(input())\nc = collections.Counter(s)\nfor s1 in c.values():\n\tif s1 % 2 !=0:\n\t\tprint('No')\n\t\texit()\nprint('Yes')", "import collections", "collections", "s = list(input())", "s", "list(input())", "list", "input()", "input", "c = collections.Counter(s)", "c", "collections.Counter(s)", "collections.Counter", "collections", "Counter", "s", "for s1 in c.values():\n\tif s1 % 2 !=0:\n\t\tprint('No')\n\t\texit()", "s1", "c.values()", "c.values", "c", "values", "if s1 % 2 !=0:\n\t\tprint('No')\n\t\texit()", "s1 % 2 !=0", "s1 % 2", "s1", "2", "0", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "c = collections.Counter(s)", "collections.Counter(s)", "c", "s = list(input())", "list(input())", "s" ]

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

[ [ 7, 6 ], [ 14, 13 ], [ 6, 17 ], [ 24, 23 ], [ 23, 28 ], [ 32, 31 ], [ 35, 34 ], [ 13, 34 ], [ 40, 37 ], [ 31, 38 ], [ 34, 39 ], [ 37, 41 ], [ 31, 42 ], [ 34, 43 ], [ 31, 49 ], [ 65, 62 ] ]

[ "\ndef resolve():\n import sys\n input = sys.stdin.readline\n # row = [int(x) for x in input().rstrip().split(\" \")]\n # n = int(input().rstrip())\n w = input().rstrip()\n\n import string\n\n result = {alp: True for alp in string.ascii_lowercase}\n\n for c in w:\n result[c] = not result[c]\n\n if all(result.values()):\n print(\"Yes\")\n else:\n print(\"No\")\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n import sys\n input = sys.stdin.readline\n # row = [int(x) for x in input().rstrip().split(\" \")]\n # n = int(input().rstrip())\n w = input().rstrip()\n\n import string\n\n result = {alp: True for alp in string.ascii_lowercase}\n\n for c in w:\n result[c] = not result[c]\n\n if all(result.values()):\n print(\"Yes\")\n else:\n print(\"No\")", "resolve", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "w = input().rstrip()", "w", "input().rstrip()", "().rstrip", "()", "input", "rstrip", "import string", "string", "alp: True for alp in string.ascii_lowercase", "for alp in string.ascii_lowercase", "alp", "string.ascii_lowercase", "string", "ascii_lowercase", "for alp in string.ascii_lowercase", "alp", "True", "result = {alp: True for alp in string.ascii_lowercase}", "result", "{alp: True for alp in string.ascii_lowercase}", "for c in w:\n result[c] = not result[c]\n\n ", "c", "w", "result[c] = not result[c]", "result[c]", "result", "c", "not result[c]", "result[c]", "result", "c", "if all(result.values()):\n print(\"Yes\")\n else:\n print(\"No\")", "all(result.values())", "all", "result.values()", "result.values", "result", "values", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n import sys\n input = sys.stdin.readline\n # row = [int(x) for x in input().rstrip().split(\" \")]\n # n = int(input().rstrip())\n w = input().rstrip()\n\n import string\n\n result = {alp: True for alp in string.ascii_lowercase}\n\n for c in w:\n result[c] = not result[c]\n\n if all(result.values()):\n print(\"Yes\")\n else:\n print(\"No\")", "def resolve():\n import sys\n input = sys.stdin.readline\n # row = [int(x) for x in input().rstrip().split(\" \")]\n # n = int(input().rstrip())\n w = input().rstrip()\n\n import string\n\n result = {alp: True for alp in string.ascii_lowercase}\n\n for c in w:\n result[c] = not result[c]\n\n if all(result.values()):\n print(\"Yes\")\n else:\n print(\"No\")", "resolve" ]

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

[ [ 43, 4 ], [ 40, 8 ], [ 44, 13 ], [ 46, 15 ], [ 41, 20 ], [ 24, 23 ], [ 47, 23 ], [ 23, 28 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "import collections\n\ns = input()\n\nc = collections.Counter(s)\n \nv = list(c.values())\n\nfor i in v:\n if i % 2 == 1:\n print(\"No\")\n exit()\nprint(\"Yes\")", "import collections", "collections", "s = input()", "s", "input()", "input", "c = collections.Counter(s)", "c", "collections.Counter(s)", "collections.Counter", "collections", "Counter", "s", "v = list(c.values())", "v", "list(c.values())", "list", "c.values()", "c.values", "c", "values", "for i in v:\n if i % 2 == 1:\n print(\"No\")\n exit()", "i", "v", "if i % 2 == 1:\n print(\"No\")\n exit()", "i % 2 == 1", "i % 2", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "c = collections.Counter(s)", "collections.Counter(s)", "c", "s = input()", "input()", "s", "v = list(c.values())", "list(c.values())", "v" ]

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

[ [ 45, 2 ], [ 51, 8 ], [ 46, 13 ], [ 42, 15 ], [ 19, 18 ], [ 52, 18 ], [ 46, 25 ], [ 18, 27 ], [ 48, 31 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ] ]

[ "# coding: utf-8\nw = list(input())\n\nw_ = list(set(w))\nflg = True\nfor a in w_:\n if w.count(a)%2 != 0:\n flg = False\n\nif flg:\n print(\"Yes\")\nelse:\n print('No')", "w = list(input())", "w", "list(input())", "list", "input()", "input", "w_ = list(set(w))", "w_", "list(set(w))", "list", "set(w)", "set", "w", "flg = True", "flg", "True", "for a in w_:\n if w.count(a)%2 != 0:\n flg = False", "a", "w_", "if w.count(a)%2 != 0:\n flg = False", "w.count(a)%2 != 0", "w.count(a)%2", "w.count(a)", "w.count", "w", "count", "a", "2", "0", "flg = False", "flg", "False", "if flg:\n print(\"Yes\")\nelse:\n print('No')", "flg", "print(\"Yes\")", "print", "\"Yes\"", "print('No')", "print", "'No'", "flg = True", "True", "flg", "w = list(input())", "list(input())", "w", "flg = False", "False", "flg", "w_ = list(set(w))", "list(set(w))", "w_" ]

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

[ [ 30, 2 ], [ 9, 8 ], [ 31, 13 ], [ 8, 18 ], [ 30, 31 ] ]

[ "s = input()\nfrom collections import Counter\nprint('Yes' if all([cnt%2==0 for cnt in Counter(s).values()]) else 'No')", "s = input()", "s", "input()", "input", "from collections import Counter", "cnt%2==0 for cnt in Counter(s).values()", "for cnt in Counter(s).values()", "cnt", "Counter(s).values()", "(s).values", "(s)", "Counter", "s", "values", "for cnt in Counter(s).values()", "cnt%2==0", "cnt%2", "cnt", "2", "0", "print('Yes' if all([cnt%2==0 for cnt in Counter(s).values()]) else 'No')", "print", "'Yes' if all([cnt%2==0 for cnt in Counter(s).values()]) else 'No'", "all([cnt%2==0 for cnt in Counter(s).values()])", "all", "[cnt%2==0 for cnt in Counter(s).values()]", "'Yes'", "'No'", "s = input()", "input()", "s" ]

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

[ [ 86, 2 ], [ 8, 7 ], [ 83, 15 ], [ 19, 18 ], [ 87, 18 ], [ 18, 23 ], [ 18, 26 ], [ 38, 29 ], [ 84, 30 ], [ 18, 34 ], [ 84, 40 ], [ 18, 44 ], [ 80, 50 ], [ 54, 53 ], [ 84, 62 ], [ 53, 63 ], [ 89, 67 ], [ 90, 71 ], [ 81, 71 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ] ]

[ "s = input()\nalp=[0 for i in range(0, 28)]\nfor j in s:\n\tif j>='a' and j<='z':\n\t\talp[(ord(j)-ord('a'))]=alp[(ord(j)-ord('a'))]+1\nf=0\nfor i in range(0 ,26):\n\tif alp[i]%2!=0:\n\t\tf=1\nif f==1:\n\tprint(\"No\")\nelse:\n\tprint(\"Yes\")", "s = input()", "s", "input()", "input", "0 for i in range(0, 28)", "for i in range(0, 28)", "i", "range(0, 28)", "range", "0", "28", "for i in range(0, 28)", "0", "alp=[0 for i in range(0, 28)]", "alp", "[0 for i in range(0, 28)]", "for j in s:\n\tif j>='a' and j<='z':\n\t\talp[(ord(j)-ord('a'))]=alp[(ord(j)-ord('a'))]+1", "j", "s", "if j>='a' and j<='z':\n\t\talp[(ord(j)-ord('a'))]=alp[(ord(j)-ord('a'))]+1", "j>='a' and j<='z'", "j>='a'", "j", "'a'", "j<='z'", "j", "'z'", "alp[(ord(j)-ord('a'))]=alp[(ord(j)-ord('a'))]+1", "alp[(ord(j)-ord('a'))]", "alp", "ord(j)-ord('a')", "ord(j)", "ord", "j", "ord('a')", "ord", "'a'", "alp[(ord(j)-ord('a'))]+1", "alp[(ord(j)-ord('a'))]", "alp", "ord(j)-ord('a')", "ord(j)", "ord", "j", "ord('a')", "ord", "'a'", "1", "f=0", "f", "0", "for i in range(0 ,26):\n\tif alp[i]%2!=0:\n\t\tf=1", "i", "range(0 ,26)", "range", "0", "26", "if alp[i]%2!=0:\n\t\tf=1", "alp[i]%2!=0", "alp[i]%2", "alp[i]", "alp", "i", "2", "0", "f=1", "f", "1", "if f==1:\n\tprint(\"No\")\nelse:\n\tprint(\"Yes\")", "f==1", "f", "1", "print(\"No\")", "print", "\"No\"", "print(\"Yes\")", "print", "\"Yes\"", "f=0", "0", "f", "alp=[0 for i in range(0, 28)]", "[0 for i in range(0, 28)]", "alp", "s = input()", "input()", "s", "f=1", "1", "f" ]

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

[ [ 52, 2 ], [ 8, 7 ], [ 53, 7 ], [ 7, 10 ], [ 55, 13 ], [ 17, 16 ], [ 53, 16 ], [ 22, 19 ], [ 56, 20 ], [ 16, 21 ], [ 58, 24 ], [ 28, 27 ], [ 56, 30 ], [ 27, 35 ], [ 49, 39 ], [ 50, 45 ], [ 59, 45 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "w = input()\nchar_map = { c: 0 for c in w }\nfor c in w:\n char_map[c] += 1\n\nflag = True\nfor val in char_map.values():\n if val % 2 != 0:\n flag = False\n break\n\nprint('Yes' if flag else 'No')", "w = input()", "w", "input()", "input", "c: 0 for c in w", "for c in w", "c", "w", "for c in w", "c", "0", "char_map = { c: 0 for c in w }", "char_map", "{ c: 0 for c in w }", "for c in w:\n char_map[c] += 1", "c", "w", "char_map[c] += 1", "char_map[c]", "char_map", "c", "1", "flag = True", "flag", "True", "for val in char_map.values():\n if val % 2 != 0:\n flag = False\n break", "val", "char_map.values()", "char_map.values", "char_map", "values", "if val % 2 != 0:\n flag = False\n break", "val % 2 != 0", "val % 2", "val", "2", "0", "flag = False", "flag", "False", "break", "print('Yes' if flag else 'No')", "print", "'Yes' if flag else 'No'", "flag", "'Yes'", "'No'", "flag = False", "False", "flag", "w = input()", "input()", "w", "char_map = { c: 0 for c in w }", "{ c: 0 for c in w }", "char_map", "flag = True", "True", "flag" ]

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

[ [ 40, 3 ], [ 46, 7 ], [ 41, 10 ], [ 43, 12 ], [ 41, 17 ], [ 20, 19 ], [ 44, 19 ], [ 47, 27 ], [ 19, 28 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "from collections import Counter\nw = input()\nc = Counter(w)\nli = set(list(w))\nfor i in li:\n if int(c[i]) % 2 != 0:\n print(\"No\")\n exit()\nprint(\"Yes\")", "from collections import Counter", "w = input()", "w", "input()", "input", "c = Counter(w)", "c", "Counter(w)", "Counter", "w", "li = set(list(w))", "li", "set(list(w))", "set", "list(w)", "list", "w", "for i in li:\n if int(c[i]) % 2 != 0:\n print(\"No\")\n exit()", "i", "li", "if int(c[i]) % 2 != 0:\n print(\"No\")\n exit()", "int(c[i]) % 2 != 0", "int(c[i]) % 2", "int(c[i])", "int", "c[i]", "c", "i", "2", "0", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "w = input()", "input()", "w", "li = set(list(w))", "set(list(w))", "li", "c = Counter(w)", "Counter(w)", "c" ]

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

[ [ 7, 6 ], [ 11, 10 ], [ 6, 15 ], [ 18, 17 ], [ 10, 20 ], [ 17, 25 ], [ 44, 41 ] ]

[ "# B - 美しい文字列\ndef main():\n import collections\n\n w = input()\n\n w_c = collections.Counter(w)\n\n for v in w_c.values():\n if v % 2 != 0:\n print('No')\n exit()\n else:\n print('Yes')\n \n\n \nif __name__ == \"__main__\":\n main()", "def main():\n import collections\n\n w = input()\n\n w_c = collections.Counter(w)\n\n for v in w_c.values():\n if v % 2 != 0:\n print('No')\n exit()\n else:\n print('Yes')\n \n\n ", "main", "import collections", "collections", "w = input()", "w", "input()", "input", "w_c = collections.Counter(w)", "w_c", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "for v in w_c.values():\n if v % 2 != 0:\n print('No')\n exit()\n else:\n print('Yes')\n \n\n ", "v", "w_c.values()", "w_c.values", "w_c", "values", "if v % 2 != 0:\n print('No')\n exit()\n ", "v % 2 != 0", "v % 2", "v", "2", "0", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n import collections\n\n w = input()\n\n w_c = collections.Counter(w)\n\n for v in w_c.values():\n if v % 2 != 0:\n print('No')\n exit()\n else:\n print('Yes')\n \n\n ", "def main():\n import collections\n\n w = input()\n\n w_c = collections.Counter(w)\n\n for v in w_c.values():\n if v % 2 != 0:\n print('No')\n exit()\n else:\n print('Yes')\n \n\n ", "main" ]

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

[ [ 55, 4 ], [ 49, 10 ], [ 56, 15 ], [ 58, 17 ], [ 50, 24 ], [ 50, 29 ], [ 52, 34 ], [ 53, 38 ], [ 59, 38 ], [ 50, 41 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "import collections\nw = list(input())\nwc = collections.Counter(w)\nnum = 0\nfor i, x in enumerate(wc):\n if(wc[x]%2==0):\n num += 1\nif(num==len(wc)):\n print('Yes')\nelse:\n print('No')", "import collections", "collections", "w = list(input())", "w", "list(input())", "list", "input()", "input", "wc = collections.Counter(w)", "wc", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "num = 0", "num", "0", "for i, x in enumerate(wc):\n if(wc[x]%2==0):\n num += 1", "i", "x", "enumerate(wc)", "enumerate", "wc", "if(wc[x]%2==0):\n num += 1", "wc[x]%2==0", "wc[x]%2", "wc[x]", "wc", "x", "2", "0", "num += 1", "num", "1", "if(num==len(wc)):\n print('Yes')\nelse:\n print('No')", "num==len(wc)", "num", "len(wc)", "len", "wc", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "wc = collections.Counter(w)", "collections.Counter(w)", "wc", "num += 1", "1", "num", "w = list(input())", "list(input())", "w", "num = 0", "0", "num" ]

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

[ [ 43, 3 ], [ 40, 8 ], [ 13, 12 ], [ 41, 12 ], [ 18, 15 ], [ 44, 16 ], [ 12, 17 ], [ 21, 20 ], [ 44, 23 ], [ 20, 28 ], [ 40, 41 ], [ 43, 44 ] ]

[ "from collections import defaultdict\nd=defaultdict(int)\ns=input()\nfor i in s:\n d[i]+=1\nfor v in d.values():\n if v%2==1:\n print(\"No\")\n exit()\nprint(\"Yes\")", "from collections import defaultdict", "d=defaultdict(int)", "d", "defaultdict(int)", "defaultdict", "int", "s=input()", "s", "input()", "input", "for i in s:\n d[i]+=1", "i", "s", "d[i]+=1", "d[i]", "d", "i", "1", "for v in d.values():\n if v%2==1:\n print(\"No\")\n exit()", "v", "d.values()", "d.values", "d", "values", "if v%2==1:\n print(\"No\")\n exit()", "v%2==1", "v%2", "v", "2", "1", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "s=input()", "input()", "s", "d=defaultdict(int)", "defaultdict(int)", "d" ]

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

[ [ 59, 2 ], [ 65, 6 ], [ 62, 9 ], [ 13, 12 ], [ 63, 12 ], [ 18, 15 ], [ 66, 16 ], [ 12, 17 ], [ 21, 20 ], [ 60, 20 ], [ 26, 23 ], [ 66, 24 ], [ 20, 25 ], [ 53, 28 ], [ 32, 31 ], [ 63, 31 ], [ 23, 36 ], [ 15, 36 ], [ 66, 37 ], [ 31, 38 ], [ 56, 42 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "w=input()\n\ndict={}\nalh=\"abcdefghijklmnopqrstuvwxyz\"\nfor i in alh:\n dict[i]=0\nfor i in w:\n dict[i]+=1\nflag=True\nfor i in alh:\n if dict[i]%2==1:\n flag=False\nif flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "w=input()", "w", "input()", "input", "dict={}", "dict", "{}", "alh=\"abcdefghijklmnopqrstuvwxyz\"", "alh", "\"abcdefghijklmnopqrstuvwxyz\"", "for i in alh:\n dict[i]=0", "i", "alh", "dict[i]=0", "dict[i]", "dict", "i", "0", "for i in w:\n dict[i]+=1", "i", "w", "dict[i]+=1", "dict[i]", "dict", "i", "1", "flag=True", "flag", "True", "for i in alh:\n if dict[i]%2==1:\n flag=False", "i", "alh", "if dict[i]%2==1:\n flag=False", "dict[i]%2==1", "dict[i]%2", "dict[i]", "dict", "i", "2", "1", "flag=False", "flag", "False", "if flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "flag", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "flag=True", "True", "flag", "flag=False", "False", "flag", "w=input()", "input()", "w", "alh=\"abcdefghijklmnopqrstuvwxyz\"", "\"abcdefghijklmnopqrstuvwxyz\"", "alh", "dict={}", "{}", "dict" ]

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

[ [ 40, 2 ], [ 43, 8 ], [ 41, 11 ], [ 14, 13 ], [ 44, 13 ], [ 37, 16 ], [ 41, 19 ], [ 13, 21 ], [ 38, 25 ], [ 37, 38 ], [ 40, 41 ], [ 43, 44 ] ]

[ "w = list(input())\nW = set(w)\n\nfor i in W:\n ans = w.count(i)\n if ans % 2 == 1:\n print(\"No\")\n exit()\nprint(\"Yes\")", "w = list(input())", "w", "list(input())", "list", "input()", "input", "W = set(w)", "W", "set(w)", "set", "w", "for i in W:\n ans = w.count(i)\n if ans % 2 == 1:\n print(\"No\")\n exit()", "i", "W", "ans = w.count(i)", "ans", "w.count(i)", "w.count", "w", "count", "i", "if ans % 2 == 1:\n print(\"No\")\n exit()", "ans % 2 == 1", "ans % 2", "ans", "2", "1", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "ans = w.count(i)", "w.count(i)", "ans", "w = list(input())", "list(input())", "w", "W = set(w)", "set(w)", "W" ]

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

[ [ 31, 2 ], [ 34, 7 ], [ 32, 10 ], [ 13, 12 ], [ 35, 15 ], [ 12, 20 ], [ 31, 32 ], [ 34, 35 ] ]

[ "w = input()\nfrom collections import Counter\nwc = Counter(w)\n\nfor c in wc.values():\n if c%2 == 1:\n print('No')\n break\nelse:\n print('Yes')", "w = input()", "w", "input()", "input", "from collections import Counter", "wc = Counter(w)", "wc", "Counter(w)", "Counter", "w", "for c in wc.values():\n if c%2 == 1:\n print('No')\n break\nelse:\n print('Yes')", "c", "wc.values()", "wc.values", "wc", "values", "if c%2 == 1:\n print('No')\n break", "c%2 == 1", "c%2", "c", "2", "1", "print('No')", "print", "'No'", "break", "print('Yes')", "print", "'Yes'", "w = input()", "input()", "w", "wc = Counter(w)", "Counter(w)", "wc" ]

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

[ [ 62, 2 ], [ 65, 6 ], [ 10, 9 ], [ 63, 14 ], [ 66, 17 ], [ 63, 21 ], [ 63, 24 ], [ 9, 25 ], [ 59, 27 ], [ 31, 30 ], [ 66, 30 ], [ 30, 35 ], [ 60, 40 ], [ 60, 45 ], [ 60, 51 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "s = input()\nl = []\nfor i in range(len(s)):\n\tl.append(s.count(s[i]))\nr = []\nfor x in l:\n\tif(x%2!=0):\n\t\tr.append(False)\n\telse:\n\t\tr.append(True)\n\nif(all(r)):\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")", "s = input()", "s", "input()", "input", "l = []", "l", "[]", "for i in range(len(s)):\n\tl.append(s.count(s[i]))", "i", "range(len(s))", "range", "len(s)", "len", "s", "l.append(s.count(s[i]))", "l.append", "l", "append", "s.count(s[i])", "s.count", "s", "count", "s[i]", "s", "i", "r = []", "r", "[]", "for x in l:\n\tif(x%2!=0):\n\t\tr.append(False)\n\telse:\n\t\tr.append(True)", "x", "l", "if(x%2!=0):\n\t\tr.append(False)\n\telse:\n\t\tr.append(True)", "x%2!=0", "x%2", "x", "2", "0", "r.append(False)", "r.append", "r", "append", "False", "r.append(True)", "r.append", "r", "append", "True", "if(all(r)):\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")", "all(r)", "all", "r", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "r = []", "[]", "r", "s = input()", "input()", "s", "l = []", "[]", "l" ]

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

[ [ 68, 2 ], [ 77, 6 ], [ 69, 13 ], [ 71, 17 ], [ 86, 20 ], [ 69, 23 ], [ 65, 25 ], [ 29, 28 ], [ 87, 34 ], [ 87, 38 ], [ 28, 39 ], [ 87, 41 ], [ 28, 43 ], [ 83, 46 ], [ 66, 51 ], [ 75, 51 ], [ 84, 51 ], [ 80, 55 ], [ 74, 59 ], [ 81, 63 ], [ 72, 63 ], [ 78, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "w = input()\nans = 'Yes'\nif len(w) % 2 == 1:\n ans = 'No'\nelse:\n s = sorted(w)\n count = 1\n for i in range(1, len(s)):\n if s[i] == s[i - 1]:\n count += 1\n else:\n if count % 2 == 1:\n ans = 'No'\n break\n count = 1\nprint(ans)", "w = input()", "w", "input()", "input", "ans = 'Yes'", "ans", "'Yes'", "if len(w) % 2 == 1:\n ans = 'No'\nelse:\n s = sorted(w)\n count = 1\n for i in range(1, len(s)):\n if s[i] == s[i - 1]:\n count += 1\n else:\n if count % 2 == 1:\n ans = 'No'\n break\n count = 1", "len(w) % 2 == 1", "len(w) % 2", "len(w)", "len", "w", "2", "1", "ans = 'No'", "ans", "'No'", "s = sorted(w)", "s", "sorted(w)", "sorted", "w", "count = 1", "count", "1", "for i in range(1, len(s)):\n if s[i] == s[i - 1]:\n count += 1\n else:\n if count % 2 == 1:\n ans = 'No'\n break\n count = 1", "i", "range(1, len(s))", "range", "1", "len(s)", "len", "s", "if s[i] == s[i - 1]:\n count += 1\n else:\n if count % 2 == 1:\n ans = 'No'\n break\n count = 1", "s[i] == s[i - 1]", "s[i]", "s", "i", "s[i - 1]", "s", "i - 1", "i", "1", "count += 1", "count", "1", "if count % 2 == 1:\n ans = 'No'\n break\n ", "count % 2 == 1", "count % 2", "count", "2", "1", "ans = 'No'", "ans", "'No'", "break", "count = 1", "count", "1", "print(ans)", "print", "ans", "count = 1", "1", "count", "w = input()", "input()", "w", "ans = 'No'", "'No'", "ans", "count = 1", "1", "count", "ans = 'Yes'", "'Yes'", "ans", "ans = 'No'", "'No'", "ans", "count += 1", "1", "count", "s = sorted(w)", "sorted(w)", "s" ]

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

[ [ 5, 4 ], [ 9, 8 ], [ 4, 11 ], [ 14, 13 ], [ 4, 16 ], [ 19, 18 ], [ 13, 21 ], [ 24, 23 ], [ 8, 23 ], [ 13, 30 ], [ 23, 32 ], [ 37, 36 ], [ 41, 40 ], [ 40, 44 ], [ 36, 44 ], [ 53, 50 ] ]

[ "# -*- coding: utf-8 -*-\n\ndef main():\n\n w = input()\n setW = set(w)\n listW = list(w)\n n = len(listW)\n\n for i in setW:\n if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "def main():\n\n w = input()\n setW = set(w)\n listW = list(w)\n n = len(listW)\n\n for i in setW:\n if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n print(ans)", "main", "w = input()", "w", "input()", "input", "setW = set(w)", "setW", "set(w)", "set", "w", "listW = list(w)", "listW", "list(w)", "list", "w", "n = len(listW)", "n", "len(listW)", "len", "listW", "for i in setW:\n if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n ", "i", "setW", "if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n ", "listW.count(i) % 2 == 1", "listW.count(i) % 2", "listW.count(i)", "listW.count", "listW", "count", "i", "2", "1", "ans = 'No'", "ans", "'No'", "break", "ans = 'Yes'", "ans", "'Yes'", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n\n w = input()\n setW = set(w)\n listW = list(w)\n n = len(listW)\n\n for i in setW:\n if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n print(ans)", "def main():\n\n w = input()\n setW = set(w)\n listW = list(w)\n n = len(listW)\n\n for i in setW:\n if listW.count(i) % 2 == 1:\n ans = 'No'\n break\n\n else:\n ans = 'Yes'\n\n print(ans)", "main" ]

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

[ [ 58, 2 ], [ 55, 6 ], [ 61, 9 ], [ 13, 12 ], [ 59, 12 ], [ 12, 16 ], [ 56, 17 ], [ 22, 19 ], [ 56, 20 ], [ 12, 21 ], [ 56, 25 ], [ 12, 27 ], [ 31, 30 ], [ 56, 33 ], [ 30, 38 ], [ 64, 42 ], [ 65, 46 ], [ 62, 46 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "s = input()\nd = {}\nflag = 1\nfor i in s:\n if i in d:\n d[i] += 1\n else:\n d.setdefault(i, 1)\n \nfor j in d.values():\n if j % 2 != 0:\n flag = 0\nif flag == 0:\n print(\"No\")\nelse:\n print(\"Yes\")", "s = input()", "s", "input()", "input", "d = {}", "d", "{}", "flag = 1", "flag", "1", "for i in s:\n if i in d:\n d[i] += 1\n else:\n d.setdefault(i, 1)\n ", "i", "s", "if i in d:\n d[i] += 1\n else:\n d.setdefault(i, 1)\n ", "i in d", "i", "d", "d[i] += 1", "d[i]", "d", "i", "1", "d.setdefault(i, 1)", "d.setdefault", "d", "setdefault", "i", "1", "for j in d.values():\n if j % 2 != 0:\n flag = 0", "j", "d.values()", "d.values", "d", "values", "if j % 2 != 0:\n flag = 0", "j % 2 != 0", "j % 2", "j", "2", "0", "flag = 0", "flag", "0", "if flag == 0:\n print(\"No\")\nelse:\n print(\"Yes\")", "flag == 0", "flag", "0", "print(\"No\")", "print", "\"No\"", "print(\"Yes\")", "print", "\"Yes\"", "d = {}", "{}", "d", "s = input()", "input()", "s", "flag = 1", "1", "flag", "flag = 0", "0", "flag" ]

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

[ [ 33, 3 ], [ 30, 7 ], [ 11, 10 ], [ 34, 15 ], [ 10, 20 ], [ 36, 24 ], [ 37, 28 ], [ 31, 28 ], [ 30, 31 ], [ 33, 34 ], [ 36, 37 ] ]

[ "from collections import Counter\ns = input()\nres = 'Yes'\nfor i in Counter(s).values():\n if i % 2 ==1:\n res = 'No'\nprint(res)", "from collections import Counter", "s = input()", "s", "input()", "input", "res = 'Yes'", "res", "'Yes'", "for i in Counter(s).values():\n if i % 2 ==1:\n res = 'No'", "i", "Counter(s).values()", "(s).values", "(s)", "Counter", "s", "values", "if i % 2 ==1:\n res = 'No'", "i % 2 ==1", "i % 2", "i", "2", "1", "res = 'No'", "res", "'No'", "print(res)", "print", "res", "res = 'Yes'", "'Yes'", "res", "s = input()", "input()", "s", "res = 'No'", "'No'", "res" ]

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

[ [ 29, 2 ], [ 32, 8 ], [ 30, 13 ], [ 29, 30 ], [ 32, 33 ] ]

[ "w = input()\n\nimport collections as c\n\ncounts = c.Counter(w)\nif all(elem % 2 == 0 for elem in counts.values()):\n print('Yes')\nelse:\n print('No')", "w = input()", "w", "input()", "input", "import collections as c", "collections", "counts = c.Counter(w)", "counts", "c.Counter(w)", "c.Counter", "c", "Counter", "w", "if all(elem % 2 == 0 for elem in counts.values()):\n print('Yes')\nelse:\n print('No')", "all(elem % 2 == 0 for elem in counts.values())", "all", "elem % 2 == 0", "elem % 2", "elem", "2", "0", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "w = input()", "input()", "w", "counts = c.Counter(w)", "c.Counter(w)", "counts" ]

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

[ [ 38, 4 ], [ 35, 8 ], [ 39, 13 ], [ 16, 15 ], [ 36, 18 ], [ 15, 23 ], [ 35, 36 ], [ 38, 39 ] ]

[ "import collections\nw = input()\ncw = collections.Counter(w)\nfor val in cw.values():\n if val%2 == 1:\n print('No')\n exit()\nprint('Yes')", "import collections", "collections", "w = input()", "w", "input()", "input", "cw = collections.Counter(w)", "cw", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "for val in cw.values():\n if val%2 == 1:\n print('No')\n exit()", "val", "cw.values()", "cw.values", "cw", "values", "if val%2 == 1:\n print('No')\n exit()", "val%2 == 1", "val%2", "val", "2", "1", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "cw = collections.Counter(w)", "collections.Counter(w)", "cw", "w = input()", "input()", "w" ]

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

[ [ 5, 4 ], [ 9, 8 ], [ 13, 12 ], [ 4, 17 ], [ 4, 21 ], [ 12, 22 ], [ 8, 23 ], [ 30, 25 ], [ 8, 26 ], [ 4, 28 ], [ 12, 29 ], [ 37, 32 ], [ 8, 33 ], [ 4, 35 ], [ 12, 36 ], [ 40, 39 ], [ 43, 42 ], [ 8, 45 ], [ 42, 50 ], [ 55, 54 ], [ 54, 58 ], [ 39, 58 ], [ 8, 61 ], [ 76, 73 ] ]

[ "def main():\n w = input()\n d = dict()\n\n for i in range(len(w)):\n if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n correct = 0\n for v in d.values():\n if v % 2 == 0:\n correct += 1\n\n if correct == len(d):\n print(\"Yes\")\n else:\n print(\"No\")\n\n\nif __name__ == '__main__':\n main()", "def main():\n w = input()\n d = dict()\n\n for i in range(len(w)):\n if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n correct = 0\n for v in d.values():\n if v % 2 == 0:\n correct += 1\n\n if correct == len(d):\n print(\"Yes\")\n else:\n print(\"No\")", "main", "w = input()", "w", "input()", "input", "d = dict()", "d", "dict()", "dict", "for i in range(len(w)):\n if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n ", "i", "range(len(w))", "range", "len(w)", "len", "w", "if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n ", "w[i] in d", "w[i]", "w", "i", "d", "d[w[i]] += 1", "d[w[i]]", "d", "w[i]", "w", "i", "1", "d[w[i]] = 1", "d[w[i]]", "d", "w[i]", "w", "i", "1", "correct = 0", "correct", "0", "for v in d.values():\n if v % 2 == 0:\n correct += 1\n\n ", "v", "d.values()", "d.values", "d", "values", "if v % 2 == 0:\n correct += 1\n\n ", "v % 2 == 0", "v % 2", "v", "2", "0", "correct += 1", "correct", "1", "if correct == len(d):\n print(\"Yes\")\n else:\n print(\"No\")", "correct == len(d)", "correct", "len(d)", "len", "d", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n w = input()\n d = dict()\n\n for i in range(len(w)):\n if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n correct = 0\n for v in d.values():\n if v % 2 == 0:\n correct += 1\n\n if correct == len(d):\n print(\"Yes\")\n else:\n print(\"No\")", "def main():\n w = input()\n d = dict()\n\n for i in range(len(w)):\n if (w[i] in d):\n d[w[i]] += 1\n else:\n d[w[i]] = 1\n\n correct = 0\n for v in d.values():\n if v % 2 == 0:\n correct += 1\n\n if correct == len(d):\n print(\"Yes\")\n else:\n print(\"No\")", "main" ]

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

[ [ 4, 3 ], [ 3, 15 ], [ 36, 21 ], [ 36, 37 ] ]

[ "s=[*input()];print('NYoe s'[all([1 if s.count(i)%2==0 else 0 for i in set(s)])::2])", "1 if s.count(i)%2==0 else 0 for i in set(s)", "for i in set(s)", "i", "set(s)", "set", "s", "for i in set(s)", "1 if s.count(i)%2==0 else 0", "s.count(i)%2==0", "s.count(i)%2", "s.count(i)", "s.count", "s", "count", "i", "2", "0", "1", "0", "s=[*input()]", "s", "[*input()]", "*input()", "input()", "input", "print('NYoe s'[all([1 if s.count(i)%2==0 else 0 for i in set(s)])::2])", "print", "'NYoe s'[all([1 if s.count(i)%2==0 else 0 for i in set(s)])::2]", "'NYoe s'", "all([1 if s.count(i)%2==0 else 0 for i in set(s)])::2", "all([1 if s.count(i)%2==0 else 0 for i in set(s)])", "all", "[1 if s.count(i)%2==0 else 0 for i in set(s)]", "2", "s=[*input()]", "[*input()]", "s" ]

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

[ [ 33, 2 ], [ 7, 6 ], [ 34, 11 ], [ 34, 17 ], [ 34, 20 ], [ 6, 21 ], [ 33, 34 ] ]

[ "#!/usr/bin/env python3\nw = input()\n\nfor i in range(len(w)):\n if w.count(w[i]) % 2 != 0:\n print('No')\n exit()\nprint('Yes')", "w = input()", "w", "input()", "input", "for i in range(len(w)):\n if w.count(w[i]) % 2 != 0:\n print('No')\n exit()", "i", "range(len(w))", "range", "len(w)", "len", "w", "if w.count(w[i]) % 2 != 0:\n print('No')\n exit()", "w.count(w[i]) % 2 != 0", "w.count(w[i]) % 2", "w.count(w[i])", "w.count", "w", "count", "w[i]", "w", "i", "2", "0", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "w = input()", "input()", "w" ]

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

[ [ 47, 2 ], [ 44, 6 ], [ 10, 9 ], [ 48, 9 ], [ 15, 12 ], [ 45, 13 ], [ 9, 14 ], [ 45, 18 ], [ 9, 20 ], [ 25, 24 ], [ 48, 27 ], [ 12, 31 ], [ 45, 32 ], [ 24, 33 ], [ 44, 45 ], [ 47, 48 ] ]

[ "s=input()\nd={}\nfor i in s:\n d[i]=d.get(i,0)+1\nfor i in set(s):\n if d[i]%2==1:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "s=input()", "s", "input()", "input", "d={}", "d", "{}", "for i in s:\n d[i]=d.get(i,0)+1", "i", "s", "d[i]=d.get(i,0)+1", "d[i]", "d", "i", "d.get(i,0)+1", "d.get(i,0)", "d.get", "d", "get", "i", "0", "1", "for i in set(s):\n if d[i]%2==1:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "i", "set(s)", "set", "s", "if d[i]%2==1:\n print(\"No\")\n break", "d[i]%2==1", "d[i]%2", "d[i]", "d", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "d={}", "{}", "d", "s=input()", "input()", "s" ]

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

[ [ 69, 2 ], [ 66, 6 ], [ 10, 9 ], [ 70, 14 ], [ 70, 19 ], [ 9, 20 ], [ 67, 21 ], [ 28, 23 ], [ 67, 24 ], [ 70, 26 ], [ 9, 27 ], [ 35, 30 ], [ 67, 31 ], [ 70, 33 ], [ 9, 34 ], [ 72, 37 ], [ 67, 53 ], [ 73, 57 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "w = input()\nbeau = {}\nfor i in range(len(w)):\n if not w[i] in beau:\n beau[w[i]] = 1\n else:\n beau[w[i]] += 1\nnum = sum(list(map(lambda x: x%2,list(beau.values()))))\nif num == 0:\n print('Yes')\nelse:\n print('No')", "w = input()", "w", "input()", "input", "beau = {}", "beau", "{}", "for i in range(len(w)):\n if not w[i] in beau:\n beau[w[i]] = 1\n else:\n beau[w[i]] += 1", "i", "range(len(w))", "range", "len(w)", "len", "w", "if not w[i] in beau:\n beau[w[i]] = 1\n else:\n beau[w[i]] += 1", "not w[i] in beau", "w[i] in beau", "w[i]", "w", "i", "beau", "beau[w[i]] = 1", "beau[w[i]]", "beau", "w[i]", "w", "i", "1", "beau[w[i]] += 1", "beau[w[i]]", "beau", "w[i]", "w", "i", "1", "num = sum(list(map(lambda x: x%2,list(beau.values()))))", "num", "sum(list(map(lambda x: x%2,list(beau.values()))))", "sum", "list(map(lambda x: x%2,list(beau.values())))", "list", "map(lambda x: x%2,list(beau.values()))", "map", "lambda x: x%2", "x%2", "x", "2", "x", "list(beau.values())", "list", "beau.values()", "beau.values", "beau", "values", "if num == 0:\n print('Yes')\nelse:\n print('No')", "num == 0", "num", "0", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "beau = {}", "{}", "beau", "w = input()", "input()", "w", "num = sum(list(map(lambda x: x%2,list(beau.values()))))", "sum(list(map(lambda x: x%2,list(beau.values()))))", "num" ]

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

[ [ 110, 8 ], [ 14, 13 ], [ 111, 13 ], [ 30, 20 ], [ 13, 22 ], [ 30, 30 ], [ 35, 34 ], [ 39, 38 ], [ 102, 42 ], [ 34, 43 ], [ 38, 46 ], [ 38, 48 ], [ 113, 50 ], [ 119, 53 ], [ 122, 56 ], [ 63, 63 ], [ 74, 71 ], [ 120, 78 ], [ 116, 83 ], [ 105, 85 ], [ 123, 94 ], [ 117, 98 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ] ]

[ "# -*- coding: utf-8 -*-\n# template: v1.2\n\nimport io\nimport sys\nimport math\n\nCASES = \"abcdefghijklmnopqrstuvwxyz\"\n\ndef solve(s):\n # implement process\n for c in CASES:\n if s.count(c) % 2 != 0:\n return \"No\"\n return \"Yes\"\n\ndef main():\n # input\n s = input()\n \n # process\n ans = str( solve(s) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###\n_DEB = 0 # 1:ON / 0:OFF\n\n_INPUT = \"\"\"\\\nabaccaba\n\"\"\"\n_EXPECTED = \"\"\"\\\nYes\n\n\"\"\"\n\ndef logd(str):\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###\nif __name__ == \"__main__\":\n if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ans = main()\n\n if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")", "import io", "io", "import sys", "sys", "import math", "math", "CASES = \"abcdefghijklmnopqrstuvwxyz\"", "CASES", "\"abcdefghijklmnopqrstuvwxyz\"", "def solve(s):\n # implement process\n for c in CASES:\n if s.count(c) % 2 != 0:\n return \"No\"\n return \"Yes\"", "solve", "for c in CASES:\n if s.count(c) % 2 != 0:\n return \"No\"\n ", "c", "CASES", "if s.count(c) % 2 != 0:\n return \"No\"\n ", "s.count(c) % 2 != 0", "s.count(c) % 2", "s.count(c)", "s.count", "s", "count", "c", "2", "0", "return \"No\"", "\"No\"", "return \"Yes\"", "\"Yes\"", "s", "s", "def main():\n # input\n s = input()\n \n # process\n ans = str( solve(s) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###", "main", "s = input()", "s", "input()", "input", "ans = str( solve(s) )", "ans", "str( solve(s) )", "str", "solve(s)", "solve", "s", "print(ans)", "print", "ans", "return ans", "ans", "_DEB = 0", "_DEB", "0", "_INPUT = \"\"\"\\\nabaccaba\n\"\"\"", "_INPUT", "\"\"\"\\\nabaccaba\n\"\"\"", "_EXPECTED = \"\"\"\\\nYes\n\n\"\"\"", "_EXPECTED", "\"\"\"\\\nYes\n\n\"\"\"", "def logd(str):\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###", "logd", "if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###", "_DEB", "str", "str", "if __name__ == \"__main__\":\n if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ans = main()\n\n if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ", "_DEB", "sys.stdin = io.StringIO(_INPUT)", "sys.stdin", "sys", "stdin", "io.StringIO(_INPUT)", "io.StringIO", "io", "StringIO", "_INPUT", "print(\"!! Debug Mode !!\")", "print", "\"!! Debug Mode !!\"", "ans = main()", "ans", "main()", "main", "if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")", "_DEB", "print()", "print", "if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")", "_EXPECTED.strip() == ans.strip()", "_EXPECTED.strip()", "_EXPECTED.strip", "_EXPECTED", "strip", "ans.strip()", "ans.strip", "ans", "strip", "def solve(s):\n # implement process\n for c in CASES:\n if s.count(c) % 2 != 0:\n return \"No\"\n return \"Yes\"", "def solve(s):\n # implement process\n for c in CASES:\n if s.count(c) % 2 != 0:\n return \"No\"\n return \"Yes\"", "solve", "def main():\n # input\n s = input()\n \n # process\n ans = str( solve(s) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###", "def main():\n # input\n s = input()\n \n # process\n ans = str( solve(s) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###", "main", "def logd(str):\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###", "def logd(str):\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###", "logd", "CASES = \"abcdefghijklmnopqrstuvwxyz\"", "\"abcdefghijklmnopqrstuvwxyz\"", "CASES", "_DEB = 0", "0", "_DEB", "ans = main()", "main()", "ans", "_INPUT = \"\"\"\\\nabaccaba\n\"\"\"", "\"\"\"\\\nabaccaba\n\"\"\"", "_INPUT", "_EXPECTED = \"\"\"\\\nYes\n\n\"\"\"", "\"\"\"\\\nYes\n\n\"\"\"", "_EXPECTED" ]

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

[ [ 73, 6 ], [ 79, 10 ], [ 14, 13 ], [ 74, 13 ], [ 80, 17 ], [ 13, 19 ], [ 80, 22 ], [ 82, 25 ], [ 80, 30 ], [ 85, 32 ], [ 83, 37 ], [ 41, 40 ], [ 86, 45 ], [ 83, 45 ], [ 86, 52 ], [ 83, 52 ], [ 40, 53 ], [ 88, 57 ], [ 76, 60 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "import collections\nimport sys\na=input()\nb=[]\n\nfor i in a:\n b.append(i)\n \nb.sort()\nc=collections.Counter(b)\nc=list(c.values())\n\nfor i in range(len(c)):\n if int(c[i])%2==0:\n q=0\n else:\n q=1\n print('No')\n sys.exit()\n \nprint('Yes')", "import collections", "collections", "import sys", "sys", "a=input()", "a", "input()", "input", "b=[]", "b", "[]", "for i in a:\n b.append(i)\n ", "i", "a", "b.append(i)", "b.append", "b", "append", "i", "b.sort()", "b.sort", "b", "sort", "c=collections.Counter(b)", "c", "collections.Counter(b)", "collections.Counter", "collections", "Counter", "b", "c=list(c.values())", "c", "list(c.values())", "list", "c.values()", "c.values", "c", "values", "for i in range(len(c)):\n if int(c[i])%2==0:\n q=0\n else:\n q=1\n print('No')\n sys.exit()\n ", "i", "range(len(c))", "range", "len(c)", "len", "c", "if int(c[i])%2==0:\n q=0\n else:\n q=1\n print('No')\n sys.exit()\n ", "int(c[i])%2==0", "int(c[i])%2", "int(c[i])", "int", "c[i]", "c", "i", "2", "0", "q=0", "q", "0", "q=1", "q", "1", "print('No')", "print", "'No'", "sys.exit()", "sys.exit", "sys", "exit", "print('Yes')", "print", "'Yes'", "a=input()", "input()", "a", "q=1", "1", "q", "b=[]", "[]", "b", "c=collections.Counter(b)", "collections.Counter(b)", "c", "c=list(c.values())", "list(c.values())", "c", "q=0", "0", "q" ]

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

[ [ 43, 2 ], [ 52, 8 ], [ 44, 11 ], [ 46, 13 ], [ 17, 16 ], [ 53, 16 ], [ 44, 23 ], [ 16, 25 ], [ 49, 32 ], [ 50, 37 ], [ 47, 37 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "w = list(input())\n\nw_set = set(w)\nflag = 0\n\nfor l in w_set:\n if w.count(l)%2 != 0:\n print('No')\n flag = 1\n break\n\nif flag==0:\n print('Yes')", "w = list(input())", "w", "list(input())", "list", "input()", "input", "w_set = set(w)", "w_set", "set(w)", "set", "w", "flag = 0", "flag", "0", "for l in w_set:\n if w.count(l)%2 != 0:\n print('No')\n flag = 1\n break", "l", "w_set", "if w.count(l)%2 != 0:\n print('No')\n flag = 1\n break", "w.count(l)%2 != 0", "w.count(l)%2", "w.count(l)", "w.count", "w", "count", "l", "2", "0", "print('No')", "print", "'No'", "flag = 1", "flag", "1", "break", "if flag==0:\n print('Yes')", "flag==0", "flag", "0", "print('Yes')", "print", "'Yes'", "w = list(input())", "list(input())", "w", "flag = 0", "0", "flag", "flag = 1", "1", "flag", "w_set = set(w)", "set(w)", "w_set" ]

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

[ [ 40, 4 ], [ 46, 14 ], [ 18, 17 ], [ 41, 20 ], [ 17, 25 ], [ 43, 29 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "import collections #Counterを使いたいから\n\nc = collections.Counter(list(input())) #出現回数が多い順に要素を取得 キーと値\n\nf = True\nfor val in c.values():\n if val%2==1:\n f = False\nif f:\n print(\"Yes\")\nelse:\n print(\"No\")", "import collections", "collections", "c = collections.Counter(list(input()))", "c", "collections.Counter(list(input()))", "collections.Counter", "collections", "Counter", "list(input())", "list", "input()", "input", "f = True", "f", "True", "for val in c.values():\n if val%2==1:\n f = False", "val", "c.values()", "c.values", "c", "values", "if val%2==1:\n f = False", "val%2==1", "val%2", "val", "2", "1", "f = False", "f", "False", "if f:\n print(\"Yes\")\nelse:\n print(\"No\")", "f", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "c = collections.Counter(list(input()))", "collections.Counter(list(input()))", "c", "f = False", "False", "f", "f = True", "True", "f" ]

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

[ [ 31, 3 ], [ 10, 9 ], [ 32, 12 ], [ 32, 18 ], [ 9, 19 ], [ 31, 32 ] ]

[ "from collections import Counter\n\nc = Counter(input())\n\nfor k in c.keys():\n if c[k] % 2 == 1:\n print('No')\n exit()\n \nprint('Yes')", "from collections import Counter", "c = Counter(input())", "c", "Counter(input())", "Counter", "input()", "input", "for k in c.keys():\n if c[k] % 2 == 1:\n print('No')\n exit()\n ", "k", "c.keys()", "c.keys", "c", "keys", "if c[k] % 2 == 1:\n print('No')\n exit()\n ", "c[k] % 2 == 1", "c[k] % 2", "c[k]", "c", "k", "2", "1", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "c = Counter(input())", "Counter(input())", "c" ]

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

[ [ 41, 4 ], [ 38, 10 ], [ 42, 13 ], [ 16, 15 ], [ 39, 15 ], [ 42, 15 ], [ 39, 22 ], [ 42, 22 ], [ 15, 24 ], [ 38, 39 ], [ 41, 42 ] ]

[ "import sys\nst = str(input())\n\nst = sorted(st)\n\nfor i in st:\n if st.count(i) % 2 != 0:\n print('No')\n sys.exit()\nprint('Yes')", "import sys", "sys", "st = str(input())", "st", "str(input())", "str", "input()", "input", "st = sorted(st)", "st", "sorted(st)", "sorted", "st", "for i in st:\n if st.count(i) % 2 != 0:\n print('No')\n sys.exit()", "i", "st", "if st.count(i) % 2 != 0:\n print('No')\n sys.exit()", "st.count(i) % 2 != 0", "st.count(i) % 2", "st.count(i)", "st.count", "st", "count", "i", "2", "0", "print('No')", "print", "'No'", "sys.exit()", "sys.exit", "sys", "exit", "print('Yes')", "print", "'Yes'", "st = sorted(st)", "sorted(st)", "st", "st = str(input())", "str(input())", "st" ]

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

[ [ 38, 2 ], [ 35, 6 ], [ 10, 9 ], [ 39, 18 ], [ 36, 21 ], [ 9, 22 ], [ 35, 36 ], [ 38, 39 ] ]

[ "w=input()\ndata='abcdefghijklmnopqrstuvwxyz'\nfor i in range(26):\n if w.count(data[i])%2==0:\n continue\n else:\n print('No')\n exit()\nprint('Yes')", "w=input()", "w", "input()", "input", "data='abcdefghijklmnopqrstuvwxyz'", "data", "'abcdefghijklmnopqrstuvwxyz'", "for i in range(26):\n if w.count(data[i])%2==0:\n continue\n else:\n print('No')\n exit()", "i", "range(26)", "range", "26", "if w.count(data[i])%2==0:\n continue\n else:\n print('No')\n exit()", "w.count(data[i])%2==0", "w.count(data[i])%2", "w.count(data[i])", "w.count", "w", "count", "data[i]", "data", "i", "2", "0", "continue", "print('No')", "print", "'No'", "exit()", "exit", "print('Yes')", "print", "'Yes'", "data='abcdefghijklmnopqrstuvwxyz'", "'abcdefghijklmnopqrstuvwxyz'", "data", "w=input()", "input()", "w" ]

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

[ [ 64, 2 ], [ 67, 8 ], [ 12, 11 ], [ 65, 16 ], [ 68, 19 ], [ 65, 22 ], [ 11, 23 ], [ 73, 26 ], [ 68, 31 ], [ 61, 34 ], [ 38, 37 ], [ 74, 42 ], [ 74, 48 ], [ 37, 49 ], [ 70, 54 ], [ 71, 59 ], [ 62, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ] ]

[ "w1 = str(input())\nw2 = []\nfor i in range(len(w1)):\n w2.append(w1[i])\nfrom collections import Counter\nw = Counter(w2).most_common()\nx = 'Yes'\nfor h in range(len(w)):\n if w[h][1]%2 != 0:\n x = 'No'\n break\nprint(x)", "w1 = str(input())", "w1", "str(input())", "str", "input()", "input", "w2 = []", "w2", "[]", "for i in range(len(w1)):\n w2.append(w1[i])", "i", "range(len(w1))", "range", "len(w1)", "len", "w1", "w2.append(w1[i])", "w2.append", "w2", "append", "w1[i]", "w1", "i", "from collections import Counter", "w = Counter(w2).most_common()", "w", "Counter(w2).most_common()", "(w2).most_common", "(w2)", "Counter", "w2", "most_common", "x = 'Yes'", "x", "'Yes'", "for h in range(len(w)):\n if w[h][1]%2 != 0:\n x = 'No'\n break", "h", "range(len(w))", "range", "len(w)", "len", "w", "if w[h][1]%2 != 0:\n x = 'No'\n break", "w[h][1]%2 != 0", "w[h][1]%2", "w[h][1]", "[h]", "w", "h", "1", "2", "0", "x = 'No'", "x", "'No'", "break", "print(x)", "print", "x", "x = 'Yes'", "'Yes'", "x", "w1 = str(input())", "str(input())", "w1", "w2 = []", "[]", "w2", "x = 'No'", "'No'", "x", "w = Counter(w2).most_common()", "Counter(w2).most_common()", "w" ]

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

[ [ 47, 2 ], [ 50, 6 ], [ 48, 9 ], [ 44, 11 ], [ 15, 14 ], [ 51, 14 ], [ 45, 18 ], [ 48, 22 ], [ 14, 24 ], [ 27, 26 ], [ 45, 26 ], [ 26, 31 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ] ]

[ "w = input()\nx = set(w)\ny = []\nfor i in x:\n y.append(w.count(i))\nfor j in y:\n if j%2 == 0:\n continue\n else:\n print(\"No\")\n exit()\nprint(\"Yes\")", "w = input()", "w", "input()", "input", "x = set(w)", "x", "set(w)", "set", "w", "y = []", "y", "[]", "for i in x:\n y.append(w.count(i))", "i", "x", "y.append(w.count(i))", "y.append", "y", "append", "w.count(i)", "w.count", "w", "count", "i", "for j in y:\n if j%2 == 0:\n continue\n else:\n print(\"No\")\n exit()", "j", "y", "if j%2 == 0:\n continue\n else:\n print(\"No\")\n exit()", "j%2 == 0", "j%2", "j", "2", "0", "continue", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "y = []", "[]", "y", "w = input()", "input()", "w", "x = set(w)", "set(w)", "x" ]

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

[ [ 31, 2 ], [ 34, 6 ], [ 32, 9 ], [ 12, 11 ], [ 35, 11 ], [ 32, 18 ], [ 11, 20 ], [ 31, 32 ], [ 34, 35 ] ]

[ "w=input()\nx=set(w)\nfor i in x:\n if w.count(i)%2!=0:\n print('No')\n break\nelse:\n print('Yes')", "w=input()", "w", "input()", "input", "x=set(w)", "x", "set(w)", "set", "w", "for i in x:\n if w.count(i)%2!=0:\n print('No')\n break\nelse:\n print('Yes')", "i", "x", "if w.count(i)%2!=0:\n print('No')\n break", "w.count(i)%2!=0", "w.count(i)%2", "w.count(i)", "w.count", "w", "count", "i", "2", "0", "print('No')", "print", "'No'", "break", "print('Yes')", "print", "'Yes'", "w=input()", "input()", "w", "x=set(w)", "set(w)", "x" ]

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

[ [ 56, 2 ], [ 53, 6 ], [ 47, 9 ], [ 13, 12 ], [ 44, 18 ], [ 57, 21 ], [ 12, 25 ], [ 45, 29 ], [ 54, 29 ], [ 50, 33 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "s = input()\ncheck = 0\nflag = True\nfor i in range(97,123):\n check =s.count(chr(i))\n if check % 2 == 1 :\n flag = False\nif flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "s = input()", "s", "input()", "input", "check = 0", "check", "0", "flag = True", "flag", "True", "for i in range(97,123):\n check =s.count(chr(i))\n if check % 2 == 1 :\n flag = False", "i", "range(97,123)", "range", "97", "123", "check =s.count(chr(i))", "check", "s.count(chr(i))", "s.count", "s", "count", "chr(i)", "chr", "i", "if check % 2 == 1 :\n flag = False", "check % 2 == 1", "check % 2", "check", "2", "1", "flag = False", "flag", "False", "if flag:\n print(\"Yes\")\nelse:\n print(\"No\")", "flag", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "check =s.count(chr(i))", "s.count(chr(i))", "check", "flag = True", "True", "flag", "flag = False", "False", "flag", "check = 0", "0", "check", "s = input()", "input()", "s" ]

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

[ [ 46, 3 ], [ 52, 9 ], [ 47, 12 ], [ 49, 14 ], [ 18, 17 ], [ 53, 22 ], [ 17, 27 ], [ 43, 31 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "from collections import Counter\nw = list(input())\nc = Counter(w)\nf = True\nfor i in list(c.values()):\n if i % 2 == 1:\n f = False\n break\n\nif f:\n print(\"Yes\")\nelse:\n print(\"No\")", "from collections import Counter", "w = list(input())", "w", "list(input())", "list", "input()", "input", "c = Counter(w)", "c", "Counter(w)", "Counter", "w", "f = True", "f", "True", "for i in list(c.values()):\n if i % 2 == 1:\n f = False\n break", "i", "list(c.values())", "list", "c.values()", "c.values", "c", "values", "if i % 2 == 1:\n f = False\n break", "i % 2 == 1", "i % 2", "i", "2", "1", "f = False", "f", "False", "break", "if f:\n print(\"Yes\")\nelse:\n print(\"No\")", "f", "print(\"Yes\")", "print", "\"Yes\"", "print(\"No\")", "print", "\"No\"", "f = False", "False", "f", "w = list(input())", "list(input())", "w", "f = True", "True", "f", "c = Counter(w)", "Counter(w)", "c" ]

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

[ [ 5, 4 ], [ 9, 8 ], [ 15, 14 ], [ 4, 14 ], [ 26, 17 ], [ 8, 18 ], [ 14, 22 ], [ 29, 28 ], [ 8, 28 ], [ 28, 33 ], [ 51, 48 ] ]

[ "def main():\n w = input()\n lst = [0] * 26\n\n for c in w:\n lst[ord(c) - ord(\"a\")] += 1\n\n for num in lst:\n if num % 2 != 0:\n print(\"No\")\n break\n else:\n print(\"Yes\")\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n w = input()\n lst = [0] * 26\n\n for c in w:\n lst[ord(c) - ord(\"a\")] += 1\n\n for num in lst:\n if num % 2 != 0:\n print(\"No\")\n break\n else:\n print(\"Yes\")", "main", "w = input()", "w", "input()", "input", "lst = [0] * 26", "lst", "[0] * 26", "[0]", "0", "26", "for c in w:\n lst[ord(c) - ord(\"a\")] += 1\n\n ", "c", "w", "lst[ord(c) - ord(\"a\")] += 1", "lst[ord(c) - ord(\"a\")]", "lst", "ord(c) - ord(\"a\")", "ord(c)", "ord", "c", "ord(\"a\")", "ord", "\"a\"", "1", "for num in lst:\n if num % 2 != 0:\n print(\"No\")\n break\n else:\n print(\"Yes\")", "num", "lst", "if num % 2 != 0:\n print(\"No\")\n break\n ", "num % 2 != 0", "num % 2", "num", "2", "0", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n w = input()\n lst = [0] * 26\n\n for c in w:\n lst[ord(c) - ord(\"a\")] += 1\n\n for num in lst:\n if num % 2 != 0:\n print(\"No\")\n break\n else:\n print(\"Yes\")", "def main():\n w = input()\n lst = [0] * 26\n\n for c in w:\n lst[ord(c) - ord(\"a\")] += 1\n\n for num in lst:\n if num % 2 != 0:\n print(\"No\")\n break\n else:\n print(\"Yes\")", "main" ]

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

[ [ 40, 2 ], [ 43, 8 ], [ 15, 14 ], [ 41, 14 ], [ 24, 17 ], [ 44, 18 ], [ 14, 22 ], [ 40, 41 ], [ 43, 44 ] ]

[ "#B - 美しい文字列\nw = list(input())\n\ncount = [0]*26\nfor i in w:\n count[ord(i)-97] += 1\nif all(i%2 == 0 for i in count):\n print('Yes')\nelse:\n print('No')", "w = list(input())", "w", "list(input())", "list", "input()", "input", "count = [0]*26", "count", "[0]*26", "[0]", "0", "26", "for i in w:\n count[ord(i)-97] += 1", "i", "w", "count[ord(i)-97] += 1", "count[ord(i)-97]", "count", "ord(i)-97", "ord(i)", "ord", "i", "97", "1", "if all(i%2 == 0 for i in count):\n print('Yes')\nelse:\n print('No')", "all(i%2 == 0 for i in count)", "all", "i%2 == 0", "i%2", "i", "2", "0", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "w = list(input())", "list(input())", "w", "count = [0]*26", "[0]*26", "count" ]

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

[ [ 48, 4 ], [ 42, 10 ], [ 49, 15 ], [ 45, 17 ], [ 43, 22 ], [ 26, 25 ], [ 46, 25 ], [ 25, 30 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "import collections\nw = list(input())\nc = collections.Counter(w)\ntmp = list(c.values())\nfor i in tmp:\n if i % 2 == 1:\n print(\"No\")\n exit()\nprint(\"Yes\")", "import collections", "collections", "w = list(input())", "w", "list(input())", "list", "input()", "input", "c = collections.Counter(w)", "c", "collections.Counter(w)", "collections.Counter", "collections", "Counter", "w", "tmp = list(c.values())", "tmp", "list(c.values())", "list", "c.values()", "c.values", "c", "values", "for i in tmp:\n if i % 2 == 1:\n print(\"No\")\n exit()", "i", "tmp", "if i % 2 == 1:\n print(\"No\")\n exit()", "i % 2 == 1", "i % 2", "i", "2", "1", "print(\"No\")", "print", "\"No\"", "exit()", "exit", "print(\"Yes\")", "print", "\"Yes\"", "c = collections.Counter(w)", "collections.Counter(w)", "c", "tmp = list(c.values())", "list(c.values())", "tmp", "w = list(input())", "list(input())", "w" ]

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

[ [ 42, 2 ], [ 51, 6 ], [ 43, 9 ], [ 48, 11 ], [ 43, 14 ], [ 17, 16 ], [ 49, 16 ], [ 52, 23 ], [ 16, 25 ], [ 39, 29 ], [ 45, 33 ], [ 46, 37 ], [ 40, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ] ]

[ "w = input()\nwl = list(w)\nws = set(w)\nfor i in ws:\n if wl.count(i) % 2 == 1:\n r = 'No'\n break\n else:\n r = 'Yes'\n \nprint(r)", "w = input()", "w", "input()", "input", "wl = list(w)", "wl", "list(w)", "list", "w", "ws = set(w)", "ws", "set(w)", "set", "w", "for i in ws:\n if wl.count(i) % 2 == 1:\n r = 'No'\n break\n else:\n r = 'Yes'\n ", "i", "ws", "if wl.count(i) % 2 == 1:\n r = 'No'\n break\n else:\n r = 'Yes'\n ", "wl.count(i) % 2 == 1", "wl.count(i) % 2", "wl.count(i)", "wl.count", "wl", "count", "i", "2", "1", "r = 'No'", "r", "'No'", "break", "r = 'Yes'", "r", "'Yes'", "print(r)", "print", "r", "r = 'No'", "'No'", "r", "w = input()", "input()", "w", "r = 'Yes'", "'Yes'", "r", "ws = set(w)", "set(w)", "ws", "wl = list(w)", "list(w)", "wl" ]

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

[ [ 50, 2 ], [ 53, 6 ], [ 13, 12 ], [ 51, 17 ], [ 28, 19 ], [ 54, 20 ], [ 51, 25 ], [ 12, 26 ], [ 31, 30 ], [ 54, 38 ], [ 30, 39 ], [ 50, 51 ], [ 53, 54 ] ]

[ "w=input()\nl=[0]*26\nfor i in range(len(w)):\n l[ord(w[i])-97]+=1\nfor j in range(26):\n if l[j]%2==1:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "w=input()", "w", "input()", "input", "l=[0]*26", "l", "[0]*26", "[0]", "0", "26", "for i in range(len(w)):\n l[ord(w[i])-97]+=1", "i", "range(len(w))", "range", "len(w)", "len", "w", "l[ord(w[i])-97]+=1", "l[ord(w[i])-97]", "l", "ord(w[i])-97", "ord(w[i])", "ord", "w[i]", "w", "i", "97", "1", "for j in range(26):\n if l[j]%2==1:\n print(\"No\")\n break\nelse:\n print(\"Yes\")", "j", "range(26)", "range", "26", "if l[j]%2==1:\n print(\"No\")\n break", "l[j]%2==1", "l[j]%2", "l[j]", "l", "j", "2", "1", "print(\"No\")", "print", "\"No\"", "break", "print(\"Yes\")", "print", "\"Yes\"", "w=input()", "input()", "w", "l=[0]*26", "[0]*26", "l" ]

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

[ [ 49, 2 ], [ 46, 6 ], [ 50, 11 ], [ 43, 13 ], [ 17, 16 ], [ 47, 16 ], [ 52, 19 ], [ 50, 22 ], [ 16, 26 ], [ 53, 30 ], [ 40, 34 ], [ 41, 38 ], [ 44, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "S = input()\ns = list(set(S))\n\nans = \"Yes\"\n\nfor i in s:\n num = S.count(str(i))\n if num % 2 == 1:\n ans = \"No\"\n\nprint(ans)", "S = input()", "S", "input()", "input", "s = list(set(S))", "s", "list(set(S))", "list", "set(S)", "set", "S", "ans = \"Yes\"", "ans", "\"Yes\"", "for i in s:\n num = S.count(str(i))\n if num % 2 == 1:\n ans = \"No\"", "i", "s", "num = S.count(str(i))", "num", "S.count(str(i))", "S.count", "S", "count", "str(i)", "str", "i", "if num % 2 == 1:\n ans = \"No\"", "num % 2 == 1", "num % 2", "num", "2", "1", "ans = \"No\"", "ans", "\"No\"", "print(ans)", "print", "ans", "ans = \"No\"", "\"No\"", "ans", "ans = \"Yes\"", "\"Yes\"", "ans", "s = list(set(S))", "list(set(S))", "s", "S = input()", "input()", "S", "num = S.count(str(i))", "S.count(str(i))", "num" ]

[ 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, 41, 28, 13, 13, 4, 2, 13, 13, 0, 13, 13, 4, 18, 13, 13, 13, 0, 13, 2, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 2, 17, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 17, 13, 17, 14, 2, 2, 13, 17, 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, 17, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 17, 14, 2, 2, 2, 13, 17, 40, 2, 13, 18, 13, 2, 13, 17, 17, 40, 2, 13, 18, 13, 2, 13, 17, 2, 17, 13, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 18, 13, 2, 13, 17, 2, 13, 17, 18, 18, 13, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 4, 13, 2, 18, 18, 13, 13, 13, 17, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 219, 4 ], [ 219, 13 ], [ 204, 15 ], [ 29, 28 ], [ 205, 28 ], [ 28, 32 ], [ 214, 33 ], [ 207, 35 ], [ 205, 39 ], [ 214, 41 ], [ 210, 43 ], [ 205, 47 ], [ 220, 48 ], [ 52, 51 ], [ 211, 57 ], [ 216, 62 ], [ 66, 65 ], [ 220, 69 ], [ 73, 72 ], [ 211, 78 ], [ 65, 83 ], [ 72, 86 ], [ 211, 87 ], [ 94, 89 ], [ 217, 91 ], [ 72, 92 ], [ 65, 93 ], [ 65, 98 ], [ 72, 103 ], [ 208, 105 ], [ 65, 107 ], [ 72, 112 ], [ 208, 114 ], [ 65, 116 ], [ 211, 120 ], [ 127, 122 ], [ 217, 124 ], [ 72, 125 ], [ 65, 126 ], [ 217, 129 ], [ 72, 130 ], [ 65, 132 ], [ 65, 138 ], [ 72, 142 ], [ 208, 144 ], [ 65, 146 ], [ 72, 151 ], [ 208, 153 ], [ 65, 155 ], [ 211, 159 ], [ 166, 161 ], [ 217, 163 ], [ 72, 164 ], [ 65, 165 ], [ 217, 169 ], [ 72, 171 ], [ 208, 173 ], [ 65, 175 ], [ 65, 178 ], [ 217, 182 ], [ 72, 183 ], [ 65, 185 ], [ 193, 188 ], [ 217, 190 ], [ 72, 191 ], [ 65, 192 ], [ 217, 199 ], [ 211, 200 ], [ 220, 201 ], [ 204, 205 ], [ 207, 208 ], [ 210, 211 ], [ 219, 214 ], [ 216, 217 ], [ 219, 220 ] ]

[ "import sys\n\nn,a=map(int, input().split())\ncards=list(map(int, input().split()))\n\nintegers=[x-a for x in cards]\ncards.append(a)\nf=max(cards)*n\n\n\ndp=[[0 for i in range(n+1)] for j in range(2*f+1) ]\n\nfor y in range(n+1):\n for x in range(2*f+1):\n if y==0 and x==f:\n dp[x][y]=1\n elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):\n dp[x][y]=dp[x][y-1]\n elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:\n dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]\n else:\n dp[x][y]=0\nprint(dp[f][n]-1)\n", "import sys", "sys", "n,a=map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "cards=list(map(int, input().split()))", "cards", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x-a for x in cards", "for x in cards", "x", "cards", "for x in cards", "x-a", "x", "a", "integers=[x-a for x in cards]", "integers", "[x-a for x in cards]", "cards.append(a)", "cards.append", "cards", "append", "a", "f=max(cards)*n", "f", "max(cards)*n", "max(cards)", "max", "cards", "n", "[0 for i in range(n+1)] for j in range(2*f+1)", "for j in range(2*f+1)", "j", "range(2*f+1)", "range", "2*f+1", "2*f", "2", "f", "1", "for j in range(2*f+1)", "[0 for i in range(n+1)]", "dp=[[0 for i in range(n+1)] for j in range(2*f+1) ]", "dp", "[[0 for i in range(n+1)] for j in range(2*f+1) ]", "for y in range(n+1):\n for x in range(2*f+1):\n if y==0 and x==f:\n dp[x][y]=1\n elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):\n dp[x][y]=dp[x][y-1]\n elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:\n dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]\n else:\n dp[x][y]=0", "y", "range(n+1)", "range", "n+1", "n", "1", "for x in range(2*f+1):\n if y==0 and x==f:\n dp[x][y]=1\n elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):\n dp[x][y]=dp[x][y-1]\n elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:\n dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]\n else:\n dp[x][y]=0", "x", "range(2*f+1)", "range", "2*f+1", "2*f", "2", "f", "1", "if y==0 and x==f:\n dp[x][y]=1\n elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):\n dp[x][y]=dp[x][y-1]\n elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:\n dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]\n else:\n dp[x][y]=0", "y==0 and x==f", "y==0", "y", "0", "x==f", "x", "f", "dp[x][y]=1", "dp[x][y]", "[x]", "dp", "x", "y", "1", "elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):\n dp[x][y]=dp[x][y-1]\n ", "y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f)", "y>0", "y", "0", "x-integers[y-1]<0 or x-integers[y-1]>2*f", "x-integers[y-1]<0", "x-integers[y-1]", "x", "integers[y-1]", "integers", "y-1", "y", "1", "0", "x-integers[y-1]>2*f", "x-integers[y-1]", "x", "integers[y-1]", "integers", "y-1", "y", "1", "2*f", "2", "f", "dp[x][y]=dp[x][y-1]", "dp[x][y]", "[x]", "dp", "x", "y", "dp[x][y-1]", "[x]", "dp", "x", "y-1", "y", "1", "elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:\n dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]\n ", "y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f", "y>0 and x-integers[y-1]>=0", "y>0", "y", "0", "x-integers[y-1]>=0", "x-integers[y-1]", "x", "integers[y-1]", "integers", "y-1", "y", "1", "0", "x-integers[y-1]<=2*f", "x-integers[y-1]", "x", "integers[y-1]", "integers", "y-1", "y", "1", "2*f", "2", "f", "dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]", "dp[x][y]", "[x]", "dp", "x", "y", "dp[x-integers[y-1]][y-1]+dp[x][y-1]", "dp[x-integers[y-1]][y-1]", "[x-integers[y-1]]", "dp", "x-integers[y-1]", "x", "integers[y-1]", "integers", "y-1", "y", "1", "y-1", "y", "1", "dp[x][y-1]", "[x]", "dp", "x", "y-1", "y", "1", "dp[x][y]=0", "dp[x][y]", "[x]", "dp", "x", "y", "0", "print(dp[f][n]-1)", "print", "dp[f][n]-1", "dp[f][n]", "[f]", "dp", "f", "n", "1", "cards=list(map(int, input().split()))", "list(map(int, input().split()))", "cards", "integers=[x-a for x in cards]", "[x-a for x in cards]", "integers", "f=max(cards)*n", "max(cards)*n", "f", "a=map(int, input().split())", "map(int, input().split())", "a", "dp=[[0 for i in range(n+1)] for j in range(2*f+1) ]", "[[0 for i in range(n+1)] for j in range(2*f+1) ]", "dp", "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, 13, 4, 2, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 2, 2, 39, 17, 17, 13, 17, 0, 13, 13, 0, 18, 18, 13, 17, 2, 17, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 17, 13, 17, 0, 13, 2, 13, 18, 13, 2, 13, 17, 14, 2, 40, 13, 17, 2, 13, 2, 2, 17, 13, 17, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 13, 18, 18, 13, 2, 13, 17, 13, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 4, 13, 2, 18, 18, 13, 13, 2, 17, 13, 17, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 154, 2 ], [ 154, 11 ], [ 157, 13 ], [ 27, 26 ], [ 158, 26 ], [ 26, 30 ], [ 155, 31 ], [ 163, 33 ], [ 38, 37 ], [ 149, 41 ], [ 149, 50 ], [ 160, 53 ], [ 63, 56 ], [ 161, 58 ], [ 149, 62 ], [ 66, 65 ], [ 149, 70 ], [ 74, 73 ], [ 149, 79 ], [ 151, 82 ], [ 73, 84 ], [ 164, 86 ], [ 158, 86 ], [ 65, 88 ], [ 152, 93 ], [ 152, 96 ], [ 149, 100 ], [ 108, 103 ], [ 161, 105 ], [ 65, 106 ], [ 73, 107 ], [ 161, 111 ], [ 65, 113 ], [ 73, 115 ], [ 161, 118 ], [ 65, 120 ], [ 152, 122 ], [ 129, 124 ], [ 161, 126 ], [ 65, 127 ], [ 73, 128 ], [ 161, 131 ], [ 65, 133 ], [ 73, 135 ], [ 161, 141 ], [ 149, 142 ], [ 149, 145 ], [ 154, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ], [ 163, 164 ] ]

[ "N,A=map(int,input().split())\nx=list(map(int,input().split()))\nx=[i-A for i in x]\ndp=[[0]*50*N*2 for i in range(N+1)]\ndp[0][50*N]=1\nfor i in range(1,N+1):\n for j in range(50*N*2):\n n=j-x[i-1]\n if n>=0 and n<50*N*2:\n dp[i][j]=dp[i-1][j]+dp[i-1][n]\n else:\n dp[i][j]=dp[i-1][j]\n #else:\n #print(dp[i])\n\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", "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]", "[0]*50*N*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*N*2", "[0]*50*N", "[0]*50", "[0]", "0", "50", "N", "2", "dp=[[0]*50*N*2 for i in range(N+1)]", "dp", "[[0]*50*N*2 for i 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(1,N+1):\n for j in range(50*N*2):\n n=j-x[i-1]\n if n>=0 and n<50*N*2:\n dp[i][j]=dp[i-1][j]+dp[i-1][n]\n else:\n dp[i][j]=dp[i-1][j]\n #else:\n #print(dp[i])", "i", "range(1,N+1)", "range", "1", "N+1", "N", "1", "for j in range(50*N*2):\n n=j-x[i-1]\n if n>=0 and n<50*N*2:\n dp[i][j]=dp[i-1][j]+dp[i-1][n]\n else:\n dp[i][j]=dp[i-1][j]\n #else:\n #print(dp[i])", "j", "range(50*N*2)", "range", "50*N*2", "50*N", "50", "N", "2", "n=j-x[i-1]", "n", "j-x[i-1]", "j", "x[i-1]", "x", "i-1", "i", "1", "if n>=0 and n<50*N*2:\n dp[i][j]=dp[i-1][j]+dp[i-1][n]\n else:\n dp[i][j]=dp[i-1][j]\n #else:\n #print(dp[i])", "n>=0 and n<50*N*2", "n>=0", "n", "0", "n<50*N*2", "n", "50*N*2", "50*N", "50", "N", "2", "dp[i][j]=dp[i-1][j]+dp[i-1][n]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j]+dp[i-1][n]", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "dp[i-1][n]", "[i-1]", "dp", "i-1", "i", "1", "n", "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][50*N]-1)", "print", "dp[N][50*N]-1", "dp[N][50*N]", "[N]", "dp", "N", "50*N", "50", "N", "1", "N,A=map(int,input().split())", "map(int,input().split())", "N", "n=j-x[i-1]", "j-x[i-1]", "n", "A=map(int,input().split())", "map(int,input().split())", "A", "x=list(map(int,input().split()))", "list(map(int,input().split()))", "x", "dp=[[0]*50*N*2 for i in range(N+1)]", "[[0]*50*N*2 for i in range(N+1)]", "dp", "x=[i-A for i in x]", "[i-A for i in x]", "x" ]

[ 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, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 0, 13, 4, 13, 13, 28, 13, 13, 4, 18, 13, 13, 28, 13, 13, 4, 18, 13, 13, 14, 2, 13, 18, 13, 13, 0, 18, 18, 13, 13, 13, 13, 0, 18, 18, 13, 13, 13, 13, 14, 2, 2, 13, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 18, 13, 13, 0, 13, 18, 18, 13, 13, 2, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 161, 3 ], [ 161, 12 ], [ 149, 14 ], [ 155, 26 ], [ 36, 31 ], [ 156, 33 ], [ 39, 38 ], [ 150, 38 ], [ 164, 41 ], [ 156, 50 ], [ 147, 50 ], [ 165, 63 ], [ 71, 66 ], [ 165, 68 ], [ 78, 73 ], [ 165, 75 ], [ 38, 83 ], [ 165, 85 ], [ 99, 90 ], [ 165, 92 ], [ 38, 98 ], [ 110, 101 ], [ 165, 103 ], [ 38, 109 ], [ 146, 112 ], [ 165, 113 ], [ 167, 115 ], [ 119, 118 ], [ 153, 123 ], [ 162, 128 ], [ 118, 129 ], [ 147, 131 ], [ 156, 131 ], [ 118, 132 ], [ 158, 134 ], [ 147, 137 ], [ 156, 137 ], [ 118, 138 ], [ 162, 140 ], [ 118, 141 ], [ 159, 144 ], [ 168, 144 ], [ 165, 146 ], [ 146, 147 ], [ 149, 150 ], [ 161, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ] ]

[ "from collections import defaultdict\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\n\ndp = defaultdict(dict)\ndp[0][0] = 1 # カード0枚で合計\n\nfor x in X:\n newDP = defaultdict(dict)\n for card, memo in dp.items():\n for k, v in memo.items():\n # カードXを追加しない\n if k in newDP[card]:\n newDP[card][k] += v\n else:\n newDP[card][k] = v\n # カードXを追加するよ\n if k + x in newDP[card + 1]:\n newDP[card + 1][k + x] += v\n else:\n newDP[card + 1][k + x] = v\n dp = newDP\n\nans = 0\nfor i in range(1, N + 1):\n if A * i in dp[i]:\n ans += dp[i][A * i]\nprint(ans)", "from collections import defaultdict", "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 = defaultdict(dict)", "dp", "defaultdict(dict)", "defaultdict", "dict", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for x in X:\n newDP = defaultdict(dict)\n for card, memo in dp.items():\n for k, v in memo.items():\n # カードXを追加しない\n if k in newDP[card]:\n newDP[card][k] += v\n else:\n newDP[card][k] = v\n # カードXを追加するよ\n if k + x in newDP[card + 1]:\n newDP[card + 1][k + x] += v\n else:\n newDP[card + 1][k + x] = v\n dp = newDP", "x", "X", "newDP = defaultdict(dict)", "newDP", "defaultdict(dict)", "defaultdict", "dict", "for card, memo in dp.items():\n for k, v in memo.items():\n # カードXを追加しない\n if k in newDP[card]:\n newDP[card][k] += v\n else:\n newDP[card][k] = v\n # カードXを追加するよ\n if k + x in newDP[card + 1]:\n newDP[card + 1][k + x] += v\n else:\n newDP[card + 1][k + x] = v\n ", "card", "memo", "dp.items()", "dp.items", "dp", "items", "for k, v in memo.items():\n # カードXを追加しない\n if k in newDP[card]:\n newDP[card][k] += v\n else:\n newDP[card][k] = v\n # カードXを追加するよ\n if k + x in newDP[card + 1]:\n newDP[card + 1][k + x] += v\n else:\n newDP[card + 1][k + x] = v\n ", "k", "v", "memo.items()", "memo.items", "memo", "items", "if k in newDP[card]:\n newDP[card][k] += v\n else:\n newDP[card][k] = v\n # カードXを追加するよ\n ", "k in newDP[card]", "k", "newDP[card]", "newDP", "card", "newDP[card][k] += v", "newDP[card][k]", "[card]", "newDP", "card", "k", "v", "newDP[card][k] = v", "newDP[card][k]", "[card]", "newDP", "card", "k", "v", "if k + x in newDP[card + 1]:\n newDP[card + 1][k + x] += v\n else:\n newDP[card + 1][k + x] = v\n ", "k + x in newDP[card + 1]", "k + x", "k", "x", "newDP[card + 1]", "newDP", "card + 1", "card", "1", "newDP[card + 1][k + x] += v", "newDP[card + 1][k + x]", "[card + 1]", "newDP", "card + 1", "card", "1", "k + x", "k", "x", "v", "newDP[card + 1][k + x] = v", "newDP[card + 1][k + x]", "[card + 1]", "newDP", "card + 1", "card", "1", "k + x", "k", "x", "v", "dp = newDP", "dp", "newDP", "ans = 0", "ans", "0", "for i in range(1, N + 1):\n if A * i in dp[i]:\n ans += dp[i][A * i]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "if A * i in dp[i]:\n ans += dp[i][A * i]", "A * i in dp[i]", "A * i", "A", "i", "dp[i]", "dp", "i", "ans += dp[i][A * i]", "ans", "dp[i][A * i]", "[i]", "dp", "i", "A * i", "A", "i", "print(ans)", "print", "ans", "dp = newDP", "newDP", "dp", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "N, A = map(int, input().split())", "map(int, input().split())", "N", "dp = defaultdict(dict)", "defaultdict(dict)", "dp", "ans += dp[i][A * i]", "dp[i][A * i]", "ans", "A = map(int, input().split())", "map(int, input().split())", "A", "newDP = defaultdict(dict)", "defaultdict(dict)", "newDP", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 12, 13, 0, 13, 2, 2, 4, 13, 13, 4, 13, 13, 13, 17, 0, 13, 4, 18, 13, 13, 0, 13, 39, 2, 13, 17, 2, 13, 17, 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, 0, 18, 18, 18, 13, 13, 13, 39, 17, 18, 13, 2, 13, 17, 18, 18, 18, 13, 2, 13, 17, 13, 39, 17, 18, 13, 2, 13, 17, 14, 40, 13, 17, 0, 18, 18, 18, 13, 13, 13, 39, 18, 13, 2, 13, 17, 2, 18, 18, 18, 13, 2, 13, 17, 13, 39, 18, 13, 2, 13, 17, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 39, 2, 13, 18, 13, 2, 13, 17, 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, 29, 13, 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, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 7, 6 ], [ 169, 11 ], [ 171, 14 ], [ 167, 15 ], [ 19, 18 ], [ 25, 24 ], [ 167, 27 ], [ 167, 30 ], [ 35, 34 ], [ 44, 37 ], [ 18, 40 ], [ 47, 46 ], [ 167, 51 ], [ 55, 54 ], [ 46, 58 ], [ 74, 61 ], [ 18, 64 ], [ 46, 65 ], [ 54, 66 ], [ 171, 70 ], [ 46, 72 ], [ 18, 77 ], [ 46, 79 ], [ 54, 81 ], [ 171, 85 ], [ 46, 87 ], [ 54, 91 ], [ 106, 94 ], [ 18, 97 ], [ 46, 98 ], [ 54, 99 ], [ 171, 102 ], [ 46, 104 ], [ 18, 110 ], [ 46, 112 ], [ 54, 114 ], [ 171, 117 ], [ 46, 119 ], [ 18, 124 ], [ 46, 126 ], [ 54, 129 ], [ 6, 133 ], [ 171, 135 ], [ 46, 137 ], [ 141, 140 ], [ 144, 143 ], [ 167, 148 ], [ 152, 151 ], [ 143, 153 ], [ 169, 154 ], [ 157, 156 ], [ 18, 160 ], [ 167, 161 ], [ 143, 162 ], [ 151, 163 ], [ 156, 165 ], [ 140, 165 ], [ 167, 167 ], [ 169, 169 ], [ 171, 171 ], [ 216, 177 ], [ 216, 186 ], [ 213, 188 ], [ 208, 202 ], [ 217, 203 ], [ 211, 204 ], [ 214, 205 ], [ 216, 211 ], [ 213, 214 ], [ 216, 217 ] ]

[ "import numpy as np\n\n\ndef main(n, a, x):\n SUM_MAX = max(a, max(x)) * n + 1\n dp = np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)\n\n dp[0][0][0] = 1\n for j in range(1, n + 1):\n for k in range(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n patterns = 0\n for k in range(1, n + 1):\n ka = k * a\n patterns += dp[n][k][ka]\n return patterns\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 SUM_MAX = max(a, max(x)) * n + 1\n dp = np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)\n\n dp[0][0][0] = 1\n for j in range(1, n + 1):\n for k in range(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n patterns = 0\n for k in range(1, n + 1):\n ka = k * a\n patterns += dp[n][k][ka]\n return patterns", "main", "SUM_MAX = max(a, max(x)) * n + 1", "SUM_MAX", "max(a, max(x)) * n + 1", "max(a, max(x)) * n", "max(a, max(x))", "max", "a", "max(x)", "max", "x", "n", "1", "dp = np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)", "dp", "np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)", "np.zeros", "np", "zeros", "shape=(n + 1, n + 1, SUM_MAX)", "shape", "(n + 1, n + 1, SUM_MAX)", "n + 1", "n", "1", "n + 1", "n", "1", "SUM_MAX", "dtype=int", "dtype", "int", "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(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n ", "j", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "for k in range(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n ", "k", "range(j + 1)", "range", "j + 1", "j", "1", "dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]", "dp[j][k][0:x[j - 1]]", "[k]", "[j]", "dp", "j", "k", "0:x[j - 1]", "0", "x[j - 1]", "x", "j - 1", "j", "1", "dp[j - 1][k][0:x[j - 1]]", "[k]", "[j - 1]", "dp", "j - 1", "j", "1", "k", "0:x[j - 1]", "0", "x[j - 1]", "x", "j - 1", "j", "1", "if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n ", "k >= 1", "k", "1", "dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]", "dp[j][k][x[j - 1]:]", "[k]", "[j]", "dp", "j", "k", "x[j - 1]:", "x[j - 1]", "x", "j - 1", "j", "1", "dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]", "dp[j - 1][k][x[j - 1]:]", "[k]", "[j - 1]", "dp", "j - 1", "j", "1", "k", "x[j - 1]:", "x[j - 1]", "x", "j - 1", "j", "1", "dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]", "[k - 1]", "[j - 1]", "dp", "j - 1", "j", "1", "k - 1", "k", "1", ":SUM_MAX - x[j - 1]", "SUM_MAX - x[j - 1]", "SUM_MAX", "x[j - 1]", "x", "j - 1", "j", "1", "patterns = 0", "patterns", "0", "for k in range(1, n + 1):\n ka = k * a\n patterns += dp[n][k][ka]\n ", "k", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "ka = k * a", "ka", "k * a", "k", "a", "patterns += dp[n][k][ka]", "patterns", "dp[n][k][ka]", "[k]", "[n]", "dp", "n", "k", "ka", "return patterns", "patterns", "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", "def main(n, a, x):\n SUM_MAX = max(a, max(x)) * n + 1\n dp = np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)\n\n dp[0][0][0] = 1\n for j in range(1, n + 1):\n for k in range(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n patterns = 0\n for k in range(1, n + 1):\n ka = k * a\n patterns += dp[n][k][ka]\n return patterns", "def main(n, a, x):\n SUM_MAX = max(a, max(x)) * n + 1\n dp = np.zeros(shape=(n + 1, n + 1, SUM_MAX), dtype=int)\n\n dp[0][0][0] = 1\n for j in range(1, n + 1):\n for k in range(j + 1):\n dp[j][k][0:x[j - 1]] = dp[j - 1][k][0:x[j - 1]]\n if k >= 1:\n dp[j][k][x[j - 1]:] = dp[j - 1][k][x[j - 1]:] + dp[j - 1][k - 1][:SUM_MAX - x[j - 1]]\n\n patterns = 0\n for k in range(1, n + 1):\n ka = k * a\n patterns += dp[n][k][ka]\n return patterns", "main", "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" ]

[ 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, 4, 13, 4, 13, 13, 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, 2, 2, 17, 13, 13, 17, 14, 2, 2, 13, 17, 2, 13, 2, 13, 13, 0, 18, 18, 13, 13, 13, 17, 14, 2, 40, 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, 40, 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, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 210, 2 ], [ 210, 11 ], [ 198, 13 ], [ 27, 26 ], [ 199, 26 ], [ 26, 30 ], [ 208, 31 ], [ 213, 33 ], [ 201, 36 ], [ 199, 41 ], [ 208, 42 ], [ 46, 45 ], [ 211, 49 ], [ 204, 54 ], [ 58, 57 ], [ 211, 61 ], [ 65, 64 ], [ 211, 71 ], [ 202, 72 ], [ 57, 77 ], [ 64, 80 ], [ 211, 82 ], [ 202, 83 ], [ 90, 85 ], [ 205, 87 ], [ 57, 88 ], [ 64, 89 ], [ 57, 94 ], [ 64, 99 ], [ 214, 101 ], [ 57, 103 ], [ 64, 108 ], [ 214, 110 ], [ 57, 112 ], [ 211, 117 ], [ 202, 118 ], [ 125, 120 ], [ 205, 122 ], [ 57, 123 ], [ 64, 124 ], [ 205, 127 ], [ 57, 129 ], [ 64, 131 ], [ 57, 135 ], [ 64, 141 ], [ 214, 143 ], [ 57, 145 ], [ 211, 150 ], [ 202, 151 ], [ 158, 153 ], [ 205, 155 ], [ 57, 156 ], [ 64, 157 ], [ 205, 161 ], [ 57, 163 ], [ 64, 165 ], [ 205, 168 ], [ 57, 170 ], [ 64, 173 ], [ 214, 175 ], [ 57, 177 ], [ 185, 180 ], [ 205, 182 ], [ 57, 183 ], [ 64, 184 ], [ 205, 191 ], [ 211, 192 ], [ 211, 194 ], [ 202, 195 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 210, 208 ], [ 210, 211 ], [ 213, 214 ] ]

[ "N, A = map(int, input().split())\nX = list(map(int, input().split()))\nY = [x - A for x in X]\nLMT = max(max(X), A)\n\ndp = [[0 for _ in range(2 * N * LMT + 1)] for _ in range(N + 1)]\n \nfor j in range(N + 1) :\n for t in range(2 * N * LMT + 1):\n if j == 0 and t == N * LMT:\n dp[j][t] = 1\n elif j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT):\n dp[j][t] = dp[j - 1][t]\n elif j >= 1 and (0 <= t - Y[j - 1] <= 2 * N * LMT):\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - Y[j - 1]]\n else:\n dp[j][t] = 0\nprint(dp[N][N*LMT]-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 - A for x in X", "for x in X", "x", "X", "for x in X", "x - A", "x", "A", "Y = [x - A for x in X]", "Y", "[x - A for x in X]", "LMT = max(max(X), A)", "LMT", "max(max(X), A)", "max", "max(X)", "max", "X", "A", "[0 for _ in range(2 * N * LMT + 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 * LMT + 1)]", "dp = [[0 for _ in range(2 * N * LMT + 1)] for _ in range(N + 1)]", "dp", "[[0 for _ in range(2 * N * LMT + 1)] for _ in range(N + 1)]", "for j in range(N + 1) :\n for t in range(2 * N * LMT + 1):\n if j == 0 and t == N * LMT:\n dp[j][t] = 1\n elif j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT):\n dp[j][t] = dp[j - 1][t]\n elif j >= 1 and (0 <= t - Y[j - 1] <= 2 * N * LMT):\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - Y[j - 1]]\n else:\n dp[j][t] = 0", "j", "range(N + 1)", "range", "N + 1", "N", "1", "for t in range(2 * N * LMT + 1):\n if j == 0 and t == N * LMT:\n dp[j][t] = 1\n elif j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT):\n dp[j][t] = dp[j - 1][t]\n elif j >= 1 and (0 <= t - Y[j - 1] <= 2 * N * LMT):\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - Y[j - 1]]\n else:\n dp[j][t] = 0", "t", "range(2 * N * LMT + 1)", "range", "2 * N * LMT + 1", "2 * N * LMT", "2 * N", "2", "N", "LMT", "1", "if j == 0 and t == N * LMT:\n dp[j][t] = 1\n elif j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT):\n dp[j][t] = dp[j - 1][t]\n elif j >= 1 and (0 <= t - Y[j - 1] <= 2 * N * LMT):\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - Y[j - 1]]\n else:\n dp[j][t] = 0", "j == 0 and t == N * LMT", "j == 0", "j", "0", "t == N * LMT", "t", "N * LMT", "N", "LMT", "dp[j][t] = 1", "dp[j][t]", "[j]", "dp", "j", "t", "1", "elif j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT):\n dp[j][t] = dp[j - 1][t]\n ", "j >= 1 and (t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT)", "j >= 1", "j", "1", "t - Y[j - 1] < 0 or t - Y[j - 1] > 2 * N * LMT", "t - Y[j - 1] < 0", "t - Y[j - 1]", "t", "Y[j - 1]", "Y", "j - 1", "j", "1", "0", "t - Y[j - 1] > 2 * N * LMT", "t - Y[j - 1]", "t", "Y[j - 1]", "Y", "j - 1", "j", "1", "2 * N * LMT", "2 * N", "2", "N", "LMT", "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 (0 <= t - Y[j - 1] <= 2 * N * LMT):\n dp[j][t] = dp[j - 1][t] + dp[j - 1][t - Y[j - 1]]\n ", "j >= 1 and (0 <= t - Y[j - 1] <= 2 * N * LMT)", "j >= 1", "j", "1", "0 <= t - Y[j - 1] <= 2 * N * LMT", "0 <= t - Y[j - 1]", "0", "t - Y[j - 1]", "t", "Y[j - 1]", "Y", "j - 1", "j", "1", "2 * N * LMT", "2 * N", "2", "N", "LMT", "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][N*LMT]-1)", "print", "dp[N][N*LMT]-1", "dp[N][N*LMT]", "[N]", "dp", "N", "N*LMT", "N", "LMT", "1", "X = list(map(int, input().split()))", "list(map(int, input().split()))", "X", "LMT = max(max(X), A)", "max(max(X), A)", "LMT", "dp = [[0 for _ in range(2 * N * LMT + 1)] for _ in range(N + 1)]", "[[0 for _ in range(2 * N * LMT + 1)] for _ 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", "Y = [x - A for x in X]", "[x - A for x in X]", "Y" ]

[ 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, 17, 2, 13, 17, 28, 13, 4, 13, 17, 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, 18, 13, 2, 13, 17, 17, 0, 18, 18, 18, 13, 13, 2, 13, 18, 13, 2, 13, 17, 2, 13, 17, 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, 17, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 163, 2 ], [ 163, 11 ], [ 145, 13 ], [ 27, 26 ], [ 161, 30 ], [ 151, 35 ], [ 45, 38 ], [ 152, 41 ], [ 48, 47 ], [ 161, 52 ], [ 56, 55 ], [ 61, 60 ], [ 47, 63 ], [ 72, 65 ], [ 152, 68 ], [ 47, 69 ], [ 55, 70 ], [ 60, 71 ], [ 152, 75 ], [ 47, 77 ], [ 55, 79 ], [ 60, 80 ], [ 55, 84 ], [ 146, 86 ], [ 47, 88 ], [ 107, 92 ], [ 152, 95 ], [ 47, 96 ], [ 55, 98 ], [ 146, 100 ], [ 47, 102 ], [ 60, 105 ], [ 152, 110 ], [ 47, 112 ], [ 55, 114 ], [ 60, 115 ], [ 154, 117 ], [ 121, 120 ], [ 161, 125 ], [ 157, 128 ], [ 120, 130 ], [ 164, 131 ], [ 148, 133 ], [ 152, 137 ], [ 158, 139 ], [ 120, 140 ], [ 149, 143 ], [ 155, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 163, 161 ], [ 163, 164 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\ndp = [[[0] * (n + 1) for _ in range(2501)] for _ in range(n + 1)]\n\ndp[0][0][0] = 1\nfor i in range(1, n+1):\n for s in range(2501):\n for k in range(i):\n # no use\n dp[i][s][k] += dp[i-1][s][k]\n\n # use\n if s + x[i-1] <= 2500:\n dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]\n\nans = 0\nfor k in range(1, n + 1):\n target = k * a\n ans += dp[-1][target][k]\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] * (n + 1) for _ in range(2501)] 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(2501)]", "dp = [[[0] * (n + 1) for _ in range(2501)] for _ in range(n + 1)]", "dp", "[[[0] * (n + 1) for _ in range(2501)] 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 s in range(2501):\n for k in range(i):\n # no use\n dp[i][s][k] += dp[i-1][s][k]\n\n # use\n if s + x[i-1] <= 2500:\n dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "for s in range(2501):\n for k in range(i):\n # no use\n dp[i][s][k] += dp[i-1][s][k]\n\n # use\n if s + x[i-1] <= 2500:\n dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]", "s", "range(2501)", "range", "2501", "for k in range(i):\n # no use\n dp[i][s][k] += dp[i-1][s][k]\n\n # use\n if s + x[i-1] <= 2500:\n dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]", "k", "range(i)", "range", "i", "dp[i][s][k] += dp[i-1][s][k]", "dp[i][s][k]", "[s]", "[i]", "dp", "i", "s", "k", "dp[i-1][s][k]", "[s]", "[i-1]", "dp", "i-1", "i", "1", "s", "k", "if s + x[i-1] <= 2500:\n dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]", "s + x[i-1] <= 2500", "s + x[i-1]", "s", "x[i-1]", "x", "i-1", "i", "1", "2500", "dp[i][s + x[i-1]][k+1] += dp[i-1][s][k]", "dp[i][s + x[i-1]][k+1]", "[s + x[i-1]]", "[i]", "dp", "i", "s + x[i-1]", "s", "x[i-1]", "x", "i-1", "i", "1", "k+1", "k", "1", "dp[i-1][s][k]", "[s]", "[i-1]", "dp", "i-1", "i", "1", "s", "k", "ans = 0", "ans", "0", "for k in range(1, n + 1):\n target = k * a\n ans += dp[-1][target][k]", "k", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "target = k * a", "target", "k * a", "k", "a", "ans += dp[-1][target][k]", "ans", "dp[-1][target][k]", "[target]", "[-1]", "dp", "-1", "target", "k", "print(ans)", "print", "ans", "x = list(map(int, input().split()))", "list(map(int, input().split()))", "x", "ans += dp[-1][target][k]", "dp[-1][target][k]", "ans", "dp = [[[0] * (n + 1) for _ in range(2501)] for _ in range(n + 1)]", "[[[0] * (n + 1) for _ in range(2501)] for _ in range(n + 1)]", "dp", "ans = 0", "0", "ans", "target = k * a", "k * a", "target", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 29, 13, 23, 13, 12, 13, 29, 4, 18, 4, 18, 18, 13, 13, 13, 13, 12, 13, 29, 4, 18, 13, 13, 13, 13, 23, 13, 23, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 18, 13, 13, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 39, 42, 2, 4, 13, 13, 13, 0, 13, 4, 18, 13, 13, 13, 13, 14, 40, 2, 13, 13, 4, 18, 13, 13, 13, 29, 4, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 39, 42, 2, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 17, 14, 40, 2, 13, 13, 4, 18, 13, 13, 13, 29, 4, 13, 13, 23, 13, 23, 13, 23, 13, 15, 15, 15, 15, 13, 15, 13, 15, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 15, 13, 4, 18, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 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, 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, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 13, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 37, 36 ], [ 48, 39 ], [ 48, 48 ], [ 71, 68 ], [ 73, 69 ], [ 71, 71 ], [ 73, 73 ], [ 79, 78 ], [ 96, 81 ], [ 92, 87 ], [ 94, 88 ], [ 92, 92 ], [ 94, 94 ], [ 96, 96 ], [ 101, 100 ], [ 100, 106 ], [ 135, 107 ], [ 110, 109 ], [ 131, 114 ], [ 133, 115 ], [ 109, 119 ], [ 100, 120 ], [ 100, 123 ], [ 109, 125 ], [ 100, 129 ], [ 131, 131 ], [ 133, 133 ], [ 135, 135 ], [ 140, 139 ], [ 139, 145 ], [ 173, 146 ], [ 149, 148 ], [ 328, 150 ], [ 169, 151 ], [ 171, 152 ], [ 148, 157 ], [ 139, 158 ], [ 139, 161 ], [ 148, 163 ], [ 139, 167 ], [ 169, 169 ], [ 171, 171 ], [ 173, 173 ], [ 333, 200 ], [ 348, 207 ], [ 322, 209 ], [ 348, 210 ], [ 315, 212 ], [ 355, 214 ], [ 217, 216 ], [ 349, 219 ], [ 224, 221 ], [ 316, 222 ], [ 216, 223 ], [ 340, 224 ], [ 228, 227 ], [ 349, 231 ], [ 330, 239 ], [ 247, 242 ], [ 331, 244 ], [ 250, 249 ], [ 349, 254 ], [ 258, 257 ], [ 267, 262 ], [ 331, 264 ], [ 249, 265 ], [ 257, 266 ], [ 331, 269 ], [ 249, 271 ], [ 257, 273 ], [ 257, 279 ], [ 316, 281 ], [ 249, 283 ], [ 292, 287 ], [ 331, 289 ], [ 249, 290 ], [ 257, 291 ], [ 331, 294 ], [ 249, 296 ], [ 257, 299 ], [ 316, 301 ], [ 249, 303 ], [ 331, 310 ], [ 315, 316 ], [ 330, 331 ], [ 333, 334 ], [ 348, 340 ], [ 348, 349 ] ]

[ "def getN():\n return int(input())\ndef getNM():\n return map(int, input().split())\ndef getList():\n return list(map(int, input().split()))\ndef getArray(intn):\n return [int(input()) for i in range(intn)]\ndef input():\n return sys.stdin.readline().rstrip()\ndef rand_N(ran1, ran2):\n return random.randint(ran1, ran2)\ndef rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]\ndef rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)\n\ndef rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)\n\nfrom collections import defaultdict, deque, Counter\nfrom sys import exit\nfrom decimal import *\nimport heapq\nimport math\nfrom fractions import gcd\nimport random\nimport string\nimport copy\nfrom itertools import combinations, permutations, product\nfrom operator import mul\nfrom functools import reduce\nfrom bisect import bisect_left, bisect_right\n\nimport sys\nsys.setrecursionlimit(1000000000)\nmod = 10 ** 9 + 7\n\n\n#############\n# Main Code #\n#############\n\nN, A = getNM()\nQ = getList()\nfor i in range(N):\n Q[i] -= A\n\ndp = [[0] * 5002 for i in range(N + 1)]\ndp[0][2501] = 1\n\nfor i in range(1, N + 1):\n for j in range(5002):\n dp[i][j] += dp[i - 1][j]\n if 0 <= j - Q[i - 1] <= 5001:\n dp[i][j] += dp[i - 1][j - Q[i - 1]]\n\nprint(dp[-1][2501] - 1)", "def getN():\n return int(input())", "getN", "return int(input())", "int(input())", "int", "input()", "input", "def getNM():\n return map(int, input().split())", "getNM", "return map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def getList():\n return list(map(int, input().split()))", "getList", "return list(map(int, input().split()))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def getArray(intn):\n return [int(input()) for i in range(intn)]", "getArray", "int(input()) for i in range(intn)", "for i in range(intn)", "i", "range(intn)", "range", "intn", "for i in range(intn)", "int(input())", "int", "input()", "input", "return [int(input()) for i in range(intn)]", "[int(input()) for i in range(intn)]", "intn", "intn", "def input():\n return sys.stdin.readline().rstrip()", "input", "return 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 rand_N(ran1, ran2):\n return random.randint(ran1, ran2)", "rand_N", "return random.randint(ran1, ran2)", "random.randint(ran1, ran2)", "random.randint", "random", "randint", "ran1", "ran2", "ran1", "ran1", "ran2", "ran2", "def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]", "rand_List", "random.randint(ran1, ran2) for i in range(rantime)", "for i in range(rantime)", "i", "range(rantime)", "range", "rantime", "for i in range(rantime)", "random.randint(ran1, ran2)", "random.randint", "random", "randint", "ran1", "ran2", "return [random.randint(ran1, ran2) for i in range(rantime)]", "[random.randint(ran1, ran2) for i in range(rantime)]", "ran1", "ran1", "ran2", "ran2", "rantime", "rantime", "def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)", "rand_ints_nodup", "ns = []", "ns", "[]", "while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n ", "len(ns) < rantime", "len(ns)", "len", "ns", "rantime", "n = random.randint(ran1, ran2)", "n", "random.randint(ran1, ran2)", "random.randint", "random", "randint", "ran1", "ran2", "if not n in ns:\n ns.append(n)\n ", "not n in ns", "n in ns", "n", "ns", "ns.append(n)", "ns.append", "ns", "append", "n", "return sorted(ns)", "sorted(ns)", "sorted", "ns", "ran1", "ran1", "ran2", "ran2", "rantime", "rantime", "def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)", "rand_query", "r_query = []", "r_query", "[]", "while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n ", "len(r_query) < rantime", "len(r_query)", "len", "r_query", "rantime", "n_q = rand_ints_nodup(ran1, ran2, 2)", "n_q", "rand_ints_nodup(ran1, ran2, 2)", "rand_ints_nodup", "ran1", "ran2", "2", "if not n_q in r_query:\n r_query.append(n_q)\n ", "not n_q in r_query", "n_q in r_query", "n_q", "r_query", "r_query.append(n_q)", "r_query.append", "r_query", "append", "n_q", "return sorted(r_query)", "sorted(r_query)", "sorted", "r_query", "ran1", "ran1", "ran2", "ran2", "rantime", "rantime", "from collections import defaultdict, deque, Counter", "from sys import exit", "from decimal import *", "import heapq", "heapq", "import math", "math", "from fractions import gcd", "import random", "random", "import string", "string", "import copy", "copy", "from itertools import combinations, permutations, product", "from operator import mul", "from functools import reduce", "from bisect import bisect_left, bisect_right", "import sys", "sys", "sys.setrecursionlimit(1000000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "1000000000", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, A = getNM()", "N", "getNM()", "getNM", "A", "Q = getList()", "Q", "getList()", "getList", "for i in range(N):\n Q[i] -= A", "i", "range(N)", "range", "N", "Q[i] -= A", "Q[i]", "Q", "i", "A", "[0] * 5002 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] * 5002", "[0]", "0", "5002", "dp = [[0] * 5002 for i in range(N + 1)]", "dp", "[[0] * 5002 for i in range(N + 1)]", "dp[0][2501] = 1", "dp[0][2501]", "[0]", "dp", "0", "2501", "1", "for i in range(1, N + 1):\n for j in range(5002):\n dp[i][j] += dp[i - 1][j]\n if 0 <= j - Q[i - 1] <= 5001:\n dp[i][j] += dp[i - 1][j - Q[i - 1]]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "for j in range(5002):\n dp[i][j] += dp[i - 1][j]\n if 0 <= j - Q[i - 1] <= 5001:\n dp[i][j] += dp[i - 1][j - Q[i - 1]]", "j", "range(5002)", "range", "5002", "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 0 <= j - Q[i - 1] <= 5001:\n dp[i][j] += dp[i - 1][j - Q[i - 1]]", "0 <= j - Q[i - 1] <= 5001", "0 <= j - Q[i - 1]", "0", "j - Q[i - 1]", "j", "Q[i - 1]", "Q", "i - 1", "i", "1", "5001", "dp[i][j] += dp[i - 1][j - Q[i - 1]]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i - 1][j - Q[i - 1]]", "[i - 1]", "dp", "i - 1", "i", "1", "j - Q[i - 1]", "j", "Q[i - 1]", "Q", "i - 1", "i", "1", "print(dp[-1][2501] - 1)", "print", "dp[-1][2501] - 1", "dp[-1][2501]", "[-1]", "dp", "-1", "2501", "1", "Q = getList()", "getList()", "Q", "def getArray(intn):\n return [int(input()) for i in range(intn)]", "def getArray(intn):\n return [int(input()) for i in range(intn)]", "getArray", "def getNM():\n return map(int, input().split())", "def getNM():\n return map(int, input().split())", "getNM", "def input():\n return sys.stdin.readline().rstrip()", "def input():\n return sys.stdin.readline().rstrip()", "input", "def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)", "def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)", "rand_ints_nodup", "dp = [[0] * 5002 for i in range(N + 1)]", "[[0] * 5002 for i in range(N + 1)]", "dp", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "def getN():\n return int(input())", "def getN():\n return int(input())", "getN", "A = getNM()", "getNM()", "A", "def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]", "def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]", "rand_List", "def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)", "def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)", "rand_query", "N, A = getNM()", "getNM()", "N", "def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)", "def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)", "rand_N", "def getList():\n return list(map(int, input().split()))", "def getList():\n return list(map(int, input().split()))", "getList" ]

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 2, 4, 13, 13, 17, 23, 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, 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, 0, 18, 18, 18, 13, 2, 13, 17, 13, 13, 18, 18, 18, 13, 13, 13, 13, 14, 2, 40, 2, 13, 18, 13, 13, 17, 40, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 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, 17, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 233, 11 ], [ 227, 16 ], [ 230, 23 ], [ 224, 35 ], [ 239, 50 ], [ 236, 65 ], [ 77, 76 ], [ 231, 83 ], [ 77, 85 ], [ 88, 87 ], [ 231, 96 ], [ 101, 100 ], [ 76, 104 ], [ 110, 109 ], [ 119, 112 ], [ 109, 115 ], [ 122, 121 ], [ 76, 124 ], [ 127, 126 ], [ 121, 130 ], [ 134, 133 ], [ 147, 138 ], [ 109, 141 ], [ 121, 143 ], [ 126, 145 ], [ 133, 146 ], [ 109, 150 ], [ 121, 151 ], [ 126, 152 ], [ 133, 153 ], [ 133, 158 ], [ 87, 160 ], [ 121, 161 ], [ 126, 164 ], [ 121, 165 ], [ 178, 167 ], [ 109, 170 ], [ 121, 172 ], [ 126, 175 ], [ 133, 177 ], [ 109, 181 ], [ 121, 182 ], [ 126, 183 ], [ 133, 185 ], [ 87, 187 ], [ 121, 188 ], [ 191, 190 ], [ 194, 193 ], [ 76, 198 ], [ 202, 201 ], [ 109, 205 ], [ 193, 207 ], [ 193, 209 ], [ 85, 210 ], [ 201, 213 ], [ 190, 213 ], [ 222, 219 ], [ 224, 225 ], [ 227, 228 ], [ 230, 231 ], [ 233, 234 ], [ 236, 237 ], [ 239, 240 ] ]

[ "# -*- coding: utf-8 -*-\nimport sys\nsys.setrecursionlimit(10**9)\nINF=10**18\nMOD=10**9+7\ninput=lambda: sys.stdin.readline().rstrip()\nYesNo=lambda b: bool([print('Yes')] if b else print('No'))\nYESNO=lambda b: bool([print('YES')] if b else print('NO'))\nint1=lambda x:int(x)-1\n\ndef main():\n N,A=map(int,input().split())\n x=list(map(int,input().split()))\n dp=[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n for i in range(N):\n for j in range(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ans=0\n for i in range(1,N+1):\n ans+=dp[-1][i][i*A]\n print(ans)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "INF=10**18", "INF", "10**18", "10", "18", "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", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "lambda b: bool([print('Yes')] if b else print('No'))", "bool([print('Yes')] if b else print('No'))", "bool", "[print('Yes')] if b else print('No')", "b", "[print('Yes')]", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "b", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "YESNO", "lambda b: bool([print('YES')] if b else print('NO'))", "bool([print('YES')] if b else print('NO'))", "bool", "[print('YES')] if b else print('NO')", "b", "[print('YES')]", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "b", "int1=lambda x:int(x)-1", "int1", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "def main():\n N,A=map(int,input().split())\n x=list(map(int,input().split()))\n dp=[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n for i in range(N):\n for j in range(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ans=0\n for i in range(1,N+1):\n ans+=dp[-1][i][i*A]\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", "[[0]*2501 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]*2501 for _ in range(N+1)]", "dp=[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]", "dp", "[[[0]*2501 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(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ", "i", "range(N)", "range", "N", "for j in range(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ", "k", "range(2501)", "range", "2501", "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 k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ", "k-x[i]>=0 and j<=i", "k-x[i]>=0", "k-x[i]", "k", "x[i]", "x", "i", "0", "j<=i", "j", "i", "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", "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", "def main():\n N,A=map(int,input().split())\n x=list(map(int,input().split()))\n dp=[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n for i in range(N):\n for j in range(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ans=0\n for i in range(1,N+1):\n ans+=dp[-1][i][i*A]\n print(ans)", "def main():\n N,A=map(int,input().split())\n x=list(map(int,input().split()))\n dp=[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0]=1\n for i in range(N):\n for j in range(i+1):\n for k in range(2501):\n dp[i+1][j][k]+=dp[i][j][k]\n if k-x[i]>=0 and j<=i:\n dp[i+1][j+1][k]+=dp[i][j][k-x[i]]\n ans=0\n for i in range(1,N+1):\n ans+=dp[-1][i][i*A]\n print(ans)", "main", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "MOD=10**9+7", "10**9+7", "MOD", "input=lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "INF=10**18", "10**18", "INF", "int1=lambda x:int(x)-1", "lambda x:int(x)-1", "int1", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "lambda b: bool([print('YES')] if b else print('NO'))", "YESNO" ]

[ 7, 15, 13, 12, 13, 12, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 13, 0, 18, 18, 18, 13, 13, 17, 17, 17, 0, 18, 18, 18, 13, 17, 17, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 18, 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, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 18, 18, 18, 13, 2, 13, 17, 13, 2, 13, 13, 4, 13, 13, 10, 12, 13, 10, 18, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 199, 10 ], [ 187, 17 ], [ 173, 19 ], [ 187, 20 ], [ 190, 22 ], [ 182, 24 ], [ 28, 27 ], [ 188, 31 ], [ 196, 36 ], [ 40, 39 ], [ 188, 42 ], [ 51, 44 ], [ 197, 47 ], [ 39, 48 ], [ 62, 53 ], [ 197, 56 ], [ 191, 60 ], [ 65, 64 ], [ 188, 68 ], [ 71, 70 ], [ 64, 75 ], [ 79, 78 ], [ 179, 83 ], [ 188, 84 ], [ 78, 89 ], [ 191, 91 ], [ 64, 92 ], [ 102, 95 ], [ 197, 98 ], [ 64, 99 ], [ 70, 100 ], [ 78, 101 ], [ 197, 105 ], [ 64, 107 ], [ 70, 109 ], [ 78, 110 ], [ 119, 112 ], [ 197, 115 ], [ 64, 116 ], [ 70, 117 ], [ 78, 118 ], [ 197, 123 ], [ 64, 125 ], [ 70, 127 ], [ 78, 128 ], [ 197, 132 ], [ 64, 134 ], [ 70, 137 ], [ 78, 140 ], [ 191, 142 ], [ 64, 143 ], [ 193, 145 ], [ 149, 148 ], [ 188, 153 ], [ 175, 156 ], [ 197, 160 ], [ 188, 162 ], [ 148, 164 ], [ 179, 166 ], [ 148, 167 ], [ 176, 170 ], [ 194, 170 ], [ 175, 176 ], [ 187, 179 ], [ 187, 188 ], [ 190, 191 ], [ 193, 194 ], [ 196, 197 ], [ 199, 200 ] ]

[ "import sys\n\ndef I(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LMI(): return list(map(int, sys.stdin.readline().split()))\nMOD = 10 ** 9 + 7\n\nN, A = MI()\nX = LMI()\n\n# dp[i][j][s] := i番目までのカードからj枚を選んで合計がsになる組み合わせの数\ndp = [[[0] * 2502 for _ in range(N + 2)] for _ in range(N + 1)]\nfor i in range(N):\n dp[i][0][0] = 1\ndp[0][1][X[0]] = 1\nfor i in range(1, N):\n for j in range(1, i + 2):\n for s in range(A * N + 1):\n if s - X[i] < 0:\n dp[i][j][s] = dp[i - 1][j][s]\n else:\n dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]\n\nans = 0\nfor i in range(1, N + 1):\n ans += dp[N - 1][i][A * i]\nprint(ans)", "import sys", "sys", "def I(): return int(sys.stdin.readline())", "I", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "def LMI(): return list(map(int, sys.stdin.readline().split()))", "LMI", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, A = MI()", "N", "MI()", "MI", "A", "X = LMI()", "X", "LMI()", "LMI", "[[0] * 2502 for _ in range(N + 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] * 2502 for _ in range(N + 2)]", "dp = [[[0] * 2502 for _ in range(N + 2)] for _ in range(N + 1)]", "dp", "[[[0] * 2502 for _ in range(N + 2)] for _ in range(N + 1)]", "for i in range(N):\n dp[i][0][0] = 1", "i", "range(N)", "range", "N", "dp[i][0][0] = 1", "dp[i][0][0]", "[0]", "[i]", "dp", "i", "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(1, i + 2):\n for s in range(A * N + 1):\n if s - X[i] < 0:\n dp[i][j][s] = dp[i - 1][j][s]\n else:\n dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "i", "range(1, N)", "range", "1", "N", "for j in range(1, i + 2):\n for s in range(A * N + 1):\n if s - X[i] < 0:\n dp[i][j][s] = dp[i - 1][j][s]\n else:\n dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "j", "range(1, i + 2)", "range", "1", "i + 2", "i", "2", "for s in range(A * N + 1):\n if s - X[i] < 0:\n dp[i][j][s] = dp[i - 1][j][s]\n else:\n dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "s", "range(A * N + 1)", "range", "A * N + 1", "A * N", "A", "N", "1", "if s - X[i] < 0:\n dp[i][j][s] = dp[i - 1][j][s]\n else:\n dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "s - X[i] < 0", "s - X[i]", "s", "X[i]", "X", "i", "0", "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", "dp[i][j][s] = dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "dp[i][j][s]", "[j]", "[i]", "dp", "i", "j", "s", "dp[i - 1][j][s] + dp[i - 1][j - 1][s - X[i]]", "dp[i - 1][j][s]", "[j]", "[i - 1]", "dp", "i - 1", "i", "1", "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", "ans = 0", "ans", "0", "for i in range(1, N + 1):\n ans += dp[N - 1][i][A * i]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "ans += dp[N - 1][i][A * i]", "ans", "dp[N - 1][i][A * i]", "[i]", "[N - 1]", "dp", "N - 1", "N", "1", "i", "A * i", "A", "i", "print(ans)", "print", "ans", "def MI(): return map(int, sys.stdin.readline().split())", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "ans += dp[N - 1][i][A * i]", "dp[N - 1][i][A * i]", "ans", "A = MI()", "MI()", "A", "def LMI(): return list(map(int, sys.stdin.readline().split()))", "def LMI(): return list(map(int, sys.stdin.readline().split()))", "LMI", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I", "N, A = MI()", "MI()", "N", "X = LMI()", "LMI()", "X", "ans = 0", "0", "ans", "dp = [[[0] * 2502 for _ in range(N + 2)] for _ in range(N + 1)]", "[[[0] * 2502 for _ in range(N + 2)] for _ in range(N + 1)]", "dp", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

[ 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, 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, 0, 13, 18, 18, 18, 13, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 143, 2 ], [ 143, 11 ], [ 146, 13 ], [ 27, 26 ], [ 138, 30 ], [ 152, 35 ], [ 45, 38 ], [ 153, 41 ], [ 48, 47 ], [ 138, 50 ], [ 53, 52 ], [ 138, 55 ], [ 58, 57 ], [ 138, 61 ], [ 144, 62 ], [ 153, 67 ], [ 47, 68 ], [ 52, 69 ], [ 57, 70 ], [ 81, 72 ], [ 153, 75 ], [ 47, 77 ], [ 52, 79 ], [ 57, 80 ], [ 153, 84 ], [ 47, 85 ], [ 52, 86 ], [ 57, 87 ], [ 104, 89 ], [ 153, 92 ], [ 47, 94 ], [ 52, 97 ], [ 57, 100 ], [ 147, 102 ], [ 47, 103 ], [ 153, 107 ], [ 47, 108 ], [ 52, 109 ], [ 57, 110 ], [ 149, 112 ], [ 116, 115 ], [ 138, 120 ], [ 140, 123 ], [ 153, 127 ], [ 138, 128 ], [ 115, 129 ], [ 144, 131 ], [ 115, 132 ], [ 141, 135 ], [ 150, 135 ], [ 143, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\ndp = [[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]\ndp[0][0][0] = 1\n\nfor i in range(n):\n for use in range(n):\n for total in range(n * a):\n if dp[i][use][total]:\n dp[i + 1][use][total] += dp[i][use][total]\n dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]\n\nans = 0\nfor i in range(1, n + 1):\n ans += dp[n][i][a * i]\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", "[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)", "for _ in range(n + 10)", "_", "range(n + 10)", "range", "n + 10", "n", "10", "for _ in range(n + 10)", "[[0] * (50 * (n + 10)) for _ in range(n + 10)]", "dp = [[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]", "dp", "[[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ 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 use in range(n):\n for total in range(n * a):\n if dp[i][use][total]:\n dp[i + 1][use][total] += dp[i][use][total]\n dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]", "i", "range(n)", "range", "n", "for use in range(n):\n for total in range(n * a):\n if dp[i][use][total]:\n dp[i + 1][use][total] += dp[i][use][total]\n dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]", "use", "range(n)", "range", "n", "for total in range(n * a):\n if dp[i][use][total]:\n dp[i + 1][use][total] += dp[i][use][total]\n dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]", "total", "range(n * a)", "range", "n * a", "n", "a", "if dp[i][use][total]:\n dp[i + 1][use][total] += dp[i][use][total]\n dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]", "dp[i][use][total]", "[use]", "[i]", "dp", "i", "use", "total", "dp[i + 1][use][total] += dp[i][use][total]", "dp[i + 1][use][total]", "[use]", "[i + 1]", "dp", "i + 1", "i", "1", "use", "total", "dp[i][use][total]", "[use]", "[i]", "dp", "i", "use", "total", "dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]", "dp[i + 1][use + 1][total + x[i]]", "[use + 1]", "[i + 1]", "dp", "i + 1", "i", "1", "use + 1", "use", "1", "total + x[i]", "total", "x[i]", "x", "i", "dp[i][use][total]", "[use]", "[i]", "dp", "i", "use", "total", "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", "n, a = map(int, input().split())", "map(int, input().split())", "n", "ans += dp[n][i][a * i]", "dp[n][i][a * i]", "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 = [[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]", "[[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]", "dp" ]

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

[ [ 79, 4 ], [ 79, 13 ], [ 17, 16 ], [ 16, 27 ], [ 80, 28 ], [ 82, 30 ], [ 85, 35 ], [ 42, 41 ], [ 83, 41 ], [ 86, 50 ], [ 58, 53 ], [ 86, 54 ], [ 41, 57 ], [ 86, 60 ], [ 41, 63 ], [ 69, 66 ], [ 86, 67 ], [ 41, 68 ], [ 86, 73 ], [ 79, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "import collections\n\nn, a = map(int, input().split())\nls = sorted([x - a for x in map(int, input().split())])\ncounter = collections.Counter()\nfor x in ls:\n for k, v in list(counter.items()):\n counter[k + x] = counter[k + x] + v\n counter[x] += 1\nprint(counter[0])", "import collections", "collections", "n, a = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x - a for x in map(int, input().split())", "for x in map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for x in map(int, input().split())", "x - a", "x", "a", "ls = sorted([x - a for x in map(int, input().split())])", "ls", "sorted([x - a for x in map(int, input().split())])", "sorted", "[x - a for x in map(int, input().split())]", "counter = collections.Counter()", "counter", "collections.Counter()", "collections.Counter", "collections", "Counter", "for x in ls:\n for k, v in list(counter.items()):\n counter[k + x] = counter[k + x] + v\n counter[x] += 1", "x", "ls", "for k, v in list(counter.items()):\n counter[k + x] = counter[k + x] + v\n ", "k", "v", "list(counter.items())", "list", "counter.items()", "counter.items", "counter", "items", "counter[k + x] = counter[k + x] + v", "counter[k + x]", "counter", "k + x", "k", "x", "counter[k + x] + v", "counter[k + x]", "counter", "k + x", "k", "x", "v", "counter[x] += 1", "counter[x]", "counter", "x", "1", "print(counter[0])", "print", "counter[0]", "counter", "0", "n, a = map(int, input().split())", "map(int, input().split())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "ls = sorted([x - a for x in map(int, input().split())])", "sorted([x - a for x in map(int, input().split())])", "ls", "counter = collections.Counter()", "collections.Counter()", "counter" ]

[ 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, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 18, 18, 13, 13, 39, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 13, 2, 13, 17, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 162, 2 ], [ 162, 11 ], [ 165, 13 ], [ 150, 25 ], [ 148, 27 ], [ 163, 28 ], [ 32, 31 ], [ 151, 35 ], [ 144, 40 ], [ 48, 43 ], [ 145, 45 ], [ 51, 50 ], [ 166, 50 ], [ 55, 54 ], [ 151, 58 ], [ 145, 63 ], [ 169, 63 ], [ 54, 64 ], [ 156, 67 ], [ 71, 70 ], [ 151, 74 ], [ 70, 79 ], [ 50, 80 ], [ 84, 83 ], [ 163, 88 ], [ 96, 91 ], [ 157, 93 ], [ 70, 94 ], [ 83, 95 ], [ 145, 98 ], [ 169, 98 ], [ 70, 100 ], [ 50, 101 ], [ 83, 103 ], [ 168, 106 ], [ 157, 107 ], [ 153, 109 ], [ 113, 112 ], [ 151, 117 ], [ 121, 120 ], [ 163, 125 ], [ 112, 130 ], [ 120, 131 ], [ 148, 132 ], [ 159, 134 ], [ 169, 137 ], [ 145, 137 ], [ 112, 138 ], [ 120, 139 ], [ 160, 142 ], [ 154, 142 ], [ 144, 145 ], [ 162, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 157, 168 ], [ 168, 169 ] ]

[ "n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\nm = a * n\n\n# dp[i][j]: j 個使って合計がi\ndp = [[0 for j in range(n+1)] for i in range(m+1)]\ndp[0][0] = 1\n\n\nfor xk in x:\n # xkまで見たときを計算\n dpk = [dp[i][:] for i in range(m+1)]\n for i in range(m+1):\n if i - xk >= 0:\n for j in range(1,n+1):\n dpk[i][j] += dp[i-xk][j-1]\n dp = dpk\n\nans = 0\n\nfor i in range(1,m+1):\n for j in range(1,n+1):\n if i / j == a:\n ans += dp[i][j]\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", "m = a * n", "m", "a * n", "a", "n", "[0 for j in range(n+1)] for i in range(m+1)", "for i in range(m+1)", "i", "range(m+1)", "range", "m+1", "m", "1", "for i in range(m+1)", "[0 for j in range(n+1)]", "dp = [[0 for j in range(n+1)] for i in range(m+1)]", "dp", "[[0 for j in range(n+1)] for i in range(m+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for xk in x:\n # xkまで見たときを計算\n dpk = [dp[i][:] for i in range(m+1)]\n for i in range(m+1):\n if i - xk >= 0:\n for j in range(1,n+1):\n dpk[i][j] += dp[i-xk][j-1]\n dp = dpk", "xk", "x", "dp[i][:] for i in range(m+1)", "for i in range(m+1)", "i", "range(m+1)", "range", "m+1", "m", "1", "for i in range(m+1)", "dp[i][:]", "[i]", "dp", "i", ":", "dpk = [dp[i][:] for i in range(m+1)]", "dpk", "[dp[i][:] for i in range(m+1)]", "for i in range(m+1):\n if i - xk >= 0:\n for j in range(1,n+1):\n dpk[i][j] += dp[i-xk][j-1]\n ", "i", "range(m+1)", "range", "m+1", "m", "1", "if i - xk >= 0:\n for j in range(1,n+1):\n dpk[i][j] += dp[i-xk][j-1]\n ", "i - xk >= 0", "i - xk", "i", "xk", "0", "for j in range(1,n+1):\n dpk[i][j] += dp[i-xk][j-1]\n ", "j", "range(1,n+1)", "range", "1", "n+1", "n", "1", "dpk[i][j] += dp[i-xk][j-1]", "dpk[i][j]", "[i]", "dpk", "i", "j", "dp[i-xk][j-1]", "[i-xk]", "dp", "i-xk", "i", "xk", "j-1", "j", "1", "dp = dpk", "dp", "dpk", "ans = 0", "ans", "0", "for i in range(1,m+1):\n for j in range(1,n+1):\n if i / j == a:\n ans += dp[i][j]", "i", "range(1,m+1)", "range", "1", "m+1", "m", "1", "for j in range(1,n+1):\n if i / j == a:\n ans += dp[i][j]", "j", "range(1,n+1)", "range", "1", "n+1", "n", "1", "if i / j == a:\n ans += dp[i][j]", "i / j == a", "i / j", "i", "j", "a", "ans += dp[i][j]", "ans", "dp[i][j]", "[i]", "dp", "i", "j", "print(ans)", "print", "ans", "dp = [[0 for j in range(n+1)] for i in range(m+1)]", "[[0 for j in range(n+1)] for i in range(m+1)]", "dp", "a = map(int, input().split())", "map(int, input().split())", "a", "m = a * n", "a * n", "m", "ans = 0", "0", "ans", "dpk = [dp[i][:] for i in range(m+1)]", "[dp[i][:] for i in range(m+1)]", "dpk", "ans += dp[i][j]", "dp[i][j]", "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 = dpk", "dpk", "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, 28, 13, 4, 13, 13, 0, 18, 13, 13, 13, 0, 13, 17, 41, 28, 13, 4, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 2, 18, 18, 13, 2, 13, 17, 2, 13, 18, 13, 2, 13, 17, 18, 18, 13, 2, 13, 17, 13, 14, 2, 40, 13, 17, 2, 13, 18, 13, 2, 13, 17, 0, 18, 18, 13, 13, 13, 18, 18, 13, 2, 13, 17, 13, 14, 2, 2, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 14, 2, 40, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 13, 17, 4, 13, 2, 18, 18, 13, 13, 17, 17, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 173, 2 ], [ 173, 11 ], [ 176, 13 ], [ 26, 25 ], [ 174, 28 ], [ 33, 30 ], [ 177, 31 ], [ 25, 32 ], [ 168, 33 ], [ 164, 35 ], [ 40, 39 ], [ 170, 46 ], [ 50, 49 ], [ 174, 53 ], [ 57, 56 ], [ 49, 63 ], [ 56, 66 ], [ 177, 68 ], [ 49, 70 ], [ 78, 73 ], [ 171, 75 ], [ 49, 76 ], [ 56, 77 ], [ 171, 81 ], [ 49, 83 ], [ 56, 86 ], [ 177, 88 ], [ 49, 90 ], [ 171, 94 ], [ 49, 96 ], [ 56, 98 ], [ 49, 102 ], [ 56, 105 ], [ 177, 107 ], [ 49, 109 ], [ 117, 112 ], [ 171, 114 ], [ 49, 115 ], [ 56, 116 ], [ 171, 119 ], [ 49, 121 ], [ 56, 123 ], [ 56, 127 ], [ 49, 130 ], [ 138, 133 ], [ 171, 135 ], [ 49, 136 ], [ 56, 137 ], [ 56, 142 ], [ 49, 145 ], [ 153, 148 ], [ 171, 150 ], [ 49, 151 ], [ 56, 152 ], [ 171, 159 ], [ 174, 160 ], [ 164, 165 ], [ 173, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ] ]

[ "n,a=map(int,input().split())\nlists=list(map(int,input().split()))\n \nfor i in range(n):\n lists[i]-=a\nanswer=0\ndp=[[0 for i in range(5001)] for _ in range(51)]\n#dp[i][j]で0からi枚目まで好きなように選択してそのそうわがｊ-2500となるような撮り方の総数\n#最終的に求めるのはdp[i][0]である\n \nfor i in range(n+1):\n for j in range(4951):\n if i>=1 and j>=lists[i-1]:\n dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]\n if i>=1 and j<lists[i-1]:\n dp[i][j]=dp[i-1][j]\n else:\n if j==2500 and i==0:\n dp[i][j]=1\n elif j!=2500 and i==0:\n dp[i][j]=0\nprint(dp[n][2500]-1) ", "n,a=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "lists=list(map(int,input().split()))", "lists", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n):\n lists[i]-=a", "i", "range(n)", "range", "n", "lists[i]-=a", "lists[i]", "lists", "i", "a", "answer=0", "answer", "0", "[0 for i in range(5001)] for _ in range(51)", "for _ in range(51)", "_", "range(51)", "range", "51", "for _ in range(51)", "[0 for i in range(5001)]", "dp=[[0 for i in range(5001)] for _ in range(51)]", "dp", "[[0 for i in range(5001)] for _ in range(51)]", "for i in range(n+1):\n for j in range(4951):\n if i>=1 and j>=lists[i-1]:\n dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]\n if i>=1 and j<lists[i-1]:\n dp[i][j]=dp[i-1][j]\n else:\n if j==2500 and i==0:\n dp[i][j]=1\n elif j!=2500 and i==0:\n dp[i][j]=0", "i", "range(n+1)", "range", "n+1", "n", "1", "for j in range(4951):\n if i>=1 and j>=lists[i-1]:\n dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]\n if i>=1 and j<lists[i-1]:\n dp[i][j]=dp[i-1][j]\n else:\n if j==2500 and i==0:\n dp[i][j]=1\n elif j!=2500 and i==0:\n dp[i][j]=0", "j", "range(4951)", "range", "4951", "if i>=1 and j>=lists[i-1]:\n dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]\n ", "i>=1 and j>=lists[i-1]", "i>=1", "i", "1", "j>=lists[i-1]", "j", "lists[i-1]", "lists", "i-1", "i", "1", "dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]", "dp[i][j]", "[i]", "dp", "i", "j", "dp[i-1][j-lists[i-1]]+dp[i-1][j]", "dp[i-1][j-lists[i-1]]", "[i-1]", "dp", "i-1", "i", "1", "j-lists[i-1]", "j", "lists[i-1]", "lists", "i-1", "i", "1", "dp[i-1][j]", "[i-1]", "dp", "i-1", "i", "1", "j", "if i>=1 and j<lists[i-1]:\n dp[i][j]=dp[i-1][j]\n else:\n if j==2500 and i==0:\n dp[i][j]=1\n elif j!=2500 and i==0:\n dp[i][j]=0", "i>=1 and j<lists[i-1]", "i>=1", "i", "1", "j<lists[i-1]", "j", "lists[i-1]", "lists", "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", "if j==2500 and i==0:\n dp[i][j]=1\n elif j!=2500 and i==0:\n dp[i][j]=0", "j==2500 and i==0", "j==2500", "j", "2500", "i==0", "i", "0", "dp[i][j]=1", "dp[i][j]", "[i]", "dp", "i", "j", "1", "elif j!=2500 and i==0:\n dp[i][j]=0", "j!=2500 and i==0", "j!=2500", "j", "2500", "i==0", "i", "0", "dp[i][j]=0", "dp[i][j]", "[i]", "dp", "i", "j", "0", "print(dp[n][2500]-1)", "print", "dp[n][2500]-1", "dp[n][2500]", "[n]", "dp", "n", "2500", "1", "answer=0", "0", "answer", "a=map(int,input().split())", "map(int,input().split())", "a", "dp=[[0 for i in range(5001)] for _ in range(51)]", "[[0 for i in range(5001)] for _ in range(51)]", "dp", "n,a=map(int,input().split())", "map(int,input().split())", "n", "lists=list(map(int,input().split()))", "list(map(int,input().split()))", "lists" ]

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

[ [ 160, 2 ], [ 160, 12 ], [ 18, 17 ], [ 17, 28 ], [ 161, 29 ], [ 148, 31 ], [ 36, 35 ], [ 149, 35 ], [ 35, 38 ], [ 35, 41 ], [ 151, 43 ], [ 50, 49 ], [ 149, 49 ], [ 49, 52 ], [ 49, 55 ], [ 154, 57 ], [ 64, 63 ], [ 158, 67 ], [ 145, 74 ], [ 82, 77 ], [ 146, 79 ], [ 149, 88 ], [ 91, 90 ], [ 155, 93 ], [ 152, 95 ], [ 105, 98 ], [ 146, 100 ], [ 90, 104 ], [ 146, 107 ], [ 90, 109 ], [ 90, 113 ], [ 146, 116 ], [ 126, 119 ], [ 146, 121 ], [ 90, 125 ], [ 146, 128 ], [ 90, 131 ], [ 146, 138 ], [ 158, 139 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ], [ 160, 158 ], [ 160, 161 ] ]

[ "# -*- coding: utf-8 -*-\nN, A = map(int, input().split(' '))\nimport collections\n\nX = [int(a) - A for a in input().split(' ')]\nsum_positives = sum([x for x in X if x > 0])\nsum_negatives = sum([x for x in X if x < 0])\n\ndp = [dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)]\ndp[0][0] = 1\n\nfor i, x in enumerate(X):\n for j in range(sum_negatives, sum_positives+1):\n dp[i + 1][j] = dp[i][j]\n if (j - x) in dp[i]:\n dp[i + 1][j] += dp[i][j - x]\n\n# for d in dp:\n# print(d)\n\nprint(dp[N][0] - 1)\nexit()", "N, A = map(int, input().split(' '))", "N", "map(int, input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "A", "import collections", "collections", "int(a) - A for a in input().split(' ')", "for a in input().split(' ')", "a", "input().split(' ')", "().split", "()", "input", "split", "' '", "for a in input().split(' ')", "int(a) - A", "int(a)", "int", "a", "A", "X = [int(a) - A for a in input().split(' ')]", "X", "[int(a) - A for a in input().split(' ')]", "x for x in X if x > 0", "for x in X if x > 0", "x", "X", "x > 0", "x", "0", "if x > 0", "x", "sum_positives = sum([x for x in X if x > 0])", "sum_positives", "sum([x for x in X if x > 0])", "sum", "[x for x in X if x > 0]", "x for x in X if x < 0", "for x in X if x < 0", "x", "X", "x < 0", "x", "0", "if x < 0", "x", "sum_negatives = sum([x for x in X if x < 0])", "sum_negatives", "sum([x for x in X if x < 0])", "sum", "[x for x in X if x < 0]", "dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])", "dict", "[(i, 0) for i in range(sum_negatives, sum_positives+1)]", "dp = [dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)]", "dp", "[dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i, x in enumerate(X):\n for j in range(sum_negatives, sum_positives+1):\n dp[i + 1][j] = dp[i][j]\n if (j - x) in dp[i]:\n dp[i + 1][j] += dp[i][j - x]\n\n# for d in dp:\n# print(d)", "i", "x", "enumerate(X)", "enumerate", "X", "for j in range(sum_negatives, sum_positives+1):\n dp[i + 1][j] = dp[i][j]\n if (j - x) in dp[i]:\n dp[i + 1][j] += dp[i][j - x]\n\n# for d in dp:\n# print(d)", "j", "range(sum_negatives, sum_positives+1)", "range", "sum_negatives", "sum_positives+1", "sum_positives", "1", "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", "if (j - x) in dp[i]:\n dp[i + 1][j] += dp[i][j - x]\n\n# for d in dp:\n# print(d)", "(j - x) in dp[i]", "j - x", "j", "x", "dp[i]", "dp", "i", "dp[i + 1][j] += dp[i][j - x]", "dp[i + 1][j]", "[i + 1]", "dp", "i + 1", "i", "1", "j", "dp[i][j - x]", "[i]", "dp", "i", "j - x", "j", "x", "print(dp[N][0] - 1)", "print", "dp[N][0] - 1", "dp[N][0]", "[N]", "dp", "N", "0", "1", "exit()", "exit", "dp = [dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)]", "[dict([(i, 0) for i in range(sum_negatives, sum_positives+1)])\n for _ in range(N+1)]", "dp", "X = [int(a) - A for a in input().split(' ')]", "[int(a) - A for a in input().split(' ')]", "X", "sum_positives = sum([x for x in X if x > 0])", "sum([x for x in X if x > 0])", "sum_positives", "sum_negatives = sum([x for x in X if x < 0])", "sum([x for x in X if x < 0])", "sum_negatives", "N, A = map(int, input().split(' '))", "map(int, input().split(' '))", "N", "A = map(int, input().split(' '))", "map(int, input().split(' '))", "A" ]

[ 7, 12, 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, 41, 28, 13, 4, 13, 2, 13, 17, 4, 4, 13, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 4, 13, 13, 0, 18, 13, 2, 13, 17, 4, 18, 18, 13, 13, 13, 28, 13, 13, 4, 18, 18, 13, 13, 13, 0, 18, 18, 13, 2, 13, 17, 2, 13, 13, 2, 4, 18, 18, 13, 13, 13, 2, 13, 13, 17, 13, 0, 13, 2, 18, 18, 13, 13, 17, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 25 ], [ 35, 34 ], [ 4, 38 ], [ 45, 44 ], [ 52, 47 ], [ 44, 49 ], [ 15, 58 ], [ 65, 60 ], [ 44, 61 ], [ 44, 68 ], [ 44, 77 ], [ 90, 81 ], [ 44, 83 ], [ 44, 94 ], [ 104, 103 ], [ 44, 107 ], [ 4, 108 ], [ 103, 113 ], [ 122, 119 ] ]

[ "def abc044_c():\n N, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split())) # 平均ターゲットを引いた状態\n dp = [dict() for _ in range(N+1)] # 負の値を取り得るため、配列でなく辞書で持つ\n dp[0][0] = 1 # 0枚時点で何も選ばない、を初期値とする\n for i, x in enumerate(X):\n dp[i+1] = dp[i].copy() # 前の状態を引き継ぐ\n for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ans = dp[N][0] - 1\n print(ans)\n\nif __name__ == '__main__':\n abc044_c()", "def abc044_c():\n N, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split())) # 平均ターゲットを引いた状態\n dp = [dict() for _ in range(N+1)] # 負の値を取り得るため、配列でなく辞書で持つ\n dp[0][0] = 1 # 0枚時点で何も選ばない、を初期値とする\n for i, x in enumerate(X):\n dp[i+1] = dp[i].copy() # 前の状態を引き継ぐ\n for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ans = dp[N][0] - 1\n print(ans)", "abc044_c", "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", "dict() for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "dict()", "dict", "dp = [dict() for _ in range(N+1)]", "dp", "[dict() for _ in range(N+1)]", "dp[0][0] = 1", "dp[0][0]", "[0]", "dp", "0", "0", "1", "for i, x in enumerate(X):\n dp[i+1] = dp[i].copy() # 前の状態を引き継ぐ\n for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ", "i", "x", "enumerate(X)", "enumerate", "X", "dp[i+1] = dp[i].copy()", "dp[i+1]", "dp", "i+1", "i", "1", "dp[i].copy()", "[i].copy", "[i]", "dp", "i", "copy", "for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ", "val", "cnt", "dp[i].items()", "[i].items", "[i]", "dp", "i", "items", "dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt", "dp[i+1][val + x]", "[i+1]", "dp", "i+1", "i", "1", "val + x", "val", "x", "dp[i].get(val + x, 0) + cnt", "dp[i].get(val + x, 0)", "[i].get", "[i]", "dp", "i", "get", "val + x", "val", "x", "0", "cnt", "ans = dp[N][0] - 1", "ans", "dp[N][0] - 1", "dp[N][0]", "[N]", "dp", "N", "0", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n abc044_c()", "__name__ == '__main__'", "__name__", "'__main__'", "abc044_c()", "abc044_c", "def abc044_c():\n N, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split())) # 平均ターゲットを引いた状態\n dp = [dict() for _ in range(N+1)] # 負の値を取り得るため、配列でなく辞書で持つ\n dp[0][0] = 1 # 0枚時点で何も選ばない、を初期値とする\n for i, x in enumerate(X):\n dp[i+1] = dp[i].copy() # 前の状態を引き継ぐ\n for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ans = dp[N][0] - 1\n print(ans)", "def abc044_c():\n N, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split())) # 平均ターゲットを引いた状態\n dp = [dict() for _ in range(N+1)] # 負の値を取り得るため、配列でなく辞書で持つ\n dp[0][0] = 1 # 0枚時点で何も選ばない、を初期値とする\n for i, x in enumerate(X):\n dp[i+1] = dp[i].copy() # 前の状態を引き継ぐ\n for val, cnt in dp[i].items():\n dp[i+1][val + x] = dp[i].get(val + x, 0) + cnt # 前のターンのxシフト分を加算\n ans = dp[N][0] - 1\n print(ans)", "abc044_c" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 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, 2, 4, 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, 2, 17, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 28, 13, 4, 13, 17, 17, 14, 40, 40, 17, 2, 2, 13, 17, 18, 13, 2, 13, 17, 17, 0, 18, 18, 13, 13, 2, 13, 17, 2, 18, 18, 13, 2, 13, 17, 2, 2, 13, 17, 18, 13, 2, 13, 17, 18, 18, 13, 2, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 2, 13, 17, 18, 18, 13, 2, 13, 17, 2, 13, 17, 4, 13, 2, 18, 18, 13, 13, 2, 17, 17, 17, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 18, 13, 10, 13, 13 ]

[ [ 167, 4 ], [ 13, 12 ], [ 168, 16 ], [ 12, 21 ], [ 161, 23 ], [ 161, 25 ], [ 29, 28 ], [ 168, 32 ], [ 28, 38 ], [ 162, 39 ], [ 164, 41 ], [ 46, 45 ], [ 159, 49 ], [ 170, 57 ], [ 67, 60 ], [ 171, 62 ], [ 70, 69 ], [ 159, 74 ], [ 78, 77 ], [ 77, 88 ], [ 165, 91 ], [ 69, 93 ], [ 104, 97 ], [ 171, 99 ], [ 69, 100 ], [ 77, 102 ], [ 171, 107 ], [ 69, 109 ], [ 77, 113 ], [ 165, 116 ], [ 69, 118 ], [ 171, 122 ], [ 69, 124 ], [ 77, 127 ], [ 137, 130 ], [ 171, 132 ], [ 69, 133 ], [ 77, 135 ], [ 171, 139 ], [ 69, 141 ], [ 77, 144 ], [ 171, 151 ], [ 159, 152 ], [ 161, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ] ]

[ "import sys\ninput = sys.stdin.readline\n\nN, A = [int(x) for x in input().split()]\nx = [int(x) - A for x in input().split()]\n\ndp = [[0] * 5001 for _ in range(N + 1)]\ndp[0][0 + 2500] = 1\n\nfor i in range(1, N + 1):\n for j in range(-2500, 2501):\n if 5000 >= j + 2500 - x[i - 1] >= 0:\n dp[i][j + 2500] = dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]\n else:\n dp[i][j + 2500] = dp[i - 1][j + 2500]\n\nprint(dp[N][0 + 2500] - 1) # 何も選ばないものを引く", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "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) - 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()]", "[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 + 2500] = 1", "dp[0][0 + 2500]", "[0]", "dp", "0", "0 + 2500", "0", "2500", "1", "for i in range(1, N + 1):\n for j in range(-2500, 2501):\n if 5000 >= j + 2500 - x[i - 1] >= 0:\n dp[i][j + 2500] = dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]\n else:\n dp[i][j + 2500] = dp[i - 1][j + 2500]", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "for j in range(-2500, 2501):\n if 5000 >= j + 2500 - x[i - 1] >= 0:\n dp[i][j + 2500] = dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]\n else:\n dp[i][j + 2500] = dp[i - 1][j + 2500]", "j", "range(-2500, 2501)", "range", "-2500", "2501", "if 5000 >= j + 2500 - x[i - 1] >= 0:\n dp[i][j + 2500] = dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]\n else:\n dp[i][j + 2500] = dp[i - 1][j + 2500]", "5000 >= j + 2500 - x[i - 1] >= 0", "5000 >= j + 2500 - x[i - 1]", "5000", "j + 2500 - x[i - 1]", "j + 2500", "j", "2500", "x[i - 1]", "x", "i - 1", "i", "1", "0", "dp[i][j + 2500] = dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]", "dp[i][j + 2500]", "[i]", "dp", "i", "j + 2500", "j", "2500", "dp[i - 1][j + 2500 - x[i - 1]] + dp[i - 1][j + 2500]", "dp[i - 1][j + 2500 - x[i - 1]]", "[i - 1]", "dp", "i - 1", "i", "1", "j + 2500 - x[i - 1]", "j + 2500", "j", "2500", "x[i - 1]", "x", "i - 1", "i", "1", "dp[i - 1][j + 2500]", "[i - 1]", "dp", "i - 1", "i", "1", "j + 2500", "j", "2500", "dp[i][j + 2500] = dp[i - 1][j + 2500]", "dp[i][j + 2500]", "[i]", "dp", "i", "j + 2500", "j", "2500", "dp[i - 1][j + 2500]", "[i - 1]", "dp", "i - 1", "i", "1", "j + 2500", "j", "2500", "print(dp[N][0 + 2500] - 1)", "print", "dp[N][0 + 2500] - 1", "dp[N][0 + 2500]", "[N]", "dp", "N", "0 + 2500", "0", "2500", "1", "N, A = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "N", "A = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "A", "x = [int(x) - A for x in input().split()]", "[int(x) - A for x in input().split()]", "x", "input = sys.stdin.readline", "sys.stdin.readline", "input", "dp = [[0] * 5001 for _ in range(N + 1)]", "[[0] * 5001 for _ in range(N + 1)]", "dp" ]

[ 7, 15, 13, 0, 13, 18, 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, 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, 13, 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, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 40, 2, 13, 13, 13, 0, 13, 18, 18, 18, 13, 17, 13, 2, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 173, 4 ], [ 16, 15 ], [ 174, 22 ], [ 16, 24 ], [ 27, 26 ], [ 174, 35 ], [ 39, 38 ], [ 26, 41 ], [ 45, 44 ], [ 15, 48 ], [ 54, 53 ], [ 63, 56 ], [ 53, 59 ], [ 66, 65 ], [ 15, 68 ], [ 71, 70 ], [ 15, 73 ], [ 76, 75 ], [ 38, 78 ], [ 53, 84 ], [ 65, 85 ], [ 70, 86 ], [ 75, 87 ], [ 100, 91 ], [ 53, 94 ], [ 65, 96 ], [ 70, 98 ], [ 75, 99 ], [ 53, 103 ], [ 65, 104 ], [ 70, 105 ], [ 75, 106 ], [ 123, 108 ], [ 53, 111 ], [ 65, 113 ], [ 70, 116 ], [ 75, 119 ], [ 26, 121 ], [ 65, 122 ], [ 53, 126 ], [ 65, 127 ], [ 70, 128 ], [ 75, 129 ], [ 132, 131 ], [ 38, 133 ], [ 24, 134 ], [ 137, 136 ], [ 140, 139 ], [ 15, 144 ], [ 139, 149 ], [ 24, 150 ], [ 38, 151 ], [ 154, 153 ], [ 53, 157 ], [ 139, 159 ], [ 139, 161 ], [ 24, 162 ], [ 153, 165 ], [ 136, 165 ], [ 177, 171 ], [ 173, 174 ] ]

[ "import sys\ninput = sys.stdin.buffer.readline\n\ndef main():\n N,A = map(int,input().split())\n x = list(map(int,input().split()))\n S = sum(x)\n \n dp = [[[0 for _ in range(S+1)] for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(S):\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]\n\n M = S//A\n ans = 0\n for i in range(1,N+1):\n if i*A <= S:\n ans += dp[-1][i][i*A]\n \n print(ans)\n \nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "def main():\n N,A = map(int,input().split())\n x = list(map(int,input().split()))\n S = sum(x)\n \n dp = [[[0 for _ in range(S+1)] for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(S):\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]\n\n M = S//A\n ans = 0\n for i in range(1,N+1):\n if i*A <= S:\n ans += dp[-1][i][i*A]\n \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", "S = sum(x)", "S", "sum(x)", "sum", "x", "[[0 for _ in range(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 for _ in range(S+1)] for _ in range(N+1)]", "dp = [[[0 for _ in range(S+1)] for _ in range(N+1)] for _ in range(N+1)]", "dp", "[[[0 for _ in range(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):\n for k in range(S):\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]\n\n ", "i", "range(N)", "range", "N", "for j in range(N):\n for k in range(S):\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]\n\n ", "j", "range(N)", "range", "N", "for k in range(S):\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]\n\n ", "k", "range(S)", "range", "S", "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", "M = S//A", "M", "S//A", "S", "A", "ans = 0", "ans", "0", "for i in range(1,N+1):\n if i*A <= S:\n ans += dp[-1][i][i*A]\n \n ", "i", "range(1,N+1)", "range", "1", "N+1", "N", "1", "if i*A <= S:\n ans += dp[-1][i][i*A]\n \n ", "i*A <= S", "i*A", "i", "A", "S", "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", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "def main():\n N,A = map(int,input().split())\n x = list(map(int,input().split()))\n S = sum(x)\n \n dp = [[[0 for _ in range(S+1)] for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(S):\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]\n\n M = S//A\n ans = 0\n for i in range(1,N+1):\n if i*A <= S:\n ans += dp[-1][i][i*A]\n \n print(ans)\n ", "def main():\n N,A = map(int,input().split())\n x = list(map(int,input().split()))\n S = sum(x)\n \n dp = [[[0 for _ in range(S+1)] for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(S):\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]\n\n M = S//A\n ans = 0\n for i in range(1,N+1):\n if i*A <= S:\n ans += dp[-1][i][i*A]\n \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, 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, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 18, 13, 13, 13, 14, 2, 13, 13, 0, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 13, 18, 18, 18, 13, 13, 2, 13, 17, 13, 14, 2, 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, 18, 18, 18, 13, 2, 13, 17, 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, 4, 13, 10, 18, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 206, 2 ], [ 206, 11 ], [ 191, 13 ], [ 27, 26 ], [ 204, 30 ], [ 197, 35 ], [ 39, 38 ], [ 204, 42 ], [ 52, 45 ], [ 198, 48 ], [ 38, 49 ], [ 55, 54 ], [ 204, 57 ], [ 60, 59 ], [ 54, 63 ], [ 67, 66 ], [ 204, 71 ], [ 207, 72 ], [ 192, 77 ], [ 54, 78 ], [ 66, 79 ], [ 54, 82 ], [ 59, 83 ], [ 96, 85 ], [ 198, 88 ], [ 54, 90 ], [ 59, 93 ], [ 66, 95 ], [ 198, 99 ], [ 54, 100 ], [ 59, 102 ], [ 66, 104 ], [ 54, 107 ], [ 59, 108 ], [ 121, 110 ], [ 198, 113 ], [ 54, 115 ], [ 59, 118 ], [ 66, 120 ], [ 198, 125 ], [ 54, 126 ], [ 59, 128 ], [ 66, 130 ], [ 198, 134 ], [ 54, 135 ], [ 59, 136 ], [ 66, 138 ], [ 192, 140 ], [ 54, 141 ], [ 154, 143 ], [ 198, 146 ], [ 54, 148 ], [ 59, 151 ], [ 66, 153 ], [ 198, 157 ], [ 54, 158 ], [ 59, 159 ], [ 66, 161 ], [ 192, 163 ], [ 54, 164 ], [ 200, 166 ], [ 170, 169 ], [ 204, 174 ], [ 194, 177 ], [ 198, 181 ], [ 204, 182 ], [ 169, 183 ], [ 207, 185 ], [ 169, 186 ], [ 195, 189 ], [ 201, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ], [ 200, 201 ], [ 206, 204 ], [ 206, 207 ] ]

[ "n, a = map(int, input().split())\nX = list(map(int, input().split()))\ndp = [ [[0]*(n*a+1) for j in range(i+1)] for i in range(n+1) ]\nfor i in range(n+1):\n dp[i][0][0] = 1\nfor i in range(n):\n for j in range(i+1):\n for k in range(n*a+1):\n if X[i] > k:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n else:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]\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", "[[0]*(n*a+1) for j in range(i+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*a+1) for j in range(i+1)]", "dp = [ [[0]*(n*a+1) for j in range(i+1)] for i in range(n+1) ]", "dp", "[ [[0]*(n*a+1) for j in range(i+1)] for i in range(n+1) ]", "for i in range(n+1):\n dp[i][0][0] = 1", "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 for j in range(i+1):\n for k in range(n*a+1):\n if X[i] > k:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n else:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]", "i", "range(n)", "range", "n", "for j in range(i+1):\n for k in range(n*a+1):\n if X[i] > k:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n else:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]", "j", "range(i+1)", "range", "i+1", "i", "1", "for k in range(n*a+1):\n if X[i] > k:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n else:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]", "k", "range(n*a+1)", "range", "n*a+1", "n*a", "n", "a", "1", "if X[i] > k:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n else:\n if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]", "X[i] > k", "X[i]", "X", "i", "k", "if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n ", "i > j", "i", "j", "dp[i+1][j+1][k] = dp[i][j+1][k]", "dp[i+1][j+1][k]", "[j+1]", "[i+1]", "dp", "i+1", "i", "1", "j+1", "j", "1", "k", "dp[i][j+1][k]", "[j+1]", "[i]", "dp", "i", "j+1", "j", "1", "k", "if i > j:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-X[i]]\n else:\n dp[i+1][j+1][k] = dp[i][j][k-X[i]]", "i > j", "i", "j", "dp[i+1][j+1][k] = dp[i][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+1][k] + dp[i][j][k-X[i]]", "dp[i][j+1][k]", "[j+1]", "[i]", "dp", "i", "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+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", "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", "ans += dp[n][i][a*i]", "dp[n][i][a*i]", "ans", "dp = [ [[0]*(n*a+1) for j in range(i+1)] for i in range(n+1) ]", "[ [[0]*(n*a+1) for j in range(i+1)] for i in range(n+1) ]", "dp", "ans = 0", "0", "ans", "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, 2, 39, 17, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 41, 28, 13, 4, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 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, 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, 14, 40, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 2, 18, 18, 18, 13, 2, 13, 17, 2, 13, 17, 2, 13, 18, 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, 13, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13 ]

[ [ 170, 2 ], [ 170, 11 ], [ 173, 13 ], [ 30, 29 ], [ 176, 36 ], [ 40, 39 ], [ 51, 44 ], [ 177, 47 ], [ 39, 48 ], [ 54, 53 ], [ 162, 58 ], [ 62, 61 ], [ 53, 66 ], [ 70, 69 ], [ 69, 75 ], [ 174, 77 ], [ 53, 78 ], [ 87, 80 ], [ 177, 83 ], [ 53, 84 ], [ 61, 85 ], [ 69, 86 ], [ 177, 90 ], [ 53, 92 ], [ 61, 94 ], [ 69, 95 ], [ 69, 98 ], [ 174, 100 ], [ 53, 101 ], [ 110, 103 ], [ 177, 106 ], [ 53, 107 ], [ 61, 108 ], [ 69, 109 ], [ 177, 114 ], [ 53, 116 ], [ 61, 119 ], [ 69, 122 ], [ 174, 124 ], [ 53, 125 ], [ 177, 129 ], [ 53, 131 ], [ 61, 133 ], [ 69, 134 ], [ 167, 136 ], [ 140, 139 ], [ 162, 144 ], [ 164, 147 ], [ 177, 151 ], [ 162, 152 ], [ 139, 153 ], [ 139, 155 ], [ 171, 156 ], [ 165, 159 ], [ 168, 159 ], [ 170, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ] ]

[ "N,A = map(int,input().split())\nls1 = [0] + list(map(int,input().split()))\n\ndp = [[[0 for k in range(2600)] for j in range(51) ] for i in range(51)]\nfor i in range(51):\n dp[i][0][0] = 1\nfor j in range(1,N+1):\n for k in range(1,j+1):\n for s in range(2600):\n if s < ls1[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][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", "ls1 = [0] + list(map(int,input().split()))", "ls1", "[0] + list(map(int,input().split()))", "[0]", "0", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "[[0 for k in range(2600)] for j in range(51) ] for i in range(51)", "for i in range(51)", "i", "range(51)", "range", "51", "for i in range(51)", "[[0 for k in range(2600)] for j in range(51) ]", "dp = [[[0 for k in range(2600)] for j in range(51) ] for i in range(51)]", "dp", "[[[0 for k in range(2600)] for j in range(51) ] for i in range(51)]", "for i in range(51):\n dp[i][0][0] = 1", "i", "range(51)", "range", "51", "dp[i][0][0] = 1", "dp[i][0][0]", "[0]", "[i]", "dp", "i", "0", "0", "1", "for j in range(1,N+1):\n for k in range(1,j+1):\n for s in range(2600):\n if s < ls1[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "j", "range(1,N+1)", "range", "1", "N+1", "N", "1", "for k in range(1,j+1):\n for s in range(2600):\n if s < ls1[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "k", "range(1,j+1)", "range", "1", "j+1", "j", "1", "for s in range(2600):\n if s < ls1[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "s", "range(2600)", "range", "2600", "if s < ls1[j]:\n dp[j][k][s] = dp[j-1][k][s]\n elif s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "s < ls1[j]", "s", "ls1[j]", "ls1", "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 s >= ls1[j]:\n dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "s >= ls1[j]", "s", "ls1[j]", "ls1", "j", "dp[j][k][s] = dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "dp[j][k][s]", "[k]", "[j]", "dp", "j", "k", "s", "dp[j-1][k-1][s-ls1[j]] + dp[j-1][k][s]", "dp[j-1][k-1][s-ls1[j]]", "[k-1]", "[j-1]", "dp", "j-1", "j", "1", "k-1", "k", "1", "s-ls1[j]", "s", "ls1[j]", "ls1", "j", "dp[j-1][k][s]", "[k]", "[j-1]", "dp", "j-1", "j", "1", "k", "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", "N,A = map(int,input().split())", "map(int,input().split())", "N", "ans += dp[N][k][k*A]", "dp[N][k][k*A]", "ans", "ans = 0", "0", "ans", "A = map(int,input().split())", "map(int,input().split())", "A", "ls1 = [0] + list(map(int,input().split()))", "[0] + list(map(int,input().split()))", "ls1", "dp = [[[0 for k in range(2600)] for j in range(51) ] for i in range(51)]", "[[[0 for k in range(2600)] for j in range(51) ] for i in range(51)]", "dp" ]