Language: C++

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <forward_list>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#if __has_include(<optional>)
#include <optional>
#elif __has_include(<experimental/optional>)
#include <experimental/optional>
#endif
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#if __has_include(<variant>)
#include <variant>
#elif __has_include(<experimental/variant>)
#include <experimental/variant>
#endif
#include <vector>
// using namespace std;
constexpr int64_t MOD = 1000000007;

template <class T>
class read;

template <class T, size_t n>
class read<std::array<T, n>>
{
public:
	using ret_type = std::array<T, n>;
	ret_type operator()() const
	{
		ret_type v;
		for (size_t i = 0; i < n; i++) v[i] = read<T>()();
		return v;
	}
};

template <class T>
constexpr std::size_t _tuple_size_v = std::tuple_size<T>::value;
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) _apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
{
	return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}
template <class F, class Tuple>
constexpr decltype(auto) _apply(F&& f, Tuple&& t)
{
	return _apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
	                   std::make_index_sequence<_tuple_size_v<std::remove_reference_t<Tuple>>>{});
}

template <class... Ts>
class read<std::tuple<Ts...>>
{
public:
	using ret_type = std::tuple<Ts...>;
	ret_type operator()() const
	{
		ret_type v;
		::_apply([](auto&... args) { (void)std::initializer_list<int>{(void(f(args)), 0)...}; }, v);
		return v;
	}

private:
	template <class T>
	static int f(T& arg)
	{
		arg = read<T>()();
		return 0;
	}
};

template <class T1, class T2>
class read<std::pair<T1, T2>>
{
public:
	using ret_type = std::pair<T1, T2>;
	ret_type operator()() const { return ret_type{read<T1>()(), read<T2>()()}; }
};

template <class T, class Allocator>
class read<std::vector<T, Allocator>>
{
public:
	using ret_type = std::vector<T, Allocator>;
	ret_type operator()(size_t len) const
	{
		ret_type v;
		for (size_t i = 0; i < len; i++) v.push_back(read<T>()());
		return v;
	}
};

template <class T>
class read
{
public:
	using ret_type = T;
	ret_type operator()() const
	{
		ret_type v;
		std::cin >> v;
		return v;
	}
};

template <class T, size_t n>
std::ostream& operator<<(std::ostream& os, const std::array<T, n>& v)
{
	auto f = false;
	os << "array(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

template <class T>
static int my_cout_impl(const T& arg, std::ostream& os, bool& f)
{
	if (f) os << ", ";
	os << arg;
	f = true;
	return 0;
}

template <class... Ts>
std::ostream& operator<<(std::ostream& os, const std::tuple<Ts...>& v)
{
	auto f = false;
	os << "tuple(";
	::_apply([&os, &f](const auto&... args) { (void)std::initializer_list<int>{(void(my_cout_impl(args, os, f)), 0)...}; }, v);
	return os << ")";
}

template <class T1, class T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& v)
{
	return os << "pair(" << v.first << ", " << v.second << ")";
}

template <class T, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::vector<T, Allocator>& v)
{
	auto f = false;
	os << "vector(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

template <class Key, class T, class Compare, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::map<Key, T, Compare, Allocator>& v)
{
	auto f = false;
	os << "map(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p.first << ": " << p.second;
		f = true;
	}
	return os << ")";
}

template <class Key, class T, class Compare, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::multimap<Key, T, Compare, Allocator>& v)
{
	auto f = false;
	os << "multimap(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p.first << ": " << p.second;
		f = true;
	}
	return os << ")";
}

template <class Key, class Compare, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::set<Key, Compare, Allocator>& v)
{
	auto f = false;
	os << "set(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p;
		f = true;
	}
	return os << ")";
}

template <class Key, class Compare, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::multiset<Key, Compare, Allocator>& v)
{
	auto f = false;
	os << "multiset(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p;
		f = true;
	}
	return os << ")";
}

template <class Key, class T, class Hash, class Pred, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::unordered_map<Key, T, Hash, Pred, Allocator>& v)
{
	auto f = false;
	os << "unordered_map(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p.first << ": " << p.second;
		f = true;
	}
	return os << ")";
}

template <class Key, class T, class Hash, class Pred, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::unordered_multimap<Key, T, Hash, Pred, Allocator>& v)
{
	auto f = false;
	os << "unordered_multimap(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p.first << ": " << p.second;
		f = true;
	}
	return os << ")";
}

template <class Key, class Hash, class Pred, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::unordered_set<Key, Hash, Pred, Allocator>& v)
{
	auto f = false;
	os << "unordered_set(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p;
		f = true;
	}
	return os << ")";
}

template <class Key, class Hash, class Pred, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::unordered_multiset<Key, Hash, Pred, Allocator>& v)
{
	auto f = false;
	os << "unordered_multiset(";
	for (auto& p : v)
	{
		if (f) os << ", ";
		os << p;
		f = true;
	}
	return os << ")";
}

