/*
* C++11 code template for contests.
* @author: Andrey Kalendarov
* @e-mail: andreykalendarov@gmail.com
*/

/*______ DEFINES _______*/

#define _SCL_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
//#define ANDREIKKAA_TOPCODER
//#define ANDREIKKAA_ALLOCATOR
#define ANDREIKKAA_CLASS Solution
#define ANDREIKKAA_METHOD solve
#define ANDREIKKAA_PARAMETERS void
#define ANDREIKKAA_CALL
#define ANDREIKKAA_RETURN_TYPE void
typedef long long ll;
typedef long double ld;
#define first x
#define second y
const int MEMORY_LIMIT_MB = 200;
const int TIME_LIMIT_S = 1;
const char input_filename[] =
#if defined(ANDREIKKAA)
"input.txt"
#else
""
#endif
;
const char output_filename[] =
#if defined(ANDREIKKAA)
""
#else
""
#endif
;

/* ______ INCLUDES ______ */
#include <cassert>
#include <ciso646>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <array>
#include <bitset>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <algorithm>
#include <complex>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <locale>
#include <numeric>
#include <regex>
#include <string>
#include <utility>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;

/* _____ ALLOCATION _____ */

#if defined(ANDREIKKAA_ALLOCATOR)
char alloc_memory[MEMORY_LIMIT_MB * 1000 * 1000];
size_t alloc_pointer = 0;
inline void* operator new(size_t x) { alloc_pointer += x; return alloc_memory + alloc_pointer - x; }
inline void operator delete(void*) { }
#endif

/*____ I-O OPERATORS ____*/
template<typename T, typename U> inline ostream &operator<<(ostream &out, const pair<T, U> &p) { out << p.first << ' ' << p.second; return out; }
template<typename T, typename U> inline istream &operator >> (istream &in, pair<T, U> &p) { in >> p.first >> p.second; return in; }
template<typename T> inline ostream &operator<<(ostream &out, const vector<T> &v) { if (v.empty()) return out; out << v.front(); for (auto it = ++v.begin(); it != v.end(); ++it) out << ' ' << *it; return out; }
template<typename T> inline istream &operator >> (istream &in, vector<T> &v) { for (auto &i : v) in >> i; return in; }

/* ________ CODE ________ */

const int MAX_N = 4 * 1000 * 1000 + 228;
int p[MAX_N];
int a[MAX_N >> 2];

void push_t(int v, int l, int r)
{
	if (r - l == 1 || p[v] == MAX_N)
	{
		return;
	}

	if (p[v << 1] > p[v])
	{
		p[v << 1] = p[v];
	}
	if (p[v << 1 | 1] > p[v] + ((l + r) >> 1) - l)
	{
		p[v << 1 | 1] = p[v] + ((l + r) >> 1) - l;
	}
	p[v] = MAX_N;
}

void form_t(int v, int l, int r)
{
	if (r - l == 1)
	{
		if (p[v] != MAX_N)
		{
			a[l] = p[v];
		}
		return;
	}
	else
	{
		push_t(v, l, r);
		form_t(v << 1, l, (l + r) >> 1);
		form_t(v << 1 | 1, (l + r) >> 1, r);
	}
}

void upd_t(int v, int l, int r, const int L, const int R, const int X, const int Y)
{
	push_t(v, l, r);
	if (R <= l || r <= L)
		return;

	if (L <= l && r <= R)
	{
		p[v] = X + l - Y;
		return;
	}

	upd_t(v << 1, l, (l + r) >> 1, L, R, X, Y);
	upd_t(v << 1 | 1, (l + r) >> 1, r, L, R, X, Y);
}

ll bp(ll a, int b)
{
	const int MOD = 1000 * 1000 * 1000 + 7;
	ll res = 1;
	while (b)
	{
		if (b & 1)
			res = (res * a) % MOD;
		a = (a * a) % MOD;
		b >>= 1;
	}
	return res;
}

inline ANDREIKKAA_RETURN_TYPE mainFunction(ANDREIKKAA_PARAMETERS)
{
	string s, t, u;
	cin >> s >> t >> u;
	cout << s[0] << t[0] << u[0] << endl;
}

class ANDREIKKAA_CLASS
{
public:
	ANDREIKKAA_RETURN_TYPE ANDREIKKAA_METHOD(ANDREIKKAA_PARAMETERS)
	{
		if (input_filename[0] != '\0')
			freopen(input_filename, "r", stdin);
		if (output_filename[0] != '\0')
			freopen(output_filename, "w", stdout);
		cin.tie(nullptr);
		ios_base::sync_with_stdio(false);
		//cout << setprecision(20);
		//cout << fixed;
		return mainFunction(ANDREIKKAA_CALL);
	}
#if defined(ANDREIKKAA)
	inline ANDREIKKAA_CLASS() { _start = clock(); }
	inline ~ANDREIKKAA_CLASS() { cerr << "Time: " << (clock() - _start) / (ld)CLOCKS_PER_SEC << endl; }
private:
	time_t _start;
#endif
};

#if defined(ANDREIKKAA) || !defined(ANDREIKKAA_TOPCODER)
int main()
{
	auto _s = new ANDREIKKAA_CLASS; _s->ANDREIKKAA_METHOD(ANDREIKKAA_CALL); delete _s;
#if defined(ANDREIKKAA)
	while (true);
#endif
}
#endif


Measured memory_bytes: 764