Problem:
 Score : 100 points    Problem Statement Snuke is going to open a contest named "AtCoder s Contest".
Here, s is a string of length 1 or greater, where the first character is an uppercase English letter, and the second and subsequent characters are lowercase English letters.  Snuke has decided to abbreviate the name of the contest as "A x C".
Here, x is the uppercase English letter at the beginning of s .  Given the name of the contest, print the abbreviation of the name.      Constraints  The length of s is between 1 and 100 , inclusive.  The first character in s is an uppercase English letter.  The second and subsequent characters in s are lowercase English letters.         Input The input is given from Standard Input in the following format:  AtCoder s Contest      Output Print the abbreviation of the name of the contest.        Sample Input 1 AtCoder Beginner Contest      Sample Output 1 ABC  The contest in which you are participating now.       Sample Input 2 AtCoder Snuke Contest      Sample Output 2 ASC  This contest does not actually exist.       Sample Input 3 AtCoder X Contest      Sample Output 3 AXC

Solution (Python):
arr = list(input().split())
print(arr[0][0] + arr[1][0] + arr[2][0])

Solution (Python):
import sys

input = sys.stdin.buffer.readline
in_n = lambda: int(input())
in_nn = lambda: map(int, input().split())
in_s = lambda: input().rstrip().decode('utf-8')
in_map = lambda: [s == ord('.') for s in input() if s != ord('\n')]

MOD = 10**9 + 7
INF = 8 * 10**18


def main():

    _, s, _ = in_s().split()

    print("A" + s[0] + "C")


if __name__ == '__main__':
    main()

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

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():
    a, s, b = s_map()
    
    print(a[0] + s[0] + b[0])

if __name__ == '__main__':
    main()

Solution (Python):
_, s, _ = input().split()
print("A" + s[0] + "C")

Solution (Python):
s=input().split()
s2=s[1]

print("A"+s2[0]+"C")

Solution (Python):
title = list(map(str, input().split()))
print('A'+title[1][0]+'C')

Solution (Python):
s=input().split()
s=[s[i][0] for i in range(len(s))]
print("".join(s))

Solution (Python):
def iroha():
    head, string, heel = map(str, input().split())
    headC = head[0]
    Capital = string[0]
    heelC = heel[0]
    print(headC + Capital + heelC)

if __name__ == "__main__":
    iroha()

Solution (Python):
a,b,c=input().split()
print('A'+b[0]+'C')

Solution (Python):
a,b,c=input().split()
print('A'+b[0]+'C')

Solution (Python):
a,b,c=map(str,input().split())
print('A'+b[0]+'C')

Solution (Python):
lst=input().split()
x=lst[1]
print('A'+x[0]+'C')

Solution (Python):
a,b,c = input().split()

print((a[0]+b[0]+c[0]).upper())

Solution (Python):
str1=list(input().split())
print(str1[0][0]+str1[1][0]+str1[2][0])

Solution (Python):
a,x,c = input().split()

print('A'+x[0]+'C')

Solution (Python):
x,y,z = input().split()
print(x[0]+y[0]+z[0])

Solution (Python):
l = list(input().split())
print("A" + l[1][0] + "C")

Solution (Python):
a,b,c = list(input().split())

print(a[0] + b[0] + c[0])

Solution (Python):
a,b,c = map(str,input().split())

ans = ["A",b[0],"C"]

ans = ''.join(ans)
print(ans)

Solution (Python):
"""
ABC048 A - AtCoder *** Contest
https://atcoder.jp/contests/abc048/tasks/abc048_a
"""
a,b,c = input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
s = input()
print("A"+s[8]+"C")

Solution (Python):
S = input()
s = 'A'+S[8].upper() + 'C'
print(s)

Solution (Python):


def main():
    a, s, c = input().split()
    print(a[0] + s[0] + c[0])


if __name__ == "__main__":
    main()

Solution (Python):
a,s,c=map(str,input().split())

print('A'+s[0]+'C')

Solution (Python):
A,B,C=input().split()
print("A"+B[0]+"C")

Solution (Python):
a,s,c=input().split()
print("A" + s[0].upper() + "C")

