stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.793171238854176x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;





int main() {

      

   long int n;

   scanf("%ld",&n);

   long int i;

   long int ans=0;;

   for(i=n;;--i)

      {

          ans=sqrt(i);

          if((ans*ans)==i)

              break;

      }

      

      printf("%ld",i);

     

	return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7280287378493506x):
#include<bits/stdc++.h>



using namespace std;



int main()

{

    long long n;

    long double ft;

    cin>>n;

    n+=1;

    while(n--){

        ft=sqrt(n);

        if(ft-floor(ft)==0){

            cout<<n;

            break;

        }

    }

    return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7728501761800741x):
#include<bits/stdc++.h>

#include<math.h>

typedef long long int lli;

using namespace std;

int main(){

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);cout.tie(NULL);

    long int n,temp;

    cin>>n;

    temp=sqrt(n);

    cout<<temp*temp;

	return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.768170395054107x):
#include <iostream>

#include<math.h>

using namespace std;



int main() {

	// your code goes here

long double n,i;

long int find;

long double f;

cin>>n;

for(i=n;i>0;i--)

{

    f=sqrt(i);

    if((floor(f)-f)==0)

    {

        find=i;

        break;

    }

}

cout<<find;



	return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7928807078351074x):
#include <iostream>

using namespace std;



int main() {

	//cout<<"GfG!";

	unsigned long long int n, i, sq, s;

	cin>>n;

	i = 1;  sq = i;

	while(sq <= n)

	{

	    s = i * i;

	    if (s > n)

	        break;

	    sq = i*i;

	    i++;

	}

	cout<<sq;

	return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7719324865118407x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

bool isPerfectSquare(long double x) 

{   

  // Find floating point value of  

  // square root of x. 

  long double sr = sqrt(x); 

  

  // If square root is an integer 

  return ((sr - floor(sr)) == 0); 

} 

int main(int argc, char const *argv[])

{    

   

    

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    ll int n;

    cin>>n;

    while(n>=1){

        if(isPerfectSquare(n)){

            cout<<n<<endl;break;

        }

        n--;

    }





    return 0;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7720700440988582x):
#include <bits/stdc++.h>

#define fast ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)

#define mod 1000000007

#define pb push_back

#define mp make_pair

#define rep(i,a,b) for(ll i=a;i<=b;i++)

#define N  1000





typedef unsigned long long ull;

typedef long long ll;

typedef long double ld;



using namespace std;



int main() {

	fast;

	ll n;

	cin>>n;

	ll k= floor(sqrt(n));

	cout<<k*k;

}
// Slower C++ solution:
/***

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 *      百年修得同船渡，千年修得代码重.

 */

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <cstring>

#include <string>

#include <stack>

using namespace std;

//int n,m,x,y;

//char a[1010][1010];

//int vis[1010][1010];

//void dfs()

//{

//

//}

//int main()

//{

//    while(~scanf("%d%d",&n,&m))

//    {

//        for(int i=0;i<n;i++)

//        scanf("%s",a[i]);

//        for(int i=0;i<n;i++)

//            for(int j=0;j<m;j++)

//        {

//            if(a[i][j]=='*')

//                vis[i][j]=2;

//                if(a[i][j]=='+')

//                    vis[i][j]=1;

//                if(a[i][j]=='F')

//                    vis[i][j]=3;

//                if(a[i][j]=='G')

//                {

//                    x=i;

//                    y=j;

//                }

//                if(i==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(i==n&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==0&&a[i][j]=='+')

//                    vis[i][j]=4;

//                if(j==m&&a[i][j]=='+')

//                    vis[i][j]=4;

//

//        }

//

//     for(int i=0;i<n;i++)

//            {

//                for(int j=0;j<m;j++)

//                printf("%d ",vis[i][j]);

//                printf("\n");

//            }

// }

//    return 0;

//}

long long a[100000];

int main()

{

    long long n;

   for(int i=1;i<=100000;i++)

   a[i]=i*i;

   while(~scanf("%lld",&n))

   {int flag=0;

       for(int i=1;i<100000;i++)

       {

           if(a[i]==n)

           {

               printf("%lld\n",a[i]);

               break;

           }

           if(a[i]>n)

           {

               printf("%lld\n",a[i-1]);

               break;

           }

       }

   }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7596823722360984x):
//#include "stdafx.h"

#include <bits/stdc++.h>

#define ll long long

#define vi vector<int>

#define e "\n"

#define MaRiaMa { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }

#define fix(n) cout << fixed << setprecision(n);

using namespace std;

int main()

{

	MaRiaMa;

	double x;

	int n;

	cin >> n;

	while(n!=0)

	{

		x = sqrt(n);

		if (x != int(sqrt(n)))

		{

			n--;

                        x=0;

		}

		else

		{

			cout << n;

			return 0;

		}

	}

}