#include <iostream>
#include <cmath>
using namespace std;


long gcd(long A, long B);


int main()
{
   int N;
   while(cin>>N)
   {
      bool* found;
      found = new bool[N+1];
      for(int i=0 ; i<=N ; i++)
	      found[i] = false;
      int not_found = N;   //discards the numbers that are part of any triple
                           //by decrementing it if we encountered any number
                           //in a triple for the first time
      int num_triples = 0;
      for(i=1 ; i<=N-2 ; i++)
	      for(int j=i+1 ; j<=N-1 ; j++)
	          if(   pow(pow((double)i, 2)+pow((double)j, 2), 0.5) == (int)pow(pow(i, 2)+pow(j, 2), 0.5)
	           && pow(pow(i, 2)+pow(j, 2), 0.5) <= N)
	          {
		  int k = pow(pow(i, 2)+pow(j, 2), 0.5);
		  //cout<<i<<" "<<j<<" "<<k<<endl;
		  if((pow(i, 2) + pow(j, 2)) == pow(k, 2))
		  { 
	                  if(!found[i])
		     { 
		         found[i] = true;
		         not_found--;
	                  }
		     if(!found[j])
		    { 
		        found[j] = true;
		        not_found--;
		    }
		    if(!found[k])
		   { 
		       found[k] = true;
		       not_found--;
		   } 
		if((gcd(i, k) == 1) && (gcd(j, k) == 1) && (gcd(i, j) == 1)) 
		     num_triples++;
	     }
       }
      cout<<num_triples<<" "<<not_found<<endl;
   }
   return 0;
}


long gcd(long A, long B)
{
   if(B > A)
       gcd(B, A);
   if(B == 0)
       return A;
   return gcd(B, A%B);
}

#include <iostream>

struct Triple{long x,y,z;};


long gcd(long a, long b)						 //Eulidean Algorithm
{
	if (a < b)
		gcd(b,a);
	if (b == 0)
		return a;
	return gcd(b,a%b);
}

int main()
{
	long N = 10000;
	long prime_triples_count = 0, triples_count = 0, p_count = 0;
	
	Triple sols[50000];

	for (long z = 1; z <= N; z++)					 
	{		
		for (long y = 1; y < z; y++)
		{			
			for (long x = 1; x < y; x++)
		 {			 
			 if (z*z == (y*y) + (x*x))			 
			 {						 		
				    sols[triples_count].x=x; 
					sols[triples_count].y=y; 
					sols[triples_count].z=z;
				 triples_count++;													 
				 if (gcd(x,y) == 1 && gcd(x,z) == 1 && gcd(y,z) == 1)
					 prime_triples_count++;										 
				}
			}
		}
	}

	for (long p = 1; p <= N; p++)		 
	{		
		long i;
		for (i = 0; i < triples_count; i++)	
	 {				 		
			if (p == sols[i].x || p == sols[i].y || p == sols[i].z)
				break;
		}		
		if (i >= triples_count)		   
		{
			p_count++;		
		}
	}
	
	std::cout<<prime_triples_count<<&quot; &quot;<<p_count<<&quot;\n&quot;;	 
			
	return 0;
}

int gcd(int a, int b) {
  int t;
  while (b != 0) {
    t = b;
    b = a % b;
    a = t;
  }
  return a;
}