UPP/upp-srw-v2.2.0/CMakeFortranCompilerId_8F_source.html

      PROGRAM cmakefortrancompilerid

#if 0

! Identify the compiler

#endif

#if defined(_MSC_VER)

       print *, 'INFO:simulate[MSVC]'

# if _MSC_VER >= 1900

       print *, 'INFO:simulate_version[019.00]'

# elif _MSC_VER >= 1800

       print *, 'INFO:simulate_version[018.00]'

# elif _MSC_VER >= 1700

       print *, 'INFO:simulate_version[017.00]'

# elif _MSC_VER >= 1600

       print *, 'INFO:simulate_version[016.00]'

# elif _MSC_VER >= 1500

       print *, 'INFO:simulate_version[015.00]'

# elif _MSC_VER >= 1400

       print *, 'INFO:simulate_version[014.00]'

# elif _MSC_VER >= 1310

       print *, 'INFO:simulate_version[013.01]'

# else

       print *, 'INFO:simulate_version[013.00]'

# endif

#endif

#if defined(__INTEL_LLVM_COMPILER)

        print *, 'INFO:compiler[IntelLLVM]'

! __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and

! later.  Look for 6 digit vs. 8 digit version number to decide encoding.

! VVVV is no smaller than the current year when a version is released.

# if __INTEL_LLVM_COMPILER < 1000000

#  define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)

#  define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)

#  define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)

# else

#  define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)

#  define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)

#  define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)

# endif

#elif defined(__INTEL_COMPILER) && __INTEL_COMPILER == 201900

        print *, 'INFO:compiler[IntelLLVM]'

! ifx 2021.1 forgot to define __INTEL_LLVM_COMPILER.

! Instead it defines __INTEL_COMPILER == 201900.

# define COMPILER_VERSION_MAJOR DEC(2021)

# define COMPILER_VERSION_MINOR DEC(1)

# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)

# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)

#elif defined(__INTEL_COMPILER) || defined(__ICC)

        print *, 'INFO:compiler[Intel]'

! __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later.

# if __INTEL_COMPILER < 2021

#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)

#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)

#  if defined(__INTEL_COMPILER_UPDATE)

#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)

#  else

#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)

#  endif

# else

#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)

#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)

!  The third version component from --version is an update index,

!  but no macro is provided for it.

#  define COMPILER_VERSION_PATCH DEC(0)

# endif

# if defined(__INTEL_COMPILER_BUILD_DATE)

#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)

# endif

#elif defined(__SUNPRO_F95)

        print *, 'INFO:compiler[SunPro]'

# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F95>>8)

# define COMPILER_VERSION_MINOR HEX(__SUNPRO_F95>>4 & 0xF)

# define COMPILER_VERSION_PATCH HEX(__SUNPRO_F95    & 0xF)

#elif defined(__SUNPRO_F90)

        print *, 'INFO:compiler[SunPro]'

# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F90>>8)

# define COMPILER_VERSION_MINOR HEX(__SUNPRO_F90>>4 & 0xF)

# define COMPILER_VERSION_PATCH HEX(__SUNPRO_F90    & 0xF)

#elif defined(_CRAYFTN)

        print *, 'INFO:compiler[Cray]'

# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)

# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)

# if defined(_RELEASE_PATCHLEVEL)

#  define COMPILER_VERSION_PATCH DEC(_RELEASE_PATCHLEVEL)

# endif

#elif defined(__G95__)

        print *, 'INFO:compiler[G95]'

# define COMPILER_VERSION_MAJOR DEC(__G95__)

# define COMPILER_VERSION_MINOR DEC(__G95_MINOR__)

#elif defined(__PATHSCALE__)

        print *, 'INFO:compiler[PathScale]'

# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)

# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)

# if defined(__PATHCC_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)

# endif

#elif defined(__ABSOFT__)

        print *, 'INFO:compiler[Absoft]'

#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))

        print *, 'INFO:compiler[LCC]'

# define COMPILER_VERSION_MAJOR DEC(1)

# define COMPILER_VERSION_MINOR DEC(__LCC__ - 100)

# if defined(__LCC_MINOR__)

#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)

# endif

#elif defined(__GNUC__)

        print *, 'INFO:compiler[GNU]'

