Datasets:

TnT

/

Multi_CodeNet4Repair

like 7

p02546

u001689394

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if not list[x-1] == list[-1]:\n if list[x] == list[x+1]:\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n n = n - 1\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n n = n - 1\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n n = n - 1\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "n = input()\na = 's'\nb = 'es'\nif n[-1] == 's':\n n = n + b\nelse:\n n = n + a", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n n = n - 1\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n n = n - 1\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n n = n - 1\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n y = 1\n if not x+7 > len(list):\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "n = input()\na = 's'\nb = 'es'\nif n[-1] == 's':\n n = n + b\nelse:\n n = n + a\nprint(n)"]

['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted']

['s039487440', 's119616299', 's436867598', 's441767902', 's492205887', 's312485570']

[8936.0, 9116.0, 9028.0, 9228.0, 9084.0, 9016.0]

[27.0, 34.0, 27.0, 21.0, 28.0, 24.0]

[500, 522, 79, 522, 474, 88]

p02546

u013227739

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nif l[-1] == 's':\n s += 'es'\nelse:\n s += 's'", 's = input()\nl = []\nfor i in s:\n l.append(i)\nif l[-1] == \'s\':\n l.append(\'es\')\n print("".join(j for j in l))\nelse:\n l.append(\'s\')\n print("".join(j for j in l))\n \n \n \n \n \n ']

['Runtime Error', 'Accepted']

['s967267890', 's590706178']

[8960.0, 9112.0]

[24.0, 31.0]

[61, 235]

p02546

u014170064

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['x = input()\nif x.endswith("s") == True:\n x = x + "es"\nelse:\n x = x + "s"', 'x = input()\nif x.endswith("s") == True:\n x = x + "es"\nelse:\n x = x + "s"\nprint(x)']

['Wrong Answer', 'Accepted']

['s745677340', 's358497855']

[9080.0, 8920.0]

[27.0, 26.0]

[74, 83]

p02546

u027977105

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N = int(input())\nz = 0\nfor a in range(N):\n for b in range(N):\n c = N - (a+1)*(b+1)\n if c > 0:\n z = z+1\n else:\n pass\nprint(z)', 's = input()\nif s[-1]=="s":\n t = s + "es"\nelse:\n t = s + "s"\nprint(t)']

['Runtime Error', 'Accepted']

['s876956801', 's845656598']

[9064.0, 9080.0]

[26.0, 25.0]

[170, 74]

p02546

u032625182

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["import os,sys\nc=0\n\nn=input()\nfor i in range(int(n)):\n m=input()\n one=m[0]\n two=m[2]\n if(one==two):\n c+=1\n \nif(c>=3):\n print('Yes')\nelse:\n print('No')\n", "import os,sys\n\ns=input()\nn=len(s)\nif s[n-1]=='s':\n s=s+'es'\nelse:\n s=s+'s'\n\nprint(s)"]

['Runtime Error', 'Accepted']

['s998157104', 's300557894']

[9164.0, 9028.0]

[26.0, 29.0]

[178, 90]

p02546

u034194513

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = list(input())\n\nes = list("es")\nss = list("s")\n\nprint(len(s))\n\n\nf = s[len(s)-1]\nprint(f)\n\nif f == "s":\n ans = s+es\n ans = "".join(ans)\n print(ans)\nelse:\n ans = s+ss\n ans = "".join(ans)\n print(ans)\n \n', 's = list(input())\n\nes = list("es")\nss = list("s")\n\n#print(len(s))\n\n\nf = s[len(s)-1]\n#print(f)\n\nif f == "s":\n ans = s+es\n ans = "".join(ans)\n print(ans)\nelse:\n ans = s+ss\n ans = "".join(ans)\n print(ans)\n \n']

['Wrong Answer', 'Accepted']

['s312740921', 's588080099']

[9120.0, 9032.0]

[34.0, 31.0]

[209, 211]

p02546

