Problem:


Score : 100 points

Problem Statement

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.

Constraints

S is a string of length 1 between 1000, inclusive.

S contains only lowercase English letters.

Input

Input is given from Standard Input in the following format:

S

Output

Print the plural form of the given Taknese word.

Sample Input 1

apple

Sample Output 1

apples

apple ends with e, so its plural form is apples.

Sample Input 2

bus

Sample Output 2

buses

bus ends with s, so its plural form is buses.

Sample Input 3

box

Sample Output 3

boxs



Sample input:
apple


Sample output:
apples

Submission status: Accepted

Solution code:
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
import math
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii():  return int(input())
def si():  return input()
def mi():  return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li():  return list(mi())
 
def dmain():
    sys.setrecursionlimit(1000000)
    threading.stack_size(1024000)
    thread = threading.Thread(target=main)
    thread.start()
    
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list  m = [x[:] for x in mark] .. Avoid Using Deepcopy
 
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1] 
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
 
def ceil(x,y):
    if x%y==0:
        return x//y
    else:
        return x//y+1
 
def powerMod(x,y,p):
    res = 1
    x %= p
    while y > 0:
        if y&1:
            res = (res*x)%p
        y = y>>1
        x = (x*x)%p
    return res
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
    
def isPrime(n) : # Check Prime Number or not 
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True
 
 
 
def read():
    sys.stdin  = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
 
def main():
    
              
    #for _ in range(ii()):
    s = input()
    if s[-1] != 's':
        print(s + 's')
    elif s[-1] == 's':
        print(s + 'es')
    
    
    
    
    
        
    
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
# endregion
 
 
if __name__ == "__main__":
    #read()
    main()
    #dmain()
 
# Comment Read()

Submission status: Accepted

Solution code:
s = input()
suffix = ''
if s.endswith('s'):
    suffix = 'es'
else:
    suffix = 's'

print(s + suffix)

Submission status: Accepted

Solution code:
def main():
    S = input()

    if S.endswith('s'):
        answer = S + 'es'
    else:
        answer = S + 's'

    print(answer)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main() -> None:
    s = input()

    print(s + 's' if s[-1] != 's' else s + 'es')

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))

#################

S = str(input())

if S[-1] == 's':
    print(S+'es')
else:
    print(S+'s')

Submission status: Accepted

Solution code:
n=input()
print([n+"s",n+"es"][n[-1]=="s"])

Submission status: Accepted

Solution code:
def solution(s):
  return s + 'es' if s[-1] == 's' else s + 's'
print(solution(input()))

Submission status: Accepted

Solution code:
S = input()
if S[-1] == 's':
    S += 'es'
else:
    S += 's'

print(S)

Submission status: Accepted

Solution code:
S = input()

if S[-1] == 's': print(S + 'es')
else: print(S + 's')

Submission status: Accepted

Solution code:
s = input()
if s[-1] != "s":
    s += "s"
else:
    s += "es" 
print(s)

Submission status: Accepted

Solution code:
S=input()
if S[len(S)-1]=='s':
    print(S+"es")
else:
    print(S+'s')

Submission status: Accepted

Solution code:
a = input()
if(a[-1] == 's'):
  print(a+'es')
else:
  print(a+'s')

Submission status: Accepted

Solution code:
S = input()
 
if S[-1] == "s":
    S += "es"
else:
    S += "s"
 
print(S)

Submission status: Accepted

Solution code:
s = input()
if s[-1] != "s":
  print(s + "s")
else:
  print(s + "es")

Submission status: Accepted

Solution code:
a=input()
if a[-1]!='s':
  a = a+"s"
else:
  a = a+"es"
print(a)

Submission status: Accepted

Solution code:
S = input()

if S[-1] == 's':
  print(S + 'es')
  
else:
  print(S + 's')

Submission status: Accepted

Solution code:
s = input()
print(s + 's' if s[-1] != 's' else s + 'es')

Submission status: Accepted

Solution code:
S = input()

if S[-1] == 's':
    S += 'es'
else:
    S += 's'
    
print(S)

Submission status: Accepted

