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 pprint import pprint
# import math
# import collections

S = input()
# n, k = map(int, input().split(' '))
# a = list(map(int, input().split(' ')))
# a = []
# for i in range(n):
#     a.append(int(input()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input('')

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

Submission status: Accepted

Solution code:
import math
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])
    if arr==[]:
        arr.append([n, 1])
    return arr
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    divisors.sort()
    return divisors
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
mod = 10**9 + 7

#maincode-------------------------------------------------

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# import sys; input = sys.stdin.buffer.readline
# sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 10 ** 9 + 7; INF = float("inf")

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

def inverse(N, mod):
	return (pow(N, mod - 2, mod))

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

if __name__ == '__main__':
	main()

Submission status: Accepted

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

    print(s)
    

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
"""
# A - Plural Form
"""
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:
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("{}es".format(s))
else:
    print("{}s".format(s))

Submission status: Accepted

Solution code:
i1=lambda : input()
i2=lambda : int(input())
i3=lambda : map(int,input().split())
i4=lambda n : [list(map(int,input().split()) for _ in range(n))]

S=i1()

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

Submission status: Accepted

Solution code:
S=input()

end=S[-1]

if(end=="s"):
    print(S+"es")
else:
    print(S+"s")

Submission status: Accepted

Solution code:
import sys
import math
import collections
import bisect
import itertools
import decimal
import copy
import heapq

# import numpy as np

# sys.setrecursionlimit(10 ** 6)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353

ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: map(int, sys.stdin.readline().rstrip().split())
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
flush = lambda: sys.stdout.flush()


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

    print(s)


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:
'''بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ'''
#codeforces
gi = lambda : list(map(int,input().split()))
s = input()
if s[-1] == 's':
  print(s + 'es')
else:
  print(s + 's')

Submission status: Accepted

Solution code:
import sys
import math
import collections
import decimal
import itertools
from collections import deque
from functools import reduce
import heapq
import copy
import numpy as np
#n = int(input())
#n, m = map(int, sys.stdin.readline().split())
s = input()
#a = list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

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

    return S


if __name__ == "__main__":
    S = input()
    print(solve(S))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()
S_list = list(S)

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

print(S)

Submission status: Accepted

Solution code:
s = str(input())
if 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')


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
from sys import stdin,stdout
# n=int(stdin.readline())
# a=list(map(int,stdin.readline().split()))
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[-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[-1]=="s":s+="es"
else: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:
s = input()

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

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[-1] == 's' else S + 's')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s=input()

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

Submission status: Accepted

Solution code:
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# from time import time
# from itertools import product,permutations,\
    # combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

mod = int(1e9+7)
# mod = 998244353
INF = 1<<50

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

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

if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# abc179_a.py

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

Submission status: Accepted

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    s = s_input()

    print(s+ 'es' if s[-1] == 's' else s + '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:
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

from collections import deque
from collections import Counter
import bisect
def main():
    S_ = S()
    if S_[-1] == 's':
        S_ += 'es'
    else:
        S_ += 's'
    print(S_)
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':
    answer = S + 'es'
else:
    answer = S + 's'

print(answer)

Submission status: Accepted

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

if __name__ == '__main__':
    print(main())

Submission status: Accepted

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

Submission status: Accepted

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


def main():
    t = 1
    while t > 0:
        solve()
        t -= 1


main()

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


main()

Submission status: Accepted

Solution code:
from __future__ import division, print_function
# https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
import os
import sys
from difflib import SequenceMatcher
# seqMatch = SequenceMatcher(None,str1,str2) 
 #  # find match of longest sub-string 
    #  # output will be like Match(a=0, b=0, size=5) 
    #  match = seqMatch.find_longest_match(0, len(str1), 0, len(str2))
from io import BytesIO, IOBase
from collections import Counter,deque
from heapq import heapify,heappush,heappop
from math import gcd,ceil,sqrt,log2,log
from itertools import accumulate,repeat,permutations,compress

from operator import itemgetter
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def rl():
    return list(map(int,input().split()))
def arp(arr):
    return ' '.join([str(i) for i in arr])
    

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



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





















































































































###################################################################################
# region fastio

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

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
from io import StringIO
import unittest
#import itertools
#import heapq
#from collections import deque
#d = deque()

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    #n,m,k=map(int, readline().rstrip().split())
    #arr=list(map(int, readline().rstrip().split()))
    #n=int(readline())
    ss=readline().rstrip()
    if ss[-1]=="s":
        print(ss+"es")
    else:
        print(ss+"s")
    #yn(1)

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

### ----------------
### ここまで 
### ----------------

Submission status: Accepted

Solution code:
from __future__ import division, print_function
import bisect
import math
import heapq
import itertools
import sys
from collections import deque
from atexit import register
from collections import Counter
from functools import reduce
if sys.version_info[0] < 3:
    from io import BytesIO as stream
else:
    from io import StringIO as stream
 
 
if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)
 
        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)
 
        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)
 
    input = raw_input
    range = xrange
 
    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip
 
 