u035453792

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\nif s[-1]=="s":\n print(s+"es")\nelse:\n print(s)', 's = input()\nif s[-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']

['Wrong Answer', 'Accepted']

['s770945909', 's540100328']

[8940.0, 8976.0]

[27.0, 26.0]

[59, 63]

p02546

u039526919

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s=input()\nif s[-1]=='s':\n print(s[:-1]+'es')\nelif s[-1]!='s':\n print(s[:-1]+'s')", 'from pattern.en import pluralize, singularize\ns=input()\nprint(pluralize(s))', "s=input()\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')"]

['Wrong Answer', 'Runtime Error', 'Accepted']

['s569734355', 's786356193', 's247164242']

[9088.0, 8948.0, 9020.0]

[31.0, 29.0, 32.0]

[82, 75, 65]

p02546

u050103839

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = str(input())\nif S[-1] == 's':\n S += 's'\nelse:\n S += 'es'\nreturn S\n\n", "S = str(input())\nif S[-1] == 's':\n\tS += 's'\nelse:\n\tS += 'es'\nprint(S)", "S = str(input())\nif S[-1] != 's':\n S += 's'\nelse:\n S += 'es'\nprint(S)"]

['Runtime Error', 'Wrong Answer', 'Accepted']

['s726196521', 's852647444', 's490519169']

[9012.0, 9016.0, 9084.0]

[32.0, 33.0, 30.0]

[73, 69, 71]

p02546

u057362336

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s=input()\nif s[-1]=='s':\n s+='es'\nelse:\n s+='s'", "s=input()\nif s[-1]=='s':\n s+='es'\nelse:\n s+='s'\nprint(s)"]

['Wrong Answer', 'Accepted']

['s403951392', 's673707969']

[9076.0, 9076.0]

[31.0, 31.0]

[49, 58]

p02546

u060012100

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s= input()\nif s.endwith('s'):\n print(s+'es')\nelse:\n print(s+'s')", "s= input()\nif s.endswith('s'):\n print(s+'es')\nelse:\n print(s+'s')"]

['Runtime Error', 'Accepted']

['s871107146', 's839278517']

[9084.0, 9076.0]

[23.0, 30.0]

[66, 67]

p02546

u061835391

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s=input()\nn=len(s)\nif s[n-1]!=s:\n s=s[0:n-1]+'s'\nelse:\n s=s[0:n-1]+'es'\nprint(s)", "s=input()\nn=len(s)\nif s[n-1]!='s':\n s=s[0:n]+'s'\nelif s[n-1]=='s':\n s=s[0:n]+'es'\nprint(s)\n"]

['Wrong Answer', 'Accepted']

['s875057069', 's196072887']

[9032.0, 9024.0]

[27.0, 27.0]

[82, 93]

p02546

u063346608

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S = input()\n\nif len(S)-1 =="e" :\n\tprint(S + "s")\nelse :\n\tprint(S + "es")', 'S = input()\n\nif S[len(S)-1] =="s" :\n\tprint(S + "es")\nelse :\n\tprint(S + "s")']

['Wrong Answer', 'Accepted']

['s087174427', 's225669140']

[9100.0, 9032.0]

[32.0, 30.0]

[72, 75]

p02546

u071905150

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nif s[s.length-1] == 's':\n print(s+'es')\nelse:\n print(s+'s')\n\n", "s = input()\nif s[len(s)-1] == 's':\n print(s+'es')\nelse:\n print(s+'s')\n\n"]

['Runtime Error', 'Accepted']

['s064896218', 's118599423']

[9080.0, 9012.0]

[27.0, 29.0]

[79, 77]

p02546

u075109824

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['import inflect\ns = input()\n\np = inflect.engine()\nprint(p.plural(s))', '# import inflect\ns = input()\n\n# p = inflect.engine()\n# print(p.plural(s))\n\n\nif s[-1:] == "s":\n print(s+"es")\nelse:\n print(s+"s")']

['Runtime Error', 'Accepted']

['s602145761', 's427308694']

[9080.0, 9084.0]

[24.0, 30.0]

[67, 134]

p02546

u085186789

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["words = input()\nif words[-1] != s:\n words += 's'\nelse:\n words += 'es'\nprint(words)\n \n \n ", 'words = input()\nif words[-1] != s:\n words += "s"\nelse:\n words += "es"\nprint(words)\n \n \n \n', 'words = input()\nif words[-1] != "s":\n words += "s"\nelse:\n words += "es"\nprint(words)\n \n \n \n']

['Runtime Error', 'Runtime Error', 'Accepted']

['s598459942', 's976766112', 's375503948']

[8996.0, 8792.0, 9064.0]

[26.0, 21.0, 28.0]

[92, 93, 95]

p02546

u087590461

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["N= int(input())\ncount=0\nfor i in range(N):\n\tp,q=map(int,input().split(' '))\n\tif p==q:\n\t\tcount+=1\n\telse:\n\t\tcount=0\n\nif count>=3:\n\tprint('Yes')\nelse:\n \tprint('No')", '# -*- coding: utf-8 -*-\n"""Untitled3.ipynb\n\nAutomatically generated by Colaboratory.\n\nOriginal file is located at\n https://colab.research.google.com/drive/1VVfPJl7_dXodPfxyID5RNKhqW1ZRqVux\n"""\n\nN= int(input())\ncount=0\nfor i in range(N):\n p,q=map(int,input().split(\' \'))\n if count<3:\n if p==q:\n count+=1\n else:\n count=0\n else:\n pass\n\nif count>=3:\n print(\'Yes\')\nelse:\n print(\'No\')', "S= input()\nif S[-1]=='s':\n\tS+='es'\nelse:\n\tS+='s'\nprint(S)"]

['Runtime Error', 'Runtime Error', 'Accepted']

['s653089307', 's845717695', 's904687663']

[9164.0, 9104.0, 9084.0]

[25.0, 27.0, 27.0]

[162, 405, 57]

p02546

u090068671

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = input()\nif S[-1]=='s':\n print(S+'s')\nelse:\n print(S+'es')", "def resolve():\n\tS = input()\n\tif S[-1] =='s':\n\t\tprint(S+'es')\n\telse:\n\t\tprint(S+'s')\nresolve()"]

['Wrong Answer', 'Accepted']

['s135306876', 's637403593']

[9088.0, 9024.0]

[27.0, 30.0]

[63, 92]

p02546

u092061507

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['import bisect\nN, K = map(int, input().split())\n\nLR = [list(map(int, input().split())) for i in range(K)]\nS = set()\nfor i in LR:\n for j in range(i[0], i[1]+1):\n S.add(j)\nL = sorted(list(S))\n\ndp = [0 for i in range(N)]\ndp[0] = 1\nfor i in range(1, N):\n x = bisect.bisect(L, i)\n t = L[:x]\n for j in t:\n dp[i] += dp[i-j]\n dp[i] = dp[i] % 998244353\n\nprint(dp[-1] % 998244353)\n', "S = input()\n\nif S[-1] == 's':\n print(S + 'es')\nelse:\n print(S + 's')\n"]

['Runtime Error', 'Accepted']

['s696179687', 's333814525']

[9020.0, 9080.0]

[28.0, 26.0]

[399, 75]

p02546

u093838453

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n = int(input())\ncount=0\n\nfor num in range(n):\n d1,d2 = map(int,input().split())\n if d1 == d2:\n count += 1\nelse:\n if count>0:\n print("Yes")\n else:\n print("No")', 's=input()\n\nif s.endswith("s"):\n print(s+"es")\nelse:\n print(s+"s")\n']

['Runtime Error', 'Accepted']

['s344447384', 's703564861']

[9172.0, 9072.0]

[21.0, 29.0]

[192, 72]

p02546

u101850722

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\np = ""\n\nif(s.endswith("s")){\n p = s + "es"\n}else{\n p = s + "s"\n}\n\nprint(s)', 's = input()\np = ""\n\nif(s.endswith("s")):\n p = s + "es"\nelse:\n p = s + "s"\n\nprint(p)\n']

['Runtime Error', 'Accepted']

['s705893424', 's331360661']

[8864.0, 9004.0]

[27.0, 25.0]

[88, 86]

p02546

u105862524

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["word = int(input())\n\nif word[-1] == 's': \n\tprint(word + 'es')\nelse:\n\tprint(word + 's')", "word = input()\n \nif word[-1] == 's':\n\tprint(word + 'es')\nelse:print(word + 's')"]

['Runtime Error', 'Accepted']

['s849086045', 's155029037']

[9148.0, 9072.0]

[27.0, 28.0]

[86, 79]

p02546

u106311097

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["#!python3.8\n# -*- coding: utf-8 -*-\n# abc179/abc179_b\nimport sys\n\ns2nn = lambda s: [int(c) for c in s.split(' ')]\nss2nn = lambda ss: [int(s) for s in list(ss)]\nss2nnn = lambda ss: [s2nn(s) for s in list(ss)]\ni2s = lambda: sys.stdin.readline().rstrip()\ni2n = lambda: int(i2s())\ni2nn = lambda: s2nn(i2s())\nii2ss = lambda n: [i2s() for _ in range(n)]\nii2nn = lambda n: ss2nn(ii2ss(n))\nii2nnn = lambda n: ss2nnn(ii2ss(n))\n\ndef main():\n return\n\nmain()\n", "#!python3.8\n# -*- coding: utf-8 -*-\n# abc179/abc179_a\nimport sys\n\ns2nn = lambda s: [int(c) for c in s.split(' ')]\nss2nn = lambda ss: [int(s) for s in list(ss)]\nss2nnn = lambda ss: [s2nn(s) for s in list(ss)]\ni2s = lambda: sys.stdin.readline().rstrip()\ni2n = lambda: int(i2s())\ni2nn = lambda: s2nn(i2s())\nii2ss = lambda n: [i2s() for _ in range(n)]\nii2nn = lambda n: ss2nn(ii2ss(n))\nii2nnn = lambda n: ss2nnn(ii2ss(n))\n\ndef main():\n S = i2s()\n if S[-1] != 's':\n print(S + 's')\n else:\n print(S + 'es')\n return\n\nmain()\n"]

['Wrong Answer', 'Accepted']

['s552738512', 's454246346']

[9120.0, 9132.0]

[33.0, 27.0]

[450, 542]

p02546

u110207693

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["if s[-1] == 's': \n s += 'es' \nelse: \n s += 's' \nprint(s) ", "s = input() \nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's' \nprint(s)"]

['Runtime Error', 'Accepted']

['s278211830', 's270240582']

[9080.0, 9072.0]

[30.0, 26.0]

[174, 175]

p02546

u111559399

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

[" x= str(input())\na=list(x)\nl=len(a)\nif a[l-1]=='s':\n print(x+'es')\nelse:\n print(x+'s')", "x= str(input())\na=list(x)\nl=len(a)\nif a[l-1]=='s':\n print(x+'es')\nelse:\n print(x+'s')"]

['Runtime Error', 'Accepted']

['s897330088', 's950473533']

[9004.0, 8976.0]

[23.0, 30.0]

[92, 91]

p02546

u124445903

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=input()\nt=len(s)\nif s[t-1]==s:\n s=s+"es"\nelse:\n s=s+\'s\'\n ', "st=input()\nt=len(st)\nn=t-1\nif st[n]=='s':\n st=st+'es'\nelse:\n st=st+'s'\nprint(st)\n \n "]

['Wrong Answer', 'Accepted']