template <class T, class Container>
std::ostream& operator<<(std::ostream& os, const std::queue<T, Container>& v)
{
	std::queue<T, Container> v2 = v;
	auto f = false;
	os << "queue(";
	while (!v2.empty())
	{
		os << (f ? ", " : "front: ") << v2.front();
		v2.pop();
		f = true;
	}
	return os << ")";
}

template <class T, class Container>
std::ostream& operator<<(std::ostream& os, const std::stack<T, Container>& v)
{
	std::stack<T, Container> v2 = v;
	auto f = false;
	os << "stack(";
	while (!v2.empty())
	{
		os << (f ? ", " : "top: ") << v2.top();
		v2.pop();
		f = true;
	}
	return os << ")";
}

template <class T, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::deque<T, Allocator>& v)
{
	auto f = false;
	os << "deque(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

template <class T, class Container, class Compare>
std::ostream& operator<<(std::ostream& os, const std::priority_queue<T, Container, Compare>& v)
{
	std::priority_queue<T, Container, Compare> v2 = v;
	auto f = false;
	os << "priority_queue(";
	while (!v2.empty())
	{
		os << (f ? ", " : "top: ") << v2.top();
		v2.pop();
		f = true;
	}
	return os << ")";
}

template <class T, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::list<T, Allocator>& v)
{
	auto f = false;
	os << "list(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

template <class T>
std::ostream& operator<<(std::ostream& os, const std::initializer_list<T>& v)
{
	auto f = false;
	os << "initializer_list(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

template <class T, class Allocator>
std::ostream& operator<<(std::ostream& os, const std::forward_list<T, Allocator>& v)
{
	auto f = false;
	os << "forward_list(";
	for (auto& e : v)
	{
		if (f) os << ", ";
		os << e;
		f = true;
	}
	return os << ")";
}

std::map<int, int> compress(const std::vector<int>& v)
{
	std::map<int, int> m;
	for (auto x : v) m[x] = 0;
	int n = 0;
	for (auto& t : m) t.second = n++;
	return m;
}

// [b, ..., e] must be a shuffle of [0, 1, ..., len - 1] (len = e - b)
template <class RanIt>
std::vector<std::vector<typename std::iterator_traits<RanIt>::value_type>> to_cycles(RanIt b, RanIt e)
{
	using T = std::iterator_traits<RanIt>::value_type;
	std::vector<std::vector<T>> cycs;
	T len = e - b;
	std::vector<bool> done(len, false);
	for (T i = 0; i < len; ++i)
	{
		if (done[i]) continue;
		std::vector<T> cyc;
		cyc.push_back(i);
		auto j = b[i];
		while (j != i)
		{
			cyc.push_back(j);
			done[j] = true;
			j = b[j];
		}
		cycs.push_back(std::move(cyc));
	}
	return cycs;
}

template <class T>
auto to_cycles(const T& v)
{
	return to_cycles(std::begin(v), std::end(v));
}

int main()
{
	std::cin.tie(nullptr);
	std::ios::sync_with_stdio(false);
	auto r = read<int>()();
	std::cout << r * r << std::endl;
	std::cout << std::flush;
	return 0;
}


Compiler output:
a.cc: In function 'std::vector<std::vector<typename std::iterator_traits< <template-parameter-1-1> >::value_type> > to_cycles(RanIt, RanIt)':
a.cc:413:19: error: need 'typename' before 'std::iterator_traits<_Iter>::value_type' because 'std::iterator_traits<_Iter>' is a dependent scope
  413 |         using T = std::iterator_traits<RanIt>::value_type;
      |                   ^~~
      |                   typename 
a.cc:414:33: error: 'T' was not declared in this scope
  414 |         std::vector<std::vector<T>> cycs;
      |                                 ^
a.cc:414:33: error: template argument 1 is invalid
a.cc:414:33: error: template argument 2 is invalid
a.cc:414:34: error: template argument 1 is invalid
  414 |         std::vector<std::vector<T>> cycs;
      |                                  ^~
a.cc:414:34: error: template argument 2 is invalid
a.cc:415:10: error: expected ';' before 'len'
  415 |         T len = e - b;
      |          ^~~~
      |          ;
a.cc:416:32: error: 'len' was not declared in this scope
  416 |         std::vector<bool> done(len, false);
      |                                ^~~
a.cc:417:15: error: expected ';' before 'i'
  417 |         for (T i = 0; i < len; ++i)
      |               ^~
      |               ;
a.cc:417:23: error: 'i' was not declared in this scope
  417 |         for (T i = 0; i < len; ++i)
      |                       ^
a.cc:420:30: error: template argument 2 is invalid
  420 |                 std::vector<T> cyc;
      |                              ^
a.cc:421:21: error: request for member 'push_back' in 'cyc', which is of non-class type 'int'
  421 |                 cyc.push_back(i);
      |                     ^~~~~~~~~
a.cc:425:29: error: request for member 'push_back' in 'cyc', which is of non-class type 'int'
  425 |                         cyc.push_back(j);
      |                             ^~~~~~~~~
a.cc:429:22: error: request for member 'push_back' in 'cycs', which is of non-class type 'int'
  429 |                 cycs.push_back(std::move(cyc));
      |                      ^~~~~~~~~