Solution code:
s = input()
if s[-1] =='s':
  print(s + 'es')
else:
  print(s + 's')

Submission status: Accepted

Solution code:
n = input()
if n[-1] == 's':
  print(n + 'es')
else:
  print(n + 's')

Submission status: Accepted

Solution code:
line = input()
 
if line[len(line)-1] == ("s"):
  line += "es"
else:
  line += "s"
print(line)

Submission status: Accepted

Solution code:
import sys
def S(): return sys.stdin.readline().rstrip()


S = S()
print(S+'es' if S[-1] == 's' else S+'s')

Submission status: Accepted

Solution code:
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')

# (int(x) for x in input().split())
s = input().strip()
if s[-1] == 's':
    print(s + 'es')
else:
    print(s + 's')

Submission status: Accepted

Solution code:
s=input()
if s[-1] == "s":
  print(s+"es")
else:
  print(s+"s")

Submission status: Accepted

Solution code:
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    S = input()
    if S[-1] == 's':
        S += 'es'
    else:
        S += 's'
    print(S)
resolve()

Submission status: Accepted

Solution code:
s = input()
l = []
for i in range(len(s)):
    l.append(s[i])
if l[len(l)-1] == "s":
    print(s+str("es"))
else:
    print(s+str("s"))

Submission status: Accepted

Solution code:
x = input()
print(x+'s' if x[-1] != "s" else x+'es' )

Submission status: Accepted

Solution code:
S = input()

if S.endswith('s'):
    print(S + 'es')
else:
    print(S + 's')

Submission status: Accepted

Solution code:
palavra= input()
tam= len(palavra)
if palavra[tam-1]=='s':
    print(palavra+'es')
else:
    print(palavra+'s')

Submission status: Accepted

Solution code:
s=input().strip()
if s[-1] == "s":
    print(s+"es")
else:
    print(s+"s")

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
s = S()
ans = ''
if s[-1] == 's':
    ans = s + 'es'
else:
    ans = s + 's'
print(ans)

Submission status: Accepted

Solution code:
s=input()
if s[-1]=='s':
    s+="es"
else:
    s+="s"
print(s)

Submission status: Accepted

Solution code:
s = input()

if s[-1] == "s":
    print(s + "es")
else:
    print(s + "s")

Submission status: Accepted

Solution code:
s = input()
if s[-1] == "s":
    x = "es"
else:
    x = "s"
print(s, x, sep = "")

Submission status: Accepted

Solution code:
s = input()
if s.endswith('s'):
  s += 'es'
else:
  s += 's'
print(s)

Submission status: Accepted

Solution code:
S = input()
 
if S[-1] == 's': S += 'es'
else: S += 's'
print(S)

Submission status: Accepted

Solution code:
s=input()
print(s+"es") if s[-1]=="s" else print(s+"s")

Submission status: Accepted

Solution code:
s = input()
t = len(s) - 1
if s[t] == "s":
  print(s + "es")
else:
  print(s + "s")

Submission status: Accepted

Solution code:
s = input()
print(s+'es' if s[-1] == 's' else s+'s')

Submission status: Accepted

Solution code:
s = input()
if s[-1] == "s":print(s+"es")
else:print(s+"s")

Submission status: Accepted

Solution code:
s = input()

if s[len(s) -  1] != "s":
    s += "s"

elif s[len(s) - 1] == "s":
    s += "es"

print(s)

Submission status: Accepted

Solution code:
s=input().strip()
print(s+'s' if s[-1]!='s' else s+'es')

Submission status: Accepted

Solution code:
S = input()
if S[-1] == "s":
    S += "es"
else:
    S += "s"
print(S)

Submission status: Accepted

Solution code:
S = str(input())

if S[-1]=="s":
	print(S+"es")
else:
	print(S+"s")


# 2darray [[0] * 4 for i in range(3)]
# import itertools

Submission status: Accepted

Solution code:
s = input()
if s[-1] != 's':
    print(s + 's')
else:
    print(s + 'es')

Submission status: Accepted

Solution code:
s = input()
ans = s
if s[-1] == "s":
    ans += "e"
