anchor.diff:  
           ! Brute force approach to distinguishing primes
   
  -        pure function isprime (s)
  +        pure function isprime_64 (s)
   
                   integer (int64), intent(in) :: s
                   integer (int64) :: i, top
  -                logical :: isprime
  -
  -                isprime = .NOT. (s < 2 .OR. mod(s, 2) == 0);
  +                logical :: isprime_64
  +
  +                isprime_64 = .NOT. (s < 2 .OR. mod(s, 2) == 0);
   
                   top = int(sqrt(real(s)));
                   i = 3;
   
  -                do while(isprime .AND. i <= top)
  -                        isprime = (mod(s, i) /= 0);
  +                do while(isprime_64 .AND. i <= top)
  +                        isprime_64 = (mod(s, i) /= 0);
                           i = i + 2;
                   end do
   
  -                isprime = (isprime .OR. s == 2);
  -
  -                return
  -
  -        end function isprime
  +                isprime_64 = (isprime_64 .OR. s == 2);
  +
  +                return
  +
  +        end function isprime_64
  +
  +
  +        pure function isprime_32 (s)
  +
  +                integer (int32), intent(in) :: s
  +                integer (int32) :: i, top
  +                logical :: isprime_32
  +
  +                isprime_32 = .NOT. (s < 2 .OR. mod(s, 2) == 0);
  +
  +                top = int(sqrt(real(s)));
  +                i = 3;
  +
  +                do while(isprime_32 .AND. i <= top)
  +                        isprime_32 = (mod(s, i) /= 0);
  +                        i = i + 2;
  +                end do
  +
  +                isprime_32 = (isprime_32 .OR. s == 2);
  +
  +                return
  +
  +        end function isprime_32
   
   
           ! Uses Euler's method for calculating the greatest common divisor
  
positive.code:                 module procedure intlen_64, intlen_128
          end interface intlen
  
  contains
  
          ! This is here because I really miss the '+=' operator from C
          ! Operates on TWO instances of 64 bit numbers.
  
          pure subroutine inc_64(base, offset)
  
                  integer (int64), intent(out) :: base;
  
negative.code: 
          ! Immeadiate addition
          interface inc
                  module procedure inc_32, inc_64, inc_128
          end interface inc
  
          ! Immeadiate division
  