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>
       
 
       
#define PARALLEL
       
const auto numCores = 8; // 4 = four cores, 8 = eight cores, etc.
       
 
       
// ---------- code copied from my toolbox ----------

       
 
       
// find greatest common divisor

       
template <typename T>
       
T gcd(T a, T b)
       
{
       
  while (a != 0)
       
  {
       
    T c = a;
       
    a = b % a;
       
    b = c;
       
  }
       
  return b;
       
}
       
 
       
// ---------- problem-specific code ----------

       
 
       
// 90 degrees (based on code from problem 75)

       
unsigned int search90(unsigned int limit)
       
{
       
  unsigned int result = 0;
       
 
       
  unsigned int last = sqrt(limit / 2);
       
#ifdef PARALLEL
       
#pragma omp parallel for num_threads(numCores) reduction(+:result) schedule(dynamic)
       
#endif
       
  for (unsigned int m = 2; m < last; m++)
       
    for (unsigned int n = (m & 1) + 1; n < m; n += 2) // m + n must be odd
       
    {
       
      // only valid m and n
       
      if (gcd(m, n) != 1)
       
        continue;
       
 
       
      // compute basic triplet
       
      auto a = m*m - n*n;
       
      auto b = 2*m*n;
       
      auto c = m*m + n*n;
       
 
       
      // too large ?
       
      auto sum = a + b + c;
       
      if (sum > limit)
       
        break;
       
 
       
      // all its multiples are valid, too
       
      auto numMultiples = limit / sum;
       
      result += numMultiples;
       
    }
       
 
       
  return result;
       
}
       
 
       
// 60 degrees

       
unsigned int search60(unsigned int limit)
       
{
       
  unsigned int last = sqrt(limit*3/2);
       
  unsigned int result = 0;
       
#ifdef PARALLEL
       
#pragma omp parallel for num_threads(numCores) reduction(+:result) schedule(dynamic)
       
#endif
       
  for (unsigned int m = 2; m < last; m++)
       
    for (unsigned int n = 1; 2*n <= m; n++)
       
    {
       
      // only valid m and n
       
      if (gcd(m, n) != 1)
       
        continue;
       
 
       
      // compute next triplet
       
      auto a = m*m - m*n + n*n;
       
      auto b = 2*m*n - n*n;
       
      auto c = m*m - n*n;
       
 
       
      auto sum = a + b + c;
       
      // divide by their greatest common divisor to get the basic triplet
       
      // gcd(a,b,c) is either 1 or 3
       
      if (a % 3 == 0 && b % 3 == 0 && c % 3 == 0)
       
        sum /= 3;
       
      if (sum > 3*limit)
       
        break;
       
 
       
      if (sum <= limit)
       
      {
       
        // all its multiples are valid, too
       
        auto numMultiples = limit / sum;
       
        result += numMultiples;
       
      }
       
    }
       
 
       
  return result;
       
}
       
 
       
// 120 degrees

       
unsigned int search120(unsigned int limit)
       
{
       
  unsigned int result = 0;
       
 
       
  unsigned int last = sqrt(limit*3/2);
       
#ifdef PARALLEL
       
#pragma omp parallel for num_threads(numCores) reduction(+:result) schedule(dynamic)
       
#endif
       
  for (unsigned int m = 2; m < last; m++)
       
    for (unsigned int n = 1; 2*n <= m; n++)
       
    {
       
      // only valid m and n
       
      if (gcd(m, n) != 1)
       
        continue;
       
 
       
      // compute next triplet
       
      auto a = m*m + m*n + n*n;
       
      auto b = 2*m*n + n*n;
       
      auto c = m*m - n*n;
       
 
       
      // skip mirrored triangles
       
      if (b > c)
       
        break;
       
      // note: a is always the longest side
       
 
       
      auto sum = a + b + c;
       
      // divide by their greatest common divisor to get the basic triplet
       
      // gcd(a,b,c) is either 1 or 3
       
      if (a % 3 == 0 && b % 3 == 0 && c % 3 == 0)
       
        sum /= 3;
       
      if (sum > 3*limit)
       
        break;
       
 
       
      // all its multiples are valid, too
       
      auto numMultiples = limit / sum;
       
      result += numMultiples;
       
    }
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 100000000;
       
  std::cin >> limit;
       
 
       
  auto num60  = search60 (limit);
       
  auto num90  = search90 (limit);
       
  auto num120 = search120(limit);
       
 
       
  auto result = num60 + num90 + num120;
       
  std::cout << result << std::endl;
       
  return 0;
       
}

This solution contains 25 empty lines, 22 comments and 12 preprocessor commands.