['s258374583', 's452246526']

[9024.0, 9036.0]

[30.0, 26.0]

[64, 92]

p02546

u128282559

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n = int(input())\na = []\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if d1 == d2:\n a.append(True)\n else:\n a.append(False)\na.append(False)\na.append(False)\nfor i in a:\n if i == True:\n if a[a.index(i)+1] and a[a.index(i)+2]:\n print("Yes")\n exit()\nprint("No")', 's =str(input())\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")']

['Runtime Error', 'Accepted']

['s193331499', 's644945074']

[9188.0, 9088.0]

[28.0, 34.0]

[321, 77]

p02546

u146803137

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\nn = int(input())\nx = [0 for i in range(n)]\ny = [0 for i in range(n)]\nans = 'No'\n\nfor i in range(n):\n x[i],y[i] = map(int,input().split())\n\nfor i in range(n-2):\n if (x[i] == y[i])and(x[i+1] == y[i+1])and(x[i+2] == y[i+2]):\n ans = 'Yes'\n\nprint(ans)", "import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\nn = int(input())\nx = [0 for i in range(n)]\ny = [0 for i in range(n)]\nans = 'No'\n\nfor i in range(n):\n x[i],y[i] = map(int,input().split())\n\nfor i in range(n-2):\n if (x[i] == x[i])and(x[i+1] == x[i+1])and(x[i+2] == x[i+2]):\n ans = 'Yes'\n\nprint(ans)", "import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\ns = input()\nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's'\nprint(s)"]

['Runtime Error', 'Runtime Error', 'Accepted']

['s710156920', 's777065594', 's513701325']

[9248.0, 9244.0, 9296.0]

[24.0, 31.0, 29.0]

[2239, 2239, 2050]

p02546

u153823221

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\n\nif s[-1] = "s":\n print(s + "es")\nelse:\n print(s + "s")', 'n = int(input())\np = [list(map(int,input().split())) for i in range(n)]\n\n\na = p[0]\nb = 0\nans = 0\ntf = 1\n\nfor j in range(n):\n if sum(p[j]) // 2 *2 ==sum(p[j]):\n ans += 1\n else:\n ans = 0\n if ans ==3:\n tf = 0\n print("Yes")\n break\n \nif tf == 1:\n print("No")', 's = input()\n \nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")\n\n \n']

['Runtime Error', 'Runtime Error', 'Accepted']

['s434864040', 's532593061', 's863774928']

[9000.0, 9080.0, 9080.0]

[25.0, 25.0, 33.0]

[69, 276, 76]

p02546

u163528399

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N=int(input())\ny=0\nfor j in range(1,N):\n for k in range(1,N): \n if (N-k)%j==0:\n y=y+1\nprint(y)', 'x=input()\nif x[-1]==("s"):\n print(x+"es")\nelif x[-1]!=("s"):\n print(x+"s")']

['Runtime Error', 'Accepted']

['s264784307', 's462287311']

[9152.0, 9088.0]

[27.0, 32.0]

[115, 80]

p02546

u167542063

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=input()\nif s[-1]==s:\n\ts1= s +"es"\n \tprint(s1)\nelse:\n \ts2 = s +"s"\n \tprint(s2)', 's=input()\nif s[-1]==s:\n\ts1= s +"es"\n print(s1)\nelse:\n \ts2 = s +"s"\n print(s2)', 's3="s"\nes="es"\nS=input()\nif S[-1]=="s":\n\ts1= S + es\n\tprint(s1)\nelse:\n\ts2 = S + s3\n\tprint(s2)']

['Runtime Error', 'Runtime Error', 'Accepted']

['s391923894', 's841354424', 's579260456']

[9008.0, 8940.0, 9032.0]

[28.0, 29.0, 30.0]

[84, 82, 92]

p02546

u175590965

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\nif s[-1] == "s":\n print(s+"s")\nelse:\n print(s+"es")', 's = input()\nif s[-1] == "s":\n print(s+"es")\nelse:\n print(s+"s")']

['Wrong Answer', 'Accepted']

['s230531987', 's063870122']

[8948.0, 9008.0]

[30.0, 29.0]

[69, 69]

p02546

u181138123

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['def createPlural(s):\n if s[-1] == "s":\n return s[:-1] + "es"\n else:\n return s + "s"\n\ns = input()\ns_plural = cratePlural\nprint(s_plural)', 'def createPlural(s):\n if s[-1] == "s":\n return s + "es"\n else:\n return s + "s"\n\ns = input()\ns_plural = createPlural(s)\nprint(s_plural)']

['Runtime Error', 'Accepted']

['s529748994', 's226015735']

[9100.0, 9084.0]

[25.0, 31.0]

[155, 154]

p02546

u185405877

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n=input()\nl=len(n)\nif n[l-1]==s:\n print(n+"es")\nelse:\n print(n+"s")', 'n=input()\nl=len(n)\nif n[l-1]=="s":\n print(n+"es")\nelse:\n print(n+"s")']

['Runtime Error', 'Accepted']

['s308092352', 's657090324']

[9088.0, 9112.0]

[26.0, 30.0]

[69, 71]

p02546

u221272125

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\na = 's'\nif s[-1] == 's':\n a = 'es'\ns.append(a)", "s = input()\na = 's'\nif s[-1] == 's':\n a = 'es'\ns = s + a\nprint(s)"]

['Runtime Error', 'Accepted']

['s051227810', 's290070017']

[9040.0, 9080.0]

[29.0, 34.0]

[61, 68]

p02546

u224392054

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['import math\n\nfrom fractions import Fraction as frac\n\nMOD = 1e9 + 7\n\ndef gcd(a, b):\n\n if b == 0:\n\n return a\n\n return gcd(b, a % b)\n\ndef lcm(a, b):\n\n return a * b // gcd(a, b)\n\ndef solve(case_no):\n\n s = str(input())\n\n if s[len(s) - 1] == \'s\':\n\n \tprint(s + "es") else:\n\n \tprint(s + \'s\')\n\nt = 1\n\n# t = int(input())\n\nfor i in range(1, t + 1):\n\n solve(i)', 'import math\n\nfrom fractions import Fraction as frac\n\nMOD = 1e9 + 7\n\ndef gcd(a, b):\n\n if b == 0:\n\n return a\n\n return gcd(b, a % b)\n\ndef lcm(a, b):\n\n return a * b // gcd(a, b)\n\ndef solve(case_no):\n\n s = str(input())\n\n if s[len(s) - 1] == \'s\':\n\n \tprint(s + "es")\n else:\n\n \tprint(s + \'s\')\n\nt = 1\n\n# t = int(input())\n\nfor i in range(1, t + 1):\n\n solve(i)']

['Runtime Error', 'Accepted']

['s107111510', 's916714167']

[9032.0, 10392.0]

[25.0, 39.0]

[382, 383]

p02546

u224989615

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count > 2:\n break\n elif d1 == d2:\n count += 1\n else:\n count == 0\nif count > 2:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count == 3:\n break\n elif d1 == d2:\n count += 1\n else:\n count == 0\nif count == 3:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count > 2:\n break\n else:\n if d1 == d2:\n count += 1\n else:\n count = 0\nif count > 2:\n print("Yes")\nelse:\n print("No")', 's = input()\nif s[-1] == "s":\n print(s+"es")\nelse:\n print(s+"s")']

['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']

['s086544729', 's813446537', 's912385241', 's041566138']

[9168.0, 9080.0, 9156.0, 9024.0]

[24.0, 25.0, 29.0, 28.0]

[212, 214, 225, 65]

p02546