Solution (Python):
a,b,c = input().split()
print("A"+b[0]+"C")

Solution (Python):
s = list(input().split())
print("A" + s[1][0] + "C")

Solution (Python):
s1, s2, s3 = input().split()
print(s1[0] + s2[0] + s3[0])

Solution (Python):
a = list(map(str,input().split()))
midle = list(a[1])
print("A"+midle[0]+"C")

Solution (Python):
a, b, c = list(map(list, input().split()))

print("A" + b[0] + "C")

Solution (Python):
a,b,c = input().split(" ")
print(f"A{b[0]}C")

Solution (Python):
a = input().split()
print(*[h[0] for h in a], sep='')

Solution (Python):
a,b,c =input().split()
print('A' + b[0] + 'C')

Solution (Python):
if __name__ == "__main__":
	str = input()
	a,b,c = str.split()
	print(a[0]+b[0]+c[0])

Solution (Python):
str = input()

s = str.replace("AtCoder ", "").replace(" Contest", "")

s_capital = s[:1]

contest_abbr = 'A' + s_capital + 'C'

print(contest_abbr)

Solution (Python):
a, b, c = input().split()
print(a[0] + b[0] + c[0])

Solution (Python):
s = list(map(str, input().split()))

print(s[0][0] + s[1][0] + s[2][0])

Solution (Python):
a,b,c,=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
a,b,c=input().split()
print("A"+b[0]+"C")

Solution (Python):
a, b, c = input().split()
print(a[0] + b[0] + c[0])

Solution (Python):
A, x, C = list(map(str, input().split()))
S = 'A' + x[0].upper() + 'C'
print(S)

Solution (Python):
a,b,c = input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
a, x, c = input().split()
print('A' + x[0] + 'C')

Solution (Python):
def solve():
    print('A'+input()[8]+'C')


if __name__ == "__main__":
    solve()

Solution (Python):
a,b,c=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
def main():
    a, b, c = input().split()
    print("A" + b[0] + "C")


if __name__ == "__main__":
    main()

Solution (Python):
a, b, c = input().split()
print(a[0] + b[0] + c[0])

Solution (Python):
S = input().split()
print(S[0][0]+S[1][0]+S[2][0])

Solution (Python):
a,b,c=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
x=input()
print("A"+x[8]+"C")

Solution (Python):
x = input()[8]
print("A"+x+"C")

Solution (Python):
a = map(str, input().split())
name_list = list(a)
print('{}{}{}'.format(name_list[0][0], name_list[1][0], name_list[2][0]))

Solution (Python):

S=input().split()
s=S[1]
rev_s=list(s)
print('A'+rev_s[0]+'C')

Solution (Python):
s = input().split()
print(f"A{s[1][0]}C")

Solution (Python):
a, b, c = input().split()
print("A" + b[0] + "C")

Solution (Python):
print(''.join([s[0] for s in input().split()]))

Solution (Python):
a, b, c = input().split()

print(a[0] + b[0] + c[0])

Solution (Python):
a, b, c = input().split()

print('A' + b[0] + 'C')

Solution (Python):
a = list(map(str, input().split()))
print(a[0][0] + a[1][0] + a[2][0])

Solution (Python):
print(f'A{input()[8]}C')

Solution (Python):
print(*[i[0] for i in input().split()],sep='')

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    s = S()
    print('A' + s[8] + 'C')

main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def main():
    _, s, _ = input().split()
    print("A{}C".format(s[0]))




if __name__ == "__main__":
    main()

Solution (Python):
print('A' + input().split()[1][0] + 'C')

Solution (Python):
names = input().split()
print("".join([a[0] for a in names]))

Solution (Python):
a,b,c=input().split()
print("A"+b[0]+"C")

Solution (Python):
S=list(map(str,input().split()))
print("A"+S[1][0]+"C")

Solution (Python):
s = input().split()[1]
print("A"+s[0]+"C")

Solution (Python):
AtCoder, s, Contest = input().split()
print(AtCoder[0] + s[0] + Contest[0])

Solution (Python):
a,s,c=map(str,input().split())
print(("A"+s[0]+"C"))

