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>
       
 
       
unsigned int maxPileSize = 1000;
       
 
       
// compute linear index from two offsets

       
unsigned int id(unsigned int a, unsigned int b)
       
{
       
  return a * (maxPileSize + 1) + b;
       
}
       
 
       
int main()
       
{
       
  std::cin >> maxPileSize;
       
 
       
  // the current position is only lost if every possible move leads to a position
       
  // where the opponent wins
       
  // that means: no matter how many stones I pick from one, two or three piles,
       
  //             the follow-up state must not be lost
       
 
       
  const bool Won  = false;
       
  const bool Lost = true;
       
 
       
  // assume each position is potentially won - unless proven otherwise
       
  std::vector<bool> one((maxPileSize + 1) * (maxPileSize + 1), Won);
       
  std::vector<bool> two((maxPileSize + 1) * (maxPileSize + 1), Won);
       
  std::vector<bool> all((maxPileSize + 1) * (maxPileSize + 1), Won);
       
 
       
  // count x+y+z for each lost position
       
  unsigned int count = 0;
       
 
       
  for (unsigned int x = 0; x <= maxPileSize; x++)
       
    for (unsigned int y = x; y <= maxPileSize; y++)
       
    {
       
      // copy this condition from the inner loop (and keep there for the sake of completeness, though it's redundant)
       
      if (one[id(x,y)] == Lost)
       
        continue;
       
 
       
      for (unsigned int z = y; z <= maxPileSize; z++)
       
      {
       
        // can current player win by clearing one pile ?
       
        // check if (0,y,z) or (x,0,z) or (x,y,0) wins
       
        // take x stones from first  pile: check (x-x,  y,   z ) = (0, y, z)
       
        // take y stones from second pile: check ( x,  y-y,  z ) = (x, 0, z)
       
        // take z stones from third  pile: check ( x,   y,  z-z) = (x, y, 0)
       
        if (one[id(y,z)] == Lost ||
       
            one[id(x,z)] == Lost ||
       
            one[id(x,y)] == Lost)
       
          continue; // opponent can be forced into a lost position
       
 
       
        // can current player win by clearing one pile
       
        // and removing the same number of stones from a second pile ?
       
        // take x stones from first and second pile: check (x-x, y-x,  z ) = (0, y-x,  z )
       
        // take y stones from first and second pile: check ( x,  y-y, z-y) = (x,  0,  z-y)
       
        // take x stones from first and third  pile: check (x-x,  y,  z-x) = (0,  y,  z-x)
       
        // (note that x <= y <= z, therefore can't take z stones)
       
        if (two[id(y-x, z)] == Lost ||
       
            two[id(z-y, x)] == Lost ||
       
            two[id(z-x, y)] == Lost)
       
          continue; // opponent can be forced into a lost position
       
 
       
        // can current player win by clearing the first pile
       
        // and removing the same number of stones from the second and third pile ?
       
        // note that x <= y <= z
       
        // take x stones from all piles: check (x-x, y-x, z-x) = (0, y-x, z-x)
       
        if (all[id(y-x, z-x)] == Lost)
       
          continue; // opponent can be forced into a lost position
       
 
       
        // current player lost, opponents wins all follow-up positions
       
        count += x + y + z;
       
 
       
        // mark all reachable positions as lost
       
        // (same indices and arrays as used in the if-conditions above)
       
        one[id(y, z)] = Lost;
       
        one[id(x, z)] = Lost;
       
        one[id(x, y)] = Lost;
       
 
       
        two[id(y-x, z)] = Lost;
       
        two[id(z-y, x)] = Lost;
       
        two[id(z-x, y)] = Lost;
       
 
       
        all[id(y-x, z-x)] = Lost;
       
      }
       
    }
       
 
       
  // and done !
       
  std::cout << count << std::endl;
       
  return 0;
       
}

This solution contains 16 empty lines, 27 comments and 2 preprocessor commands.