def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.
 
    Args:
        sync (bool, optional): The new synchronization setting.
 
    """
    global input, flush
 
    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')
 
        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

def main():
    # sys.stdin  = open("input.txt")
    s=input()
    if s[-1]=="s":
        print(s+"es")
    else:
        print(s+"s")

if __name__ == '__main__':
    sync_with_stdio(False)
    main()

Submission status: Accepted

Solution code:
A = input()

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

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from decimal import *
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor, trunc, log
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

x = input()

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

Submission status: Accepted

Solution code:
n = str(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()
#S = int(input())
#s = input().split()
#hw = [[int(i) for i in input().split()] for _ in range(N)]
#A = list(map(int, input().split()))

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
"""MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWO:,'..'xXWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMO. .:kOo.,kNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMO. .lNWWo..lXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MNOxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxMMMMWKxoloxKWNc  .:xxd;  ,dxxxkXMXkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxMM
MKc''''''''''''''''.  ..'''''.   .''''.  .''MMMWx..,:. .xXo''.  .''.  ..'';kMk;'''''.  .'.''.  .''''''.  ..''.   .''MM
MWNXNNNNNNNNNNNNNNNO' ;KNNNNNKo. cKNNNd. lXNMMMK; ,0Wx. :NWXXl .dNNO' ;KNNNWMWNNNNNXc .kNNNNx. cXNNNNNO' ;KNN0; 'ONNMM
MMMMMMMMMMMMMMMMMWM0' :NMMMMWMX: .OMWWx. oWMMMMWx. ';. .dNMWWo .xMM0' :NWWMMMMMMMMWWl .OMMMWk. lWWMMWM0' ;XMMX: ,KMMMM
MMMMMMWMWkccccccccc;. :NMWNNNKd. :XMMWx. oWMMMWKo. .',. .,ldx; .dMM0' :NMMMMMMMNNWMWl .OMMMWk. lWMMMMM0' ;XMMX: ,0MMMM
MMWXKNWMWxcc,. .;cc;. :XMk,''..'lKWMMWx. oWMNx:. .lONNKxl.     .xMM0' :NMMMMMM0:,oKO' ,KMMMMk. lWWNkoc,. .;::;. ,KMMMM
MMXc.lXMMWWWNd..xWM0' :NM0;  ;kXWMMMWNl  oWMK:.;xXWWMWXx:. ,c' .dMM0' :NMMMMMMKc. ...;kWMMMMk. lWWc .:;. .clc:. ,KMMMM
MWWx. lXMWMMMK, lWM0' :NMMNx'.,ldxxoc'   oWMWNKNWWWN0o' .:kNWo .dMM0' :NMMMMMMMNO;  ,OWWWMMMk. lWM' lXx. lNMMX: ,KMMMM
MMMWk'.,xKNX0c..kWM0' :NMMMMNkl;,'',:l:  oWMMMMMWMWO' 'l0WMWWo .xMM0' :NMMMMMMMMMNd. .oXWMMMk. lWMd.....;0WMMX: ,KMMMM
MMMMWKo'...'..:kWMM0' :NMMMMMMMWWNNWWWx. oWMMMMMMMMWOxXWMWMWWo .xMM0' :NMMMMMMMMMMMKl. ,kNMMk. lWMWKkxx0NMWMMX: ,KMMMM
MMMMMMMN0kxk0XNWMMWKl;xNMMMMMMMMMMMMWM0c;kWMMMMMMMMMMMWWMMMMWk;:OMMXl,dNMMMMMMMMMMMMWO; .dNM0c;kWWMMMMMMMMMMMNd,oXMMMM
MMMMMMMMWWMWMMMMMMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMWMMMMMMMMMMMMMMNkxKWMMWWMMMMMMMMMMMMMMWMMWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"""


#				 Author: Udit "luctivud" Gupta @ https://www.linkedin.com/in/udit-gupta-1b7863135/					 #


import math;   		from collections import *
import sys;   		from functools import reduce
import time;   		from itertools import groupby

# sys.setrecursionlimit(10**6)

# def input()         : return sys.stdin.readline()
def get_ints()      : return map(int, input().strip().split())
def get_list()      : return list(get_ints())
def get_string()    : return list(input().strip().split())
def printxsp(*args) : return print(*args, end="")
def printsp(*args)  : return print(*args, end=" ")


DIRECTIONS = [(+0, +1), (+0, -1), (+1, +0), (+1, -1)] 
NEIGHBOURS = [(-1, -1), (-1, +0), (-1, +1), (+0, -1),\
              (+1, +1), (+1, +0), (+1, -1), (+0, +1)]



# MAIN >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

# for _test_ in range(int(input())): 
s = input()
if s[-1] == 's' :
	print(s+'es')
else:
	print(s+'s')

Submission status: Accepted

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

Submission status: Accepted

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


s = input()

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

Submission status: Accepted

Solution code:
import sys
#import string
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
#import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as np
#import sympy

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def solve():
    s = str(stdin.readline().rstrip())
    #A, B, C = map(int, stdin.readline().rstrip().split())
    #l = list(map(int, stdin.readline().rstrip().split()))
    #numbers = [[int(c) for c in l.strip().split()] for l in sys.stdin]
    #word = [stdin.readline().rstrip() for _ in range(n)]
    #number = [[int(c) for c in stdin.readline().rstrip()] for _ in range(n)]
    #zeros = [[0] * w for i in range(h)]
    if s[-1] != "s":
        print(s + "s")
    else:
        print(s + "es")

if __name__ == '__main__':
    solve()

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

Submission status: Accepted

Solution code:
S = input()

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

Submission status: Accepted

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

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:
import sys
input = sys.stdin.readline

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



if __name__=="__main__":
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
# 
# 
# @stop_watch
def solve(S):
    if S[-1] == 's':
        print(S + 'es')
    else:
        print(S + 's')


if __name__ == '__main__':
    S = input()
    # N = int(input())
    # N, M = map(int, input().split())
    # A = [int(i) for i in input().split()]
    # B = [int(i) for i in input().split()]
    # AB = [[int(i) for i in input().split()] for _ in range(N)]
    solve(S)

    # # test
    # from random import randint
    # from func import random_str
    # solve()

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7

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

Submission status: Accepted

Solution code:
S = list(input())
if S[-1] == "s":
  S.append("es")
else:
  S.append("s")
print("".join(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()
l=len(S)
if S[l-1]=="s":
    print(S+"es")
else:
    print(S+"s")

Submission status: Accepted

Solution code:
#n = int(input())
#a, b = map(int,input().split())
#l = list(map(int,input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
s=input()
if s[-1]!='s':
    ans=s+'s'
else:
    ans=s+'es'
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = input()

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

Submission status: Accepted

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

resolve()

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

print(s)

Submission status: Accepted

Solution code:
from typing import List, Any


def read_int() -> int:
    return int(input().strip())


def read_ints() -> List[int]:
    return list(map(int, input().strip().split(' ')))


def solve() -> Any:
    s = input().strip()
    if s.endswith('s'):
        return s+'es'
    return s+'s'


if __name__ == '__main__':
    print(solve())

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 19 20:16:30 2020

@author: liang
"""
 
#A
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+='es'
else:s+='s'
print(s)