Solution (Python):
a,b,c = input().split()

print(a[0]+b[0]+c[0])

Solution (Python):
a,b,c=map(str,input().split())
print("A"+b[0]+"C")

Solution (Python):
lst = list(map(str, input().split()))
print(lst[0][0] + lst[1][0] + lst[2][0])

Solution (Python):
title = input().split(" ")
name = title[1]
fst = list(name)
print("A"+fst[0]+"C")

Solution (Python):
s = input()
print("A" + s[8] + "C")

Solution (Python):
a, b, c = map(str, input().split())
print(a[0] + b[0] + c[0])

Solution (Python):
a = input().split()
b=[]

for i in range(3):
  b.append(a[i][0])
  
print(b[0]+b[1]+b[2])

Solution (Python):
a,b,c=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
print("".join(s[0] for s in input().split()))

Solution (Python):
a,s,t = map(str,input().split())
print("A"+s[0]+"C")

Solution (Python):
s=input()
print("A"+s[8]+"C")

Solution (Python):



import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """AtCoder Beginner Contest"""
        output = """ABC"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """AtCoder Snuke Contest"""
        output = """ASC"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """AtCoder X Contest"""
        output = """AXC"""
        self.assertIO(input, output)


def resolve():
    S = list(input().split())

    print("A"+S[1][0]+"C")


if __name__ == "__main__":
    
    resolve()

Solution (Python):
S = input()
print("A"+S[8]+"C")

Solution (Python):
a,b,c=map(str,input().split())
print(a[0]+b[0]+c[0])

Solution (Python):
a,b,c=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
s=input().split()
r=''
for i in s:
    r+=i[0]
print(r)

Solution (Python):
s = input()
strs = s.split(' ')
c = strs[1][0].upper()

ans = "{}{}{}".format(strs[0][0], c, strs[2][0])
print(ans)

Solution (Python):
s, a, b = map(str, input().split())
print("A" + a[0] + "C")

Solution (Python):
s = input().split()
print('A'+ s[1][0].upper() +'C')

Solution (Python):
s = input().split()
print(s[0][0] + s[1][0] + s[2][0])

Solution (Python):
s = input().split()
print("A", s[1][0], "C", sep="")

Solution (Python):
a,b,c=input().split()
x=b[0]
A=[]
A.append('A')
A.append(x)
A.append('C')
print(''.join(A))

Solution (Python):
a, b, c = map(str, input().split())
print(a[0] + b[0] + c[0])

Solution (Python):
A,S,C=map(str,input().split())
print("A"+S[0]+"C")

Solution (Python):
s=input().split(' ')
for x in s:
	print(x[0],end="")

Solution (Python):
from sys import stdin, stdout
from time import perf_counter

import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7

s = input()
print(f"A{s[8].upper()}C ")

Solution (Python):
s = input()
print("A" + s[8] + "C")

Solution (Python):
s = list(input().split())
n = s[1]
print("A" + n[0] + "C")

Solution (Python):
from sys import stdin, stdout
from time import perf_counter

import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7





s = input()
print(f"A{s[8].upper()}C")

Solution (Python):
from sys import stdin, stdout
from time import perf_counter

import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7







s = input()



print(f"A{s[8].upper()}C")

Solution (Python):
S=list(input().split())
print(S[0][0]+S[1][0]+S[2][0])

Solution (Python):
s=input()
ss=s[8]
print("A"+ss+"C")

Solution (Python):
s=input().split()
print('A'+s[1][0]+'C')

Solution (Python):
S = input().split()
print(''.join([s[0].upper() for s in S]))

Solution (Python):
s = list(input().split())

print('A' + s[1][0] + 'C')

Solution (Python):
x = input()
y = x.split(' ')
print(y[0][0] + y[1][0] + y[2][0])

Solution (Python):
print("A" + input()[8] + "C")

Solution (Python):
s = input()
print("A"+s[8]+"C")

Solution (Python):
text = input().split()
for i in text:
  print(i[0], end="")

Solution (Python):
a, b , c = input().split()

print(a[0]+b[0]+c[0])

Solution (Python):
sentence = input()
new_sent = sentence.split(" ")
acro = ""
for i in new_sent:
  acro += i[0]
print(acro)

Solution (Python):
a = input()
b = a.split()
x = b[1]
y = x[0]
print("A", y, "C", sep = '')

Solution (Python):
print('A'+input()[8]+'C')

Solution (Python):

def main():
    _, s, _ = input().split()

    print('A{0}C'.format(s[0]))
            

if __name__ ==  "__main__":
    main()

Solution (Python):
a, b, c = input().split()
print(a[0] + b[0] + c[0])

Solution (Python):
S=list(input().split())
s=S[1]
print('A'+s[0]+'C')

Solution (Python):
a,x,b=input().split()
print(a[0]+x[0]+b[0])

Solution (Python):
s = list(map(str,input().split()))
print(s[0][0]+s[1][0]+s[2][0])

Solution (Python):
import sys

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


def main():
    A, x, B = input().split()
    ans = A[0] + x[0] + B[0]
    print(ans.upper())



if __name__ == '__main__':
    main()

Solution (Python):
L = [x for x in input().split()]
ans = L[0][0] + L[1][0] + L[2][0]
print(ans)

Solution (Python):
_,s,_=input().split()
print(f'A{s[0].upper()}C')

Solution (Python):
contest = input().split()
print("A" + contest[1][0] + "C")

Solution (Python):
AtCoder,s,Contest = map(str, input().split())
w = 'A' + str(s[0]) + 'C'
print(w)

Solution (Python):
A,B,C=input().split()
print(A[0]+B[0]+C[0])

Solution (Python):
x=input()

x_list=list(x)
x_1=x_list[8]

print("".join(['A',x_1,'C']))

Solution (Python):
_, s, _ = input().split()
print("A{}C".format(s[0].upper()))

Solution (Python):
a,b,c = input().split()
print('A'+b[0] +'C')

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re












import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
s = input().split()
print(s[0][0] + s[1][0] + s[2][0])

Solution (Python):
A, B, C  = map(list,input().split())
print(A[0]+B[0]+C[0])

Solution (Python):




s = input().split()


ans = 'A' + s[1][0] + 'C'


print(ans)

Solution (Python):
S = input().split()
print("A"+S[1][0]+"C")

Solution (Python):
s = list(input().split())
print(s[0][0] + s[1][0] + s[2][0])

Solution (Python):
a, b, c = map(str, input().split())
print('A'+b[0].upper()+'C')

Solution (Python):
s = input()
sl = s.split()
print(sl[0][0]+sl[1][0]+sl[2][0])

Solution (Python):
S = input().split()
print(S[0][0] + S[1][0] + S[2][0])

Solution (Python):
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import product, combinations,permutations
from copy import deepcopy, copy
from math import sqrt, log10
import sys
sys.setrecursionlimit(4100000)



if __name__ == '__main__':
    A, X, C = list(input().split())

    print('A'+X[0]+'C')

Solution (Python):
s = list(input().split())
print(s[0][0]+s[1][0]+s[2][0])

Solution (Python):
s=input().split()[1]
print("A"+s[0]+"C")

Solution (Python):
a,b,c = input().split()
print(a[0],b[0],c[0],sep ="")

Solution (Python):
S = input().split()
print('A'+S[1][0]+'C')

Solution (Python):

def main():
    s = input().split()
    print(s[0][0].upper()+s[1][0].upper()+s[2][0].upper())


if __name__ == "__main__":
    main()

Solution (Python):
A=list(map(str,input().split()))
print(A[0][0]+A[1][0]+A[2][0])

Solution (Python):
s = input()
print(s[0]+s[8]+s[-7])

Solution (Python):
s = input()
print('A{}C'.format(s.split()[1][0].upper()))

Solution (Python):
a,s,c = input().split()

print("A"+s[0]+"C")

Solution (Python):
s = list(input().split())
print('A' + s[1][0] + 'C')

Solution (Python):
_, s, _ = input().split()
print("A{}C".format(s[0]))

Solution (Python):
s = input()
print("A"+s[8]+"C")

Solution (Python):







a,s,b = map(str, input().split())

print("A"+s[0]+"C")

Solution (Python):
lst = input().split()
print(lst[0][0] + lst[1][0] + lst[2][0])

Solution (Python):
a,b,c = map(str, input().split())

print(a[0]+b[0]+c[0])

Solution (Python):
print("A"+input()[8]+"C")

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    _, s, _ = LSS()    

    print('A' + s[0] + 'C')

if __name__ == '__main__':
    resolve()

Solution (Python):
a, b, c = map(str,input().split())
print(a[0]+b[0]+c[0])

Solution (Python):
a,b,c = map(str,input().split())
print( a[0] + b[0] + c[0] )

Solution (Python):
A,B,C=input().split()
print(A[0]+B[0]+C[0])

Solution (Python):
s = input()
 
print("A"+s[8]+"C")

Solution (Python):
x=input().split()
print(x[0][0]+x[1][0]+x[2][0])

Solution (Python):
AtCoder, s, Contest = input().split()

s = s[0]
ans = 'A'+ s + 'C'
print(ans)

Solution (Python):
a, b, c = list(map(str, input().split()))
s = b[0]
print('A' + s + 'C')

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

A, s, C = input().split()
print(''.join([A[0], s[0], C[0]]))

Solution (Python):
S = input().split()
ans = f'A{S[1][0]}C'
print(ans)

Solution (Python):
print("".join(s[0] for s in input().split()))

Solution (Python):
a,x,b=input().split()
print("A"+x[0]+"C")

Solution (Python):
print(f'A{input().split()[1][0]}C')

Solution (Python):
def main():
 s = list(input().split())
 ans = s[0][0] + s[1][0] + s[2][0]
 print(ans)

main()

Solution (Python):
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import product, combinations,permutations
from copy import deepcopy
import sys
sys.setrecursionlimit(4100000)



if __name__ == '__main__':
    a, s, c = map(str, input().split())
    print('A'+s[0]+'C')

Solution (Python):
x = input().split()
print("A"+x[1][0]+"C")

Solution (Python):
S = input().split()
print("A"+S[1][0]+"C")

Solution (Python):




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

lis=input().rstrip().split(" ")
print("A"+lis[1][0]+"C")

Solution (Python):
s = input().split()
print(s[0][0]+s[1][0].upper()+s[2][0])

Solution (Python):
l = list(map(str,input().split()))
v = ''
for i in range(len(l)):
    v = v + l[i][0]
print(v)

Solution (Python):
a,b,c = input().split()
print("A"+b[0]+"C")

Solution (Python):
a = list(input().split())
print("A"+a[1][0]+"C")

Solution (Python):
ls = list(map(str,input().split()))
M = ls[1][0]
print('A'+M+'C')

Solution (Python):
li=input().split()
print("A"+li[1][0:1]+"C")

Solution (Python):
a, s, b= map(str, input().split())
print("A"+ s[0] +"C")

Solution (Python):
from copy import deepcopy
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions
from operator import itemgetter
import itertools
import copy


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


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


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


def gcd(a, b):
    while(b != 0):
        a, b = b, a % b
    return a



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
s = list(map(str, input().split()))

tmp = []
for i in range(3):
    tmp.append(s[i][0])
print(''.join(tmp))

Solution (Python):
a, s, b = map(str, input().split())
print(a[0] + s[0] + b[0])

Solution (Python):
s=input()
print('A'+s[8]+'C')

Solution (Python):
s = list(map(str, input().split()))
print('A'+s[1][0]+'C')

Solution (Python):
at, b, co= input().split()
print('A'+b[0]+'C')

Solution (Python):
a, s, c = input().split()
print('A'+s[0]+'C')

Solution (Python):
l = input().replace(' ','')
print(l[0]+l[7]+l[-7])

Solution (Python):
a=input().split()
print(a[0][0],a[1][0],a[2][0],sep="")

Solution (Python):
_, s, _ = input().split()
print("A" + s[0] + "C")

Solution (Python):
print("".join(list(map(lambda s: s[:1], input().split(" ")))))

Solution (Python):
inp=list(input().split())
index=inp[1][0]
print("A"+index+"C")

Solution (Python):
a = list(map(str,input().split()))
x = a[1]
print("A"+ x[0] + "C")

Solution (Python):
ll=list(input().split())

print(ll[0][0:1],ll[1][0:1],ll[2][0:1], sep='')

Solution (Python):

a, s, c = map(str, input().split())

print("A" + s[0] + "C")

Solution (Python):
print(f"A{input()[8]}C")

Solution (Python):
con = input().split()
print(con[0][0]+con[1][0]+con[2][0])

Solution (Python):
s=input()
ans=['A']
ans.append(s[8])
ans.append('C')
print(''.join(ans))

Solution (Python):
a, b ,c = input().split()
print('A' + b[0] + 'C')

Solution (Python):
s=input()
print(f"A{s[8]}C")

Solution (Python):
a, b, c = input().split()
print(a[0] + b[0] + c[0])

Solution (Python):
s=input()
print("A"+s[8]+"C")

Solution (Python):
print('A'+input()[8].upper()+'C')

Solution (Python):
xs = input().split()
 
print("A"+xs[1][0]+"C")

Solution (Python):
a,b,c=list(map(str,input().split()))
c=b[0]
print('A'+c+'C')

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
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 ** 9)
INF = 10**9
mod = 10**9+7

a,b,c = S()
print('A'+b[0]+'C')

Solution (Python):


def main():

    name = input()

    ans = name.split()

    print(ans[0][0] + ans[1][0] + ans[2][0])


if __name__ == "__main__":
    main()

Solution (Python):
xs = input().split()
 
print("A"+xs[1][0]+"C")

Solution (Python):
s = input().split()
print('A' + s[1][0] + 'C')

Solution (Python):
s = input()
print("A"+s[8]+"C")

Solution (Python):
_,s,_=input().split()
print(f'A{s[0]}C')

Solution (Python):
a,b,c=map(str,input().split())
ans=a[0]+b[0]+c[0]
print(ans)

Solution (Python):
a = list(input().split())
print(a[0][0]+a[1][0]+a[2][0])

Solution (Python):
a,b,c=input().split()
print(a[0]+b[0]+c[0])

Solution (Python):
_, B, _ = input().split()
print('A' + B[0] + 'C')

Solution (Python):
s=str(input())
s=s.split()
d=s[1][0]
print('A'+d+'C')

Solution (Python):
a,b,c = input().split(" ")
print(a[0]+b[0]+c[0])

Solution (Python):
def resolve():
    A, s, C = input().split()
    print(A[0]+s[0]+C[0])

resolve()

Solution (Python):
l=input().split()
print("A"+l[1][0]+"C")

Solution (Python):
def abc048():
    d=[]
    a=input()
    b=a.split()
    c=[i for i in b]
    k=''.join(c)
    for i in k:
        d.append(i)

    print(d[0],end='')
    print(d[len(c[0])],end='')
    print('C',end='')
    


abc048()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    a, b, c = readline().split()

    ans = "A" + b[0] + "C"
    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c=map(str,input().split())
print(a[0],b[0],c[0],sep='')

Solution (Python):
print("A"+input()[8]+"C")

Solution (Python):


s = str(input())
print('A'+s[8]+'C')

Solution (Python):
a,b,c = map(str,input().split())
print(a[0] + b[0] + c[0])

Solution (Python):
a, b, c = map(str, input().split())
print(a[0] + b[0] + c[0])

Solution (Python):
print("A" + input().split()[1][0] + "C")

Solution (Python):
A,s,C = map(str, input().split())

print(A[0] + s[0] + C[0])

Solution (Python):
_, s, _ = input().split()
print("A" + s[0] + "C")

Solution (Python):
a,b,c=map(str,input().split())
res = a[0]+b[0]+c[0]
print(res)

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

print('A'+LS2()[8]+'C')

Solution (Python):
S = input().split()

res = "A" + S[1][0] + "C"
print(res)

Solution (Python):
l=list(map(str,input().split()))

a=l[1]
b=a[0:1]
print("A"+b+"C")

Solution (Python):
a, b, c = input().split()
print('A' + b[0] + 'C')

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, x, c = M()
print('A' + x[0] + 'C')

Solution (Python):
a,s,c=input().split()
 
print('A{}C'.format(s[0]))

Solution (Python):
A,s,C=input().split()
print("A"+s[0]+"C")

Solution (Python):
a,b,c=input().split()
print(a[0],b[0],c[0],sep="")

Solution (Python):
A,x,C = input ().split ()
n = x[:1]
print ('A'+n+'C')

Solution (Python):
Atcorder,s,Contest=map(str,input().split())
S=list(s)
print('A'+S[0]+'C')

Solution (Python):
a, s, c = map(str, input().split())
print(a[0] + s[0] + c[0])

Solution (Python):
s = input().split()
print(s[0][0]+s[1][0]+s[2][0])

Solution (Python):
_, s, _ = input().split()

print('A'+s[0].upper()+'C')

Solution (Python):
Array = list(input().split())
tmp = Array[1]
print("A" + tmp[:1] + "C")

Solution (Python):
arr = list(input().split())
print( arr[0][0] + arr[1][0] + arr[2][0] )

Solution (Python):
l = list(input().split())
print("{}{}{}".format(l[0][0],l[1][0],l[2][0]))

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b, c = rs()
print(a[0] + b[0] + c[0])

Solution (Python):
a,b,c=map(str,input().split())
print(a[0]+b[0]+c[0])

Solution (Python):
A = input().split()
print(A[0][0] + A[1][0] + A[2][0])

Solution (Python):
s=input()
ans=['A']
ans.append(s[8])
ans.append('C')
print(''.join(ans))

Solution (Python):
s = input().split()[1]

print('A{}C'.format(s[0]))

Solution (Python):
N = list(input().split())
S = N[1]
print("A"+S[0]+"C")

Solution (Python):
s=input()
print("A"+s[8]+"C")

Solution (Python):
a,s,c = input().split()
print(a[0]+s[0]+c[0])

Solution (Python):
A,S,C=input().split()
print("A"+S[0]+"C")

Solution (Python):
arr=input().split()
print(arr[0][0]+arr[1][0]+arr[2][0])

Solution (Python):
a,s,c = input().split()
print("A"+s[0]+"C")

Solution (Python):
print("A"+input()[8]+"C")

Solution (Python):
print('A'+str(input())[8]+'C')

Solution (Python):
A,B,C = input().split()
print(A[0]+B[0]+C[0])

Solution (Python):
a, b, c = input().split()

print(a[0] + b[0] + c[0])

Solution (Python):
def main():
    li = input().split()
    ans = li[0][0]+li[1][0]+li[2][0]
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
a,b,c = input().split()
b.upper()
print(a[0]+b[0]+c[0])

Solution (Python):
a,s,c = map(str, input().split())
print(a[0] + s[0] + c[0])

Solution (Python):
a,b,c = map(str, input().split())
x=[a[0].upper(),b[0].upper(),c[0].upper()]
print("".join(x))

Solution (Python):
a,b,c = input().split()
b.upper()
print(a[0]+b[0]+c[0])

Solution (Python):
a, b, c = map(str, input().split())

print(a[0] + b[0] + c[0])

Solution (Python):

lst = input().split()


print('A', lst[1][0], 'C', sep='')

Solution (Python):
A = list(input().rstrip().split(" "))
ans = []
for i in A:
    ans.append(i[0])
print("".join(ans))

Solution (Python):
print('A' + input().split()[1][0] + 'C')

Solution (Python):
import sys
import numpy as np
import random
from decimal import Decimal
import itertools
import re
import bisect
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(10**9)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')
def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]
def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]
MOD = 1000000007

def main():
	s_list = LS()
	print('A{}C'.format(s_list[1][0]))




if __name__ == '__main__':
    main()

Solution (Python):
name=list(input().split())

s=name[1][:1]

print('A'+s+'C')

Solution (Python):
a, b, c = input().split()
print("A{}C".format(b[0]))

Solution (Python):
a,s,c=input().split()
print("A"+s[0]+"C")

Solution (Python):
print(f'A{input()[8]}C')