anchor.diff:          ! This subroutine is borne out of convenience for the native print
           ! method is usually overkill when one wishes to print an integer
   
  -        subroutine printint(i)
  +        subroutine printint_64(i)
                   
                   integer (int64), intent(in) :: i
                   write (*, '(I0)') i;
   
  -        end subroutine printint
  -
  +        end subroutine printint_64
  +
  +        subroutine printint_32(i)
  +                
  +                integer (int32), intent(in) :: i
  +                write (*, '(I0)') i;
  +
  +        end subroutine printint_32
   
           ! Reverses a 64-bit integer
   
  
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: 
          ! Brute force approach to distinguishing primes
  
          pure function isprime_64 (s)
  
                  integer (int64), intent(in) :: s
                  integer (int64) :: i, top
                  logical :: isprime_64
  
                  isprime_64 = .NOT. (s < 2 .OR. mod(s, 2) == 0);
  
                  top = int(sqrt(real(s)));
                  i = 3;
  
                  do while(isprime_64 .AND. i <= top)
                          isprime_64 = (mod(s, i) /= 0);
                          i = i + 2;
                  end do
  
                  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
  