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

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline  
ra = range
enu = enumerate


def exit(*argv, **kwarg):
    print(*argv, **kwarg)
    sys.exit()


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def a_int(): return int(readline())


def ints(): return list(map(int, readline().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, readline().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, readline().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, readline().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from functools import reduce
from math import gcd


def lcm(a, b):
    
    g = gcd(a, b)
    return a // g * b


S = input()
add = 'es' if S.endswith('s') else 's'
print(S + add)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6
mod = 10 ** 9 + 7 





S = input()

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

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

Solution (Python):

import sys
import collections as cl


def II(): return int(sys.stdin.readline())


def MI(): return map(int, sys.stdin.readline().split())


def LI(): return list(map(int, sys.stdin.readline().split()))


def main():
    target = input()
    if target[-1] == "s":
        print(target+"es")
        return

    print(target+"s")


main()

Solution (Python):
S = input()

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

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

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

print(S)

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

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

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline

def main():
    s = input().rstrip('\n')
    if s[-1] == 's':
        s += 'es'
    else:
        s += 's'

    print(s)

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
s = input()

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

print(s)

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

Solution (Python):
s = input()

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

Solution (Python):
s=str(input())
s=list(s)
if s[len(s)-1]=="s":
  print("".join(s)+"es")
else:
  print("".join(s)+"s")

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    S = rl().rstrip()
    if S[-1] == 's':
        print(S + 'es')
    else:
        print(S + 's')


if __name__ == '__main__':
    solve()

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    s = input()
    if s[-1] != 's':
        print(s+'s')
    else:
        print(s+'es')

if __name__=='__main__':
    main()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    s = input()
    if s[-1] != 's':
        print(s+'s')
    else:
        print(s+'es')

if __name__=='__main__':
    main()

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)











def inp():
    return int(input())
def inps():
    return input().rstrip()
def inpl():
    return list(map(int, input().split()))
def _debug(obj):
    print(obj, file=sys.stderr)


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

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

Solution (Python):
import sys

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

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

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

Solution (Python):
S = input()

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

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

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

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

Solution (Python):
word = input()

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

print(word)

Solution (Python):



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

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

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

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

Solution (Python):
from sys  import stdin,stdout
 
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
 
mod=1000000007
INF=float('inf')


 
 
for _ in range(1):
    s=st()
    if s[-1]=='s':
        print(''.join(s)+'es')
    else:
        print(''.join(s)+'s')

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

Solution (Python):
s = input()

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

else:
    s += 's'

print(s)

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

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

Solution (Python):
s = list(input())
if s[-1] == 's':
    s.append('es')
else:
    s.append('s')
print(''.join(s))

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

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

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

print(S)

Solution (Python):
n = input()

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

Solution (Python):
def main():
    import sys
    inl = sys.stdin.buffer.readline
    
    n = input()

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


        


    




















if __name__ == "__main__":
    main()

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

Solution (Python):
S = input()

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

Solution (Python):
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect

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

if __name__ == "__main__":
    solve()

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

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

Solution (Python):
def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

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

Solution (Python):
s = input()
p = ""

if(s.endswith("s")):
  p = s + "es"
else:
  p = s + "s"

print(p)

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

Solution (Python):
S = input()

if S.rfind("s") == len(S) - 1:
	print(S + "es")
else:
	print(S + "s")

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

Solution (Python):
word = input()
if word[-1] == 's':
    word += "e"
print(word + "s")

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

print(s)

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

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

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

Solution (Python):
'''
自宅用PCでの解答
'''
import math

import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7

dir = [(-1,0),(0,-1),(1,0),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
INF = 1<<32-1


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

    return None

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

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


if __name__ == "__main__":
    resolve()

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

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

Solution (Python):


def get_input() -> str:
    """
    標準入力を取得する.

    Returns:\n
        str: 標準入力
    """
    S = input()

    return S


def main(S: str) -> None:
    """
    メイン処理.

    Args:\n
        S (str): 文字列(1 <= |S| <= 1000, 英子文字のみ)
    """
    
    ans = S
    if S[-1] == "s":
        ans += "es"
    else:
        ans += "s"

    
    print(ans)


if __name__ == "__main__":
    
    S = get_input()

    
    main(S)

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

Solution (Python):
s=raw_input().strip()
print s+('es' if s[-1]=='s' else 's')

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

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

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

Solution (Python):
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()
    








 
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

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) : 
    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():
    
              
    
    s = input()
    if s[-1] != 's':
        print(s + 's')
    elif s[-1] == 's':
        print(s + 'es')
    
    
    
    
    
        
    


 
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")
 

 
 
if __name__ == "__main__":
    
    main()

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

print(s + suffix)

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

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

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

    print(answer)


if __name__ == "__main__":
    main()

Solution (Python):
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()
    








 
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

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) : 
    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():
    
              
    
    s = input()
    if s[-1] != 's':
        print(s + 's')
    elif s[-1] == 's':
        print(s + 'es')
    
    
    
    
    
        
    


 
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")
 

 
 
if __name__ == "__main__":
    
    main()

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

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

    return


if __name__ == '__main__':
    main()

Solution (Python):
s = input()

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

print(s)

Solution (Python):
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')

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

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

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

print(S)

Solution (Python):
S = input()

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

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

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

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

Solution (Python):
s = input()

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

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

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

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

Solution (Python):
S = input()

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

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

Solution (Python):
S = input()

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

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

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

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

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

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


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

Solution (Python):
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')


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

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

Solution (Python):
import sys
INF = 1 << 60
MOD = 10**9 + 7 
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()

Solution (Python):
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"))

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

Solution (Python):
S = input()

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

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

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

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

Solution (Python):
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)

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

Solution (Python):
s = input()

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

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

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

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

Solution (Python):
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"))

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

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

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

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

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

Solution (Python):
s = input()

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

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

print(s)

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

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

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

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

Solution (Python):
S = str(input())

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

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

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

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

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

main()

Solution (Python):
S = input()

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

Solution (Python):
s = input()

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

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

Solution (Python):
s = input()


lastword=s[-1]

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

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

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

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



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

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

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

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

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

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