// this is a program to generate the terms > 5 of  A154587
// it is not an example of good programming.

// this program uses primegen library by D.J.Bernstein, which
// provides a quite fast and easy to use sieve that generates
// primes up to 10^15.

// here unsigned long long int are assumed to be 64-bit integers
// the program is compiled and run on a 64-bit linux machine
// compiled with -std=c99

#include<pg.h>
#include<stdio.h>
#include<stdlib.h>

// Here I define a function to print 128-bit integers,
// since there is not such a function for gcc
// 128-bit integers are an extension provided by gcc
#define QLong __uint128_t
#define DD (10000000000000000000LLU)
char s_t[64];
char *toS(QLong x)
{
  if (x<DD) sprintf(s_t,"%llu",(LLong)x);
  else
    sprintf(s_t,"%llu%019llu",
            (LLong)(x/DD),(LLong)(x%DD));
  return s_t;
}
// these are the two sieves, one for primes one for non-primes
primegen pgcomp;
primegen pgprim;

// current composite
unsigned long long int  curCo=6;

// next prime to skip in looking for composites
unsigned long long int  curP=7;

// current sums of primes and composites
QLong sumP = 2+3+5;
QLong sumC = 1+4+6;

// this function returns the next composite
unsigned long long int  NextComp()
{
  curCo++;
  // if the number is equal to the next prime,
  // skip it and generate the next prime.
  
  if (curCo==curP)
    {
      curP = primegen_next(&pgcomp);
      curCo++;
    }
  return curCo;
}

// this is the step for printing intermediate results
#define STP 1000000000

int main()
{
  // to print intermediate results
  unsigned long long int  Lim = STP;

  // last prime generated in the prime sieve
  unsigned long long int  LastP;

  // I init the two sieves
  primegen_init(&pgprim);
  primegen_init(&pgcomp);

  // I skip the first primes
  primegen_next(&pgcomp); //2
  primegen_next(&pgcomp); //3
  primegen_next(&pgcomp); //5
  curP = primegen_next(&pgcomp); // curP = 7
  curCo = 6;

  // I skip the first primes in the other sieve as well
  primegen_next(&pgprim); //2
  primegen_next(&pgprim); //3
  LastP= primegen_next(&pgprim); //5

  while (1)
    {
      // if current composite is larger than Lim
      // I print it
      if (curCo>=Lim)
	{
	  printf(">> %llu g (%s)\n",curCo/STP,toS(sumC));
	  Lim += STP;
	  // if LastP is larger than 9.9*10^14 I exit
	  if (LastP>990000000000000LLU) return 0;
	}
      // if the two sums are equal I have a new term,
      // I print it and I save it on file.
      if (sumP==sumC) 
	{
	  FILE *f = fopen("A154587.txt","a");
	  fprintf(f,"%s\n",toS(sumP));
	  fclose(f);
	  printf("%s\n",toS(sumP));
	  // I update the two sums
	  sumP += (LastP=primegen_next(&pgprim));
	  sumC += NextComp();
	}
      // while the sum of primes is smaller than the sum
      // of non-primes I add primes
      while (sumP<sumC) sumP += (LastP=primegen_next(&pgprim));
      // while the sum of non-primes is smaller than the sum
      // of primes I add non-primes
      while (sumP>sumC) sumC += NextComp();
    }
  return 0;
}