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>
       
 
       
// all Fibonacci numbers below 10^17

       
std::vector<unsigned long long> fibonacci;
       
// and the sum according to my algorithm description

       
std::vector<unsigned long long> fiboSum; // fibonacci.size() == fiboSum.size()
       
 
       
// see en.wikipedia.org/wiki/Zeckendorf's_theorem
       
// return the length of the Zeckendorf representation of x

       
unsigned int zeckendorf(unsigned long long x)
       
{
       
  unsigned int result = 0;
       
 
       
  // greedy search:
       
  // in each step subtract the largest possible Fibonacci number
       
  unsigned int pos = fibonacci.size() - 1;
       
  while (x > 0)
       
  {
       
    while (fibonacci[pos] > x)
       
      pos--;
       
 
       
    x -= fibonacci[pos];
       
    result++;
       
  }
       
 
       
  return result;
       
}
       
 
       
// compute sum of the length of all Zeckendorf representations from 1 to x

       
unsigned long long search(unsigned long long x)
       
{
       
  // find largest Fibonacci number <= x
       
  auto pos = 0;
       
  while (fibonacci[pos + 1] <= x)
       
    pos++;
       
 
       
  // strip off that Fibonacci number
       
  auto reduced = x - fibonacci[pos];
       
 
       
  // done ?
       
  if (reduced == 0)
       
    return fiboSum[pos];
       
 
       
  // still more 1s in the binary Zeckendorf representation left ...
       
  return fiboSum[pos] + reduced + search(reduced);
       
}
       
 
       
int main()
       
{
       
  unsigned long long limit = 100000000000000000ULL;
       
  std::cin >> limit;
       
 
       
  // note: it took me a while to figure out that because of F(1) = F(2) = 1
       
  //       I am not allowed to represent 3 as F(1) + F(3) (which is 3 = 1 + 2)
       
  //       even though F(1) and F(3) are not consecutive
       
  //       if I remove F(1) (or F(2)) then that ambiguity disappears and everything's fine
       
 
       
  // start with Fibonacci numbers F(2) and F(3)
       
  fibonacci = { 1, 2 };
       
 
       
  // F(2) has length 1, F(3) as length 1 as well plus 1 from F(2)
       
  fiboSum   = { 1, 1+1 };
       
 
       
  // find all Fibonacci number below 10^17
       
  while (fibonacci.back() < limit)
       
  {
       
    auto size = fibonacci.size();
       
    auto nextFibo = fibonacci[size - 1] + fibonacci[size - 2];
       
    fibonacci.push_back(nextFibo);
       
 
       
    // "special" sum of Fibonacci numbers
       
    auto nextSum  = fiboSum  [size - 1] + fiboSum  [size - 2] + fibonacci[size - 2] - 1;
       
    fiboSum.push_back(nextSum);
       
  }
       
 
       
  // NOT including 10^17
       
  limit--;
       
  // display result
       
  std::cout << search(limit) << std::endl;
       
 
       
  // my old test code for the first 100 numbers
       
  //auto sum = 0;
       
  //for (auto i = 1; i < 100; i++)
       
  //{
       
  //  auto current = zeckendorf(i);
       
  //  sum += current;
       
  //  std::cout << i << "=" << current << " " << sum << " / " << search(i) << std::endl;
       
  //}
       
 
       
  return 0;
       
}

This solution contains 18 empty lines, 29 comments and 2 preprocessor commands.