u244466744

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\n\nif s[-1] != "s":\n s.append("s")\n \nelse:\n s.append("es")\n \nprint(s)', 's = input()\n\nif s[-1] != "s":\n s = s + "s"\n \nelse:\n s = s + "es"\n \nprint(s)\n']

['Runtime Error', 'Accepted']

['s671205826', 's958168853']

[9088.0, 9088.0]

[25.0, 29.0]

[83, 80]

p02546

u253220242

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["word = input()\nif word[-1] == 's':\n return ''.join(word, 'es')\nelse:\n return ''.join(word, 's')", "word = input()\nif word[-1] == 's':\n print(word+'es')\nelse:\n print(word+'s')"]

['Runtime Error', 'Accepted']

['s178857821', 's636057908']

[8984.0, 8988.0]

[32.0, 30.0]

[97, 77]

p02546

u255438107

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["n = input()\n\nif n[len(n - 1)] == 's':\n print(n + 'es')\nelse:\n print(n + 's')", "n = input()\n\nif n[len(n) - 1] == 's':\n print(n + 'es')\nelse:\n print(n + 's')"]

['Runtime Error', 'Accepted']

['s785539412', 's735815019']

[9012.0, 9096.0]

[26.0, 26.0]

[82, 82]

p02546

u263173473

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n=int(input())\ncounter=0\nfor i in range(1,n+1):\n for j in range(1,n+1):\n for k in range(n-i*k,n+1):\n if((i*j+k)==n):\n counter=counter+1\nprint(counter)', "str1=input()\nif(str1[len(str1)-1]=='s'):\n print(str1+'es')\nelse:\n print(str1+'s')"]

['Runtime Error', 'Accepted']

['s440422062', 's628855648']

[9168.0, 9028.0]

[26.0, 27.0]

[186, 87]

p02546

u267549094

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=input()\nprint(s)\nif s[-1]==\'s\':\n print(s+"es")\nprint(s+"s")\n', "s=input()\nif s[-1]=='s':\n \ts+='es'\n \treturn s\ns+='s'\nreturn s\n", "s=input()\nif s[-1]=='s':\n s+='es'\n return s\ns+='s'\nreturn s", 's=str(input())\nif(s[-1]=="s"):\n \tprint(s+"es")\nelse:\n\tprint(s+"s")']

['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted']

['s589199499', 's627716770', 's934097827', 's416512307']

[9020.0, 9008.0, 9068.0, 9096.0]

[29.0, 24.0, 25.0, 31.0]

[63, 64, 61, 67]

p02546

u267933821

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S=input()\ns=len(S)\nif S[s] == "s":\n print(S+"es")\nelse:\n print(S+"s")\n ', 'S=input()\ns=len(S)\nif S[s-1] == "s":\n print(S+"es")\nelse:\n print(S+"s")']

['Runtime Error', 'Accepted']

['s538877372', 's005251006']

[9020.0, 9100.0]

[25.0, 29.0]

[76, 73]

p02546

u271123940

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nfor i in s:\n if s[-1] == 's':\n s.join('es')\n else:\n s.join('s')\nprint(s)", 's = input()\nl = []\nfor i in s:\n l.append(i)\nif l[-1] == \'s\':\n l.append(\'es\')\n print("".join(j for j in l))\nelse:\n l.append(\'s\')\n print("".join(j for j in l))']

['Wrong Answer', 'Accepted']

['s869577898', 's839344134']

[9020.0, 9132.0]

[28.0, 34.0]

[92, 170]

p02546

u271153916

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(sa + "s")', 's = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")']

['Runtime Error', 'Accepted']

['s484012292', 's420678745']

[9084.0, 9088.0]

[32.0, 31.0]

[74, 73]

p02546

u271853076

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nif s.endwith('s'):\n\tprint(s + 'es')\nelse:\n\tprint(s + 's')", "s = input()\nif s.endswith('s'):\n print(s + 'es')\nelse:\n print(s + 's')"]

['Runtime Error', 'Accepted']

['s532656705', 's046112013']

[9024.0, 9084.0]

[29.0, 32.0]

[69, 72]

p02546

u274755552

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S = input()\nif S[-1] = "s"\n\tprint( S + "es" )\nelse print( S + "s" )\n', 'S = input()\nif S[-1] == "s":\n\tprint( S + "es" )\nelse print( S + "s" )', 'S = input()\nif S[-1] == "s":\n\tprint( S, "es" )\nelse print( S, "s" )', "S = input()\nif re.findall('[a-z]+$', S) = 's'\n\tprint( S + 'es')\n\telse print( S + 's')", 'S = input()\n\tif S[-1] = "s"\n\t\tprint( S + "es" )\n\t\telse print( S + "s" )', 'S = input()\nif S[-1] = "s"\nprint( S + "es" )\nelse print( S + "s" )', 'S = input()\nif S[-1] = "s"\n\tprint( S, "es" )\nelse print( S, "s" )', 'S = input()\nif S[-1] = "s"\n\tprint( S + "es" )\n\telse print( S + "s" )', 'S = input()\nif S[-1] == "s":\n print( S + "es" )\nelse: \n print( S + "s" )']

['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']

['s053952474', 's100547614', 's332340989', 's398397362', 's544135726', 's567933669', 's606521010', 's669656623', 's075810422']

[9000.0, 9020.0, 8948.0, 9004.0, 9004.0, 8996.0, 9000.0, 9000.0, 9056.0]

[23.0, 27.0, 29.0, 27.0, 24.0, 24.0, 23.0, 27.0, 27.0]

[68, 69, 67, 85, 71, 66, 65, 68, 74]

p02546

u286422818

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['#!/usr/local/bin/python3\n\nN, X, M = map(int, input().split())\n\ndef f(x, m):\n return x**2 % m\n\ncheck = [False for _ in range(M)]\nd = [X]\nmax_x = 0\nfor _ in range(1, N+1):\n X = f(X, M)\n if check[X]:\n break\n else:\n check[X] = True\n d.append(X)\n\nidx = d.index(X)\nans = sum(d[:idx])\nN -= idx\nd = d[idx:]\n\nsumd = sum(d)\nans += N//len(d) * sumd\n\nans += sum(d[:N%len(d)])\n\nprint(ans)\n', "S = input()\nif S[-1] == 's':\n print(S+'es')\nelse:\n print(S+'s')"]

['Runtime Error', 'Accepted']

['s920420565', 's981555775']

[9208.0, 9084.0]

[24.0, 28.0]

[405, 69]

p02546

u308914480

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=input()\nif s[-1]=s:\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\n print(s1)\n ', 's=input()\nif s[-1]=s:\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\nprint(s1)', 's=input()\nif s[-1]="s":\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\nprint(s1)', 's=input()\nif(s[-1:]==\'s\'):\n s1=s+"es"\n print(s1)\nelse:\n s2=s+"s"\n print(s2)']

['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']

['s023773188', 's172289695', 's405837618', 's487202471']

[9000.0, 9012.0, 9024.0, 9088.0]

[25.0, 27.0, 21.0, 26.0]

[86, 81, 83, 79]

p02546

u309120194

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = input()\n\na = S[:-1]\nb = S[-1]\nif b == 's': print(a + 'es')\nelse: print(a + 's')", "S = input()\n \nif S[-1] == 's': S += 'es'\nelse: S += 's'\nprint(S)"]

['Wrong Answer', 'Accepted']

['s799288703', 's658208987']

[9088.0, 8984.0]

[28.0, 26.0]

[83, 64]

p02546

u318533762

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s = input("Enter Input:")\n\nif s[len(s) - 1] != "s":\n s += "s"\n\nelif s[len(s) - 1] == "s":\n s += "es"\n\nprint(s)\n ', 's = input()\n\nif s[len(s) - 1] != "s":\n s += "s"\n\nelif s[len(s) - 1] == "s":\n s += "es"\n\nprint(s)\n ']

