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>
       
 
       
const auto Modulo = 10000000000000000ULL;
       
 
       
// odd prime numbers are marked as "true" in a bitvector

       
std::vector<bool> sieve;
       
 
       
// return true, if x is a prime number

       
bool isPrime(unsigned int x)
       
{
       
  // handle even numbers
       
  if ((x & 1) == 0)
       
    return x == 2;
       
 
       
  // lookup for odd numbers
       
  return sieve[x >> 1];
       
}
       
 
       
// find all prime numbers from 2 to size

       
void fillSieve(unsigned int size)
       
{
       
  // store only odd numbers
       
  const unsigned int half = size >> 1;
       
 
       
  // allocate memory
       
  sieve.resize(half, true);
       
  // 1 is not a prime number
       
  sieve[0] = false;
       
 
       
  // process all relevant prime factors
       
  for (unsigned int i = 1; 2*i*i < half; i++)
       
    // do we have a prime factor ?
       
    if (sieve[i])
       
    {
       
      // mark all its multiples as false
       
      unsigned int current = 3*i+1;
       
      while (current < half)
       
      {
       
        sieve[current] = false;
       
        current += 2*i+1;
       
      }
       
    }
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 5000;
       
  std::cin >> limit;
       
 
       
  // sum of all prime numbers below 5000
       
  fillSieve(limit);
       
  unsigned int maxSum = 2;
       
  for (unsigned int i = 3; i <= limit; i += 2)
       
    if (isPrime(i))
       
      maxSum += i;
       
 
       
  // one empty set, its sum is zero
       
  std::vector<unsigned long long> count(maxSum + 1, 0);
       
  unsigned int largest = 0;
       
  count[largest] = 1;
       
 
       
  // add each prime to each set
       
  for (unsigned int i = 2; i < limit; i++)
       
    if (isPrime(i))
       
    {
       
      largest += i;
       
      // look at all potential sums of sets
       
      for (auto j = largest; j >= i; j--)
       
      {
       
        count[j] += count[j - i];
       
        count[j] %= Modulo;
       
      }
       
    }
       
 
       
  // enlarge prime sieve
       
  fillSieve(maxSum); // maxSum is about 1600000
       
  // sum of all count where index is a prime number
       
  unsigned long long result = 0;
       
  for (unsigned int i = 0; i < count.size(); i++)
       
    if (isPrime(i))
       
    {
       
      result += count[i];
       
      result %= Modulo;
       
    }
       
 
       
  // show result
       
  std::cout << result << std::endl;
       
  return 0;
       
}

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