My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <cmath>
       
 
       
// return number of pairs (x,y) such that equation (16) is not zero mod 42

       
unsigned int countNotMod42()
       
{
       
  unsigned int result = 0;
       
 
       
  const auto Multiplier = 1; // no more than 5 because then long long overflows
       
  for (long long x = 0; x < 42 * Multiplier; x++)
       
    for (long long y = 0; y < 42 * Multiplier; y++)
       
    {
       
      auto zero = ((x*x - y*y)*(x*x - y*y) - 2*x*y*2*x*y) * (x*x - y*y) * x * y;
       
      if (zero % 42 != 0)
       
        result++;
       
    }
       
  return result;
       
}
       
 
       
// greatest common divisor

       
template <typename T>
       
T gcd(T x, T y)
       
{
       
  while (x != 0)
       
  {
       
    auto temp = x;
       
    x = y % x;
       
    y = temp;
       
  }
       
  return y;
       
}
       
 
       
int main()
       
{
       
  // count how many possible pairs (x,y) could generate (a,b,c) according to equation (16)
       
  std::cout << countNotMod42() << std::endl;
       
  return 0;
       
 
       
//#define SEARCH

       
#ifdef  SEARCH
       
  // ---------- try to find a non super-perfect triangle up to 10^8 ---------
       
  // note: code currently not reached because the program exited three lines ago
       
  unsigned long long limit = 100000000;
       
  std::cin >> limit;
       
 
       
  unsigned long long countNotSuperPerfect = 0;
       
 
       
  // find basic Pythagorean triples (code copied from problem 86)
       
  for (unsigned long long m = 1; m <= sqrt(2*limit); m++)
       
    for (unsigned long long n = 1; n < m; n++)
       
    {
       
      if (m % 2 == n % 2)
       
        continue;
       
      if (gcd(m, n) != 1)
       
        continue;
       
 
       
      // two sides
       
      auto a = m*m - n*n;
       
      auto b = 2*m*n;
       
      auto c = m*m + n*n;
       
      if (c > limit)
       
        break;
       
 
       
      // is c a perfect square ?
       
      unsigned long long cRoot = sqrt(c);
       
      if (cRoot * cRoot != c)
       
        continue;
       
 
       
      // is area a multiple of 6 and 28 ?
       
      auto area = a * b / 2;
       
      if (area % 6 != 0 || area % 28 != 0) // can be combined: area % lcm(6, 28) = area % 84
       
      {
       
        countNotSuperPerfect++;
       
        continue;
       
      }
       
    }
       
 
       
  // show result
       
  std::cout << countNotSuperPerfect << std::endl;
       
  return 0;
       
#endif
       
}

This solution contains 11 empty lines, 11 comments and 4 preprocessor commands.