print(ans+"s")

Submission status: Accepted

Solution code:
s = input()
print(s + 'e' * (s[-1] == 's') + 's')

Submission status: Accepted

Solution code:
def main():
    S = input().rstrip()
    if S[-1] == "s":
        S = S + "es"
    else:
        S = S + "s"
    print(S)

main()

Submission status: Accepted

Solution code:
S = input()

if S[-1] == "s":
	print( S + "es")
else:
	print( S + "s")

Submission status: Accepted

Solution code:
s = input()

lastChr = s[-1]
if lastChr == 's':
    print(s + 'es')
else:
    print(s + 's')

Submission status: Accepted

Solution code:
s = input()


lastword=s[-1]

if lastword == "s":
    print(s+"es")
else:
    print(s+"s")

Submission status: Accepted

Solution code:
word = input()
if word[-1] == 's':
  print(word+'es')
else:
  print(word+'s')

Submission status: Accepted

Solution code:
tansuu = input()
saigo = tansuu[-1]

#print(saigo)

if saigo=="s":
    tuika = "es"
else:
    tuika = "s"
    
tuikazumi = tansuu + tuika
print(tuikazumi)

Submission status: Accepted

Solution code:
s = input()
if s[-1] != "s":
  s = s + "s"
else:
  s = s + "es"
print(s)

Submission status: Accepted

Solution code:
S = input('')
if S[-1:] == 's':
    print(S + 'es')
else: 
    print(S + 's')

Submission status: Accepted

Solution code:
 
s=input()
if s[-1]=="s":
    print(s+'es')
else:
    print(s+'s')

Submission status: Accepted

Solution code:
s = input()
a = 's'
if s[-1] == 's':
    a = 'es'
s = s + a
print(s)

Submission status: Accepted

Solution code:
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007

#+++++

def main():
	#a = int(input())
	#b , c = tin()
	s = input()	
	add = 'es' if s[-1]=='s' else 's'
	return s+add
	
	
#+++++
isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		#input = sys.stdin.readline
			
	ret = main()
	if ret is not None:
		print(ret)

Submission status: Accepted

Solution code:
n=input()
if(n[len(n)-1]=='s'):
    n+="es"
else:
    n+="s"

print(n)

Submission status: Accepted

Solution code:
s = input()

if s[len(s)-1] == 's':
    s = s + 'es'
elif s[len(s)-1] != 's':
    s = s + 's'

print(s)

Submission status: Accepted

Solution code:
S = input()

if S[-1] == "s" :
    print(S + "es")
else :
    print(S + "s")

Submission status: Accepted

Solution code:
S = input()
if S[-1] == "s":
    print(S + "es")
else:
    print(S + "s")

Submission status: Accepted

Solution code:

s=input()
if s[-1]=="s":
    print(s+'es')
else:
    print(s+'s')

Submission status: Accepted

Solution code:
s = input()
l = []
for i in s:
  l.append(i)
if l[-1] == 's':
    l.append('es')
    print("".join(j for j in l))
else:
    l.append('s')
    print("".join(j for j in l))

Submission status: Accepted

Solution code:
s = input()
if s[-1] == "s":
  print(s + "es")
else:
  print(s + "s")

Submission status: Accepted

Solution code:
str = input() # sを取得し、strに値を入れる
if str[len(str)-1] == 's':
  #str = str[:len(str)-1]
  print(str + 'es')
else:
  print(str + 's')

Submission status: Accepted

Solution code:
S = input()
if S[-1] == 's':
	print(S + 'es')
else:
 	print(S + 's')

Submission status: Accepted

Solution code:

t = input()
ans = ""
if t[len(t)-1] == "s":
  ans = t + "es"
else:
  ans = t + "s"
  
print(ans)

Submission status: Accepted

Solution code:
s=input()
print(s + ('es' if s[-1]=='s' else 's'))

Submission status: Accepted

Solution code:
n=input()
if n[-1]=='s':
    print(n+'es')
else :
    print(n+'s')

Submission status: Accepted

Solution code:
S = str(input())

if(S[len(S)-1] == "s"):
    S += "es"