# define COMPILER_VERSION_MAJOR DEC(__GNUC__)

# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)

# if defined(__GNUC_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)

# endif

#elif defined(__IBMC__)

# if defined(__COMPILER_VER__)

        print *, 'INFO:compiler[zOS]'

# elif __IBMC__ >= 800

        print *, 'INFO:compiler[XL]'

#  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)

#  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)

#  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)

# else

        print *, 'INFO:compiler[VisualAge]'

#  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)

#  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)

#  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)

# endif

#elif defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__)

        print *, 'INFO:compiler[NVHPC]'

# if defined(__NVCOMPILER_MAJOR__)

#  define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)

# else

#  define COMPILER_VERSION_MAJOR DEC(__PGIC__)

# endif

# if defined(__NVCOMPILER_MINOR__)

#  define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)

# else

#  define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)

# endif

# if defined(__NVCOMPILER_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)

# elif defined(__PGIC_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)

# endif

#elif defined(__PGI)

        print *, 'INFO:compiler[PGI]'

# define COMPILER_VERSION_MAJOR DEC(__PGIC__)

# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)

# if defined(__PGIC_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)

# endif

#elif defined(__FLANG)

        print *, 'INFO:compiler[Flang]'

# define COMPILER_VERSION_MAJOR DEC(__FLANG_MAJOR__)

# define COMPILER_VERSION_MINOR DEC(__FLANG_MINOR__)

# if defined(__FLANG_PATCHLEVEL__)

#  define COMPILER_VERSION_PATCH DEC(__FLANG_PATCHLEVEL__)

# endif

#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)

        print *, 'INFO:compiler[VisualAge]'

#elif defined(__hpux) || defined(__hpux__)

        print *, 'INFO:compiler[HP]'

#elif defined(NAGFOR)

        print *, 'INFO:compiler[NAG]'

#define COMPILER_VERSION_MAJOR DEC(__NAG_COMPILER_RELEASE/10)

#define COMPILER_VERSION_MINOR DEC(__NAG_COMPILER_RELEASE % 10)

#define COMPILER_VERSION_PATCH DEC(__NAG_COMPILER_BUILD)

#elif defined(__FUJITSU)

        print *, 'INFO:compiler[Fujitsu]'

# if defined(__FRT_major__)

#   define COMPILER_VERSION_MAJOR DEC(__FRT_major__)

#   define COMPILER_VERSION_MINOR DEC(__FRT_minor__)

#   define COMPILER_VERSION_PATCH DEC(__FRT_patchlevel__)

# elif defined(__FRT_version__)

        print *, 'INFO:compiler_version['//__frt_version__//']'

# endif

#else

        print *, 'INFO:compiler[]'

#endif

#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)

        print *, 'INFO:compiler_wrapper[CrayPrgEnv]'

#endif


#if 0

! Identify the platform

#endif

#if defined(__linux) || defined(__linux__) || defined(linux)

        print *, 'INFO:platform[Linux]'

#elif defined(__CYGWIN__)

        print *, 'INFO:platform[Cygwin]'

#elif defined(__MINGW32__)

        print *, 'INFO:platform[MinGW]'

#elif defined(__APPLE__)

        print *, 'INFO:platform[Darwin]'

#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)

        print *, 'INFO:platform[Windows]'

#elif defined(__FreeBSD__) || defined(__FreeBSD)

        print *, 'INFO:platform[FreeBSD]'

#elif defined(__NetBSD__) || defined(__NetBSD)

        print *, 'INFO:platform[NetBSD]'

#elif defined(__OpenBSD__) || defined(__OPENBSD)

        print *, 'INFO:platform[OpenBSD]'

#elif defined(__sun) || defined(sun)

        print *, 'INFO:platform[SunOS]'

#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)

        print *, 'INFO:platform[AIX]'

#elif defined(__hpux) || defined(__hpux__)

        print *, 'INFO:platform[HP-UX]'

#elif defined(__HAIKU__)

        print *, 'INFO:platform[Haiku]'

#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)

        print *, 'INFO:platform[BeOS]'

#elif defined(__QNX__) || defined(__QNXNTO__)

        print *, 'INFO:platform[QNX]'

#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)

        print *, 'INFO:platform[Tru64]'

