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 <vector>
       
#include <algorithm>
       
 
       
// store a and b for n = a^2 + b^2 where a<b

       
typedef std::pair<long long, long long> SumSquares;
       
// initial dummy element

       
const SumSquares Seed({ 1, 0 });
       
 
       
// unique representations of primes p = 4n+1

       
std::vector<SumSquares> primes;
       
 
       
// enumerate all representations and return sum of the smaller part

       
unsigned int bruteForce(unsigned int n)
       
{
       
  unsigned int result = 0;
       
  for (unsigned int b = 1; b*b < n; b++)
       
    for (unsigned int a = 1; a < b; a++)
       
      if (a*a + b*b == n)
       
        result += a;
       
  return result;
       
}
       
 
       
// return true, if p = 4n+1 and p is prime

       
bool is4n1Prime(unsigned int p)
       
{
       
  // https://en.wikipedia.org/wiki/Fermat%27s_theorem_on_sums_of_two_squares
       
  // must be 4n+1
       
  if (p % 4 != 1)
       
    return false;
       
  // and prime
       
  for (auto i = 3; i*i <= p; i += 2)
       
    if (p % i == 0)
       
      return false;
       
  // all tests passed (reject p = 1)
       
  return p > 1;
       
}
       
 
       
// there is a unique sum a^2 + b^2 for each prime p = 4n+1

       
SumSquares processPrime(unsigned int prime)
       
{
       
  // same idea as bruteForce() but stop after the first solution was found
       
  for (unsigned int b = 1; b*b < prime; b++)
       
    for (unsigned int a = 1; a < b; a++)
       
      if (a*a + b*b == prime)
       
        return { a, b };
       
  return { 0, 0 }; // never reached
       
}
       
 
       
// abs isn't available for long long (only smaller int)

       
template <typename T>
       
T abs(T a)
       
{
       
  // actually C++11's std::abs should be able to handle long long values but my compiler fails ... strange !
       
  return a > 0 ? +a : -a;
       
}
       
 
       
// solve problem: combine each solution of at most index-1 prime with the prime at primes[index]
       
// return the sum of the smaller primes when finished

       
unsigned long long search(const std::vector<SumSquares>& solutions = { Seed }, size_t index = 0)
       
{
       
  // done ?
       
  if (index == primes.size())
       
  {
       
    unsigned long long sum = 0;
       
    // add the smaller squares
       
    for (auto s : solutions)
       
      if (s != Seed)
       
        sum += s.first;
       
 
       
    // finally ...
       
    return sum;
       
  }
       
 
       
  // combine all previous solutions with the current prime
       
  auto current = primes[index];
       
 
       
  std::vector<SumSquares> next;
       
  next.reserve(solutions.size() * 2);
       
  for (auto s : solutions)
       
  {
       
    // https://en.wikipedia.org/wiki/Brahmagupta%E2%80%93Fibonacci_identity
       
    // (ac + bd)^2 + (ad - bc)^2
       
    auto x =     s.first * current.first  + s.second * current.second;
       
    auto y = abs(s.first * current.second - s.second * current.first);
       
    // ensure that the first number is smaller than the second
       
    if (x > y)
       
      std::swap(x, y);
       
    // found a new representation
       
    next.push_back({ x, y });
       
 
       
    // if s is the See then (x,y) is identical in both equations
       
    if (s == Seed)
       
      continue;
       
 
       
    // now the same procedure but with swapped signs in the computation of x and y
       
    // (ac - bd)^2 + (ad + bc)^2
       
    x = abs(s.first * current.first  - s.second * current.second);
       
    y =     s.first * current.second + s.second * current.first;
       
    // ensure that the first number is smaller than the second
       
    if (x > y)
       
      std::swap(x, y);
       
    // found a new representation
       
    next.push_back({ x, y });
       
  }
       
 
       
  // without the current prime
       
  auto without = search(solutions, index + 1);
       
  // with    the current prime
       
  auto with    = search(next,      index + 1);
       
  return with + without;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 150;
       
  std::cin >> limit;
       
 
       
  // analyze a single number
       
  //std::cout << bruteForce(65) << std::endl;
       
 
       
  // find all relevant primes
       
  for (unsigned int i = 5; i <= limit; i += 4)
       
    if (is4n1Prime(i))
       
      primes.push_back(processPrime(i));
       
 
       
  // and here we go !
       
  std::cout << search() << std::endl;
       
  return 0;
       
}

This solution contains 17 empty lines, 34 comments and 3 preprocessor commands.