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 <bitset>
       
#include <unordered_set>
       
#include <algorithm>
       
 
       
// needed to compute a unique ID for each position (bruteForce only)

       
const unsigned long long MaxValue = 100000;
       
 
       
// determine whether a single position is won (true) or lost (false)
       
// reasonably fast for small values but eats quite a good amount of memory (about 800 MByte to fully analyze a,b,c <= 500)

       
bool bruteForce(unsigned int a, unsigned int b, unsigned int c)
       
{
       
  // game over ?
       
  if (a == 0 && b == 0 && c == 0)
       
    return false;
       
 
       
  // sort them in ascending order: a <= b <= c
       
  if (a > b)
       
    std::swap(a, b);
       
  if (b > c)
       
    std::swap(b, c);
       
  if (a > b)
       
    std::swap(a, b);
       
 
       
  // memoize
       
  auto id = a * MaxValue * MaxValue + b * MaxValue + c;
       
 
       
  // two separate caches
       
  static std::unordered_set<unsigned long long> cacheWon;
       
  if (cacheWon .count(id) != 0)
       
    return true;
       
  static std::unordered_set<unsigned long long> cacheLost;
       
  if (cacheLost.count(id) != 0)
       
    return false;
       
 
       
  // try every possible move:
       
  // take a square number of stones
       
  for (unsigned int i = 1; i*i <= c; i++)
       
  {
       
    // take a square number of stones from the smallest stack
       
    if (i*i <= a && !bruteForce(a - i*i, b, c))
       
    {
       
      cacheWon.insert(id);
       
      return true;
       
    }
       
 
       
    // take a square number of stones from the stack in the middle
       
    if (i*i <= b && !bruteForce(a, b - i*i, c))
       
    {
       
      cacheWon.insert(id);
       
      return true;
       
    }
       
 
       
    // take a square number of stones from the largest stack
       
    if (!bruteForce(a, b, c - i*i))
       
    {
       
      cacheWon.insert(id);
       
      return true;
       
    }
       
  }
       
 
       
  // no winning move ... meaning that the current player loses
       
  cacheLost.insert(id);
       
  return false;
       
}
       
 
       
// count all lost positions, just under 5 seconds for limit = 100000

       
unsigned long long search(unsigned int limit)
       
{
       
  // based on this great posting: https://mathstrek.blog/2012/08/05/combinatorial-game-theory-iii/
       
 
       
  // compute Nim values for a single pile
       
  std::vector<unsigned int> mex(limit + 1, 0); // fill with zeros
       
  for (unsigned int size = 0; size <= limit; size++)
       
  {
       
    // I saw in my experiments that Nim values are pretty small for limit <= 100000 (<= 74)
       
    const size_t NimLimit = 80;
       
 
       
    // collect all Nim values after each possible move
       
    std::bitset<NimLimit> moves; // initialized with zeros
       
    for (unsigned int i = 1; i*i <= size; i++)
       
      // take i^2 stones from the heap
       
      moves[mex[size - i*i]] = true;
       
 
       
    // find the smallest non-negative number which is NOT part of the "moves" container
       
    unsigned int available = 0;
       
    while (moves[available])
       
      available++;
       
    mex[size] = available;
       
  }
       
 
       
  // the largest Nim value
       
  auto maxNimValue = *std::max_element(mex.begin(), mex.end());
       
  // find largest possible number when XORing two Nim values
       
  unsigned int nextPowerOfTwo = 1; // it's 128
       
  while (nextPowerOfTwo < maxNimValue)
       
    nextPowerOfTwo *= 2;
       
 
       
  // count how often value[b] ^ value[c] occurs where a <= b <= c <= limit
       
  std::vector<unsigned int> frequency(nextPowerOfTwo, 0);
       
 
       
  unsigned long long numLost = 0;
       
  for (int a = limit; a >= 0; a--)
       
  {
       
    // modify the "frequency" container to cover new pairs (b,c), too
       
    // it already contains all pairs (b+1,c), now a is one unit smaller so b can be one smaller, too
       
    for (auto b = a; b == a; b++) // I know that it looks silly -
       
                                  // but I want to make clear it's two nested loops
       
                                  // where the outer needs only one iteration
       
      for (auto c = b; c <= (int)limit; c++)
       
        frequency[mex[b] ^ mex[c]]++;
       
 
       
    // look at Nim value of a
       
    // how many pairs (b,c) have to same Nim value such that value[a] ^ (value[b] ^ value[c]) = 0 => lost
       
    numLost += frequency[mex[a]];
       
  }
       
 
       
  return numLost;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 100000;
       
  std::cin >> limit;
       
 
       
//#define BRUTE_FORCE

       
#ifdef  BRUTE_FORCE
       
  // if limit is 500: => 21084251 positions, 2018811 lost => 800 MByte caches in bruteForce(), finish in about two minutes
       
  // brute-force
       
  unsigned long long numLost = 0;
       
  // generate every possible position and count how many are lost
       
  for (unsigned int a = 0; a <= limit; a++)
       
    for (auto b = a; b <= limit; b++)
       
      for (auto c = b; c <= limit; c++)
       
        // lost ?
       
        if (!bruteForce(a,b,c))
       
          numLost++;
       
 
       
  std::cout << numLost << std::endl;
       
#endif
       
 
       
  std::cout << search(limit) << std::endl;
       
  return 0;
       
}

This solution contains 22 empty lines, 34 comments and 7 preprocessor commands.