#elif defined(__riscos) || defined(__riscos__)

        print *, 'INFO:platform[RISCos]'

#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)

        print *, 'INFO:platform[SINIX]'

#elif defined(__UNIX_SV__)

        print *, 'INFO:platform[UNIX_SV]'

#elif defined(__bsdos__)

        print *, 'INFO:platform[BSDOS]'

#elif defined(_MPRAS) || defined(MPRAS)

        print *, 'INFO:platform[MP-RAS]'

#elif defined(__osf) || defined(__osf__)

        print *, 'INFO:platform[OSF1]'

#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)

        print *, 'INFO:platform[SCO_SV]'

#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)

        print *, 'INFO:platform[ULTRIX]'

#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)

        print *, 'INFO:platform[Xenix]'

#else

        print *, 'INFO:platform[]'

#endif

#if defined(_WIN32) && (defined(__INTEL_COMPILER) || defined(__ICC))

# if defined(_M_IA64)

        print *, 'INFO:arch[IA64]'

# elif defined(_M_X64) || defined(_M_AMD64)

        print *, 'INFO:arch[x64]'

# elif defined(_M_IX86)

        print *, 'INFO:arch[X86]'

# endif

#endif


#if 0

! Encode compiler version digits

#endif

#define DEC_8(n) (((n) / 10000000) % 10)

#define DEC_7(n) (((n) / 1000000)  % 10)

#define DEC_6(n) (((n) / 100000)   % 10)

#define DEC_5(n) (((n) / 10000)    % 10)

#define DEC_4(n) (((n) / 1000)     % 10)

#define DEC_3(n) (((n) / 100)      % 10)

#define DEC_2(n) (((n) / 10)       % 10)

#define DEC_1(n) (((n)    )        % 10)

#define HEX_8(n) ((n)>>28 & 0xF)

#define HEX_7(n) ((n)>>24 & 0xF)

#define HEX_6(n) ((n)>>20 & 0xF)

#define HEX_5(n) ((n)>>16 & 0xF)

#define HEX_4(n) ((n)>>12 & 0xF)

#define HEX_3(n) ((n)>>8  & 0xF)

#define HEX_2(n) ((n)>>4  & 0xF)

#define HEX_1(n) ((n)     & 0xF)


#if defined(COMPILER_VERSION_MAJOR)

# undef DEC

# undef HEX

# define DEC(n) DEC_1(n)

# define HEX(n) HEX_1(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_1[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_1[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_1[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_1[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_1[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_1[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_1[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_1[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_1[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_1[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_2(n)

# define HEX(n) HEX_2(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_2[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_2[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_2[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_2[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_2[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_2[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_2[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_2[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_2[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_2[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_3(n)

# define HEX(n) HEX_3(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_3[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_3[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_3[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_3[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_3[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_3[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_3[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_3[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_3[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_3[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_4(n)

# define HEX(n) HEX_4(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_4[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_4[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_4[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_4[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_4[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_4[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_4[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_4[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_4[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_4[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_5(n)

# define HEX(n) HEX_5(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_5[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_5[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_5[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_5[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_5[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_5[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_5[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_5[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_5[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_5[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_6(n)

# define HEX(n) HEX_6(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_6[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_6[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_6[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_6[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_6[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_6[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_6[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_6[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_6[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_6[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_7(n)

# define HEX(n) HEX_7(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_7[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_7[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_7[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_7[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_7[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_7[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_7[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_7[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_7[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_7[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_8(n)

# define HEX(n) HEX_8(n)

# if COMPILER_VERSION_MAJOR == 0

        print *, 'INFO:compiler_version_MAJOR_digit_8[0]'

# elif COMPILER_VERSION_MAJOR == 1

        print *, 'INFO:compiler_version_MAJOR_digit_8[1]'

# elif COMPILER_VERSION_MAJOR == 2

        print *, 'INFO:compiler_version_MAJOR_digit_8[2]'

# elif COMPILER_VERSION_MAJOR == 3

        print *, 'INFO:compiler_version_MAJOR_digit_8[3]'

# elif COMPILER_VERSION_MAJOR == 4

        print *, 'INFO:compiler_version_MAJOR_digit_8[4]'

# elif COMPILER_VERSION_MAJOR == 5

        print *, 'INFO:compiler_version_MAJOR_digit_8[5]'

