#pragma once

#include <iostream>
#include <string>

#include <algorithm>
#include <memory>
#include <functional>
#include <mutex>

#include <cmath>
#include <numeric>

#include <unordered_map>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <array>

#include <chrono>

#define forange(counter, end) forstep(counter, 0, end)
#define forstep(counter, begin, end) forstep_type(int, counter, begin, end)
#define forange_type(type, counter, end) forstep_type(type, counter, 0, end)
#define forstep_type(type, counter, begin, end) for (type counter = begin, forstep_type_end_##counter = end; counter < forstep_type_end_##counter; counter++)

#define _nodiscard [[nodiscard]]
#define cast_size(v) static_cast<size_t>(v)

constexpr size_t Size = 10'000;

struct Point {
	using Type = short;

	Type x = -1;
	Type y = -1;

	constexpr Point() {}
	constexpr Point(Type _x, Type _y) : x(_x), y(_y) {}

	constexpr inline bool operator==(const Point p) const {
		return this->x == p.x && this->y == p.y;
	}

	constexpr Point operator+(const Point p) const {
		return Point(this->x + p.x, this->y + p.y);
	}

	constexpr void operator+=(const Point p) {
		this->x += p.x;
		this->y += p.y;
	}

	constexpr bool operator<(const Point p) const {
		if (this->y != p.y)
			return this->y < p.y;
		return this->x < p.x;
	}

	std::string toString()const {
		return "{" + std::to_string(this->x) + ", " + std::to_string(this->y) + "}";
	}

};

std::ostream& operator<<(std::ostream& os, const Point& p) {
	os << p.x << " " << p.y;
	return os;
}

struct Rect {

	using Type = Point::Type;
	/**
	 * @brief 左上
	*/
	Point tl;

	/**
	 * @brief 右下
	*/
	Point br;

	constexpr Rect() {}
	constexpr Rect(Type _l, Type _t, Type _r, Type _b) : tl(_l, _t), br(_r, _b) {}
	constexpr Rect(Point tl, Point br) : tl(tl), br(br) {}

	/**
	 * @brief 面積
	 * @return 面積
	*/
	constexpr int getArea() const {
		return (br.x - tl.x) * (br.y - tl.y);
	}
	/**
	 * @brief 範囲確認
	 * @param p 希望座標
	 * @return 含有有無
	*/
	constexpr bool inside(const Point p) const {
		return tl.x < p.x&& br.x&& tl.y < p.y&& br.y;
	}

	std::string toString()const {
		return tl.toString() + "-" + br.toString();
	}

};

std::ostream& operator<<(std::ostream& os, const Rect r) {
	os << r.tl << " " << r.br;
	return os;
}

/**
 * @brief 面積からスコアを算出する
 * @param r 要求面積
 * @param rect 提供範囲
 * @return スコア
*/
inline double clacScore(const int r, const Rect rect) {

	const auto s = rect.getArea();
	const double d = 1 - (static_cast<double>(std::min(r, s)) / static_cast<double>(std::max(r, s)));
	const double p = 1 - (d * d);

	return p;
}
/**
 * @brief 面積からスコアを算出する
 * @param p 希望箇所
 * @param r 要求面積
 * @param rect 提供範囲
 * @return スコア
*/
inline double clacScore(const Point p, const int r, const Rect rect) {

	if (rect.inside(p))
	{
		return clacScore(r, rect);
	}

	return 0;
}

int main() {

	int n;

	std::cin >> n;

	std::vector<Point> input(n);
	forange(i, n)
	{
		int x, y, r;
		std::cin >> x >> y >> r;
		input[i].x = x;
		input[i].y = y;
	}

	forange(i, n)
	{
		Rect rect(input[i].x, input[i].y, input[i].x + 1, input[i].y + 1);
		std::cout << rect << std::endl;
	}

}

#include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define pii pair<int,int>
#define pll pair<lli, lli>
#define vi  vector<int>
#define vii vector<pair<int,int>>
#define vll vector<lli>
#define pb  push_back
#define mpr  make_pair
#define s  second
#define f first
#define INF 1000000001
#define inf1 1000000000000000001
#define pie 3.14159265358979323846264338327950L
#define all(x) x.begin(),x.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define testcase() int tc;cin>>tc;while(tc--)
#define clean(x) memset(x,0,sizeof(x))

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}
/// RULESSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS////
/// READ THEM ALOUD......................................................................................................
/// 1. Read the problem at least twice
/// 2. Brute force if contraints r low
/// 3. Check base cases or break case if found any T-T
/// 4. :D

lli const mod = 2e32;
lli const maxn= 2e3+7;


int main()
{
    char a,b;cin>>a>>b;
    if(a=='N')cout<<b<<endl;
    else
    {
        if(b>='A' and b<='Z'){}
        else b+=-32;
        cout<<b<<endl;
    }
}
