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 <cmath>
       
 
       
// ---------- standard prime sieve from my toolbox ----------

       
 
       
// 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 long long limit = 999966663333ULL;
       
  std::cin >> limit;
       
  fillSieve(sqrt(limit) + 100); // a few more primes than strictly necessary ...
       
 
       
  // sum of all matches
       
  unsigned long long sum = 0;
       
 
       
  // 2 is the smallest prime
       
  unsigned long long last = 2;
       
  // until lps(last^2) exceeds the limit
       
  while (last*last <= limit)
       
  {
       
    // find next prime
       
    auto next = last + 1;
       
    while (!isPrime(next))
       
      next++;
       
 
       
    // note: for each square of a prime lps(p^2) = ups(p^2) = p
       
    //       => p^2 is obviously divisible by both and hence can't be semidivisible
       
 
       
    // all loops run from "from" and "to" but skip both (because not semidivisible)
       
    auto from = last * last;
       
    auto to   = next * next;
       
 
       
    // the following loops could be replaced by clever arithmetic
       
    // but they are super-fast and most of the time is spent sieving primes anyway
       
 
       
    // divisible by lps(i)
       
    for (auto i = from + last; i < to && i <= limit; i += last)
       
      sum += i;
       
 
       
    // don't exceed the limit
       
    while (to - next > limit)
       
      to -= next;
       
    // divisible by ups(i)
       
    for (auto i = to - next; i > from; i -= next)
       
      sum += i;
       
 
       
    // but not those divisible by both
       
    for (auto i = from - from % (last * next); i < to && i <= limit; i += last * next)
       
    {
       
      if (i <= from)
       
        continue;
       
      if (i > limit)
       
        break;
       
 
       
      // counted twice, remove both
       
      sum -= i + i;
       
    }
       
 
       
    // next pair of primes
       
    last = next;
       
  }
       
 
       
  // display result
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 19 empty lines, 28 comments and 3 preprocessor commands.