anchor.diff:     LOGICAL,   OPTIONAL,    INTENT(IN   )    :: bDOF(nDOF)                         ! Optinal Mask for DOF to keep (True), or reduce (False)
      
      ! LOCALS         
  -   REAL(FEKi), ALLOCATABLE                   :: K_FEKi(:,:), M_FEKi(:,:) 
  -   REAL(FEKi), ALLOCATABLE                   :: EigVect_FEKi(:,:), Omega2_FEKi(:) 
  +   REAL(LaKi), ALLOCATABLE                   :: K_LaKi(:,:), M_LaKi(:,:) 
  +   REAL(LaKi), ALLOCATABLE                   :: EigVect_LaKi(:,:), Omega_LaKi(:) 
      INTEGER(IntKi)                            :: N
      INTEGER(IntKi)                            :: ErrStat2
      CHARACTER(ErrMsgLen)                      :: ErrMsg2
      ErrStat = ErrID_None
      ErrMsg  = ''
  +   EigVect=0.0_FeKi
  +   Omega=0.0_FeKi
   
      ! --- Unfortunate conversion to FEKi... TODO TODO consider storing M and K in FEKi
      if (present(bDOF)) then
         ! Remove unwanted DOFs
  -      call RemoveDOF(M, bDOF, M_FEKi, ErrStat2, ErrMsg2); if(Failed()) return
  -      call RemoveDOF(K, bDOF, K_FEKi, ErrStat2, ErrMsg2); if(Failed()) return
  +      call RemoveDOF(M, bDOF, M_LaKi, ErrStat2, ErrMsg2); if(Failed()) return
  +      call RemoveDOF(K, bDOF, K_LaKi, ErrStat2, ErrMsg2); if(Failed()) return
      else
         N=size(K,1)
  -      CALL AllocAry(K_FEKi      , N, N, 'K_FEKi',    ErrStat2, ErrMsg2); if(Failed()) return
  -      CALL AllocAry(M_FEKi      , N, N, 'M_FEKi',    ErrStat2, ErrMsg2); if(Failed()) return
  -      K_FEKi = real( K, FEKi )
  -      M_FEKi = real( M, FEKi )
  +      CALL AllocAry(K_LaKi      , N, N, 'K_FEKi',    ErrStat2, ErrMsg2); if(Failed()) return
  +      CALL AllocAry(M_LaKi      , N, N, 'M_FEKi',    ErrStat2, ErrMsg2); if(Failed()) return
  +      K_LaKi = real( K, LaKi )
  +      M_LaKi = real( M, LaKi )
      endif
  -   N=size(K_FEKi,1)
  +   N=size(K_LaKi,1)
   
      ! Note:  NOmega must be <= N, which is the length of Omega2, Phi!
      if ( NOmega > nDOF ) then
  
positive.code:    if(Failed()) return
  
     ! --- Determinign and sorting eigen frequencies 
     Omega2(:) =0.0_FEKi
     DO I=1,N !Initialize the key and calculate Omega
        KEY(I)=I
        Omega2(I) = AlphaR(I)/Beta(I)
  
negative.code: END SUBROUTINE EigenSolve
  
  pure subroutine sort_in_place(a,key)
     real(LaKi), intent(inout), dimension(:) :: a
     integer(IntKi), intent(inout), dimension(:) :: key
     integer(IntKi) :: tempI
     real(LaKi) :: temp
     integer(IntKi) :: i, j
     do i = 2, size(a)
        j = i - 1
  