# elif COMPILER_VERSION_MAJOR == 6

        print *, 'INFO:compiler_version_MAJOR_digit_8[6]'

# elif COMPILER_VERSION_MAJOR == 7

        print *, 'INFO:compiler_version_MAJOR_digit_8[7]'

# elif COMPILER_VERSION_MAJOR == 8

        print *, 'INFO:compiler_version_MAJOR_digit_8[8]'

# elif COMPILER_VERSION_MAJOR == 9

        print *, 'INFO:compiler_version_MAJOR_digit_8[9]'

# endif


#endif

#if defined(COMPILER_VERSION_MINOR)

# undef DEC

# undef HEX

# define DEC(n) DEC_1(n)

# define HEX(n) HEX_1(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_1[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_1[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_1[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_1[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_1[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_1[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_1[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_1[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_1[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_1[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_2(n)

# define HEX(n) HEX_2(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_2[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_2[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_2[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_2[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_2[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_2[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_2[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_2[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_2[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_2[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_3(n)

# define HEX(n) HEX_3(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_3[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_3[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_3[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_3[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_3[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_3[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_3[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_3[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_3[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_3[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_4(n)

# define HEX(n) HEX_4(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_4[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_4[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_4[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_4[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_4[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_4[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_4[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_4[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_4[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_4[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_5(n)

# define HEX(n) HEX_5(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_5[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_5[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_5[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_5[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_5[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_5[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_5[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_5[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_5[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_5[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_6(n)

# define HEX(n) HEX_6(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_6[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_6[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_6[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_6[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_6[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_6[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_6[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_6[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_6[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_6[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_7(n)

# define HEX(n) HEX_7(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_7[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_7[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_7[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_7[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_7[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_7[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_7[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_7[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_7[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_7[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_8(n)

# define HEX(n) HEX_8(n)

# if COMPILER_VERSION_MINOR == 0

        print *, 'INFO:compiler_version_MINOR_digit_8[0]'

# elif COMPILER_VERSION_MINOR == 1

        print *, 'INFO:compiler_version_MINOR_digit_8[1]'

# elif COMPILER_VERSION_MINOR == 2

        print *, 'INFO:compiler_version_MINOR_digit_8[2]'

# elif COMPILER_VERSION_MINOR == 3

        print *, 'INFO:compiler_version_MINOR_digit_8[3]'

# elif COMPILER_VERSION_MINOR == 4

        print *, 'INFO:compiler_version_MINOR_digit_8[4]'

# elif COMPILER_VERSION_MINOR == 5

        print *, 'INFO:compiler_version_MINOR_digit_8[5]'

# elif COMPILER_VERSION_MINOR == 6

        print *, 'INFO:compiler_version_MINOR_digit_8[6]'

# elif COMPILER_VERSION_MINOR == 7

        print *, 'INFO:compiler_version_MINOR_digit_8[7]'

# elif COMPILER_VERSION_MINOR == 8

        print *, 'INFO:compiler_version_MINOR_digit_8[8]'

# elif COMPILER_VERSION_MINOR == 9

        print *, 'INFO:compiler_version_MINOR_digit_8[9]'

# endif


#endif

#if defined(COMPILER_VERSION_PATCH)

# undef DEC

# undef HEX

# define DEC(n) DEC_1(n)

# define HEX(n) HEX_1(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_1[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_1[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_1[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_1[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_1[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_1[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_1[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_1[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_1[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_1[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_2(n)

# define HEX(n) HEX_2(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_2[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_2[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_2[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_2[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_2[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_2[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_2[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_2[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_2[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_2[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_3(n)

# define HEX(n) HEX_3(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_3[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_3[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_3[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_3[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_3[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_3[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_3[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_3[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_3[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_3[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_4(n)

# define HEX(n) HEX_4(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_4[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_4[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_4[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_4[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_4[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_4[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_4[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_4[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_4[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_4[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_5(n)

# define HEX(n) HEX_5(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_5[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_5[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_5[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_5[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_5[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_5[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_5[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_5[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_5[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_5[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_6(n)

# define HEX(n) HEX_6(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_6[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_6[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_6[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_6[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_6[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_6[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_6[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_6[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_6[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_6[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_7(n)