['Wrong Answer', 'Accepted']

['s944161654', 's092294715']

[9024.0, 9024.0]

[25.0, 27.0]

[122, 108]

p02546

u326408598

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S = input()\nif S[-1] == "s":\n print(S + "es")\n else:\n print(S + "s")', 's = input()\nif s[-1] != "s":\n print(s+\'s\')\nelif s[-1] == \'s\'\n print(s[:-1]+\'es\')', 'S = input()\nif S[-1] == "s":\n\tprint(S + "es")\nelse:\n \tprint(S + "s")']

['Runtime Error', 'Runtime Error', 'Accepted']

['s047798225', 's564803025', 's445960787']

[9008.0, 8952.0, 9080.0]

[24.0, 23.0, 29.0]

[73, 82, 69]

p02546

u345132740

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S=input()\nif (S[-1:]==s):\n print(S+"es")\nelse:\n print(S+"s")', 'S=input()\nif (S[-1:]=="s"):\n print(S+"es")\nelse:\n print(S+"s")']

['Runtime Error', 'Accepted']

['s762903259', 's835055129']

[8960.0, 9028.0]

[26.0, 27.0]

[62, 64]

p02546

u347502437

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['def main():\n N, X, M = map(int, input().split())\n NN = N\n li = []\n while X not in li and N != 0:\n li = li + [X]\n X = X ** 2 % M\n N -= 1\n \n if N == 0:\n print(sum(x for x in li))\n\n elif N != 0 and X in li:\n l = len(li)\n s = li.index(X)\n T = l - s\n q = (NN - s) // T\n r = (NN - s) % T\n print(sum(li[i] for i in range(s)) + sum(li[i] for i in range(s, len(li))) * q + sum(li[i] for i in range(s, s + r)))\n\n\nmain()', "S = input()\nl = len(S)\nif S[l-1] != 's':\n print(S + 's')\nelse:\n print(S + 'es')"]

['Runtime Error', 'Accepted']

['s802543888', 's573530042']

[9220.0, 9092.0]

[31.0, 25.0]

[500, 85]

p02546

u365416597

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\n\nif s[len(s)] == 's':\n print(s+'es')\nelse:\n print(s+'s') ", "s = input()\n\nif s[len(s)-1] == 's':\n print(s+'es')\nelse:\n print(s+'s') "]

['Runtime Error', 'Accepted']

['s553735161', 's190229851']

[9092.0, 9064.0]

[25.0, 30.0]

[76, 78]

p02546

u369133448

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['import collections\nn,x,m=map(int,input().split())\nif n==1 or x==0:\n print(x)\n exit()\nstart,end,loopcnt=0,0,0\na={x:0}\nwk=x\nfor i in range(1,m):\n wk=(wk*wk)%m\n if not wk in a:\n a[wk]=i\n else:\n start=a[wk]\n end=i\n break\na=sorted(a.items(),key=lambda x:x[1])\nkoteiindex=min(n,start)\nkoteiwa=0\nfor i in range(koteiindex):\n koteiwa+=a[i][0]\nloopcnt=(n-koteiindex)//(end-start)\nloopindex=start-1+(n-koteiindex)%(end-start)\nloopwa=0\namariwa=0\nfor i in range(start,end):\n if i<=loopindex:\n amariwa+=a[i][0]\n loopwa+=a[i][0]\nans=koteiwa+loopwa*loopcnt+amariwa\nprint(ans)\n', 's=input()\nif s[len(s)-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']

['Runtime Error', 'Accepted']

['s500583536', 's891654995']

[9396.0, 9032.0]

[25.0, 26.0]

[584, 67]

p02546

u371056862

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nif s[-1] == 's':\n s.append('es')\nelse:\n s.append('s')\nprint(s)", "s = input()\nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's'\nprint(s)"]

['Runtime Error', 'Accepted']

['s919076628', 's223845585']

[9012.0, 9072.0]

[28.0, 32.0]

[76, 70]

p02546

u383805907

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = input()\nif S[-1] = 's':\n return S + 'es'\nelse:\n return S + 's'\n", "def solution():\n S = input()\n if S[-1] == 's':\n return S + 'es'\n else:\n return S + 's'\n\nprint (solution())"]

['Runtime Error', 'Accepted']

['s991257704', 's136833318']

[9000.0, 9080.0]

[26.0, 32.0]

[69, 115]

p02546

