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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
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)

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

# from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
printout = sys.stdout.write
sprint = sys.stdout.flush
# from heapq import heappop, heappush
# from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
# import math
# from itertools import product, accumulate, combinations, product
# import bisect
# import numpy as np
# from copy import deepcopy
#from collections import deque
# from decimal import Decimal
# from numba import jit

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

Submission status: Accepted

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

Submission status: Accepted

Solution 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:
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

# sys.setrecursionlimit(5000)

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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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 = S + 'es'
else:
  S = S +'s'
print(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:
# import sys
# input = sys.stdin.readline

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input() #sys.stdin.readlineは最後が改行

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# author:  Taichicchi
# created: 19.09.2020 20:58:31

import sys

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




if __name__ == "__main__":
    main()

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:
# by the authority of GOD     author: manhar singh sachdev #

import os,sys
from io import BytesIO, IOBase

def main():
    s = input().strip()
    if s[-1]=='s':
        print(s+'es')
    else:
        print(s+'s')
    
#Fast IO Region
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

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 + 's')
else:
    print(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:
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():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    from collections import defaultdict
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil,pi,factorial
    from operator import itemgetter
    def I(): return int(input())
    def MI(): return map(int, input().split())
    def LI(): return list(map(int, input().split()))
    def LI2(): return [int(input()) for i in range(n)]
    def MXI(): return [[LI()]for i in range(n)]
    def SI(): return input().rstrip()
    def printns(x): print('\n'.join(x))
    def printni(x): print('\n'.join(list(map(str,x))))
    inf = 10**17
    mod = 10**9 + 7
#main code here!
    s=SI()
    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+'s')
else:
  print(s+'es')

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())


def main():

    s = in_s()

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

    print(s)


if __name__ == '__main__':
    main()

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:
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
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())
def main():




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


main()

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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:

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = input()

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

Submission status: Accepted

Solution code:
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
def celi(a,b):
    return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = list(input())

if s[-1] == 's':
  print(''.join(s+['e', 's']))
else:
  print(''.join(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:
import sys
input = sys.stdin.readline
S = input()[: -1]
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 sys

sys.setrecursionlimit(500005)
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().strip()

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

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

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

Submission status: Accepted

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

print(S)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#ABC179 A
n = input()

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

Submission status: Accepted

Solution code:
#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

def resolve():
    s = input()

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

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
#create date: 2020-09-19 21:00

import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

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

Submission status: Accepted

Solution code:
s = input ()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for _ in range(n)]
def LIR(n):
    return [LI() for _ in range(n)]
def SR(n):
    return [S() for _ in range(n)]
def LSR(n):
    return [LS() for _ in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

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

#Solve
if __name__ == "__main__":
    solve()

Submission status: Accepted

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

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:
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    S = input()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

s = input()

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

Submission status: Accepted

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

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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[-1] == "s":
  print(s+"es")
  exit()
print(s+"s")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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:
from sys import stdin
rs = lambda : stdin.readline().strip()
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s=input()

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

Submission status: Accepted

Solution code:
FAST_IO = 0
if FAST_IO:
    import io, sys, atexit
    rr = iter(sys.stdin.read().splitlines()).next
    sys.stdout = _OUTPUT_BUFFER = io.BytesIO()

    @atexit.register
    def write():
        sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
else:
    rr = raw_input
rri = lambda: int(rr())
rrm = lambda: map(int, rr().split())
rrmm = lambda n: [rrm() for _ in xrange(n)]

####
MOD = 10**9 + 7
YES, NO, IMP = "YES", "NO", "IMPOSSIBLE"
from collections import defaultdict as ddic


def solve(S):
    if S.endswith('s'):
        return S + 'es'
    return S + 's'

print solve(rr())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
from heapq import heappop, heappush
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import permutations
sys.setrecursionlimit(10 ** 7)
 
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

# map(int, input().split())
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 += 'e'
S += 's'
print(S)

Submission status: Accepted

Solution code:
# import sys
# input = sys.stdin.readline
s = input()
if s[-1] == "s":
    print(s+"es")
else:
    print(s+"s")

Submission status: Accepted

Solution code:
from sys import stdin, setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

def main():
    from builtins import int, map
    s = input()
    if s[-1] != 's':
        print(s + "s")
    else:
        print(s + "es")

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:
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
S = input()
print(S + 's' if S[-1] != 's' else S + 'es')

Submission status: Accepted

Solution code:
import sys, math, re
from functools import lru_cache
from collections import deque
sys.setrecursionlimit(10**9)
MOD = 10**9+7

def input():
    return sys.stdin.readline()[:-1]

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

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase

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


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# ------------------- fast io --------------------
from math import gcd, ceil

def pre(s):
    n = len(s)
    pi = [0] * n
    for i in range(1, n):
        j = pi[i - 1]
        while j and s[i] != s[j]:
            j = pi[j - 1]
        if s[i] == s[j]:
            j += 1
        pi[i] = j
    return pi


def prod(a):
    ans = 1
    for each in a:
        ans = (ans * each)
    return ans

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


def binary(x, length=16):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y


for _ in range(int(input()) if not True else 1):
    #n = int(input())
    #n, k = map(int, input().split())
    #a, b = map(int, input().split())
    #c, d = map(int, input().split())
    #a = list(map(int, input().split()))
    #b = list(map(int, input().split()))
    s = input()
    if s[-1] == "s":
        print(s+"es")
    else:
        print(s+"s")