Go: package main

import (
        "fmt"
)

func main () {
        var str string
        fmt.Scanf("%s", &str)
        show(len(str)-1, str)
}

func show(n int, str string) {
        if n == 0 {
                fmt.Printf("%s\n", string(str[n]))
        } else {
                fmt.Printf("%s", string(str[n]))
                show(n-1, str)
        }
}

C++: #include<iostream>
#include<string>
#include<iterator>

std::string reverse_str(std::string str);

int main()
{
    std::string str;
    while(std::cin >> str)
    {
        str = reverse_str(str);
        std::cout << str << std::endl;
    }
    return 0;
}

std::string reverse_str(std::string str)
{
    std::string str_ans;
    for(unsigned long i = 1; i <= str.size(); ++i)
    {
        decltype(str)::iterator it = std::prev(end(str),i);
        str_ans += *it;
    }
    return str_ans;
}

C++: #include <string>
#include <iostream>
using namespace std;


int main()
{
	int i;	
	string str;

	cin >> str;
	
	for( i = str.length()-1;i>=0; i--) {
		cout << str[i];
	}
	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <numeric>
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <fstream>
using namespace std;

int main()
{
	string str = "";

	getline (cin, str );

	if (str.length() != 1){
		reverse (str.begin(), str.end() );
	} // end if

	cout << str << endl;	
		
	return 0;
}

C++: #include <iostream>
#include <cstring>
using namespace std;

int main(void){
	char str[20];

    cin >> str;

	int n = strlen(str);

	for (int i = 0; i < (n / 2); i++){
		int tmp = str[i];
		str[i] = str[n - 1 - i];
		str[n - 1 - i] = tmp;
	}

	cout << str << endl;

	return 0;
}

C++: #include <iostream>
#include <algorithm>
using namespace std;

int main() {
	string str; cin >> str;
	reverse(str.begin(), str.end());
	cout << str << endl;
	return 0;
}

C++: #include <iostream>
#include <string>
using namespace std;

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#define __typeof__ decltype
#endif

#define ITER(c) __typeof__((c).begin())
#define RITER(c) __typeof__((c).rbegin())
#define FOREACH(it, c) for (ITER(c) it=(c).begin(); it != (c).end(); ++it)
#define RFOREACH(it, c) for (RITER(c) it=(c).rbegin(); it != (c).rend(); ++it)

int main(){
    string s;
    while(cin >> s){
        RFOREACH(it, s){
            cout << *it;
        }
        cout << endl;
    }
    return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>

using namespace std;

int main(){
  char c[25] = {0};
  scanf("%s", c);
  for(int i = 24; i >= 0; i--)
  {
    if(c)
      cout << c[i];
  }
  cout << endl;

  return 0;
}

C++: #include <stdio.h>
#include <string.h>

int main(void){
	char c[21];
	scanf("%s", c);
	for(int i=strlen(c)-1; i>=0; --i){
		printf("%c", *(c+i));
	}
	puts("");
	return 0;
}

C++: #include<iostream>
#include<string>
using namespace std;

int main() {
	string str;
	cin >> str;
	for (int i = 0; i < str.size(); i++){
		cout << str[str.size()-i-1];
	}
	cout << "\n";
	cin >> str;
}

C++: #include<stdio.h>
#include<string.h>

int main() {
   char r[20], temp;
   int i,j=0;
   gets(r);
   i = 0;
   j = strlen(r) - 1;

   while (i < j) {
      temp= r[i];
      r[i]=r[j];
      r[j]=temp;
      i++;
      j--;
   }
   printf("%s",r);
   return (0);
}

C++: #include<iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

int main() {

	char str[20];
	int i, len;

	cin >> str;
	len = strlen(str);

	for (i = len - 1; i >= 0; i--)
		cout << str[i] << endl;

	return 0;

}

C++: #include <iostream>
#include <algorithm>
#include <string.h>

using namespace std;

int main(void) {
	char s[21];
	cin >> s;
	reverse(s, s+strlen(s));
	cout << s << endl;
	return 0;
}

C++: #include <iostream>
#include <algorithm>
using namespace std;

int main() {
	string str; cin >> str;
	reverse(str.begin(), str.end());
	cout << str << endl;
	return 0;
}

C++: #include<algorithm>
#include<iostream>
int main(void){
std::string s;
std::cin>>s;
std::reverse(s.begin(),s.end());
std::cout<<s<<std::endl;
return 0;
}

C++: #include<cstdio>
#include<cstring>
main() {
	char str[20];

	scanf("%s", str);

	for (int i=strlen(str)-1; i >= 0; i--)printf("%c", str[i]);

	printf("\n");

	return 0;
}

C++: #include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))

using namespace std;

using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;

inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }

void solve() {
  string s; cin >> s;
  string t;
  rep(i, s.size()) t += s[s.size() - 1 - i];
  cout << t << '\n';
}

C++: #include<iostream>
#include<string>
using namespace std;
int main()
{
	char a[21] = {};
	char b[21] = {};
	int alen = 0;
	cin >> a;
	alen = strlen(a);
	for (int i = 0; alen >= 0; alen--, i++) {
		b[i] = a[alen -1];
	}
	cout << b << endl;
	

	return 0;
	
}

C++: #include <iostream>
#include <string>

using namespace std;

int main() {
	string str;
	cin>>str;

	for(int i=str.size()-1; i>=0; i--){
		cout<<str[i];
	}
	cout<<endl;
	return 0;
}

C++: #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

#include <bits/stdc++.h>
using namespace std;

int main(){
  string s;
  cin>>s;
  
  reverse(ALL(s));
  
  cout<<s<<endl;
  
  return 0;
}

C++: #include<iostream>
#include<string>
using namespace std;

int main() {
	string str,a;
	cin >> str;
	a = "";
	for(int i =str.size()-1;i>=0;i--){
		a += str[i];


	}
	cout << a << endl;
	
	return 0;
}