else:
    S += "s"

print(S)

Submission status: Accepted

Solution code:
s = input()

if s[-1] != "s":
  s = s + "s"
  
else:
  s = s + "es"
  
print(s)

Submission status: Accepted

Solution code:
S=input()
if S[len(S)-1]=='s':
    print(S+'es')
else:
    print(S+'s')

Submission status: Accepted

Solution code:
s = input()
if s[len(s)-1] == 's':
  print(s+'es')
else:
  print(s+'s')

Submission status: Accepted

Solution code:
def run(s):
    '''

    '''
    print('{}{}'.format(s, 'es' if s[-1] == 's' else 's'))

if __name__ == '__main__':
    s = input()

    run(s)

Submission status: Accepted

Solution code:
s = input()
if( s[ -1] == 's' ):
  s += 'es'
else:
  s += 's'
 
print( s )

Submission status: Accepted

Solution code:
S = input()
if S[-1] == "s":
    S = S + "es"
else:
    S = S + "s"
print(S)

Submission status: Accepted

Solution code:
s = input()
if s[-1] == 's':
    print(s +'es')
else:
    print(s + 's')

Submission status: Accepted

Solution code:
x = str(input(""))

lists = []

lists.append(x)

y = x[-1]

if y != "s":

    addd = x + "s"

else:

    addd = x + "es"

print(addd)

Submission status: Accepted

Solution code:
i=str(input())
leng=len(i)
if i[leng-1]=="s":
  print(i+"es")
else:
  print(i+"s")

Submission status: Accepted

Solution code:
word = input()
ans = []
j = 0
for i in word:
    j += 1

if word[j - 1] != 's':
    ans = word + 's'
elif word[j - 1] == 's' and j >= 1:
    ans = word + 'es'
print(ans)

Submission status: Accepted

Solution code:
def main():
    s = input()

    if s[-1]=='s':
        print(s,'es',sep='')
    else:
        print(s,'s',sep='')

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
S = input()
if S[-1] == 's':
    print(S + "es")
else:
    print(S + "s")

Submission status: Accepted

Solution code:
S = input()

if S[-1] == "s":
    print(S + "es")
else:
    print(S + "s")

Submission status: Accepted

Solution code:
S = input()
print(S+'es' if S.endswith('s') else S+'s')

Submission status: Accepted

Solution code:
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce

sys.setrecursionlimit(10**6) 

I=sys.stdin.readline

 #s="abcdefghijklmnopqrstuvwxyz"

"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
	return int(I().strip())
def li():
	return list(map(int,I().strip().split()))
def mi():
	return map(int,I().strip().split())

def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer // denom

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
def divi(n):
	if n==1:
		return 1
	cnt=2
	for i in range(2,int(n**.5)+1):
		if n%i==0:
			if i==n//i:
				cnt+=1
			else:
				cnt+=2
	return cnt


def main():
	n=I().strip()
	if n[-1]=='s':
		print(n+'es')
	else:
		print(n+'s')
	

























	
	
	





if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
noun = input()
end="s"
if noun[-1] == 's':end="es"
noun += end
print(noun)

Submission status: Accepted

Solution code:
S = input()
if S.endswith('s'):
  print(S+'es')
else:
 print(S+'s')

Submission status: Accepted

Solution code:
sing = input()
if sing[-1] == 's': plu = sing + 'es'
else : plu = sing + 's'
print(plu)

Submission status: Accepted

Solution code:
s = input()

last = s[len(s) - 1:]

if last == 's':
  print(s + 'es')
else:
  print(s + 's')

Submission status: Accepted

Solution code:
S = input()

ls = S[-1:]

if ls == 's':
  print(S+'es')
else:
  print(S+'s')

Submission status: Accepted

Solution code:
word=input()

last_letter=word[int(len(word))-1]

if last_letter=="s":
  print(word+"es")
else:
  print(word+"s")

Submission status: Accepted

Solution code:
a = input()
if a[-1] == "s" :print(a+"es")
else :print(a+"s")

Submission status: Accepted

Solution code:
n = input()

