CALCULATOR CONUNDRUM

//判圈法
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>
#include <map>
#include <string>
#include <climits> 
#include <set>
#include <string> 
#include <sstream>
#include <utility>
#include <ctime>
//#pragma comment(linker, "/STACK:1024000000,1024000000") 

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::getline;
using std::make_pair;
using std::greater; 

long long M;

int next(int n, int k)
{
	long long res = (long long)k*k;
	if(res >= M)
	{
		long long temp = M*10LL;
		while(res >= temp)
			temp *= 10LL;
		return res/(temp/M);
	}
	return res;
}

int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		int n, k;
		scanf("%d%d", &n, &k);
		M = 1LL;
		for(int i = 1; i <= n; ++i)
			M *= 10LL;
		int k1 = k, k2 = k;
		int ans = k;
		do
		{
			k1 = next(n, k1);
			k2 = next(n, k2);
			ans = max(ans, k2);
			k2 = next(n, k2);
			ans = max(ans, k2);
		} while(k1 != k2);
		printf("%d\n", ans);
	}
	return 0;
}








#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>
#include <map>
#include <string>
#include <climits> 
#include <set>
#include <string> 
#include <sstream>
#include <utility>
#include <ctime>
//#pragma comment(linker, "/STACK:1024000000,1024000000") 

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::getline;
using std::make_pair;
using std::greater; 

const int MAXN(5000010);

template<typename T>
struct SBT
{
	struct NODE
	{
		T key;
		int size;
		NODE *left, *right;
	};
	
	NODE *root, *NIL, *rear;
	NODE pool[MAXN];
	T tkey;

	void init()
	{
		NIL = pool;
		NIL->size = 0;
		NIL->left = NIL->right = NIL;
		root = NIL;
		rear = pool+1;
	}

	void newnode(NODE *&sour, const T &value)
	{
		rear->key = value;
		rear->size = 1;
		rear->left = rear->right = NIL;
		sour = rear++;
	}

	void left_rotate(NODE *&sour)
	{
		NODE *temp = sour->right;
		sour->right = temp->left;
		temp->left = sour;
		temp->size = sour->size;
		sour->size = sour->left->size + sour->right->size+1;
		sour = temp;
	}

	void right_rotate(NODE *&sour)
	{
		NODE *temp = sour->left;
		sour->left = temp->right;
		temp->right = sour;
		temp->size = sour->size;
		sour->size = sour->left->size+sour->right->size+1;
		sour = temp;
	}

	void maintain(NODE *&sour, bool flag)
	{
		if(flag == false)
		{
			if(sour->left->left->size > sour->right->size)
				right_rotate(sour);
			else
				if(sour->left->right->size > sour->right->size)
				{
					left_rotate(sour->left);
					right_rotate(sour);
				}
				else
					return;
		}
		else
		{
			if(sour->right->right->size > sour->left->size)
				left_rotate(sour);
			else
				if(sour->right->left->size > sour->left->size)
				{
					right_rotate(sour->right);
					left_rotate(sour);
				}
				else
					return;
		}
		maintain(sour->right, true);
		maintain(sour->left, false);
		maintain(sour, true);
		maintain(sour, false);
	}
	
	void insert(const T &value)
	{
		tkey = value;
		insert_(root);
	}

	void insert_(NODE *&sour)
	{
		if(sour == NIL)
		{
			newnode(sour, tkey);
			return;
		}
		++sour->size;
		if(tkey < sour->key)
			insert_(sour->left);
		else
			insert_(sour->right);
		maintain(sour, tkey >= sour->key);
	}

	NODE *search(const T &value)
	{
		NODE *sour = root;
		while(sour != NIL && value != sour->key)
		{
			if(value < sour->key)
				sour = sour->left;
			else
				sour = sour->right;
		}
		return sour;
	}
	
	void debug()
	{
		printf("/****************************************/\n");
		debug_(root, 0);
		printf("/****************************************/\n");
	}

	void debug_(NODE *sour, int vec)
	{
		if(sour == NIL)
			return;
		debug_(sour->left, vec+1);
		for(int i = 0; i < vec; ++i)
			printf("     ");
		printf("(%d %d) \n", sour->key, sour->size);
		debug_(sour->right, vec+1);
	}
};

int special[10] = {0, 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999};

SBT<int> sbt;
long long M;
//set<int> st;

int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		int n, k;
		sbt.init();
	//	st.clear();
		scanf("%d%d", &n, &k);
		M = 1LL;
		for(int i = 1; i <= n; ++i)
			M *= 10LL;
		int ans = k;
		long long res;
		do
		{
			sbt.insert(k);
			res = (long long)k*k;
			if(res >= M)
			{
				long long temp = M*10LL;
				while(res >= temp)
					temp *= 10LL;
				k = res/(temp/M);
			}
			else
				k = res;
			ans = max(ans, k);
		} while(ans != special[n] && sbt.search(k) == sbt.NIL);
		printf("%d\n", ans);
//		sbt.debug();
	}
	return 0;
}