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

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math
from collections import deque
import itertools
import heapq

from fractions import Fraction
import copy
from functools import lru_cache
from collections import defaultdict
import pprint




def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)

def soinsubunkai(n):
    a = []
    i = 1
    while i*i <= n:
        if n % i == 0 and i!=1:
            a.append(i)
            n=n//i

        if n% i !=0 or i==1:
            i += 1
    nokori=[n]
    return a + nokori

def soinsubunkai_e(n,m): 
    a = set()
    i = 1
    while n>1:
        a.add(m[n])
        n=n//m[n]
    nokori=n
    a.add(nokori)
    return a

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]


def era(n): 
    b=[i for i in range(n+1)]
    for i in range(2,int(math.sqrt(n)+10)):
        j=1
        temp=i*j
        while temp<=n:
            b[temp]=min(i,b[temp])
            temp+=i
    return b


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





if __name__ == "__main__":

    main()

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

if __name__ == '__main__':
    solve()

Solution (Python):

url = "https://atcoder.jp//contests/abc178/tasks/abc178_a"

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
input = sys.stdin.readline

S=input().strip()

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

print(S)

Solution (Python):
def N():
    return int(input())
def L():
    return list(map(int,input().split()))
def NL(n):
    return [list(map(int,input().split())) for i in range(n)]
mod = pow(10,9)+7


s =input()
l = len(s)
if s[l-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()
print(S+'s' if S[-1]!='s' else S+'es')

Solution (Python):
S = input()
print(S+"es" if S.endswith('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":
    s += "es"
else:
    s += "s"
print(s)

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

if __name__=="__main__":
    main()

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

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().strip()


def input_int():
    return int(input())


def input_int_list():
    return [int(i) for i in input().split()]


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


if __name__ == "__main__":
    main()

Solution (Python):
s = input()

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

print(s)

Solution (Python):



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

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key
from bisect import bisect_left


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

def bindex(a,x):
    i = bisect_left(a,x)
    if i != len(a) and a[i] == x:
        return i
    return None

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    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):
import sys
input = sys.stdin.readline
from collections import *

S = input()[:-1]

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):
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()
    DD = ((1,0),(0,1),(-1,0),(0,-1))

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
S = input()

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from math import gcd
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

mod=10**9+7


s=S()
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":
    print(S + "es")
else: print(S + "s")

Solution (Python):

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

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

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

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, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
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

A = input()
if A[-1] != "s":
    print(A+"s")
else:
    print(A+"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):

from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify

import itertools
import math, fractions
import sys, copy

def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]

def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))

def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]

dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")

sys.setrecursionlimit(1000000)

def main():

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

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

Solution (Python):




import sys
import heapq, functools, collections
import random
from collections import Counter, defaultdict


strr = input()










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

Solution (Python):
s = input()
if s[-1] == "s":
  s += "e"
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




'''
a,b=[],[]
for i in range(n):
    A, B = map(int, input().split())
    a.append(A)   
    b.append(B)'''

s=input().strip("\n")

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=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

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

Solution (Python):
if __name__ == "__main__":
    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):
import sys
def input(): return sys.stdin.readline().strip()

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


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):
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):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
import collections
import bisect

def main():
    S = input()

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


if __name__ == '__main__':
    main()

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

Solution (Python):

import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")

S = input()

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

Solution (Python):
s=raw_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):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy

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

Solution (Python):
s = input()

if s.endswith("s"):
  print(s + "es")
else:
  print(s + "s")

Solution (Python):
s=input();print([s+'s',s+'es'][s[-1]=='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):
a=input()
if a[-1]=="s":
   print(a+"es")
else:
   print(a+"s")

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

Solution (Python):
S = input()

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

Solution (Python):
from collections import Counter
import sys
import math
from functools import cmp_to_key

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)


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

main()

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):
def main():
    s = input()

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


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":
    ans = s + "es"
else:
    ans = s + "s"
print(ans)

Solution (Python):
import sys
from math import gcd, factorial, ceil, floor, sqrt
from bisect import bisect_left, bisect_right
from copy import deepcopy
from heapq import heapify, heappop, heappush
from itertools import permutations, combinations, product, accumulate
from collections import defaultdict, deque, Counter
sys.setrecursionlimit(10**7)

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

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
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    S=input()
    if S[-1] != "s":
        print(S+"s")
    else:
        print(S+"es")
    




if __name__ == "__main__":
    main()

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

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

Solution (Python):
S = input()

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

Solution (Python):
s = input()

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

print(res)

Solution (Python):
n = input()

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

print(k)

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):
s = input()
n = len(s)
if s[n - 1] == "s":
    s += "es"
    print(s)
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()
if s[-1] == 's':
    print(s+'es')
else:
    print(s+'s')

Solution (Python):
import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s = S()
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":
    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()

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

import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]

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

Solution (Python):
import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10**9)
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10

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

Solution (Python):

import sys


sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
printout = sys.stdout.write
sprint = sys.stdout.flush


sys.setrecursionlimit(10 ** 7)









INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7


def intread():
    return int(sysread())
def mapline(t=int):
    return map(t, sysread().split())
def mapread(t=int):
    return map(t, read().split())

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

if __name__ == "__main__":
    run()

Solution (Python):
S = input()
if 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):
def main():
    s = input()
    if s[-1] == 's':
        s += 'es'
    else:
        s += 's'
    print(s)


if __name__ == '__main__':
    main()

Solution (Python):
import sys, io, os, re
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from pprint import pprint
from math import sin, cos, pi, radians, sqrt, floor, ceil
from copy import copy, deepcopy
from collections import deque, defaultdict
from fractions import gcd
from functools import reduce
from itertools import groupby, combinations
from heapq import heapify, heappush, heappop



n1 = lambda: int(sys.stdin.readline().strip())
nn = lambda: list(map(int, sys.stdin.readline().strip().split()))
f1 = lambda: float(sys.stdin.readline().strip())
fn = lambda: list(map(float, sys.stdin.readline().strip().split()))
s1 = lambda: sys.stdin.readline().strip()
sn = lambda: list(sys.stdin.readline().strip().split())
nl = lambda n: [n1() for _ in range(n)]
fl = lambda n: [f1() for _ in range(n)]
sl = lambda n: [s1() for _ in range(n)]
nm = lambda n: [nn() for _ in range(n)]
fm = lambda n: [fn() for _ in range(n)]
sm = lambda n: [sn() for _ in range(n)]

def array1(n, d=0): return [d] * n
def array2(n, m, d=0): return [[d] * m for x in range(n)]
def array3(n, m, l, d=0): return [[[d] * l for y in xrange(m)] for x in xrange(n)]
def linc(A, d=1): return list(map(lambda x: x + d, A))
def ldec(A, d=1): return list(map(lambda x: x - d, A))

S = s1()

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

print(S)

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

s = v()
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":
  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":
  print(s + "es")
  exit(0)
else:
  print(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):
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 = S + 'es'
else:
  S = S +'s'
print(S)

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




if __name__ == "__main__":
    main()

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

Solution (Python):



def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

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":
    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":
  ans = S + "es"
else:
  ans = S + "s"
print(ans)

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

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":
  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":
  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':
    ans = s+'s'
else:
    ans = s+'es'

print(ans)

Solution (Python):
S = input().rstrip()
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()
if S[-1] == 's':
    print(S + 'es')
else:
    print(S + 's')

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

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