if n.endswith('s'):
  plural = n + 'es'
  print(plural)
else :
  plural = n + 's'
  print(plural)

Submission status: Accepted

Solution code:
s = input()
if s[-1] == 's': s += 'es'
else: s += 's'
print(s)

Submission status: Accepted

Solution code:
def actual(s: str) -> str:
    tail = s[-1]

    if tail == 's':
        return s + 'es'
    else:
        return s + 's'

s = input()
print(actual(s))

Submission status: Accepted

Solution code:
def main():
    S = input()

    if S[-1] == 's':
        S = S + 'es'
    else:
        S = S + 's'

    print(S)



main()

Submission status: Accepted

Solution code:
x = str(input(""))
lists = []
lists.append(x)
y = x[-1]
if y != "s":
    addd = x + "s"
else:
    addd = x + "es"
print(addd)

Submission status: Accepted

Solution code:
## coding: UTF-8
S = input()

if(S[-1] == 's'):
    print(S + 'es')
else:
    print(S + 's')

Submission status: Accepted

Solution code:
str=input()
if str.endswith("s"):
  print(str+"es")
else:
  print(str+"s")

Submission status: Accepted

Solution code:
string = input()

if string[-1] == 's':
	out = string + "es"
else:
	out = string + "s"
    

print(out)

Submission status: Accepted

Solution code:
s=input()
n=len(s)

if s[n-1]=='s':
  print(s+'es')
  
else:
  print(s+'s')

Submission status: Accepted

Solution code:
s=input()
if s[len(s)-1] =='s':
    print(s+'es')
else:
    print(s+'s')

Submission status: Accepted

Solution code:
s = input()

if s[len(s)-1] == 's':
    print(s+'es')
else:
    print(s+'s')

Submission status: Accepted

Solution code:
x= str(input())
a=list(x)
l=len(a)
if a[l-1]=='s':
    print(x+'es')
else:
    print(x+'s')

Submission status: Accepted

Solution code:
S = str(input())
if S[-1] == 's':
  S = S + 'es'
else:
  S = S + 's'
print(S)

Submission status: Accepted

Solution code:
S=input()
if S[-1]=="s":
    print(S+"es")
else:
    print(S+"s")

Submission status: Accepted

Solution code:
S=list(input())
n=int(len(S))
ans=''
if S[n-1]=='s':
        ans=''.join(S)+'es'
else:
        ans=''.join(S)+'s'

print(ans)

Submission status: Accepted

Solution code:
a = input()
b = [str(c) for c in a]

if b[-1] == "s":
  b.append("es")
  
else:
  b.append("s")

print(''.join(b))

Submission status: Accepted

Solution code:
import bisect
from collections import deque
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
# mod = 10 ** 9 + 7
mod = 998244353

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]



def main():
    S = input().strip()
    if S[-1] == "s":
        S += "es"
    else:
        S += "s"
    print(S)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
AA=str(input())
AB=AA[-1]
if AB=='s':
  print(AA+'es')
else:
  print(AA+'s')

Submission status: Accepted

Solution code:
s = input()

if s[len(s)-1] == 's':
	print(s+"es")
else:
	print(s+"s")

Submission status: Accepted

Solution code:
def main():
    s = input()

    if s[-1] == 's':
        print(s + 'es')
    else:
        print(s + 's')    
main()

Submission status: Accepted

Solution code:
word = input()
if (word.endswith('s')):
    print(word + 'es')
else:
    print(word + 's')

Submission status: Accepted

Solution code:
s3="s"
es="es"
S=input()
if S[-1]=="s":
	s1= S + es
	print(s1)
else:
	s2 = S + s3
	print(s2)

Submission status: Accepted

Solution code:
s=input()
if(s[-1]=='s'):
    s=s+"es"
    print(s)
else:
    s=s+"s"
    print(s)

Submission status: Accepted

Solution code:
s= input()
if s[len(s)-1] == 's':
  print(s+'es')
else:
  print(s+'s')

Submission status: Accepted

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


s = input()
if s[-1]=="s":
    s += "es"
else:
    s += "s"
print(s)

Submission status: Accepted