# define HEX(n) HEX_7(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_7[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_7[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_7[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_7[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_7[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_7[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_7[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_7[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_7[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_7[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_8(n)

# define HEX(n) HEX_8(n)

# if COMPILER_VERSION_PATCH == 0

        print *, 'INFO:compiler_version_PATCH_digit_8[0]'

# elif COMPILER_VERSION_PATCH == 1

        print *, 'INFO:compiler_version_PATCH_digit_8[1]'

# elif COMPILER_VERSION_PATCH == 2

        print *, 'INFO:compiler_version_PATCH_digit_8[2]'

# elif COMPILER_VERSION_PATCH == 3

        print *, 'INFO:compiler_version_PATCH_digit_8[3]'

# elif COMPILER_VERSION_PATCH == 4

        print *, 'INFO:compiler_version_PATCH_digit_8[4]'

# elif COMPILER_VERSION_PATCH == 5

        print *, 'INFO:compiler_version_PATCH_digit_8[5]'

# elif COMPILER_VERSION_PATCH == 6

        print *, 'INFO:compiler_version_PATCH_digit_8[6]'

# elif COMPILER_VERSION_PATCH == 7

        print *, 'INFO:compiler_version_PATCH_digit_8[7]'

# elif COMPILER_VERSION_PATCH == 8

        print *, 'INFO:compiler_version_PATCH_digit_8[8]'

# elif COMPILER_VERSION_PATCH == 9

        print *, 'INFO:compiler_version_PATCH_digit_8[9]'

# endif


#endif

#if defined(COMPILER_VERSION_TWEAK)

# undef DEC

# undef HEX

# define DEC(n) DEC_1(n)

# define HEX(n) HEX_1(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_1[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_1[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_1[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_1[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_1[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_1[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_1[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_1[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_1[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_1[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_2(n)

# define HEX(n) HEX_2(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_2[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_2[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_2[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_2[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_2[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_2[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_2[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_2[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_2[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_2[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_3(n)

# define HEX(n) HEX_3(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_3[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_3[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_3[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_3[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_3[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_3[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_3[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_3[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_3[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_3[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_4(n)

# define HEX(n) HEX_4(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_4[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_4[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_4[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_4[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_4[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_4[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_4[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_4[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_4[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_4[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_5(n)

# define HEX(n) HEX_5(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_5[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_5[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_5[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_5[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_5[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_5[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_5[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_5[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_5[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_5[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_6(n)

# define HEX(n) HEX_6(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_6[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_6[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_6[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_6[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_6[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_6[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_6[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_6[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_6[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_6[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_7(n)

# define HEX(n) HEX_7(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_7[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_7[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_7[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_7[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_7[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_7[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_7[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_7[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_7[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_7[9]'

# endif


# undef DEC

# undef HEX

# define DEC(n) DEC_8(n)

# define HEX(n) HEX_8(n)

# if COMPILER_VERSION_TWEAK == 0

        print *, 'INFO:compiler_version_TWEAK_digit_8[0]'

# elif COMPILER_VERSION_TWEAK == 1

        print *, 'INFO:compiler_version_TWEAK_digit_8[1]'

# elif COMPILER_VERSION_TWEAK == 2

        print *, 'INFO:compiler_version_TWEAK_digit_8[2]'

# elif COMPILER_VERSION_TWEAK == 3

        print *, 'INFO:compiler_version_TWEAK_digit_8[3]'

# elif COMPILER_VERSION_TWEAK == 4

        print *, 'INFO:compiler_version_TWEAK_digit_8[4]'

# elif COMPILER_VERSION_TWEAK == 5

        print *, 'INFO:compiler_version_TWEAK_digit_8[5]'

# elif COMPILER_VERSION_TWEAK == 6

        print *, 'INFO:compiler_version_TWEAK_digit_8[6]'

# elif COMPILER_VERSION_TWEAK == 7

        print *, 'INFO:compiler_version_TWEAK_digit_8[7]'

# elif COMPILER_VERSION_TWEAK == 8

        print *, 'INFO:compiler_version_TWEAK_digit_8[8]'

# elif COMPILER_VERSION_TWEAK == 9

        print *, 'INFO:compiler_version_TWEAK_digit_8[9]'

# endif


#endif


      END