u384708632

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n = int(input())\ncount = 0\nfor i in range(n):\n if i == 0:\n count = 0\n else:\n if n % i == 0:\n count += (n//i) -1\n else:\n count += (n//i)\nprint(count)', 'n = int(input())\nd = [list(map(int, input().split())) for i in range(n)]\ncount = 0\njail = False\nfor i in range(n):\n if d[i][0] == d[i][1]:\n count += 1\n if count == 3:\n jail = True\n break \n else: count = 0\nif jail == True:\n print("Yes")\nelse : print("No")\n', 's = input()\nif s[-1:] == "s":\n print(s + "es")\nelse :\n print(s + "s")\n']

['Runtime Error', 'Runtime Error', 'Accepted']

['s069454513', 's469726919', 's436564176']

[9160.0, 9180.0, 9020.0]

[25.0, 30.0, 31.0]

[197, 307, 76]

p02546

u390493770

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['\n#include <string>\n\nusing namespace std;\n\nint main()\n{\n string s;\n cin >> s;\n if (s[s.size() - 1] == \'s\') {\n cout << s << "es";\n }\n else {\n cout << s << "s";\n }\n return 0;\n}\n', "s = input()\nprint(s+'es') if s.endswith('s') else print(s+'s')\n"]

['Runtime Error', 'Accepted']

['s662094881', 's478221933']

[8936.0, 8964.0]

[26.0, 30.0]

[228, 63]

p02546

u401481862

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n, x, m = map(int, input().split())\na = x\ns = 0\nh = []\nh.append(a)\ni = 0\nfl = 0\nwhile i < n:\n s += a\n a = (a*a) % m\n if a == 0:\n break\n i += 1\n if fl == 0 and a in h:\n fl = 1\n po = h.index(a)\n ss = 0\n for j in range(po):\n ss += h[j]\n s2 = s - ss\n f = (n - po) // (i - po)\n s2 *= f\n s = s2 + ss\n i2 = i - po\n i2 *= f\n i = i2 + po\n else:\n h.append(a)\nprint(s)', "S = input()\nif S[-1] == 's':\n a = S+'es'\nelse:\n a = S+'s'\nprint(a)\n"]

['Runtime Error', 'Accepted']

['s731246078', 's875986495']

[9200.0, 9080.0]

[30.0, 32.0]

[447, 73]

p02546

u402228762

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['a = int(input())\ncount = 0\nfor i in range(a):\n a,b = map(int,input().split())\n \n if (a==b):\n count += 1\n break\n else : \n count = 0\n\nif (count >= 3):\n \n print("Yes")\nelse :\n print("No")\n', 'a = input()\n\nif (a[-1] != "s"):\n a += "s"\n\nelse :\n a += "es"\n\nprint(a)']

['Runtime Error', 'Accepted']

['s806020433', 's710530821']

[9164.0, 9080.0]

[24.0, 29.0]

[231, 76]

p02546

u409609062

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["if __name__ == '__main__':\n try:\n singular = str(input())\n singular.lower()\n if singular[len(singular)-1] != 's':\n singular += 's'\n print(s)\n else:\n singular += 'es'\n print(s)\n except Exception:\n pass", "if __name__ == '__main__':\n try:\n s = str(input())\n s.lower()\n if s[len(s)-1] != 's':\n s += 's'\n print(s)\n else:\n s += 'es'\n print(s)\n except Exception:\n pass"]

['Wrong Answer', 'Accepted']

['s080839515', 's223994002']

[9036.0, 8960.0]

[28.0, 26.0]

[285, 243]

p02546

u414050834

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s=str(input())\nt=len(s)\nif s[t]=='s':\n print(s+'es')\nelse:\n print(s+'s')", "s=str(input())\nt=len(s)\nif s[t-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')\n"]

['Runtime Error', 'Accepted']

['s026977698', 's163791374']

[9116.0, 9084.0]

[25.0, 31.0]

[74, 77]

p02546

u438070303

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['singular = input()\nif singular[-1] == "s":\n print(singular + "es)\nelse:\n print(singular + "s")', ' singular = input()\n if singular[-1] == "s":\n print(singular + "es")\n else:\n print(singular + "s")', 'singular = input()\nif singular[-1] == "s":\n print(singular + "es")\nelse:\n print(singular + "s")']

['Runtime Error', 'Runtime Error', 'Accepted']

['s687987708', 's888941598', 's168329654']

[9004.0, 9000.0, 8948.0]

[28.0, 27.0, 29.0]

[100, 121, 101]

p02546

u441320782

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['from itertools import product\nN=int(input())\ncount=0\nlis=[i for i in range(1,N+1)]\nx=list(itertools.product(lis,repeat=3))\nfor i in x:\n if y[0]*y[1]+y[2]==N:\n count+=1\n\nprint(count)', 'n=input()\nif n[-1]=="s":\n print(n+"es")\nelse:\n print(n+"s")\n']

['Runtime Error', 'Accepted']

['s818818939', 's629528275']

[9128.0, 8972.0]

[25.0, 28.0]

[185, 62]

p02546

u442636632

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N = int(input())\nA = 1\nB = 1\nC = 1\nanswer = 0\nwhile C < N:\n B = 1\n while B < N:\n A = 1\n while A < N:\n if (A * B) + C == N:\n answer += 1\n\n A += 1\n\n B += 1\n\n C += 1\n\nprint(answer)\n', "S = input()\nif S[len(S)-1] == 's':\n answer = S + 'es'\nelse:\n answer = S + 's'\nprint(answer)\n"]

['Runtime Error', 'Accepted']

['s070869098', 's733623091']

[9156.0, 9080.0]

[29.0, 27.0]

[245, 98]

p02546

u447837274

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['chr = input("")\nnum = len(s)\n\nif chr[num-1] == "s":\n print(chr + "es")\nelse:\n print(chr + "s")\n \n ', 'chr = input("")\nnum = len(chr)\n\nif chr[num-1] == "s":\n print(chr + "es")\nelse:\n print(chr + "s")']

['Runtime Error', 'Accepted']

['s957524363', 's468680454']

[9012.0, 9024.0]

[29.0, 30.0]

[102, 98]

p02546

u453529685

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N = int(input())\ncount = 0\nfor C in range(1,N):\n for A in range(1,N-C+1):\n B = (N-C)/A\n if B.is_integer():\n count += 1\nprint(count)', "s = input()\nif s[-1] == 's':\n print(s + 'es')\nelse:\n print(s + 's')"]

['Runtime Error', 'Accepted']

['s874942064', 's990908382']

[9172.0, 9020.0]

[22.0, 30.0]

[143, 69]

p02546

u454472984

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n=int(input())\nflag=0\nans=0\n\nfor i in range(n):\n d1,d2=map(int,input().split())\n if d1==d2:\n flag+=1\n if flag==3:\n ans=1\n else:\n flag=0\nif ans!=1:\n print("No")\nelse:\n print("Yes")\n ', 's=input()\nif s[len(s)-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']

['Runtime Error', 'Accepted']

['s630639305', 's152484662']

[9172.0, 9120.0]

[30.0, 30.0]

[231, 71]

p02546

u463945054

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N = int(input())\n\nk=0\n\nfor s in range(1,N):\n k = (N-1) // s\n t += k \n \nprint (t)', 'N = int(input())\n\ncount = 0\n\nfor i in range(N):\n k, t = map(int, input().split())\n if count == 3:\n print ( "yes" )\n \n break\n \n if not k == t:\n count *= 0\n if k == t:\n count += 1 \nif not count == 3:\n print ("no")\n\n', 'S = str(input())\n\nif S[-1] == "s" :\n\n print( S + "es" )\n\nelse:\n\n print( S + "s" )\n']

['Runtime Error', 'Runtime Error', 'Accepted']

['s269786459', 's998297782', 's915210401']

[9144.0, 9112.0, 9024.0]

[30.0, 24.0, 29.0]

[83, 264, 82]

p02546

u466916194

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['st = input()\nif st[-1]=="s":\n st.append("es")\nelse:\n st.append("s")', 'st = input()\nif st[-1]=="s":\n name = st+"es"\nelse:\n name = st+"s"\nprint(name)']

['Runtime Error', 'Accepted']

['s805809178', 's613804356']

[9072.0, 9028.0]

[23.0, 23.0]

[69, 79]

p02546

u470481460

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=sys.stdin\nif s[len(s)-1] =="s":\n\tprint(s + "es")\nelse:\n\tprint(s + "s")', 's=input()\nif s[len(s)-1] =="s":\n\tprint(s + "es")\nelse:\n\tprint(s + "s")']

['Runtime Error', 'Accepted']

['s471007639', 's024969767']

[9088.0, 8880.0]

[23.0, 28.0]

[72, 70]

p02546

u511975155

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n,x,m = map(int,input().split())\ndef jouken(a,waru):\n return a**2%waru\nni = 0\nnum =0\nfor i in range(n-1):\n ni = x\n if i ==0:\n num+=x\n x = jouken(ni,m)\n num+=x\nprint(num)\n', "sentence = input()\nif sentence[-1] == 's':\n print(sentence+'es')\nelse:\n print(sentence+'s')"]

['Runtime Error', 'Accepted']

['s242175771', 's193757082']

[9032.0, 9052.0]

[23.0, 30.0]

[192, 93]

p02546

u523885719

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["import sys\ninput = sys.stdin.readline\nS = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')", "import sys\ninput = sys.stdin.readline\nS = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')", "S = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')"]

['Wrong Answer', 'Wrong Answer', 'Accepted']

['s664913094', 's977718542', 's833643813']

[8824.0, 9008.0, 8992.0]

[27.0, 31.0, 28.0]

[108, 108, 70]

p02546

u536235324

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['# -*- coding: utf-8 -*-\n"""\nCreated on Sat Sep 19 13:14:17 2020\n\n@author: Admin\n"""\n\n\nn,x,m=input().split()\nm=int(m)\na=[int(x)]\nfor i in range(1,int(n)):\n zp=a[i-1]\n z=zp**2\n a.append(z%m)\n \nprint(sum(a))', '# -*- coding: utf-8 -*-\n"""\nCreated on Sat Sep 19 13:03:22 2020\n\n@author: Admin\n"""\n\na=input()\nif a[-1]==\'s\':\n print(a+\'es\')\nelse:\n print(a+\'s\')']

['Runtime Error', 'Accepted']

['s578701638', 's462825611']

[9048.0, 9088.0]

[28.0, 30.0]

[216, 150]

p02546

u546853743

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s=list(input())\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')", "s=input()\nif s[-1]=='s':\n print(s,'es',sep='')\nelse:\n print(s,'s',sep='')"]

['Runtime Error', 'Accepted']

['s177076519', 's522830081']

[9084.0, 9028.0]

[24.0, 33.0]

[71, 79]

p02546

u548272916

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["string = input()\n\nif string[-1] != 's':\n new_string = string[0:-1] + 's'\nif string[-1] = 's':\n new_string = string[0:-1] +'es'\n \nprint(new_string)", "string = input()\n \nif string[-1] != 's':\n new_string = string[0:] + 's'\nif string[-1] == 's':\n new_string = string[0:] +'es'\n \nprint(new_string)"]

['Runtime Error', 'Accepted']

['s117033063', 's844445613']

[9016.0, 9008.0]

[31.0, 24.0]

[148, 146]

p02546

u564147564

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S = str(input())\n\nif S.endswith(\'s\'):\n S += "es"\nelse:\n S += "s"', 'S = str(input())\n\nif S.endswith(\'s\'):\n S += "es"\nelse:\n S += "s"\nprint(S)']

['Wrong Answer', 'Accepted']

['s764190367', 's989552605']

[9076.0, 9084.0]

[33.0, 29.0]

[66, 75]

p02546

u570991163

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['n=int(input())\nc,f=0,0\nwhile(n>0):\n a,b=map(int,input().split())\n if(a==b):\n c+=1\n else:\n c=0\n if(c>=3):\n f=1\n break\n n-=1\nif(f==1 or c>=3):\n print("Yes")\nelse:\n print("No")', "s=input()\nif(s[-1]=='s'):\n s+='es'\nelse:\n s+='s'\nprint(s)"]

['Runtime Error', 'Accepted']

['s888893519', 's128957642']

[9132.0, 8944.0]

[22.0, 28.0]

[192, 59]

p02546

u574888872

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['from unittest import TestCase, main\nfrom A import func\n\nclass test(TestCase):\n def test_with_valid_params(self):\n test_patterns = [\n ("apple","apples"),\n ("bus","buses"),\n ("box","boxs")\n ]\n\n for S,result in test_patterns:\n with self.subTest(S=S):\n self.assertEqual(func(S),result)\n\nif __name__ == "__main__":\n main()', 'def func(S):\n if S[-1] == "s":\n return S+"es"\n else:\n return S+"s"\n\n\nif __name__ == "__main__":\n S = input()\n print(func(S))']

['Runtime Error', 'Accepted']

['s783184437', 's598916195']

[16208.0, 9036.0]

[69.0, 29.0]

[355, 138]

p02546

u582686131

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["st = input()\n\nif st[-1] == 's':\n return st + 'es'\nelse:\n return st + 's'", "st = input()\n \nif st[-1] == 's':\n print(st + 'es')\nelse:\n print(st + 's')"]

['Runtime Error', 'Accepted']

['s344059027', 's746671413']

[8980.0, 9056.0]

[27.0, 29.0]

[74, 79]

p02546

u584153341

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['import math\n\nN = int(input())\n\nif N == 2:\n cnt = 1\nelif N == 3:\n cnt = 3\nelif N > 3:\n cnt = 3\n for i in range(1,N-1):\n A = N-i\n rA = math.sqrt(A)\n intA = math.floor(rA)\n if rA == intA:\n cnt -= 1\n if intA == 1:\n cnt += 1\n else:\n for j in range(1,intA+1):\n if A%j == 0:\n cnt += 2\n\nprint(cnt)', 'import math\n\nN = int(input())\n\nif N == 2:\n cnt = 1\nelif N == 3:\n cnt = 3\n \nelif N > 3:\n for i in range(1,N-1):\n A = N-i\n rA = math.sqrt(A)\n intA = math.floor(rA)\n if rA == intA:\n cnt -= 1\n if intA == 1:\n cnt += 1\n else:\n for j in range(1,intA+1):\n if A%j == 0:\n cnt += 2\n\nprint(cnt)', "S = input()\nl = len(S)\nif S[l-1]=='s':\n S = S + 'es'\nelse:\n S = S + 's'\nprint(S)"]

['Runtime Error', 'Runtime Error', 'Accepted']

['s912792989', 's971946817', 's383532273']

[9204.0, 9036.0, 9036.0]

[28.0, 30.0, 28.0]

[410, 403, 86]

p02546

u596847957

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N=int(input()) \nXY=[map(int, input().split()) for _ in range(N)]\nX,Y=[list(i) for i in zip(*XY)]\nans="No"\n\nfor j in range(0,N-2):\n if X[j]==Y[j] and X[j+1]==Y[j+1] and X[j+2]==Y[j+2]:\n ans="Yes"\n break\n\nprint(ans)', 'S=input()\ns="s"\nes="es"\n\nif S[len(S)-1]==s:\n S=S+es\nelse:\n S=S+s\n\nprint(S)']

['Runtime Error', 'Accepted']

['s595629258', 's173894624']

[9196.0, 9020.0]

[24.0, 27.0]

[238, 80]

p02546

u620243078

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = int(input())\nif s[-1] != 's':\n s += 's'\nelse:\n s += 'es'\nprint(s)", "s = input()\n\nif s[-1] != 's':\n\n s += 's'\n\nelse:\n\n s += 'es'\n\nprint(s)\n\n"]

['Runtime Error', 'Accepted']

['s838981182', 's195076850']

[9140.0, 9008.0]

[23.0, 31.0]

[71, 73]

p02546

u624812250

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['if S[-1] == "s":\n print(S + "es")\nelse:\n print(S + "s")', 'if S[-1] == s:\n print(S + "es")\nelse:\n print(S + "s")\n ', 'S = input()\nif S[-1] == "s":\n print(S + "es")\nelse:\n print(S + "s")']

['Runtime Error', 'Runtime Error', 'Accepted']

['s125860664', 's950178252', 's047696079']

[9048.0, 8900.0, 8944.0]

[28.0, 25.0, 31.0]

[57, 58, 69]

p02546

u627600101

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['\ndef segfunc(x, y):\n return min(x, y)\n#################\n \n#####ide_ele#####\nide_ele = 10**9\n#################\n \nclass SegTree:\n \n def __init__(self, init_val, segfunc, ide_ele):\n \n n = len(init_val)\n self.segfunc = segfunc\n self.ide_ele = ide_ele\n self.num = 1 << (n - 1).bit_length()\n self.tree = [ide_ele] * 2 * self.num\n \n for i in range(n):\n self.tree[self.num + i] = init_val[i]\n \n for i in range(self.num - 1, 0, -1):\n self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])\n \n def update(self, k, x):\n \n k += self.num\n self.tree[k] = x\n while k > 1:\n self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])\n k >>= 1\n \n def query(self, l, r):\n \n res = self.ide_ele\n \n l += self.num\n r += self.num\n while l < r:\n if l & 1:\n res = self.segfunc(res, self.tree[l])\n l += 1\n if r & 1:\n res = self.segfunc(res, self.tree[r - 1])\n l >>= 1\n r >>= 1\n return res\n\n\nN, Q = map(int, input().split())\n\n\n\nans = (N-2)**2\nyoko = [N-2 for _ in range(N-2)]\ntate = [N-2 for _ in range(N-2)] \nyoko = SegTree(yoko, segfunc, ide_ele)\ntate = SegTree(tate, segfunc, ide_ele)\nminy = N-2\nminx = N-2\nfor k in range(Q):\n\tn, x = map(int, input().split())\n\tif n == 1:\n\t\ty = x -2\n\t\tif y < miny:\n\t\t\tans -= minx\n\t\t\tminy = y\n\t\t\tyoko.update(min(minx, N-3), miny)\n\t\telse:\n\t\t\tans -= tate.query(y, N-1)\n\telse:\n\t\tx = x - 2\n\t\tif x < minx:\n\t\t\tans -= miny\n\t\t\tminx = x\n\t\t\ttate.update(min(miny, N-3), minx)\n\t\telse:\n\t\t\tans -= yoko.query(x, N-1)\nprint(ans)\n', "#from collections import deque\n#from heapq import heapify, heappop, heappush\n#from bisect import insort\n#from math import gcd\n#mod = 10**9 + 7\n#N = int(input())\n#N, K = map(int, input().split())\n#A = list(map(int, input().split()))\n\n#for k in range(N):\n\n#print(ans)\n#print('Yes')\n#print('No')\nS = input()\nif S[-1] != 's':\n\tprint(S + 's')\nelse:\n\tprint(S+'es')\n"]

['Runtime Error', 'Accepted']

['s015624524', 's323799913']

[9288.0, 8956.0]

[26.0, 25.0]

[2432, 379]

p02546

u629350026

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=str(input())\ns=list(s)\nif s[len(s)-1]=="s":\n print("".join(s)+"es")\nelse:\n print("".join()+"s")', 's=str(input())\ns=list(s)\nif s[len(s)-1]=="s":\n print("".join(s)+"es")\nelse:\n print("".join(s)+"s")']

['Runtime Error', 'Accepted']

['s346773925', 's430459996']

[9044.0, 9008.0]

[27.0, 27.0]

[99, 100]

p02546

u629355744

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["s = input()\nif s[-1]=='s':\n print(s+'es')\n else:\n print(s+'s')", "s = input()\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')"]

['Runtime Error', 'Accepted']

['s428129423', 's472659812']

[8944.0, 9096.0]

[27.0, 30.0]

[67, 67]

p02546

u635759013

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S = input()\nif S[-1:] = s:\n print(S+"es")\nelse:print(S+"s")', 'N = int(input())\nnums =[]\ncount = 0\nswitch = False\nfor i in range(N):\n nums.append([int(x) for x in input().split()])\n\nfor j in nums:\n if j[0] == j[1]:\n count += 1\n elif j[0] != j[1]:\n count = 0\n if count == 3:\n switch = True\nif switch == True:\n print("Yes")\nelif switch == False:\n print("No")\n', 'S = input()\nif S[-1:] == "s":\n print(S+"es")\nelse:print(S+"s")']

['Runtime Error', 'Runtime Error', 'Accepted']

['s666806644', 's996429501', 's835261327']

[9000.0, 9204.0, 9080.0]

[30.0, 26.0, 32.0]

[60, 333, 63]

p02546

u650932312

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = input()\nif S[-1] == 's':\n ans += 'es'\nelse:\n ans += 's'\nprint(ans)", "S = input()\nif S[-1] == 's':\n ans = S+'es'\nelse:\n ans = S+'s'\nprint(ans)"]

['Runtime Error', 'Accepted']

['s995569972', 's498401779']

[8956.0, 9016.0]

[27.0, 30.0]

[72, 78]

p02546

u654571388

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['val = input()\nvalf=val[-1]\nif(valf==s):\n print(val+"es")\nelse\n print(val+"s")', 'val = input()\nvalf=val[-1]\nif(valf=="s"):\n print(val+"es")\nelse:\n print(val+"s")']

['Runtime Error', 'Accepted']

['s650432712', 's136527973']

[8952.0, 8972.0]

[30.0, 28.0]

[83, 86]

p02546

u686817216

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['s=input()\ns_list=list(s)\n\nx=len(s_list)\n\na_list=reversed(s_list)\nif a_list[0]=="s":\n s_list[x]="e"\n s_list[x+1]="s"\nelse:\n s_list[x+1]="s"\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list[x-1]="e"\n s_list[x]="s"\nelse:\n s_list.append("s")\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list.append("es")\nelse:\n s_list.append("s")\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list.append("es")\nelse:\n s_list.append("s")\n\nprint("".join(s_list))']

['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted']

['s252416134', 's633020894', 's950944697', 's344723300']

[9104.0, 9032.0, 9092.0, 9088.0]

[27.0, 29.0, 31.0, 29.0]

[156, 138, 126, 135]

p02546

u689723321

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['S=input()\nl=len(S)\ns=list(S)\nif s[l]=="s":\n print(S+"es")\nelse:\n print(S+"s")', 'S=input()\nl=len(S)\ns=list(S)\nif s[l-1]=="s":\n print(S+"es")\nelse:\n print(S+"s")\n']

['Runtime Error', 'Accepted']

['s162093523', 's888210804']

[8992.0, 9008.0]

[26.0, 24.0]

[79, 82]

p02546

u694536861

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N = int(input())\ncount = 0\n\nfor a in range(1, N):\n tmp = (N-1) // a\n if a <= (N) // 2:\n count += tmp\n else:\n count += 1 \n\nprint(count)', "S = input()\n\nif S[-1] == 's':\n print(S + 'es')\nelse:\n print(S + 's')"]

['Runtime Error', 'Accepted']

['s679429607', 's529440703']

[9164.0, 9024.0]

[22.0, 26.0]

[152, 70]

p02546

u696886537

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["f=open('in','r')\ninput=lambda:f.readline().strip()\n\ns=input()\nif s[-1]!='s':print(s+'s')\nelse:print(s+'es')", "s=input()\nif s[-1]!='s':print(s+'s')\nelse:print(s+'es')"]

['Runtime Error', 'Accepted']

['s341679771', 's101541367']

[8944.0, 9064.0]

[31.0, 27.0]

[107, 55]

p02546

u715985689

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["print(input()+('es' if s[-1] == 's' else 's'))", "print(input().strip()+('es' if s[-1] == 's' else 's'))\n", "s = input()\nprint(s+('es' if s[-1] == 's' else 's'))"]

['Runtime Error', 'Runtime Error', 'Accepted']

['s069453263', 's913736740', 's043887810']

[8956.0, 8804.0, 8952.0]

[24.0, 27.0, 32.0]

[46, 55, 52]

p02546

u719044784

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['from pattern.text.en import singularize\n\nplurals = [int(input())]\n\nsingles = [singularize(plural) for plural in plurals]\nprint singles', 's=input()\nif s[-1]==s:\n print(s+"s")\nelse:\n print(s+"es")', "S=(input())\nif S[-1]=='s':\n S = S + 'es'\nelse:\n S = S + 's'\nprint(S)"]

['Runtime Error', 'Wrong Answer', 'Accepted']

['s368168806', 's812093880', 's214808389']

[8932.0, 9024.0, 9088.0]

[25.0, 25.0, 29.0]

[134, 63, 74]

p02546

u724295910

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

["S = input()\n\nif S[-1] == 's':\n S = S + 's'\nelse:\n S = S + 'es'\n\nprint(S)", "S = input()\n\nif S[-1] == 's':\n S = S + 'es'\nelse:\n S = S + 's'\n\nprint(S)\n"]

['Wrong Answer', 'Accepted']

['s160048104', 's150348506']

[9088.0, 9080.0]

[28.0, 24.0]

[74, 75]

p02546

u728050879

In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.

['N,X,M = map(int, input().split())\n\n\nA = [-1]*(M+100)\nA[0] = X\ni = 0\ntmpans = 0\nflag = False\ncheck = [-1]*(M+1)\nslice = -1\nwhile i< N-1:\n newa = A[i]**2%M\n i+= 1\n if check[newa] != -1:\n flag = True\n slice = check[newa]\n break\n A[i] = newa\n check[newa] = i\n\nif not flag:\n print(sum(A[:i+1]))\n\nelse:\n print(sum(A[:slice])+ sum(A[slice:i])*((N-slice)//(i-slice))+sum(A[slice:slice + (N-slice)%(i-slice)]))\n', 's = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")\n']

['Runtime Error', 'Accepted']

['s592552107', 's377012692']

[9232.0, 9088.0]

[27.0, 25.0]

[444, 74]