Solution code:
l = input()
s = l[-1]
c = ''
if s == 's':
  c = l + 'es'
else:
  c = l + 's'

print(c)

Submission status: Accepted

Solution code:
s = str(input())
if s[-1] == 's':
    s += 'es'
else:
    s += 's'
print(s)

Submission status: Accepted

Solution code:
val = input()

if(val[-1] == 's'):
  print(val + 'es')
else:
  print(val+'s')

Submission status: Accepted

Solution code:
s = input()
if s[len(s)-1] == "s":
  print(s + "es")
else:
  print(s + "s")

Submission status: Accepted

Solution code:
def main():
  s = input()
  if s[-1] == 's':
    ans = s + 'es'
  else:
    ans = s + 's'
  print(ans)
  
main()

Submission status: Accepted

Solution code:
S = input()
if S[-1] == 's':
  S += 'es'
else:
  S += 's'
  
print(S)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
from typing import Any, Callable, Deque, Dict, List, Mapping, Optional, Sequence, Set, Tuple, TypeVar, Union
# import time
# import math, cmath
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import _heapify_max, _heappop_max, _siftdown_max
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import Fraction               # Fraction(a, b) => a / b ∈ Q. note: Fraction(0.1) do not returns Fraciton(1, 10). Fraction('0.1') returns Fraction(1, 10)



def main():
    Num = Union[int, float]
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79e+308
    # inf = 2 ** 63 - 1             # (for fast JIT compile in PyPy) 9.22e+18
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input():  return sys.stdin.readline().rstrip()
    def ii():     return int(input())
    def isp():    return input().split()
    def mi():     return map(int, input().split())
    def mi_0():   return map(lambda x: int(x)-1, input().split())
    def lmi():    return list(map(int, input().split()))
    def lmi_0():  return list(map(lambda x: int(x)-1, input().split()))
    def li():     return list(input())
    def debug(x): print(x, file=sys.stderr)
    # def _heappush_max(h, item): h.append(item); _siftdown_max(h, 0, len(h)-1)
    
    
    s = input()
    if s[-1] == 's':
        print(s + 'es')
    else:
        print(s + 's')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def A():
    S = input()
    if(S[-1] == 's'):
        S += 'es'
    else:
        S += 's'
    print(S)
A()

Submission status: Accepted

Solution code:
if __name__ == '__main__':
  s = str(input())

  if s[-1] != 's':
    print(f'{s}s')
  else:
    print(f'{s}es')

Submission status: Accepted

Solution code:
a = input()
N = len(a)
if a[N-1]=="s":
    b = a+"es"
else:
    b = a + "s"
print(b)

Submission status: Accepted

Solution code:
S = input()

if S[-1] == 's':
  print(S + 'es')
else:
  print(S + 's')

Submission status: Accepted

Solution code:
# coding: utf8
# 日本語を入力できるようにするために上記一文が必要


S = input()

if S[-1] == 's':
        print(S + "es")
else:
        print(S + "s")

Submission status: Accepted

Solution code:
import os,sys

s=input()
n=len(s)
if s[n-1]=='s':
    s=s+'es'
else:
    s=s+'s'

print(s)

Submission status: Accepted

Solution code:
a=input()
e=a[len(a)-1:len(a)]
if e == "s":
    print(a+"es")
else:
    print(a+"s")

Submission status: Accepted

Solution code:
def main():
    i = input()
    if(i[-1]=="s"):
        print(i+'es')
    else:
        print(i+'s')    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input()
if s[-1] != 's':
  print(s + 's')
else:
  print(s + "es")

Submission status: Accepted

Solution code:
S = input()
if S.endswith("s"): print(S + "es")
else: print(S + "s")

Submission status: Accepted

Solution code:
a = input()
if a[-1] == 's':
  a += 'es'
else:
  a += 's'
print(a)

Submission status: Accepted

Solution code:
S = input()

if(S[-1] == "s"):
    print(S + "es")
else:
    print(S + "s")

Submission status: Accepted

Solution code:
a = input()

if a[-1] == "s":
  print(a + "es")
else:
  print(a + "s")