/* intrin.def -- Public #include File (module.h template V1.0)
   The Free Software Foundation has released this file into the
   public domain.

   Owning Modules:
      intrin.c

   Modifications:
*/

/* Intrinsic names listed in alphabetical order, sorted by uppercase name.
   This list is keyed to the names of intrinsics as seen in source code.  */

DEFNAME	("ABORT",	"abort",	"Abort",	genNONE,	specABORT)	/* UNIX */
DEFNAME	("ABS",		"abs",		"Abs",		genNONE,	specABS)
DEFNAME	("ACCESS",	"access",	"Access",	genNONE,	specACCESS)	/* UNIX */
DEFNAME	("ACHAR",	"achar",	"AChar",	genNONE,	specACHAR)	/* F90,	F2C */
DEFNAME	("ACOS",	"acos",		"ACos",		genNONE,	specACOS)
DEFNAME	("ACOSD",	"acosd",	"ACosD",	genNONE,	specACOSD)	/* VXT */
DEFNAME	("ADJUSTL",	"adjustl",	"AdjustL",	genNONE,	specADJUSTL)	/* F90 */
DEFNAME	("ADJUSTR",	"adjustr",	"AdjustR",	genNONE,	specADJUSTR)	/* F90 */
DEFNAME	("AIMAG",	"aimag",	"AImag",	genNONE,	specAIMAG)
DEFNAME	("AIMAX0",	"aimax0",	"AIMax0",	genNONE,	specAIMAX0)	/* VXT */
DEFNAME	("AIMIN0",	"aimin0",	"AIMin0",	genNONE,	specAIMIN0)	/* VXT */
DEFNAME	("AINT",	"aint",		"AInt",		genNONE,	specAINT)
DEFNAME	("AJMAX0",	"ajmax0",	"AJMax0",	genNONE,	specAJMAX0)	/* VXT */
DEFNAME	("AJMIN0",	"ajmin0",	"AJMin0",	genNONE,	specAJMIN0)	/* VXT */
DEFNAME	("ALARM",	"alarm",	"Alarm",	genNONE,	specALARM)	/* UNIX */
DEFNAME	("ALL",		"all",		"All",		genNONE,	specALL)	/* F90 */
DEFNAME	("ALLOCATED",	"allocated",	"Allocated",	genNONE,	specALLOCATED)	/* F90 */
DEFNAME	("ALOG",	"alog",		"ALog",		genNONE,	specALOG)
DEFNAME	("ALOG10",	"alog10",	"ALog10",	genNONE,	specALOG10)
DEFNAME	("AMAX0",	"amax0",	"AMax0",	genNONE,	specAMAX0)
DEFNAME	("AMAX1",	"amax1",	"AMax1",	genNONE,	specAMAX1)
DEFNAME	("AMIN0",	"amin0",	"AMin0",	genNONE,	specAMIN0)
DEFNAME	("AMIN1",	"amin1",	"AMin1",	genNONE,	specAMIN1)
DEFNAME	("AMOD",	"amod",		"AMod",		genNONE,	specAMOD)
DEFNAME	("AND",		"and",		"And",		genNONE,	specAND)	/* F2C */
DEFNAME	("ANINT",	"anint",	"ANInt",	genNONE,	specANINT)
DEFNAME	("ANY",		"any",		"Any",		genNONE,	specANY)	/* F90 */
DEFNAME	("ASIN",	"asin",		"ASin",		genNONE,	specASIN)
DEFNAME	("ASIND",	"asind",	"ASinD",	genNONE,	specASIND)	/* VXT */
DEFNAME	("ASSOCIATED",	"associated",	"Associated",	genNONE,	specASSOCIATED)	/* F90 */
DEFNAME	("ATAN",	"atan",		"ATan",		genNONE,	specATAN)
DEFNAME	("ATAN2",	"atan2",	"ATan2",	genNONE,	specATAN2)
DEFNAME	("ATAN2D",	"atan2d",	"ATan2D",	genNONE,	specATAN2D)	/* VXT */
DEFNAME	("ATAND",	"atand",	"ATanD",	genNONE,	specATAND)	/* VXT */
DEFNAME	("BESJ0",	"besj0",	"BesJ0",	genNONE,	specBESJ0)	/* UNIX */
DEFNAME	("BESJ1",	"besj1",	"BesJ1",	genNONE,	specBESJ1)	/* UNIX */
DEFNAME	("BESJN",	"besjn",	"BesJN",	genNONE,	specBESJN)	/* UNIX */
DEFNAME	("BESY0",	"besy0",	"BesY0",	genNONE,	specBESY0)	/* UNIX */
DEFNAME	("BESY1",	"besy1",	"BesY1",	genNONE,	specBESY1)	/* UNIX */
DEFNAME	("BESYN",	"besyn",	"BesYN",	genNONE,	specBESYN)	/* UNIX */
DEFNAME	("BITEST",	"bitest",	"BITest",	genNONE,	specBITEST)	/* VXT */
DEFNAME	("BIT_SIZE",	"bit_size",	"Bit_Size",	genNONE,	specBIT_SIZE)	/* F90 */
DEFNAME	("BJTEST",	"bjtest",	"BJTest",	genNONE,	specBJTEST)	/* VXT */
DEFNAME	("BTEST",	"btest",	"BTest",	genNONE,	specBTEST)	/* F90,	VXT */
DEFNAME	("CABS",	"cabs",		"CAbs",		genNONE,	specCABS)
DEFNAME	("CCOS",	"ccos",		"CCos",		genNONE,	specCCOS)
DEFNAME	("CDABS",	"cdabs",	"CDAbs",	genNONE,	specCDABS)	/* VXT */
DEFNAME	("CDCOS",	"cdcos",	"CDCos",	genNONE,	specCDCOS)	/* VXT */
DEFNAME	("CDEXP",	"cdexp",	"CDExp",	genNONE,	specCDEXP)	/* VXT */
DEFNAME	("CDLOG",	"cdlog",	"CDLog",	genNONE,	specCDLOG)	/* VXT */
DEFNAME	("CDSIN",	"cdsin",	"CDSin",	genNONE,	specCDSIN)	/* VXT */
DEFNAME	("CDSQRT",	"cdsqrt",	"CDSqRt",	genNONE,	specCDSQRT)	/* VXT */
DEFNAME	("CEILING",	"ceiling",	"Ceiling",	genNONE,	specCEILING)	/* F90 */
DEFNAME	("CEXP",	"cexp",		"CExp",		genNONE,	specCEXP)
DEFNAME	("CHAR",	"char",		"Char",		genNONE,	specCHAR)
DEFNAME	("CHDIR",	"chdir",	"ChDir",	genCHDIR,	specNONE)	/* UNIX */
DEFNAME	("CHMOD",	"chmod",	"ChMod",	genCHMOD,	specNONE)	/* UNIX */
DEFNAME	("CLOG",	"clog",		"CLog",		genNONE,	specCLOG)
DEFNAME	("CMPLX",	"cmplx",	"Cmplx",	genNONE,	specCMPLX)
DEFNAME	("COMPLEX",	"complex",	"Complex",	genNONE,	specCOMPLEX)
DEFNAME	("CONJG",	"conjg",	"Conjg",	genNONE,	specCONJG)
DEFNAME	("COS",		"cos",		"Cos",		genNONE,	specCOS)
DEFNAME	("COSD",	"cosd",		"CosD",		genNONE,	specCOSD)	/* VXT */
DEFNAME	("COSH",	"cosh",		"CosH",		genNONE,	specCOSH)
DEFNAME	("COUNT",	"count",	"Count",	genNONE,	specCOUNT)	/* F90 */
DEFNAME	("CPU_TIME",	"cpu_time",	"CPU_Time",	genNONE,	specCPU_TIME)	/* F95 */
DEFNAME	("CSHIFT",	"cshift",	"CShift",	genNONE,	specCSHIFT)	/* F90 */
DEFNAME	("CSIN",	"csin",		"CSin",		genNONE,	specCSIN)
DEFNAME	("CSQRT",	"csqrt",	"CSqRt",	genNONE,	specCSQRT)
DEFNAME	("CTIME",	"ctime",	"CTime",	genCTIME,	specNONE)	/* UNIX */
DEFNAME	("DABS",	"dabs",		"DAbs",		genNONE,	specDABS)
DEFNAME	("DACOS",	"dacos",	"DACos",	genNONE,	specDACOS)
DEFNAME	("DACOSD",	"dacosd",	"DACosD",	genNONE,	specDACOSD)	/* VXT */
DEFNAME	("DASIN",	"dasin",	"DASin",	genNONE,	specDASIN)
DEFNAME	("DASIND",	"dasind",	"DASinD",	genNONE,	specDASIND)	/* VXT */
DEFNAME	("DATAN",	"datan",	"DATan",	genNONE,	specDATAN)
DEFNAME	("DATAN2",	"datan2",	"DATan2",	genNONE,	specDATAN2)
DEFNAME	("DATAN2D",	"datan2d",	"DATan2D",	genNONE,	specDATAN2D)	/* VXT */
DEFNAME	("DATAND",	"datand",	"DATanD",	genNONE,	specDATAND)	/* VXT */
DEFNAME	("DATE",	"date",		"Date",		genNONE,	specDATE)	/* VXT */
DEFNAME	("DATE_AND_TIME",	"date_and_time",	"Date_and_Time",	genNONE,	specDATE_AND_TIME)	/* F90 */
DEFNAME	("DBESJ0",	"dbesj0",	"DbesJ0",	genNONE,	specDBESJ0)	/* UNIX */
DEFNAME	("DBESJ1",	"dbesj1",	"DbesJ1",	genNONE,	specDBESJ1)	/* UNIX */
DEFNAME	("DBESJN",	"dbesjn",	"DbesJN",	genNONE,	specDBESJN)	/* UNIX */
DEFNAME	("DBESY0",	"dbesy0",	"DbesY0",	genNONE,	specDBESY0)	/* UNIX */
DEFNAME	("DBESY1",	"dbesy1",	"DbesY1",	genNONE,	specDBESY1)	/* UNIX */
DEFNAME	("DBESYN",	"dbesyn",	"DbesYN",	genNONE,	specDBESYN)	/* UNIX */
DEFNAME	("DBLE",	"dble",		"Dble",		genNONE,	specDBLE)
DEFNAME	("DBLEQ",	"dbleq",	"DbleQ",	genNONE,	specDBLEQ)	/* VXT */
DEFNAME	("DCMPLX",	"dcmplx",	"DCmplx",	genNONE,	specDCMPLX)	/* F2C,	VXT */
DEFNAME	("DCONJG",	"dconjg",	"DConjg",	genNONE,	specDCONJG)	/* F2C,	VXT */
DEFNAME	("DCOS",	"dcos",		"DCos",		genNONE,	specDCOS)
DEFNAME	("DCOSD",	"dcosd",	"DCosD",	genNONE,	specDCOSD)	/* VXT */
DEFNAME	("DCOSH",	"dcosh",	"DCosH",	genNONE,	specDCOSH)
DEFNAME	("DDIM",	"ddim",		"DDiM",		genNONE,	specDDIM)
DEFNAME	("DERF",	"derf",		"DErF",		genNONE,	specDERF)	/* UNIX */
DEFNAME	("DERFC",	"derfc",	"DErFC",	genNONE,	specDERFC)	/* UNIX */
DEFNAME	("DEXP",	"dexp",		"DExp",		genNONE,	specDEXP)
DEFNAME	("DFLOAT",	"dfloat",	"DFloat",	genNONE,	specDFLOAT)	/* F2C,	VXT */
DEFNAME	("DFLOTI",	"dfloti",	"DFlotI",	genNONE,	specDFLOTI)	/* VXT */
DEFNAME	("DFLOTJ",	"dflotj",	"DFlotJ",	genNONE,	specDFLOTJ)	/* VXT */
DEFNAME	("DIGITS",	"digits",	"Digits",	genNONE,	specDIGITS)	/* F90 */
DEFNAME	("DIM",		"dim",		"DiM",		genNONE,	specDIM)
DEFNAME	("DIMAG",	"dimag",	"DImag",	genNONE,	specDIMAG)	/* F2C, VXT */
DEFNAME	("DINT",	"dint",		"DInt",		genNONE,	specDINT)
DEFNAME	("DLOG",	"dlog",		"DLog",		genNONE,	specDLOG)
DEFNAME	("DLOG10",	"dlog10",	"DLog10",	genNONE,	specDLOG10)
DEFNAME	("DMAX1",	"dmax1",	"DMax1",	genNONE,	specDMAX1)
DEFNAME	("DMIN1",	"dmin1",	"DMin1",	genNONE,	specDMIN1)
DEFNAME	("DMOD",	"dmod",		"DMod",		genNONE,	specDMOD)
DEFNAME	("DNINT",	"dnint",	"DNInt",	genNONE,	specDNINT)
DEFNAME	("DOT_PRODUCT",	"dot_product",	"Dot_Product",	genNONE,	specDOT_PRODUCT)	/* F90 */
DEFNAME	("DPROD",	"dprod",	"DProd",	genNONE,	specDPROD)
DEFNAME	("DREAL",	"dreal",	"DReal",	genNONE,	specDREAL)	/* VXT */
DEFNAME	("DSIGN",	"dsign",	"DSign",	genNONE,	specDSIGN)
DEFNAME	("DSIN",	"dsin",		"DSin",		genNONE,	specDSIN)
DEFNAME	("DSIND",	"dsind",	"DSinD",	genNONE,	specDSIND)	/* VXT */
DEFNAME	("DSINH",	"dsinh",	"DSinH",	genNONE,	specDSINH)
DEFNAME	("DSQRT",	"dsqrt",	"DSqRt",	genNONE,	specDSQRT)
DEFNAME	("DTAN",	"dtan",		"DTan",		genNONE,	specDTAN)
DEFNAME	("DTAND",	"dtand",	"DTanD",	genNONE,	specDTAND)	/* VXT */
DEFNAME	("DTANH",	"dtanh",	"DTanH",	genNONE,	specDTANH)
DEFNAME	("DTIME",	"dtime",	"DTime",	genDTIME,	specNONE)	/* UNIX */
DEFNAME	("EOSHIFT",	"eoshift",	"EOShift",	genNONE,	specEOSHIFT)	/* F90 */
DEFNAME	("EPSILON",	"epsilon",	"Epsilon",	genNONE,	specEPSILON)	/* F90 */
DEFNAME	("ERF",		"erf",		"ErF",		genNONE,	specERF)	/* UNIX */
DEFNAME	("ERFC",	"erfc",		"ErFC",		genNONE,	specERFC)	/* UNIX */
DEFNAME	("ETIME",	"etime",	"ETime",	genETIME,	specNONE)	/* UNIX */
DEFNAME	("EXIT",	"exit",		"Exit",		genNONE,	specEXIT)	/* UNIX */
DEFNAME	("EXP",		"exp",		"Exp",		genNONE,	specEXP)
DEFNAME	("EXPONENT",	"exponent",	"Exponent",	genNONE,	specEXPONENT)	/* F90 */
DEFNAME	("FDATE",	"fdate",	"FDate",	genFDATE,	specNONE)	/* UNIX */
DEFNAME	("FGET",	"fget",		"FGet",		genFGET,	specNONE)	/* UNIX */
DEFNAME	("FGETC",	"fgetc",	"FGetC",	genFGETC,	specNONE)	/* UNIX */
DEFNAME	("FLOAT",	"float",	"Float",	genNONE,	specFLOAT)
DEFNAME	("FLOATI",	"floati",	"FloatI",	genNONE,	specFLOATI)	/* VXT */
DEFNAME	("FLOATJ",	"floatj",	"FloatJ",	genNONE,	specFLOATJ)	/* VXT */
DEFNAME	("FLOOR",	"floor",	"Floor",	genNONE,	specFLOOR)	/* F90 */
DEFNAME	("FLUSH",	"flush",	"Flush",	genNONE,	specFLUSH)	/* UNIX */
DEFNAME	("FNUM",	"fnum",		"FNum",		genNONE,	specFNUM)	/* UNIX */
DEFNAME	("FPABSP",	"fpabsp",	"FPAbsP",	genFPABSP,	specNONE)	/* F2C */
DEFNAME	("FPEXPN",	"fpexpn",	"FPExpn",	genFPEXPN,	specNONE)	/* F2C */
DEFNAME	("FPFRAC",	"fpfrac",	"FPFrac",	genFPFRAC,	specNONE)	/* F2C */
DEFNAME	("FPMAKE",	"fpmake",	"FPMake",	genFPMAKE,	specNONE)	/* F2C */
DEFNAME	("FPRRSP",	"fprrsp",	"FPRRSp",	genFPRRSP,	specNONE)	/* F2C */
DEFNAME	("FPSCAL",	"fpscal",	"FPScal",	genFPSCAL,	specNONE)	/* F2C */
DEFNAME	("FPUT",	"fput",		"FPut",		genFPUT,	specNONE)	/* UNIX */
DEFNAME	("FPUTC",	"fputc",	"FPutC",	genFPUTC,	specNONE)	/* UNIX */
DEFNAME	("FRACTION",	"fraction",	"Fraction",	genNONE,	specFRACTION)	/* F90 */
DEFNAME	("FSEEK",	"fseek",	"FSeek",	genNONE,	specFSEEK)	/* UNIX */
DEFNAME	("FSTAT",	"fstat",	"FStat",	genFSTAT,	specNONE)	/* UNIX */
DEFNAME	("FTELL",	"ftell",	"FTell",	genFTELL,	specNONE)	/* UNIX */
DEFNAME	("GERROR",	"gerror",	"GError",	genNONE,	specGERROR)	/* UNIX */
DEFNAME	("GETARG",	"getarg",	"GetArg",	genNONE,	specGETARG)	/* UNIX */
DEFNAME	("GETCWD",	"getcwd",	"GetCWD",	genGETCWD,	specNONE)	/* UNIX */
DEFNAME	("GETENV",	"getenv",	"GetEnv",	genNONE,	specGETENV)	/* UNIX */
DEFNAME	("GETGID",	"getgid",	"GetGId",	genNONE,	specGETGID)	/* UNIX */
DEFNAME	("GETLOG",	"getlog",	"GetLog",	genNONE,	specGETLOG)	/* UNIX */
DEFNAME	("GETPID",	"getpid",	"GetPId",	genNONE,	specGETPID)	/* UNIX */
DEFNAME	("GETUID",	"getuid",	"GetUId",	genNONE,	specGETUID)	/* UNIX */
DEFNAME	("GMTIME",	"gmtime",	"GMTime",	genNONE,	specGMTIME)	/* UNIX */
DEFNAME	("HOSTNM",	"hostnm",	"HostNm",	genHOSTNM,	specNONE)	/* UNIX */
DEFNAME	("HUGE",	"huge",		"Huge",		genNONE,	specHUGE)	/* F90 */
DEFNAME	("IABS",	"iabs",		"IAbs",		genNONE,	specIABS)
DEFNAME	("IACHAR",	"iachar",	"IAChar",	genNONE,	specIACHAR)	/* F90,	F2C */
DEFNAME	("IAND",	"iand",		"IAnd",		genNONE,	specIAND)	/* F90,	VXT */
DEFNAME	("IARGC",	"iargc",	"IArgC",	genNONE,	specIARGC)	/* UNIX */
DEFNAME	("IBCLR",	"ibclr",	"IBClr",	genNONE,	specIBCLR)	/* F90,	VXT */
DEFNAME	("IBITS",	"ibits",	"IBits",	genNONE,	specIBITS)	/* F90,	VXT */
DEFNAME	("IBSET",	"ibset",	"IBSet",	genNONE,	specIBSET)	/* F90,	VXT */
DEFNAME	("ICHAR",	"ichar",	"IChar",	genNONE,	specICHAR)
DEFNAME	("IDATE",	"idate",	"IDate",	genIDATE,	specNONE)	/* UNIX, VXT */
DEFNAME	("IDIM",	"idim",		"IDiM",		genNONE,	specIDIM)
DEFNAME	("IDINT",	"idint",	"IDInt",	genNONE,	specIDINT)
DEFNAME	("IDNINT",	"idnint",	"IDNInt",	genNONE,	specIDNINT)
DEFNAME	("IEOR",	"ieor",		"IEOr",		genNONE,	specIEOR)	/* F90,	VXT */
DEFNAME	("IERRNO",	"ierrno",	"IErrNo",	genNONE,	specIERRNO)	/* UNIX */
DEFNAME	("IFIX",	"ifix",		"IFix",		genNONE,	specIFIX)
DEFNAME	("IIABS",	"iiabs",	"IIAbs",	genNONE,	specIIABS)	/* VXT */
DEFNAME	("IIAND",	"iiand",	"IIAnd",	genNONE,	specIIAND)	/* VXT */
DEFNAME	("IIBCLR",	"iibclr",	"IIBClr",	genNONE,	specIIBCLR)	/* VXT */
DEFNAME	("IIBITS",	"iibits",	"IIBits",	genNONE,	specIIBITS)	/* VXT */
DEFNAME	("IIBSET",	"iibset",	"IIBSet",	genNONE,	specIIBSET)	/* VXT */
DEFNAME	("IIDIM",	"iidim",	"IIDiM",	genNONE,	specIIDIM)	/* VXT */
DEFNAME	("IIDINT",	"iidint",	"IIDInt",	genNONE,	specIIDINT)	/* VXT */
DEFNAME	("IIDNNT",	"iidnnt",	"IIDNnt",	genNONE,	specIIDNNT)	/* VXT */
DEFNAME	("IIEOR",	"iieor",	"IIEOr",	genNONE,	specIIEOR)	/* VXT */
DEFNAME	("IIFIX",	"iifix",	"IIFix",	genNONE,	specIIFIX)	/* VXT */
DEFNAME	("IINT",	"iint",		"IInt",		genNONE,	specIINT)	/* VXT */
DEFNAME	("IIOR",	"iior",		"IIOr",		genNONE,	specIIOR)	/* VXT */
DEFNAME	("IIQINT",	"iiqint",	"IIQint",	genNONE,	specIIQINT)	/* VXT */
DEFNAME	("IIQNNT",	"iiqnnt",	"IIQNnt",	genNONE,	specIIQNNT)	/* VXT */
DEFNAME	("IISHFT",	"iishft",	"IIShft",	genNONE,	specNONE)	/* VXT */
DEFNAME	("IISHFTC",	"iishftc",	"IIShftC",	genNONE,	specIISHFTC)	/* VXT */
DEFNAME	("IISIGN",	"iisign",	"IISign",	genNONE,	specIISIGN)	/* VXT */
DEFNAME	("IMAG",	"imag",		"Imag",		genNONE,	specIMAG)	/* F2C */
DEFNAME	("IMAGPART",	"imagpart",	"ImagPart",	genNONE,	specIMAGPART)	/* GNU */
DEFNAME	("IMAX0",	"imax0",	"IMax0",	genNONE,	specIMAX0)	/* VXT */
DEFNAME	("IMAX1",	"imax1",	"IMax1",	genNONE,	specIMAX1)	/* VXT */
DEFNAME	("IMIN0",	"imin0",	"IMin0",	genNONE,	specIMIN0)	/* VXT */
DEFNAME	("IMIN1",	"imin1",	"IMin1",	genNONE,	specIMIN1)	/* VXT */
DEFNAME	("IMOD",	"imod",		"IMod",		genNONE,	specIMOD)	/* VXT */
DEFNAME	("INDEX",	"index",	"Index",	genNONE,	specINDEX)
DEFNAME	("ININT",	"inint",	"INInt",	genNONE,	specININT)	/* VXT */
DEFNAME	("INOT",	"inot",		"INot",		genNONE,	specINOT)	/* VXT */
DEFNAME	("INT",		"int",		"Int",		genNONE,	specINT)
DEFNAME	("INT2",	"int2",		"Int2",		genNONE,	specINT2)	/* MS */
DEFNAME	("INT8",	"int8",		"Int8",		genNONE,	specINT8)	/* GNU */
DEFNAME	("IOR",		"ior",		"IOr",		genNONE,	specIOR)	/* F90,	VXT */
DEFNAME	("IRAND",	"irand",	"IRand",	genNONE,	specIRAND)	/* UNIX */
DEFNAME	("ISATTY",	"isatty",	"IsaTty",	genNONE,	specISATTY)	/* UNIX */
DEFNAME	("ISHFT",	"ishft",	"IShft",	genNONE,	specISHFT)	/* F90 */
DEFNAME	("ISHFTC",	"ishftc",	"IShftC",	genNONE,	specISHFTC)	/* F90,	VXT */
DEFNAME	("ISIGN",	"isign",	"ISign",	genNONE,	specISIGN)
DEFNAME	("ITIME",	"itime",	"ITime",	genNONE,	specITIME)	/* UNIX */
DEFNAME	("IZEXT",	"izext",	"IZExt",	genNONE,	specIZEXT)	/* VXT */
DEFNAME	("JIABS",	"jiabs",	"JIAbs",	genNONE,	specJIABS)	/* VXT */
DEFNAME	("JIAND",	"jiand",	"JIAnd",	genNONE,	specJIAND)	/* VXT */
DEFNAME	("JIBCLR",	"jibclr",	"JIBClr",	genNONE,	specJIBCLR)	/* VXT */
DEFNAME	("JIBITS",	"jibits",	"JIBits",	genNONE,	specJIBITS)	/* VXT */
DEFNAME	("JIBSET",	"jibset",	"JIBSet",	genNONE,	specJIBSET)	/* VXT */
DEFNAME	("JIDIM",	"jidim",	"JIDiM",	genNONE,	specJIDIM)	/* VXT */
DEFNAME	("JIDINT",	"jidint",	"JIDInt",	genNONE,	specJIDINT)	/* VXT */
DEFNAME	("JIDNNT",	"jidnnt",	"JIDNnt",	genNONE,	specJIDNNT)	/* VXT */
DEFNAME	("JIEOR",	"jieor",	"JIEOr",	genNONE,	specJIEOR)	/* VXT */
DEFNAME	("JIFIX",	"jifix",	"JIFix",	genNONE,	specJIFIX)	/* VXT */
DEFNAME	("JINT",	"jint",		"JInt",		genNONE,	specJINT)	/* VXT */
DEFNAME	("JIOR",	"jior",		"JIOr",		genNONE,	specJIOR)	/* VXT */
DEFNAME	("JIQINT",	"jiqint",	"JIQint",	genNONE,	specJIQINT)	/* VXT */
DEFNAME	("JIQNNT",	"jiqnnt",	"JIQNnt",	genNONE,	specJIQNNT)	/* VXT */
DEFNAME	("JISHFT",	"jishft",	"JIShft",	genNONE,	specJISHFT)	/* VXT */
DEFNAME	("JISHFTC",	"jishftc",	"JIShftC",	genNONE,	specJISHFTC)	/* VXT */
DEFNAME	("JISIGN",	"jisign",	"JISign",	genNONE,	specJISIGN)	/* VXT */
DEFNAME	("JMAX0",	"jmax0",	"JMax0",	genNONE,	specJMAX0)	/* VXT */
DEFNAME	("JMAX1",	"jmax1",	"JMax1",	genNONE,	specJMAX1)	/* VXT */
DEFNAME	("JMIN0",	"jmin0",	"JMin0",	genNONE,	specJMIN0)	/* VXT */
DEFNAME	("JMIN1",	"jmin1",	"JMin1",	genNONE,	specJMIN1)	/* VXT */
DEFNAME	("JMOD",	"jmod",		"JMod",		genNONE,	specJMOD)	/* VXT */
DEFNAME	("JNINT",	"jnint",	"JNInt",	genNONE,	specJNINT)	/* VXT */
DEFNAME	("JNOT",	"jnot",		"JNot",		genNONE,	specJNOT)	/* VXT */
DEFNAME	("JZEXT",	"jzext",	"JZExt",	genNONE,	specJZEXT)	/* VXT */
DEFNAME	("KILL",	"kill",		"Kill",		genKILL,	specNONE)	/* UNIX */
DEFNAME	("KIND",	"kind",		"Kind",		genNONE,	specKIND)	/* F90 */
DEFNAME	("LBOUND",	"lbound",	"LBound",	genNONE,	specLBOUND)	/* F90 */
DEFNAME	("LEN",		"len",		"Len",		genNONE,	specLEN)
DEFNAME	("LEN_TRIM",	"len_trim",	"Len_Trim",	genNONE,	specLEN_TRIM)	/* F90 */
DEFNAME	("LGE",		"lge",		"LGe",		genNONE,	specLGE)
DEFNAME	("LGT",		"lgt",		"LGt",		genNONE,	specLGT)
DEFNAME	("LINK",	"link",		"Link",		genLINK,	specNONE)	/* UNIX */
DEFNAME	("LLE",		"lle",		"LLe",		genNONE,	specLLE)
DEFNAME	("LLT",		"llt",		"LLt",		genNONE,	specLLT)
DEFNAME	("LNBLNK",	"lnblnk",	"LnBlnk",	genNONE,	specLNBLNK)	/* UNIX */
DEFNAME	("LOC",		"loc",		"Loc",		genNONE,	specLOC)	/* VXT */
DEFNAME	("LOG",		"log",		"Log",		genNONE,	specLOG)
DEFNAME	("LOG10",	"log10",	"Log10",	genNONE,	specLOG10)
DEFNAME	("LOGICAL",	"logical",	"Logical",	genNONE,	specLOGICAL)	/* F90 */
DEFNAME	("LONG",	"long",		"Long",		genNONE,	specLONG)	/* UNIX */
DEFNAME	("LSHIFT",	"lshift",	"LShift",	genNONE,	specLSHIFT)	/* F2C */
DEFNAME	("LSTAT",	"lstat",	"LStat",	genLSTAT,	specNONE)	/* UNIX */
DEFNAME	("LTIME",	"ltime",	"LTime",	genNONE,	specLTIME)	/* UNIX */
DEFNAME	("MATMUL",	"matmul",	"MatMul",	genNONE,	specMATMUL)	/* F90 */
DEFNAME	("MAX",		"max",		"Max",		genNONE,	specMAX)
DEFNAME	("MAX0",	"max0",		"Max0",		genNONE,	specMAX0)
DEFNAME	("MAX1",	"max1",		"Max1",		genNONE,	specMAX1)
DEFNAME	("MAXEXPONENT",	"maxexponent",	"MaxExponent",	genNONE,	specMAXEXPONENT)	/* F90 */
DEFNAME	("MAXLOC",	"maxloc",	"MaxLoc",	genNONE,	specMAXLOC)	/* F90 */
DEFNAME	("MAXVAL",	"maxval",	"MaxVal",	genNONE,	specMAXVAL)	/* F90 */
DEFNAME	("MCLOCK",	"mclock",	"MClock",	genNONE,	specMCLOCK)	/* UNIX */
DEFNAME	("MCLOCK8",	"mclock8",	"MClock8",	genNONE,	specMCLOCK8)	/* UNIX */
DEFNAME	("MERGE",	"merge",	"Merge",	genNONE,	specMERGE)	/* F90 */
DEFNAME	("MIN",		"min",		"Min",		genNONE,	specMIN)
DEFNAME	("MIN0",	"min0",		"Min0",		genNONE,	specMIN0)
DEFNAME	("MIN1",	"min1",		"Min1",		genNONE,	specMIN1)
DEFNAME	("MINEXPONENT",	"minexponent",	"MinExponent",	genNONE,	specMINEXPONENT)	/* F90 */
DEFNAME	("MINLOC",	"minloc",	"MinLoc",	genNONE,	specMINLOC)	/* F90 */
DEFNAME	("MINVAL",	"minval",	"MinVal",	genNONE,	specMINVAL)	/* F90 */
DEFNAME	("MOD",		"mod",		"Mod",		genNONE,	specMOD)
DEFNAME	("MODULO",	"modulo",	"Modulo",	genNONE,	specMODULO)	/* F90 */
DEFNAME	("MVBITS",	"mvbits",	"MvBits",	genNONE,	specMVBITS)	/* F90 */
DEFNAME	("NEAREST",	"nearest",	"Nearest",	genNONE,	specNEAREST)	/* F90 */
DEFNAME	("NINT",	"nint",		"NInt",		genNONE,	specNINT)
DEFNAME	("NOT",		"not",		"Not",		genNONE,	specNOT)	/* F2C,	F90,	VXT */
DEFNAME	("OR",		"or",		"Or",		genNONE,	specOR)	/* F2C */
DEFNAME	("PACK",	"pack",		"Pack",		genNONE,	specPACK)	/* F90 */
DEFNAME	("PERROR",	"perror",	"PError",	genNONE,	specPERROR)	/* UNIX */
DEFNAME	("PRECISION",	"precision",	"Precision",	genNONE,	specPRECISION)	/* F90 */
DEFNAME	("PRESENT",	"present",	"Present",	genNONE,	specPRESENT)	/* F90 */
DEFNAME	("PRODUCT",	"product",	"Product",	genNONE,	specPRODUCT)	/* F90 */
DEFNAME	("QABS",	"qabs",		"QAbs",		genNONE,	specQABS)	/* VXT */
DEFNAME	("QACOS",	"qacos",	"QACos",	genNONE,	specQACOS)	/* VXT */
DEFNAME	("QACOSD",	"qacosd",	"QACosD",	genNONE,	specQACOSD)	/* VXT */
DEFNAME	("QASIN",	"qasin",	"QASin",	genNONE,	specQASIN)	/* VXT */
DEFNAME	("QASIND",	"qasind",	"QASinD",	genNONE,	specQASIND)	/* VXT */
DEFNAME	("QATAN",	"qatan",	"QATan",	genNONE,	specQATAN)	/* VXT */
DEFNAME	("QATAN2",	"qatan2",	"QATan2",	genNONE,	specQATAN2)	/* VXT */
DEFNAME	("QATAN2D",	"qatan2d",	"QATan2D",	genNONE,	specQATAN2D)	/* VXT */
DEFNAME	("QATAND",	"qatand",	"QATanD",	genNONE,	specQATAND)	/* VXT */
DEFNAME	("QCOS",	"qcos",		"QCos",		genNONE,	specQCOS)	/* VXT */
DEFNAME	("QCOSD",	"qcosd",	"QCosD",	genNONE,	specQCOSD)	/* VXT */
DEFNAME	("QCOSH",	"qcosh",	"QCosH",	genNONE,	specQCOSH)	/* VXT */
DEFNAME	("QDIM",	"qdim",		"QDiM",		genNONE,	specQDIM)	/* VXT */
DEFNAME	("QEXP",	"qexp",		"QExp",		genNONE,	specQEXP)	/* VXT */
DEFNAME	("QEXT",	"qext",		"QExt",		genNONE,	specQEXT)	/* VXT */
DEFNAME	("QEXTD",	"qextd",	"QExtD",	genNONE,	specQEXTD)	/* VXT */
DEFNAME	("QFLOAT",	"qfloat",	"QFloat",	genNONE,	specQFLOAT)	/* VXT */
DEFNAME	("QINT",	"qint",		"QInt",		genNONE,	specQINT)	/* VXT */
DEFNAME	("QLOG",	"qlog",		"QLog",		genNONE,	specQLOG)	/* VXT */
DEFNAME	("QLOG10",	"qlog10",	"QLog10",	genNONE,	specQLOG10)	/* VXT */
DEFNAME	("QMAX1",	"qmax1",	"QMax1",	genNONE,	specQMAX1)	/* VXT */
DEFNAME	("QMIN1",	"qmin1",	"QMin1",	genNONE,	specQMIN1)	/* VXT */
DEFNAME	("QMOD",	"qmod",		"QMod",		genNONE,	specQMOD)	/* VXT */
DEFNAME	("QNINT",	"qnint",	"QNInt",	genNONE,	specQNINT)	/* VXT */
DEFNAME	("QSIN",	"qsin",		"QSin",		genNONE,	specQSIN)	/* VXT */
DEFNAME	("QSIND",	"qsind",	"QSinD",	genNONE,	specQSIND)	/* VXT */
DEFNAME	("QSINH",	"qsinh",	"QSinH",	genNONE,	specQSINH)	/* VXT */
DEFNAME	("QSQRT",	"qsqrt",	"QSqRt",	genNONE,	specQSQRT)	/* VXT */
DEFNAME	("QTAN",	"qtan",		"QTan",		genNONE,	specQTAN)	/* VXT */
DEFNAME	("QTAND",	"qtand",	"QTanD",	genNONE,	specQTAND)	/* VXT */
DEFNAME	("QTANH",	"qtanh",	"QTanH",	genNONE,	specQTANH)	/* VXT */
DEFNAME	("RADIX",	"radix",	"Radix",	genNONE,	specRADIX)	/* F90 */
DEFNAME	("RAND",	"rand",		"Rand",		genNONE,	specRAND)	/* UNIX */
DEFNAME	("RANDOM_NUMBER",	"random_number",	"Random_Number",	genNONE,	specRANDOM_NUMBER)	/* F90 */
DEFNAME	("RANDOM_SEED",	"random_seed",	"Random_Seed",	genNONE,	specRANDOM_SEED)	/* F90 */
DEFNAME	("RANGE",	"range",	"Range",	genNONE,	specRANGE)	/* F90 */
DEFNAME	("REAL",	"real",		"Real",		genNONE,	specREAL)
DEFNAME	("REALPART",	"realpart",	"RealPart",	genNONE,	specREALPART)	/* GNU */
DEFNAME	("RENAME",	"rename",	"Rename",	genRENAME,	specNONE)	/* UNIX */
DEFNAME	("REPEAT",	"repeat",	"Repeat",	genNONE,	specREPEAT)	/* F90 */
DEFNAME	("RESHAPE",	"reshape",	"Reshape",	genNONE,	specRESHAPE)	/* F90 */
DEFNAME	("RRSPACING",	"rrspacing",	"RRSpacing",	genNONE,	specRRSPACING)	/* F90 */
DEFNAME	("RSHIFT",	"rshift",	"RShift",	genNONE,	specRSHIFT)	/* F2C */
DEFNAME	("SCALE",	"scale",	"Scale",	genNONE,	specSCALE)	/* F90 */
DEFNAME	("SCAN",	"scan",		"Scan",		genNONE,	specSCAN)	/* F90 */
DEFNAME	("SECNDS",	"secnds",	"Secnds",	genNONE,	specSECNDS)	/* VXT */
DEFNAME	("SECOND",	"second",	"Second",	genSECOND,	specNONE)	/* UNIX */
DEFNAME	("SELECTED_INT_KIND",	"selected_int_kind",	"Selected_Int_Kind",	genNONE,	specSEL_INT_KIND)	/* F90 */
DEFNAME	("SELECTED_REAL_KIND",	"selected_real_kind",	"Selected_Real_Kind",	genNONE,	specSEL_REAL_KIND)	/* F90 */
DEFNAME	("SET_EXPONENT",	"set_exponent",	"Set_Exponent",	genNONE,	specSET_EXPONENT)	/* F90 */
DEFNAME	("SHAPE",	"shape",	"Shape",	genNONE,	specSHAPE)	/* F90 */
DEFNAME	("SHORT",	"short",	"Short",	genNONE,	specSHORT)	/* UNIX */
DEFNAME	("SIGN",	"sign",		"Sign",		genNONE,	specSIGN)
DEFNAME	("SIGNAL",	"signal",	"Signal",	genSIGNAL,	specNONE)	/* UNIX */
DEFNAME	("SIN",		"sin",		"Sin",		genNONE,	specSIN)
DEFNAME	("SIND",	"sind",		"SinD",		genNONE,	specSIND)	/* VXT */
DEFNAME	("SINH",	"sinh",		"SinH",		genNONE,	specSINH)
DEFNAME	("SLEEP",	"sleep",	"Sleep",	genNONE,	specSLEEP)	/* UNIX */
DEFNAME	("SNGL",	"sngl",		"Sngl",		genNONE,	specSNGL)
DEFNAME	("SNGLQ",	"snglq",	"SnglQ",	genNONE,	specSNGLQ)	/* VXT */
DEFNAME	("SPACING",	"spacing",	"Spacing",	genNONE,	specSPACING)	/* F90 */
DEFNAME	("SPREAD",	"spread",	"Spread",	genNONE,	specSPREAD)	/* F90 */
DEFNAME	("SQRT",	"sqrt",		"SqRt",		genNONE,	specSQRT)
DEFNAME	("SRAND",	"srand",	"SRand",	genNONE,	specSRAND)	/* UNIX */
DEFNAME	("STAT",	"stat",		"Stat",		genSTAT,	specNONE)	/* UNIX */
DEFNAME	("SUM",		"sum",		"Sum",		genNONE,	specSUM)	/* F90 */
DEFNAME	("SYMLNK",	"symlnk",	"SymLnk",	genSYMLNK,	specNONE)	/* UNIX */
DEFNAME	("SYSTEM",	"system",	"System",	genSYSTEM,	specNONE)	/* UNIX */
DEFNAME	("SYSTEM_CLOCK",	"system_clock",	"System_Clock",	genNONE,	specSYSTEM_CLOCK)	/* F90 */
DEFNAME	("TAN",		"tan",		"Tan",		genNONE,	specTAN)
DEFNAME	("TAND",	"tand",		"TanD",		genNONE,	specTAND)	/* VXT */
DEFNAME	("TANH",	"tanh",		"TanH",		genNONE,	specTANH)
DEFNAME	("TIME",	"time",		"Time",		genTIME,	specNONE)	/* UNIX, VXT */
DEFNAME	("TIME8",	"time8",	"Time8",	genNONE,	specTIME8)	/* UNIX */
DEFNAME	("TINY",	"tiny",		"Tiny",		genNONE,	specTINY)	/* F90 */
DEFNAME	("TRANSFER",	"transfer",	"Transfer",	genNONE,	specTRANSFER)	/* F90 */
DEFNAME	("TRANSPOSE",	"transpose",	"Transpose",	genNONE,	specTRANSPOSE)	/* F90 */
DEFNAME	("TRIM",	"trim",		"Trim",		genNONE,	specTRIM)	/* F90 */
DEFNAME	("TTYNAM",	"ttynam",	"TtyNam",	genTTYNAM,	specNONE)	/* UNIX */
DEFNAME	("UBOUND",	"ubound",	"UBound",	genNONE,	specUBOUND)	/* F90 */
DEFNAME	("UMASK",	"umask",	"UMask",	genUMASK,	specNONE)	/* UNIX */
DEFNAME	("UNLINK",	"unlink",	"Unlink",	genUNLINK,	specNONE)	/* UNIX */
DEFNAME	("UNPACK",	"unpack",	"Unpack",	genNONE,	specUNPACK)	/* F90 */
DEFNAME	("VERIFY",	"verify",	"Verify",	genNONE,	specVERIFY)	/* F90 */
DEFNAME	("XOR",		"xor",		"XOr",		genNONE,	specXOR)	/* F2C */
DEFNAME	("ZABS",	"zabs",		"ZAbs",		genNONE,	specZABS)	/* F2C */
DEFNAME	("ZCOS",	"zcos",		"ZCos",		genNONE,	specZCOS)	/* F2C */
DEFNAME	("ZEXP",	"zexp",		"ZExp",		genNONE,	specZEXP)	/* F2C */
DEFNAME	("ZEXT",	"zext",		"ZExt",		genNONE,	specZEXT)	/* VXT */
DEFNAME	("ZLOG",	"zlog",		"ZLog",		genNONE,	specZLOG)	/* F2C */
DEFNAME	("ZSIN",	"zsin",		"ZSin",		genNONE,	specZSIN)	/* F2C */
DEFNAME	("ZSQRT",	"zsqrt",	"ZSqRt",	genNONE,	specZSQRT)	/* F2C */

/* Internally generic intrinsics.

   Should properly be called "mapped" intrinsics.  These are intrinsics
   that map to one or more generally different implementations -- e.g.
   that have differing interpretations depending on the Fortran dialect
   being used.  Also, this includes the placeholder intrinsics that
   have no specific versions, but we want to reserve the names for now.  */

DEFGEN (CTIME, "CTIME",		/* UNIX */
    FFEINTRIN_specCTIME_subr,
    FFEINTRIN_specCTIME_func
  )
DEFGEN (CHDIR, "CHDIR", 	/* UNIX */
    FFEINTRIN_specCHDIR_subr,
    FFEINTRIN_specCHDIR_func
  )
DEFGEN (CHMOD, "CHMOD", 	/* UNIX */
    FFEINTRIN_specCHMOD_subr,
    FFEINTRIN_specCHMOD_func
  )
DEFGEN (DTIME, "DTIME", 	/* UNIX */
    FFEINTRIN_specDTIME_subr,
    FFEINTRIN_specDTIME_func
  )
DEFGEN (ETIME, "ETIME", 	/* UNIX */
    FFEINTRIN_specETIME_subr,
    FFEINTRIN_specETIME_func
  )
DEFGEN (FDATE, "FDATE", 	/* UNIX */
    FFEINTRIN_specFDATE_subr,
    FFEINTRIN_specFDATE_func
  )
DEFGEN (FGET, "FGET",	 	/* UNIX */
    FFEINTRIN_specFGET_subr,
    FFEINTRIN_specFGET_func
  )
DEFGEN (FGETC, "FGETC", 	/* UNIX */
    FFEINTRIN_specFGETC_subr,
    FFEINTRIN_specFGETC_func
  )
DEFGEN (FPABSP, "FPABSP",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPEXPN, "FPEXPN",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPFRAC, "FPFRAC",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPMAKE, "FPMAKE",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPRRSP, "FPRRSP",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPSCAL, "FPSCAL",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FPUT, "FPUT",	 	/* UNIX */
    FFEINTRIN_specFPUT_subr,
    FFEINTRIN_specFPUT_func
  )
DEFGEN (FPUTC, "FPUTC", 	/* UNIX */
    FFEINTRIN_specFPUTC_subr,
    FFEINTRIN_specFPUTC_func
  )
DEFGEN (FSTAT, "FSTAT", 	/* UNIX */
    FFEINTRIN_specFSTAT_subr,
    FFEINTRIN_specFSTAT_func
  )
DEFGEN (FTELL, "FTELL", 	/* UNIX */
    FFEINTRIN_specFTELL_subr,
    FFEINTRIN_specFTELL_func
  )
DEFGEN (GETCWD, "GETCWD", 	/* UNIX */
    FFEINTRIN_specGETCWD_subr,
    FFEINTRIN_specGETCWD_func
  )
DEFGEN (HOSTNM, "HOSTNM", 	/* UNIX */
    FFEINTRIN_specHOSTNM_subr,
    FFEINTRIN_specHOSTNM_func
  )
DEFGEN (IDATE, "IDATE",		/* UNIX/VXT */
    FFEINTRIN_specIDATE_unix,
    FFEINTRIN_specIDATE_vxt
  )
DEFGEN (KILL, "KILL", 		/* UNIX */
    FFEINTRIN_specKILL_subr,
    FFEINTRIN_specKILL_func
  )
DEFGEN (LINK, "LINK", 		/* UNIX */
    FFEINTRIN_specLINK_subr,
    FFEINTRIN_specLINK_func
  )
DEFGEN (LSTAT, "LSTAT", 	/* UNIX */
    FFEINTRIN_specLSTAT_subr,
    FFEINTRIN_specLSTAT_func
  )
DEFGEN (RENAME, "RENAME", 	/* UNIX */
    FFEINTRIN_specRENAME_subr,
    FFEINTRIN_specRENAME_func
  )
DEFGEN (SECOND, "SECOND",	/* UNIX/CRAY */
    FFEINTRIN_specSECOND_func,
    FFEINTRIN_specSECOND_subr
  )
DEFGEN (SIGNAL, "SIGNAL", 	/* UNIX */
    FFEINTRIN_specSIGNAL_subr,
    FFEINTRIN_specSIGNAL_func
  )
DEFGEN (STAT, "STAT", 		/* UNIX */
    FFEINTRIN_specSTAT_subr,
    FFEINTRIN_specSTAT_func
  )
DEFGEN (SYMLNK, "SYMLNK", 	/* UNIX */
    FFEINTRIN_specSYMLNK_subr,
    FFEINTRIN_specSYMLNK_func
  )
DEFGEN (SYSTEM, "SYSTEM", 	/* UNIX */
    FFEINTRIN_specSYSTEM_subr,
    FFEINTRIN_specSYSTEM_func
  )
DEFGEN (TIME, "TIME",		/* UNIX/VXT */
    FFEINTRIN_specTIME_unix,
    FFEINTRIN_specTIME_vxt
  )
DEFGEN (TTYNAM, "TTYNAM",	/* UNIX/VXT */
    FFEINTRIN_specTTYNAM_subr,
    FFEINTRIN_specTTYNAM_func
  )
DEFGEN (UMASK, "UMASK", 	/* UNIX */
    FFEINTRIN_specUMASK_subr,
    FFEINTRIN_specUMASK_func
  )
DEFGEN (UNLINK, "UNLINK", 	/* UNIX */
    FFEINTRIN_specUNLINK_subr,
    FFEINTRIN_specUNLINK_func
  )
DEFGEN (NONE, "none",
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )

/* Specific intrinsic information.

   Currently this list starts with the list of F77-standard intrinsics
   in alphabetical order, then continues with the list of all other
   intrinsics.

   The second boolean argument specifies whether the intrinsic is
   allowed by the standard to be passed as an actual argument.  */

DEFSPEC (ABS,
    "ABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impABS
  )
DEFSPEC (ACOS,
    "ACOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impACOS
  )
DEFSPEC (AIMAG,
    "AIMAG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAIMAG
  )
DEFSPEC (AINT,
    "AINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAINT
  )
DEFSPEC (ALOG,
    "ALOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impALOG
  )
DEFSPEC (ALOG10,
    "ALOG10",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impALOG10
  )
DEFSPEC (AMAX0,
    "AMAX0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMAX0
  )
DEFSPEC (AMAX1,
    "AMAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMAX1
  )
DEFSPEC (AMIN0,
    "AMIN0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMIN0
  )
DEFSPEC (AMIN1,
    "AMIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMIN1
  )
DEFSPEC (AMOD,
    "AMOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMOD
  )
DEFSPEC (ANINT,
    "ANINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impANINT
  )
DEFSPEC (ASIN,
    "ASIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impASIN
  )
DEFSPEC (ATAN,
    "ATAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impATAN
  )
DEFSPEC (ATAN2,
    "ATAN2",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impATAN2
  )
DEFSPEC (CABS,
    "CABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCABS
  )
DEFSPEC (CCOS,
    "CCOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCCOS
  )
DEFSPEC (CEXP,
    "CEXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCEXP
  )
DEFSPEC (CHAR,
    "CHAR",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCHAR
  )
DEFSPEC (CLOG,
    "CLOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCLOG
  )
DEFSPEC (CMPLX,
    "CMPLX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCMPLX
  )
DEFSPEC (CONJG,
    "CONJG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCONJG
  )
DEFSPEC (COS,
    "COS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCOS
  )
DEFSPEC (COSH,
    "COSH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCOSH
  )
DEFSPEC (CSIN,
    "CSIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCSIN
  )
DEFSPEC (CSQRT,
    "CSQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCSQRT
  )
DEFSPEC (DABS,
    "DABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDABS
  )
DEFSPEC (DACOS,
    "DACOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDACOS
  )
DEFSPEC (DASIN,
    "DASIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDASIN
  )
DEFSPEC (DATAN,
    "DATAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDATAN
  )
DEFSPEC (DATAN2,
    "DATAN2",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDATAN2
  )
DEFSPEC (DBLE,
    "DBLE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDBLE
  )
DEFSPEC (DCOS,
    "DCOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDCOS
  )
DEFSPEC (DCOSH,
    "DCOSH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDCOSH
  )
DEFSPEC (DDIM,
    "DDIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDDIM
  )
DEFSPEC (DEXP,
    "DEXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDEXP
  )
DEFSPEC (DIM,
    "DIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDIM
  )
DEFSPEC (DINT,
    "DINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDINT
  )
DEFSPEC (DLOG,
    "DLOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDLOG
  )
DEFSPEC (DLOG10,
    "DLOG10",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDLOG10
  )
DEFSPEC (DMAX1,
    "DMAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMAX1
  )
DEFSPEC (DMIN1,
    "DMIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMIN1
  )
DEFSPEC (DMOD,
    "DMOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMOD
  )
DEFSPEC (DNINT,
    "DNINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDNINT
  )
DEFSPEC (DPROD,
    "DPROD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDPROD
  )
DEFSPEC (DSIGN,
    "DSIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSIGN
  )
DEFSPEC (DSIN,
    "DSIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSIN
  )
DEFSPEC (DSINH,
    "DSINH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSINH
  )
DEFSPEC (DSQRT,
    "DSQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSQRT
  )
DEFSPEC (DTAN,
    "DTAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDTAN
  )
DEFSPEC (DTANH,
    "DTANH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDTANH
  )
DEFSPEC (EXP,
    "EXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impEXP
  )
DEFSPEC (FLOAT,
    "FLOAT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impFLOAT
  )
DEFSPEC (IABS,
    "IABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIABS
  )
DEFSPEC (ICHAR,
    "ICHAR",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impICHAR
  )
DEFSPEC (IDIM,
    "IDIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIDIM
  )
DEFSPEC (IDINT,
    "IDINT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIDINT
  )
DEFSPEC (IDNINT,
    "IDNINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIDNINT
  )
DEFSPEC (IFIX,
    "IFIX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIFIX
  )
DEFSPEC (INDEX,
    "INDEX",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINDEX
  )
DEFSPEC (INT,
    "INT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINT
  )
DEFSPEC (ISIGN,
    "ISIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impISIGN
  )
DEFSPEC (LEN,
    "LEN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLEN
  )
DEFSPEC (LGE,
    "LGE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLGE
  )
DEFSPEC (LGT,
    "LGT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLGT
  )
DEFSPEC (LLE,
    "LLE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLLE
  )
DEFSPEC (LLT,
    "LLT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLLT
  )
DEFSPEC (LOG,
    "LOG",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLOG
  )
DEFSPEC (LOG10,
    "LOG10",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLOG10
  )
DEFSPEC (MAX,
    "MAX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX
  )
DEFSPEC (MAX0,
    "MAX0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX0
  )
DEFSPEC (MAX1,
    "MAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX1
  )
DEFSPEC (MIN,
    "MIN",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN
  )
DEFSPEC (MIN0,
    "MIN0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN0
  )
DEFSPEC (MIN1,
    "MIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN1
  )
DEFSPEC (MOD,
    "MOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMOD
  )
DEFSPEC (NINT,
    "NINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impNINT
  )
DEFSPEC (REAL,
    "REAL",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impREAL
  )
DEFSPEC (SIGN,
    "SIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSIGN
  )
DEFSPEC (SIN,
    "SIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSIN
  )
DEFSPEC (SINH,
    "SINH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSINH
  )
DEFSPEC (SNGL,
    "SNGL",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSNGL
  )
DEFSPEC (SQRT,
    "SQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSQRT
  )
DEFSPEC (TAN,
    "TAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impTAN
  )
DEFSPEC (TANH,
    "TANH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impTANH
  )

DEFSPEC (ABORT,
    "ABORT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impABORT
  )
DEFSPEC (ACCESS,
    "ACCESS",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impACCESS
)
DEFSPEC (ACHAR,
    "ACHAR",
    FALSE,
    FFEINTRIN_familyASC,
    FFEINTRIN_impACHAR
  )
DEFSPEC (ACOSD,
    "ACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ADJUSTL,
    "ADJUSTL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (ADJUSTR,
    "ADJUSTR",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (AIMAX0,
    "AIMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (AIMIN0,
    "AIMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (AJMAX0,
    "AJMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (AJMIN0,
    "AJMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ALARM,
    "ALARM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impALARM
  )
DEFSPEC (ALL,
    "ALL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (ALLOCATED,
    "ALLOCATED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (AND,
    "AND",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impAND
  )
DEFSPEC (ANY,
    "ANY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (ASIND,
    "ASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ASSOCIATED,
    "ASSOCIATED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (ATAN2D,
    "ATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ATAND,
    "ATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (BESJ0,
    "BESJ0",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESJ0
)
DEFSPEC (BESJ1,
    "BESJ1",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESJ1
)
DEFSPEC (BESJN,
    "BESJN",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESJN
)
DEFSPEC (BESY0,
    "BESY0",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESY0
)
DEFSPEC (BESY1,
    "BESY1",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESY1
)
DEFSPEC (BESYN,
    "BESYN",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impBESYN
)
DEFSPEC (BIT_SIZE,
    "BIT_SIZE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impBIT_SIZE
  )
DEFSPEC (BITEST,
    "BITEST",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (BJTEST,
    "BJTEST",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (BTEST,
    "BTEST",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impBTEST
  )
DEFSPEC (CDABS,
    "CDABS",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDABS
  )
DEFSPEC (CDCOS,
    "CDCOS",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDCOS
  )
DEFSPEC (CDEXP,
    "CDEXP",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDEXP
  )
DEFSPEC (CDLOG,
    "CDLOG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDLOG
  )
DEFSPEC (CDSIN,
    "CDSIN",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDSIN
  )
DEFSPEC (CDSQRT,
    "CDSQRT",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDSQRT
  )
DEFSPEC (CEILING,
    "CEILING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (CHDIR_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impCHDIR_func
)
DEFSPEC (CHDIR_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCHDIR_subr
)
DEFSPEC (CHMOD_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impCHMOD_func
)
DEFSPEC (CHMOD_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCHMOD_subr
)
DEFSPEC (COMPLEX,
    "COMPLEX",
    FALSE,
    FFEINTRIN_familyGNU,
    FFEINTRIN_impCOMPLEX
  )
DEFSPEC (COSD,
    "COSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (COUNT,
    "COUNT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (CSHIFT,
    "CSHIFT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (CPU_TIME,
    "CPU_TIME",
    FALSE,
    FFEINTRIN_familyF95,
    FFEINTRIN_impCPU_TIME
)
DEFSPEC (CTIME_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCTIME_func
)
DEFSPEC (CTIME_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCTIME_subr
)
DEFSPEC (DACOSD,
    "DACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DASIND,
    "DASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DATAN2D,
    "DATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DATAND,
    "DATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DATE,
    "DATE",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impDATE
)
DEFSPEC (DATE_AND_TIME,
    "DATE_AND_TIME",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impDATE_AND_TIME
  )
DEFSPEC (DBESJ0,
    "DBESJ0",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESJ0
)
DEFSPEC (DBESJ1,
    "DBESJ1",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESJ1
)
DEFSPEC (DBESJN,
    "DBESJN",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESJN
)
DEFSPEC (DBESY0,
    "DBESY0",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESY0
)
DEFSPEC (DBESY1,
    "DBESY1",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESY1
)
DEFSPEC (DBESYN,
    "DBESYN",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDBESYN
)
DEFSPEC (DBLEQ,
    "DBLEQ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DCMPLX,
    "DCMPLX",
    FALSE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDCMPLX
  )
DEFSPEC (DCONJG,
    "DCONJG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDCONJG
  )
DEFSPEC (DCOSD,
    "DCOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DERF,
    "DERF",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDERF
  )
DEFSPEC (DERFC,
    "DERFC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDERFC
  )
DEFSPEC (DFLOAT,
    "DFLOAT",
    FALSE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDFLOAT
  )
DEFSPEC (DFLOTI,
    "DFLOTI",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DFLOTJ,
    "DFLOTJ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DIGITS,
    "DIGITS",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (DIMAG,
    "DIMAG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDIMAG
  )
DEFSPEC (DOT_PRODUCT,
    "DOT_PRODUCT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (DREAL,
    "DREAL",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impDREAL
  )
DEFSPEC (DSIND,
    "DSIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DTAND,
    "DTAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (DTIME_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impDTIME_func
)
DEFSPEC (DTIME_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDTIME_subr
)
DEFSPEC (EOSHIFT,
    "EOSHIFT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (EPSILON,
    "EPSILON",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (ERF,
    "ERF",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impERF
  )
DEFSPEC (ERFC,
    "ERFC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impERFC
  )
DEFSPEC (ETIME_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impETIME_func
)
DEFSPEC (ETIME_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impETIME_subr
)
DEFSPEC (EXIT,
    "EXIT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impEXIT
  )
DEFSPEC (EXPONENT,
    "EXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FDATE_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFDATE_func
)
DEFSPEC (FDATE_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFDATE_subr
)
DEFSPEC (FGET_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impFGET_func
)
DEFSPEC (FGET_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFGET_subr
)
DEFSPEC (FGETC_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impFGETC_func
)
DEFSPEC (FGETC_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFGETC_subr
)
DEFSPEC (FLOATI,
    "FLOATI",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FLOATJ,
    "FLOATJ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FLOOR,
    "FLOOR",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FLUSH,
    "FLUSH",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFLUSH
  )
DEFSPEC (FNUM,
    "FNUM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFNUM
)
DEFSPEC (FPUT_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impFPUT_func
)
DEFSPEC (FPUT_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFPUT_subr
)
DEFSPEC (FPUTC_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impFPUTC_func
)
DEFSPEC (FPUTC_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFPUTC_subr
)
DEFSPEC (FRACTION,
    "FRACTION",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FSEEK,
    "FSEEK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFSEEK
  )
DEFSPEC (FSTAT_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFSTAT_func
)
DEFSPEC (FSTAT_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFSTAT_subr
)
DEFSPEC (FTELL_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFTELL_func
  )
DEFSPEC (FTELL_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFTELL_subr
  )
DEFSPEC (GERROR,
    "GERROR",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGERROR
)
DEFSPEC (GETARG,
    "GETARG",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETARG
  )
DEFSPEC (GETCWD_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETCWD_func
)
DEFSPEC (GETCWD_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETCWD_subr
)
DEFSPEC (GETENV,
    "GETENV",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETENV
  )
DEFSPEC (GETGID,
    "GETGID",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETGID
)
DEFSPEC (GETLOG,
    "GETLOG",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETLOG
)
DEFSPEC (GETPID,
    "GETPID",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETPID
)
DEFSPEC (GETUID,
    "GETUID",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETUID
)
DEFSPEC (GMTIME,
    "GMTIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGMTIME
)
DEFSPEC (HOSTNM_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impHOSTNM_func
)
DEFSPEC (HOSTNM_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impHOSTNM_subr
)
DEFSPEC (HUGE,
    "HUGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (IACHAR,
    "IACHAR",
    FALSE,
    FFEINTRIN_familyASC,
    FFEINTRIN_impIACHAR
  )
DEFSPEC (IAND,
    "IAND",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIAND
  )
DEFSPEC (IARGC,
    "IARGC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIARGC
  )
DEFSPEC (IBCLR,
    "IBCLR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBCLR
  )
DEFSPEC (IBITS,
    "IBITS",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBITS
  )
DEFSPEC (IBSET,
    "IBSET",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBSET
  )
DEFSPEC (IDATE_unix,
    "UNIX",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIDATE_unix
)
DEFSPEC (IDATE_vxt,
    "VXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIDATE_vxt
)
DEFSPEC (IEOR,
    "IEOR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIEOR
  )
DEFSPEC (IERRNO,
    "IERRNO",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIERRNO
)
DEFSPEC (IIABS,
    "IIABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIAND,
    "IIAND",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIBCLR,
    "IIBCLR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIBITS,
    "IIBITS",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIBSET,
    "IIBSET",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIDIM,
    "IIDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIDINT,
    "IIDINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIDNNT,
    "IIDNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIEOR,
    "IIEOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIFIX,
    "IIFIX",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IINT,
    "IINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIOR,
    "IIOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIQINT,
    "IIQINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IIQNNT,
    "IIQNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IISHFT,
    "IISHFT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IISHFTC,
    "IISHFTC",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IISIGN,
    "IISIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IMAG,
    "IMAG",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impIMAGPART
  )
DEFSPEC (IMAGPART,
    "IMAGPART",
    FALSE,
    FFEINTRIN_familyGNU,
    FFEINTRIN_impIMAGPART
  )
DEFSPEC (IMAX0,
    "IMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IMAX1,
    "IMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IMIN0,
    "IMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IMIN1,
    "IMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (IMOD,
    "IMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ININT,
    "ININT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (INOT,
    "INOT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (INT2,
    "INT2",
    FALSE,
    FFEINTRIN_familyGNU,
    FFEINTRIN_impINT2
  )
DEFSPEC (INT8,
    "INT8",
    FALSE,
    FFEINTRIN_familyGNU,
    FFEINTRIN_impINT8
  )
DEFSPEC (IOR,
    "IOR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIOR
  )
DEFSPEC (IRAND,
    "IRAND",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIRAND
)
DEFSPEC (ISATTY,
    "ISATTY",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impISATTY
)
DEFSPEC (ISHFT,
    "ISHFT",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impISHFT
  )
DEFSPEC (ISHFTC,
    "ISHFTC",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impISHFTC
  )
DEFSPEC (ITIME,
    "ITIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impITIME
)
DEFSPEC (IZEXT,
    "IZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIABS,
    "JIABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIAND,
    "JIAND",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIBCLR,
    "JIBCLR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIBITS,
    "JIBITS",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIBSET,
    "JIBSET",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIDIM,
    "JIDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIDINT,
    "JIDINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIDNNT,
    "JIDNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIEOR,
    "JIEOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIFIX,
    "JIFIX",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JINT,
    "JINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIOR,
    "JIOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIQINT,
    "JIQINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JIQNNT,
    "JIQNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JISHFT,
    "JISHFT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JISHFTC,
    "JISHFTC",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JISIGN,
    "JISIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JMAX0,
    "JMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JMAX1,
    "JMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JMIN0,
    "JMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JMIN1,
    "JMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JMOD,
    "JMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JNINT,
    "JNINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JNOT,
    "JNOT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (JZEXT,
    "JZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (KILL_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impKILL_func
)
DEFSPEC (KILL_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impKILL_subr
)
DEFSPEC (KIND,
    "KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (LBOUND,
    "LBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (LINK_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impLINK_func
)
DEFSPEC (LINK_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLINK_subr
)
DEFSPEC (LEN_TRIM,
    "LEN_TRIM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impLNBLNK
  )
DEFSPEC (LNBLNK,
    "LNBLNK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLNBLNK
)
DEFSPEC (LOC,
    "LOC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLOC
  )
DEFSPEC (LOGICAL,
    "LOGICAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (LONG,
    "LONG",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLONG
  )
DEFSPEC (LSHIFT,
    "LSHIFT",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impLSHIFT
  )
DEFSPEC (LSTAT_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLSTAT_func
)
DEFSPEC (LSTAT_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLSTAT_subr
)
DEFSPEC (LTIME,
    "LTIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLTIME
)
DEFSPEC (MATMUL,
    "MATMUL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MAXEXPONENT,
    "MAXEXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MAXLOC,
    "MAXLOC",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MAXVAL,
    "MAXVAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MCLOCK,
    "MCLOCK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impMCLOCK
)
DEFSPEC (MCLOCK8,
    "MCLOCK8",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impMCLOCK8
)
DEFSPEC (MERGE,
    "MERGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MINEXPONENT,
    "MINEXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MINLOC,
    "MINLOC",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MINVAL,
    "MINVAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MODULO,
    "MODULO",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (MVBITS,
    "MVBITS",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impMVBITS
  )
DEFSPEC (NEAREST,
    "NEAREST",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (NOT,
    "NOT",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impNOT
  )
DEFSPEC (OR,
    "OR",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impOR
  )
DEFSPEC (PACK,
    "PACK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (PERROR,
    "PERROR",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impPERROR
)
DEFSPEC (PRECISION,
    "PRECISION",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (PRESENT,
    "PRESENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (PRODUCT,
    "PRODUCT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (QABS,
    "QABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QACOS,
    "QACOS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QACOSD,
    "QACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QASIN,
    "QASIN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QASIND,
    "QASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QATAN,
    "QATAN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QATAN2,
    "QATAN2",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QATAN2D,
    "QATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QATAND,
    "QATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QCOS,
    "QCOS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QCOSD,
    "QCOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QCOSH,
    "QCOSH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QDIM,
    "QDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QEXP,
    "QEXP",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QEXT,
    "QEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QEXTD,
    "QEXTD",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QFLOAT,
    "QFLOAT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QINT,
    "QINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QLOG,
    "QLOG",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QLOG10,
    "QLOG10",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QMAX1,
    "QMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QMIN1,
    "QMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QMOD,
    "QMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QNINT,
    "QNINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QSIGN,
    "QSIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QSIN,
    "QSIN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QSIND,
    "QSIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QSINH,
    "QSINH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QSQRT,
    "QSQRT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QTAN,
    "QTAN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QTAND,
    "QTAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (QTANH,
    "QTANH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (RADIX,
    "RADIX",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RAND,
    "RAND",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impRAND
)
DEFSPEC (RANDOM_NUMBER,
    "RANDOM_NUMBER",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RANDOM_SEED,
    "RANDOM_SEED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RANGE,
    "RANGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (REALPART,
    "REALPART",
    FALSE,
    FFEINTRIN_familyGNU,
    FFEINTRIN_impREALPART
  )
DEFSPEC (RENAME_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impRENAME_func
)
DEFSPEC (RENAME_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impRENAME_subr
)
DEFSPEC (REPEAT,
    "REPEAT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RESHAPE,
    "RESHAPE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RRSPACING,
    "RRSPACING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (RSHIFT,
    "RSHIFT",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impRSHIFT
  )
DEFSPEC (SCALE,
    "SCALE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SCAN,
    "SCAN",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SECNDS,
    "SECNDS",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impSECNDS
)
DEFSPEC (SECOND_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSECOND_func
)
DEFSPEC (SECOND_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSECOND_subr
)
DEFSPEC (SEL_INT_KIND,
    "SEL_INT_KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SEL_REAL_KIND,
    "SEL_REAL_KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SET_EXPONENT,
    "SET_EXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SHAPE,
    "SHAPE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SHORT,
    "SHORT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSHORT
  )
DEFSPEC (SIGNAL_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impSIGNAL_func
  )
DEFSPEC (SIGNAL_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSIGNAL_subr
  )
DEFSPEC (SIND,
    "SIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (SLEEP,
    "SLEEP",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSLEEP
)
DEFSPEC (SNGLQ,
    "SNGLQ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (SPACING,
    "SPACING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SPREAD,
    "SPREAD",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SRAND,
    "SRAND",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSRAND
)
DEFSPEC (STAT_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSTAT_func
)
DEFSPEC (STAT_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSTAT_subr
)
DEFSPEC (SUM,
    "SUM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SYMLNK_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impSYMLNK_func
)
DEFSPEC (SYMLNK_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSYMLNK_subr
)
DEFSPEC (SYSTEM_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impSYSTEM_func
  )
DEFSPEC (SYSTEM_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSYSTEM_subr
  )
DEFSPEC (SYSTEM_CLOCK,
    "SYSTEM_CLOCK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impSYSTEM_CLOCK
  )
DEFSPEC (TAND,
    "TAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (TIME8,
    "UNIX",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTIME8
)
DEFSPEC (TIME_unix,
    "UNIX",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTIME_unix
)
DEFSPEC (TIME_vxt,
    "VXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impTIME_vxt
)
DEFSPEC (TINY,
    "TINY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (TRANSFER,
    "TRANSFER",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (TRANSPOSE,
    "TRANSPOSE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (TRIM,
    "TRIM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (TTYNAM_func,
    "function",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTTYNAM_func
)
DEFSPEC (TTYNAM_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTTYNAM_subr
)
DEFSPEC (UBOUND,
    "UBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (UMASK_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impUMASK_func
)
DEFSPEC (UMASK_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impUMASK_subr
)
DEFSPEC (UNLINK_func,
    "function",
    FALSE,
    FFEINTRIN_familyBADU77,
    FFEINTRIN_impUNLINK_func
)
DEFSPEC (UNLINK_subr,
    "subroutine",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impUNLINK_subr
)
DEFSPEC (UNPACK,
    "UNPACK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (VERIFY,
    "VERIFY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (XOR,
    "XOR",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impXOR
  )
DEFSPEC (ZABS,
    "ZABS",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDABS
  )
DEFSPEC (ZCOS,
    "ZCOS",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDCOS
  )
DEFSPEC (ZEXP,
    "ZEXP",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDEXP
  )
DEFSPEC (ZEXT,
    "ZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (ZLOG,
    "ZLOG",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDLOG
  )
DEFSPEC (ZSIN,
    "ZSIN",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDSIN
  )
DEFSPEC (ZSQRT,
    "ZSQRT",
    TRUE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impCDSQRT
  )
DEFSPEC (NONE,
    "none",
    FALSE,
    FFEINTRIN_familyNONE,
    FFEINTRIN_impNONE
  )

/* Intrinsic implementations ordered in two sections:
   F77, then extensions; secondarily, alphabetical
   ordering.  */

/* The DEFIMP macro specifies the following fields for an intrinsic:

   CODE	      -- The internal name for this intrinsic; `FFEINTRIN_imp'
		 prepends this to form the `enum' name.

   NAME       -- The textual name to use when printing information on
		 this intrinsic.

   GFRTDIRECT -- The run-time library routine that is suitable for
		 a call to implement a *direct* invocation of the
		 intrinsic (e.g. `ABS(10)').

   GFRTF2C    -- The run-time library routine that is suitable for
		 passing as an argument to a procedure that will
		 invoke the argument as an EXTERNAL procedure, when
		 f2c calling conventions will be used (e.g.
		 `CALL FOO(ABS)', when FOO compiled with -ff2c).

   GFRTGNU    -- The run-time library routine that is suitable for
		 passing as an argument to a procedure that will
		 invoke the argument as an EXTERNAL procedure, when
		 GNU calling conventions will be used (e.g.
		 `CALL FOO(ABS)', when FOO compiled with -fno-f2c).

   CONTROL    -- A control string, described below.

   The DEFIMPY macro specifies the above, plus:

   Y2KBAD     -- TRUE if the intrinsic is known to be non-Y2K-compliant,
                 FALSE if it is known to be Y2K-compliant.  (In terms of
                 interface and libg2c implementation.)

*/

/* The control string has the following format:

     <return-type>:<arglist-info>:[<argitem-info>,...]

   <return-type> is:

     <return-base-type><return-kind-type>[<return-modifier>]

   <return-base-type> is:

     -    Subroutine
     A    Character
     C    Complex
     I    Integer
     L    Logical
     R    Real
     B    Boolean (I or L), decided by co-operand list (COL)
     F    Floating-point (C or R), decided by COL
     N    Numeric (C, I, or R), decided by co-operand list (COL)
     S    Scalar numeric (I or R), decided by COL, which may be COMPLEX

   <return-kind-type> is:

     -    Subroutine
     =    Decided by COL
     1    (Default)
     2    (Twice the size of 1)
     3    (Same size as CHARACTER*1)
     4    (Twice the size of 2)
     6    (Twice the size as 3)
     7    (Same size as `char *')
     C    Like 1 (F77), except (F90), if COL is COMPLEX, uses kind type of COL

   <return-modifier> is:

     *    Valid for <return-base-type> of `A' only, means program may
          declare any length for return value, default being (*)

   <arglist-info> is:

     <COL-spec>

   <COL-spec> is:

     -    No COL (return-base-type and return-kind-type must be definitive)
     *    All arguments form COL (must have more than one argument)
     n    Argument n (0 for first arg, 1 for second, etc.) forms COL

   <argitem-info> is:

     <name>=[<optionality>]<arg-base-type><arg-kind-type>[<arg-len>][<arg-rank>][<arg-extra>]

   <name> is the standard keyword name for the argument.

   <optionality> is:

     ?    Argument is optional
     !    Like ?, but argument must be omitted if previous arg was COMPLEX
     +    One or more of these arguments must be specified
     *    Zero or more of these arguments must be specified
     n    Numbered names for arguments, one or more must be specified
     p    Like n, but two or more must be specified

   <arg-base-type> is:

     -    Any is valid (arg-kind-type is 0)
     A    Character*(*)
     C    Complex
     I    Integer
     L    Logical
     R    Real
     B    Boolean (I or L)
     F    Floating-point (C or R)
     N    Numeric (C, I, or R)
     S    Scalar numeric (I or R)
     g    GOTO label (alternate-return form of CALL) (arg-kind-type is 0)
     s    Signal handler (INTEGER FUNCTION, SUBROUTINE or dummy/global
          default INTEGER variable) (arg-kind-type is 0)

   <arg-kind-type> is:

     *    Any is valid
     1    (Default)
     2    (Twice the size of 1)
     3    (Same size as CHARACTER*1)
     4    (Twice the size of 2)
     6    (Twice the size as 3)
     A    Same as first argument

   <arg-len> is:

          (Default) CHARACTER*(*)
     [n]  CHARACTER*n

   <arg-rank> is:

          (default) Rank-0 (variable or array element)
     (n)  Rank-1 array n elements long
     &    Any (arg-extra is &)

   <arg-extra> is:

          (default) Arg is INTENT(IN)
     i    Arg's attributes are all that matter (inquiry function)
     w    Arg is INTENT(OUT)
     x    Arg is INTENT(INOUT)
     &    Arg can have its address taken (LOC(), for example)

*/

DEFIMP	(ABS,		"ABS",		,ABS,,		"S=:0:A=N*")
DEFIMP	(ACOS,		"ACOS",		L_ACOS,ACOS,,	"R=:0:X=R*")
DEFIMP	(AIMAG,		"AIMAG",	,AIMAG,,	"RC:0:Z=C*")
DEFIMP	(AINT,		"AINT",		,AINT,,		"R=:0:A=R*")
DEFIMP	(ALOG,		"ALOG",		L_LOG,ALOG,,	"R1:-:X=R1")
DEFIMP	(ALOG10,	"ALOG10",	,ALOG10,,	"R1:-:X=R1")
DEFIMP	(AMAX0,		"AMAX0",	,,,		"R1:*:A=pI1")
DEFIMP	(AMAX1,		"AMAX1",	,,,		"R1:*:A=pR1")
DEFIMP	(AMIN0,		"AMIN0",	,,,		"R1:*:A=pI1")
DEFIMP	(AMIN1,		"AMIN1",	,,,		"R1:*:A=pR1")
DEFIMP	(AMOD,		"AMOD",		,AMOD,,		"R1:*:A=R1,P=R1")
DEFIMP	(ANINT,		"ANINT",	,ANINT,,	"R=:0:A=R*")
DEFIMP	(ASIN,		"ASIN",		L_ASIN,ASIN,,	"R=:0:X=R*")
DEFIMP	(ATAN,		"ATAN",		L_ATAN,ATAN,,	"R=:0:X=R*")
DEFIMP	(ATAN2,		"ATAN2",	L_ATAN2,ATAN2,,	"R=:*:Y=R*,X=R*")
DEFIMP	(CABS,		"CABS",		,CABS,,		"R1:-:A=C1")
DEFIMP	(CCOS,		"CCOS",		,CCOS,,		"C1:-:X=C1")
DEFIMP	(CEXP,		"CEXP",		,CEXP,,		"C1:-:X=C1")
DEFIMP	(CHAR,		"CHAR",		,,,		"A1:-:I=I*")
DEFIMP	(CLOG,		"CLOG",		,CLOG,,		"C1:-:X=C1")
DEFIMP	(CMPLX,		"CMPLX",	,,,		"C1:*:X=N*,Y=!S*")
DEFIMP	(CONJG,		"CONJG",	,CONJG,,	"C=:0:Z=C*")
DEFIMP	(COS,		"COS",		L_COS,COS,,	"F=:0:X=F*")
DEFIMP	(COSH,		"COSH",		L_COSH,COSH,,	"R=:0:X=R*")
DEFIMP	(CSIN,		"CSIN",		,CSIN,,		"C1:-:X=C1")
DEFIMP	(CSQRT,		"CSQRT",	,CSQRT,,	"C1:-:X=C1")
DEFIMP	(DABS,		"DABS",		,DABS,,		"R2:-:A=R2")
DEFIMP	(DACOS,		"DACOS",	L_ACOS,DACOS,,	"R2:-:X=R2")
DEFIMP	(DASIN,		"DASIN",	L_ASIN,DASIN,,	"R2:-:X=R2")
DEFIMP	(DATAN,		"DATAN",	L_ATAN,DATAN,,	"R2:-:X=R2")
DEFIMP	(DATAN2,	"DATAN2",	L_ATAN2,DATAN2,,"R2:*:Y=R2,X=R2")
DEFIMP	(DBLE,		"DBLE",		,,,		"R2:-:A=N*")
DEFIMP	(DCMPLX,	"DCMPLX",	,,,		"C2:*:X=N*,Y=!S*")
DEFIMP	(DCOS,		"DCOS",		L_COS,DCOS,,	"R2:-:X=R2")
DEFIMP	(DCOSH,		"DCOSH",	L_COSH,DCOSH,,	"R2:-:X=R2")
DEFIMP	(DDIM,		"DDIM",		,DDIM,,		"R2:*:X=R2,Y=R2")
DEFIMP	(DEXP,		"DEXP",		L_EXP,DEXP,,	"R2:-:X=R2")
DEFIMP	(DIM,		"DIM",		,DIM,,		"S=:*:X=S*,Y=S*")
DEFIMP	(DINT,		"DINT",		,DINT,,		"R2:-:A=R2")
DEFIMP	(DLOG,		"DLOG",		L_LOG,DLOG,,	"R2:-:X=R2")
DEFIMP	(DLOG10,	"DLOG10",	,DLOG10,,	"R2:-:X=R2")
DEFIMP	(DMAX1,		"DMAX1",	,,,		"R2:*:A=pR2")
DEFIMP	(DMIN1,		"DMIN1",	,,,		"R2:*:A=pR2")
DEFIMP	(DMOD,		"DMOD",		,DMOD,,		"R2:*:A=R2,P=R2")
DEFIMP	(DNINT,		"DNINT",	,DNINT,,	"R2:-:A=R2")
DEFIMP	(DPROD,		"DPROD",	,DPROD,,	"R2:*:X=R1,Y=R1")
DEFIMP	(DSIGN,		"DSIGN",	,DSIGN,,	"R2:*:A=R2,B=R2")
DEFIMP	(DSIN,		"DSIN",		L_SIN,DSIN,,	"R2:-:X=R2")
DEFIMP	(DSINH,		"DSINH",	L_SINH,DSINH,,	"R2:-:X=R2")
DEFIMP	(DSQRT,		"DSQRT",	L_SQRT,DSQRT,,	"R2:-:X=R2")
DEFIMP	(DTAN,		"DTAN",		L_TAN,DTAN,,	"R2:-:X=R2")
DEFIMP	(DTANH,		"DTANH",	L_TANH,DTANH,,	"R2:-:X=R2")
DEFIMP	(EXP,		"EXP",		L_EXP,EXP,,	"F=:0:X=F*")
DEFIMP	(FLOAT,		"FLOAT",	,,,		"R1:-:A=I*")
DEFIMP	(IABS,		"IABS",		,IABS,IABS,	"I1:-:A=I1")
DEFIMP	(ICHAR,		"ICHAR",	,,,		"I1:-:C=A*")
DEFIMP	(IDIM,		"IDIM",		,IDIM,IDIM,	"I1:*:X=I1,Y=I1")
DEFIMP	(IDINT,		"IDINT",	,,,		"I1:-:A=R2")
DEFIMP	(IDNINT,	"IDNINT",	,IDNINT,IDNINT,	"I1:-:A=R2")
DEFIMP	(IFIX,		"IFIX",		,,,		"I1:-:A=R1")
DEFIMP	(INDEX,		"INDEX",	,INDEX,INDEX,	"I1:*:String=A*,Substring=A*")
DEFIMP	(INT,		"INT",		,,,		"I1:-:A=N*")
DEFIMP	(ISIGN,		"ISIGN",	,ISIGN,ISIGN,	"I1:*:A=I1,B=I1")
DEFIMP	(LEN,		"LEN",		,LEN,LEN,	"I1:-:String=A*i")
DEFIMP	(LGE,		"LGE",		,LGE,LGE,	"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LGT,		"LGT",		,LGT,LGT,	"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LLE,		"LLE",		,LLE,LLE,	"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LLT,		"LLT",		,LLT,LLT,	"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LOG,		"LOG",		L_LOG,ALOG,,	"F=:0:X=F*")
DEFIMP	(LOG10,		"LOG10",	,,,		"R=:0:X=R*")
DEFIMP	(MAX,		"MAX",		,,,		"S=:*:A=pS*")
DEFIMP	(MIN,		"MIN",		,,,		"S=:*:A=pS*")
DEFIMP	(MAX0,		"MAX0",		,,,		"I1:*:A=pI1")
DEFIMP	(MAX1,		"MAX1",		,,,		"I1:*:A=pR1")
DEFIMP	(MIN0,		"MIN0",		,,,		"I1:*:A=pI1")
DEFIMP	(MIN1,		"MIN1",		,,,		"I1:*:A=pR1")
DEFIMP	(MOD,		"MOD",		,MOD,MOD,	"S=:*:A=S*,P=S*")
DEFIMP	(NINT,		"NINT",		,NINT,NINT,	"I1:-:A=R*")
DEFIMP	(REAL,		"REAL",		,,,		"RC:0:A=N*")
DEFIMP	(SIGN,		"SIGN",		,SIGN,,		"S=:*:A=S*,B=S*")
DEFIMP	(SIN,		"SIN",		L_SIN,SIN,,	"F=:0:X=F*")
DEFIMP	(SINH,		"SINH",		L_SINH,SINH,,	"R=:0:X=R*")
DEFIMP	(SNGL,		"SNGL",		,,,		"R1:-:A=R2")
DEFIMP	(SQRT,		"SQRT",		L_SQRT,SQRT,,	"F=:0:X=F*")
DEFIMP	(TAN,		"TAN",		L_TAN,TAN,,	"R=:0:X=R*")
DEFIMP	(TANH,		"TANH",		L_TANH,TANH,,	"R=:0:X=R*")

DEFIMP	(ABORT,		"ABORT",	ABORT,,,	"--:-:")
DEFIMP	(ACCESS,	"ACCESS",	ACCESS,,,	"I1:-:Name=A1,Mode=A1")
DEFIMP	(ACHAR,		"ACHAR",	,,,		"A1:-:I=I*")
DEFIMP	(ALARM,		"ALARM",	ALARM,,,	"--:-:Seconds=I*,Handler=s*,Status=?I1w")
DEFIMP	(AND,		"AND",		,,,		"B=:*:I=B*,J=B*")
DEFIMP	(BESJ0,		"BESJ0",	L_BESJ0,,,	"R=:0:X=R*")
DEFIMP	(BESJ1,		"BESJ1",	L_BESJ1,,,	"R=:0:X=R*")
DEFIMP	(BESJN,		"BESJN",	L_BESJN,,,	"R=:1:N=I*,X=R*")
DEFIMP	(BESY0,		"BESY0",	L_BESY0,,,	"R=:0:X=R*")
DEFIMP	(BESY1,		"BESY1",	L_BESY1,,,	"R=:0:X=R*")
DEFIMP	(BESYN,		"BESYN",	L_BESYN,,,	"R=:1:N=I*,X=R*")
DEFIMP	(BIT_SIZE,	"BIT_SIZE",	,,,		"I=:0:I=I*i")
DEFIMP	(BTEST,		"BTEST",	,,,		"L1:*:I=I*,Pos=I*")
DEFIMP	(CDABS,		"CDABS",	,CDABS,,	"R2:-:A=C2")
DEFIMP	(CDCOS,		"CDCOS",	,CDCOS,,	"C2:-:X=C2")
DEFIMP	(CDEXP,		"CDEXP",	,CDEXP,,	"C2:-:X=C2")
DEFIMP	(CDLOG,		"CDLOG",	,CDLOG,,	"C2:-:X=C2")
DEFIMP	(CDSIN,		"CDSIN",	,CDSIN,,	"C2:-:X=C2")
DEFIMP	(CDSQRT,	"CDSQRT",	,CDSQRT,,	"C2:-:X=C2")
DEFIMP	(CHDIR_func,	"CHDIR_func",	CHDIR,,,	"I1:-:Dir=A1")
DEFIMP	(CHDIR_subr,	"CHDIR_subr",	CHDIR,,,	"--:-:Dir=A1,Status=?I1w")
DEFIMP	(CHMOD_func,	"CHMOD_func",	CHMOD,,,	"I1:-:Name=A1,Mode=A1")
DEFIMP	(CHMOD_subr,	"CHMOD_subr",	CHMOD,,,	"--:-:Name=A1,Mode=A1,Status=?I1w")
DEFIMP	(COMPLEX,	"COMPLEX",	,,,		"C=:*:Real=S*,Imag=S*")
DEFIMP	(CPU_TIME,	"CPU_TIME",	SECOND,,,	"--:-:Seconds=R*w")
DEFIMP	(CTIME_func,	"CTIME_func",	CTIME,,,	"A1*:-:STime=I*")
DEFIMP	(CTIME_subr,	"CTIME_subr",	CTIME,,,	"--:-:STime=I*,Result=A1w")
DEFIMPY	(DATE,		"DATE",		DATE,,,		"--:-:Date=A1w",	TRUE)
DEFIMP	(DATE_AND_TIME,	"DATE_AND_TIME", DATE_AND_TIME,,, "--:-:Date=A1w,Time=?A1w,Zone=?A1w,Values=?I1(8)w")
DEFIMP	(DBESJ0,	"DBESJ0",	L_BESJ0,,,	"R2:-:X=R2")
DEFIMP	(DBESJ1,	"DBESJ1",	L_BESJ1,,,	"R2:-:X=R2")
DEFIMP	(DBESJN,	"DBESJN",	L_BESJN,,,	"R2:-:N=I*,X=R2")
DEFIMP	(DBESY0,	"DBESY0",	L_BESY0,,,	"R2:-:X=R2")
DEFIMP	(DBESY1,	"DBESY1",	L_BESY1,,,	"R2:-:X=R2")
DEFIMP	(DBESYN,	"DBESYN",	L_BESYN,,,	"R2:-:N=I*,X=R2")
DEFIMP	(DCONJG,	"DCONJG",	,DCONJG,,	"C2:-:Z=C2")
DEFIMP	(DERF,		"DERF",		L_ERF,DERF,,	"R2:-:X=R2")
DEFIMP	(DERFC,		"DERFC",	L_ERFC,DERFC,,	"R2:-:X=R2")
DEFIMP	(DFLOAT,	"DFLOAT",	,,,		"R2:-:A=I*")
DEFIMP	(DIMAG,		"DIMAG",	,DIMAG,,	"R2:-:Z=C2")
DEFIMP	(DREAL,		"DREAL",	,,,		"R2:-:A=N*")
DEFIMP	(DTIME_func,	"DTIME_func",	DTIME,,,	"R1:-:TArray=R1(2)w")
DEFIMP	(DTIME_subr,	"DTIME_subr",	DTIME,,,	"--:-:TArray=R1(2)w,Result=R1w")
DEFIMP	(ERF,		"ERF",		L_ERF,ERF,,	"R=:0:X=R*")
DEFIMP	(ERFC,		"ERFC",		L_ERFC,ERFC,,	"R=:0:X=R*")
DEFIMP	(ETIME_func,	"ETIME_func",	ETIME,,,	"R1:-:TArray=R1(2)w")
DEFIMP	(ETIME_subr,	"ETIME_subr",	ETIME,,,	"--:-:TArray=R1(2)w,Result=R1w")
DEFIMP	(EXIT,		"EXIT",		EXIT,,,		"--:-:Status=?I*")
DEFIMP	(FDATE_func,	"FDATE_func",	FDATE,,,	"A1*:-:")
DEFIMP	(FDATE_subr,	"FDATE_subr",	FDATE,,,	"--:-:Date=A1w")
DEFIMP	(FGET_func,	"FGET_func",	FGET,,,		"I1:-:C=A1w")
DEFIMP	(FGET_subr,	"FGET_subr",	FGET,,,		"--:-:C=A1w,Status=?I1w")
DEFIMP	(FGETC_func,	"FGETC_func",	FGETC,,,	"I1:-:Unit=I*,C=A1w")
DEFIMP	(FGETC_subr,	"FGETC_subr",	FGETC,,,	"--:-:Unit=I*,C=A1w,Status=?I1w")
DEFIMP	(FLUSH,		"FLUSH",	,,,		"--:-:Unit=?I*")
DEFIMP	(FNUM,		"FNUM",		FNUM,,,		"I1:-:Unit=I*")
DEFIMP	(FPUT_func,	"FPUT_func",	FPUT,,,		"I1:-:C=A1")
DEFIMP	(FPUT_subr,	"FPUT_subr",	FPUT,,,		"--:-:C=A1,Status=?I1w")
DEFIMP	(FPUTC_func,	"FPUTC_func",	FPUTC,,,	"I1:-:Unit=I*,C=A1")
DEFIMP	(FPUTC_subr,	"FPUTC_subr",	FPUTC,,,	"--:-:Unit=I*,C=A1,Status=?I1w")
DEFIMP	(FSEEK,		"FSEEK",	FSEEK,,,	"--:-:Unit=I*,Offset=I*,Whence=I*,ErrLab=?g*")
DEFIMP	(FSTAT_func,	"FSTAT_func",	FSTAT,,,	"I1:-:Unit=I*,SArray=I1(13)w")
DEFIMP	(FSTAT_subr,	"FSTAT_subr",	FSTAT,,,	"--:-:Unit=I*,SArray=I1(13)w,Status=?I1w")
DEFIMP	(FTELL_func,	"FTELL_func",	FTELL,,,	"I1:-:Unit=I*")
DEFIMP	(FTELL_subr,	"FTELL_subr",	FTELL,,,	"--:-:Unit=I*,Offset=I1w")
DEFIMP	(GERROR,	"GERROR",	GERROR,,,	"--:-:Message=A1w")
DEFIMP	(GETARG,	"GETARG",	GETARG,,,	"--:-:Pos=I*,Value=A1w")
DEFIMP	(GETCWD_func,	"GETCWD_func",	GETCWD,,,	"I1:-:Name=A1w")
DEFIMP	(GETCWD_subr,	"GETCWD_subr",	GETCWD,,,	"--:-:Name=A1w,Status=?I1w")
DEFIMP	(GETGID,	"GETGID",	GETGID,,,	"I1:-:")
DEFIMP	(GETLOG,	"GETLOG",	GETLOG,,,	"--:-:Login=A1w")
DEFIMP	(GETPID,	"GETPID",	GETPID,,,	"I1:-:")
DEFIMP	(GETUID,	"GETUID",	GETUID,,,	"I1:-:")
DEFIMP	(GETENV,	"GETENV",	GETENV,,,	"--:-:Name=A1,Value=A1w")
DEFIMP	(GMTIME,	"GMTIME",	GMTIME,,,	"--:-:STime=I1,TArray=I1(9)w")
DEFIMP	(HOSTNM_func,	"HOSTNM_func",	HOSTNM,,,	"I1:-:Name=A1w")
DEFIMP	(HOSTNM_subr,	"HOSTNM_subr",	HOSTNM,,,	"--:-:Name=A1w,Status=?I1w")
DEFIMP	(IACHAR,	"IACHAR",	,,,		"I1:-:C=A*")
DEFIMP	(IAND,		"IAND",		,,,		"I=:*:I=I*,J=I*")
DEFIMP	(IARGC,		"IARGC",	IARGC,,,	"I1:-:")
DEFIMP	(IBCLR,		"IBCLR",	,,,		"I=:0:I=I*,Pos=I*")
DEFIMP	(IBITS,		"IBITS",	,,,		"I=:0:I=I*,Pos=I*,Len=I*")
DEFIMP	(IBSET,		"IBSET",	,,,		"I=:0:I=I*,Pos=I*")
DEFIMP	(IDATE_unix,	"IDATE_unix",	IDATE,,,	"--:-:TArray=I1(3)w")
DEFIMPY	(IDATE_vxt,	"IDATE_vxt",	VXTIDATE,,,	"--:-:M=I1w,D=I1w,Y=I1w",	TRUE)
DEFIMP	(IEOR,		"IEOR",		,,,		"I=:*:I=I*,J=I*")
DEFIMP	(IOR,		"IOR",		,,,		"I=:*:I=I*,J=I*")
DEFIMP	(IERRNO,	"IERRNO",	IERRNO,,,	"I1:-:")
DEFIMP	(IMAGPART,	"IMAGPART",	,,,		"R=:0:Z=C*")
DEFIMP	(INT2,		"INT2",		,,,		"I6:-:A=N*")
DEFIMP	(INT8,		"INT8",		,,,		"I2:-:A=N*")
DEFIMP	(IRAND,		"IRAND",	IRAND,,,	"I1:-:Flag=?I*")
DEFIMP	(ISATTY,	"ISATTY",	ISATTY,,,	"L1:-:Unit=I*")
DEFIMP	(ISHFT,		"ISHFT",	,,,		"I=:0:I=I*,Shift=I*")
DEFIMP	(ISHFTC,	"ISHFTC",	,,,		"I=:0:I=I*,Shift=I*,Size=I*")
DEFIMP	(ITIME,		"ITIME",	ITIME,,,	"--:-:TArray=I1(3)w")
DEFIMP	(KILL_func,	"KILL_func",	KILL,,,		"I1:-:Pid=I*,Signal=I*")
DEFIMP	(KILL_subr,	"KILL_subr",	KILL,,,		"--:-:Pid=I*,Signal=I*,Status=?I1w")
DEFIMP	(LINK_func,	"LINK_func",	LINK,,,		"I1:-:Path1=A1,Path2=A1")
DEFIMP	(LINK_subr,	"LINK_subr",	LINK,,,		"--:-:Path1=A1,Path2=A1,Status=?I1w")
DEFIMP	(LNBLNK,	"LNBLNK",	LNBLNK,,,	"I1:-:String=A1")
DEFIMP	(LONG,		"LONG",		,,,		"I1:-:A=I6")
DEFIMP	(LSTAT_func,	"LSTAT_func",	LSTAT,,,	"I1:-:File=A1,SArray=I1(13)w")
DEFIMP	(LSTAT_subr,	"LSTAT_subr",	LSTAT,,,	"--:-:File=A1,SArray=I1(13)w,Status=?I1w")
DEFIMP	(LTIME,		"LTIME",	LTIME,,,	"--:-:STime=I1,TArray=I1(9)w")
DEFIMP	(LOC,		"LOC",		,,,		"I7:-:Entity=-*&&")
DEFIMP	(LSHIFT,	"LSHIFT",	,,,		"I=:0:I=I*,Shift=I*")
DEFIMP	(MCLOCK,	"MCLOCK",	MCLOCK,,,	"I1:-:")
DEFIMP	(MCLOCK8,	"MCLOCK8",	MCLOCK,,,	"I2:-:")
DEFIMP	(MVBITS,	"MVBITS",	,,,		"--:-:From=I*,FromPos=I*,Len=I*,TO=IAx,ToPos=I*")
DEFIMP	(NOT,		"NOT",		,,,		"I=:0:I=I*")
DEFIMP	(OR,		"OR",		,,,		"B=:*:I=B*,J=B*")
DEFIMP	(PERROR,	"PERROR",	PERROR,,,	"--:-:String=A1")
DEFIMP	(RAND,		"RAND",		RAND,,,		"R1:-:Flag=?I*")
DEFIMP	(REALPART,	"REALPART",	,,,		"R=:0:Z=C*")
DEFIMP	(RENAME_func,	"RENAME_func",	RENAME,,,	"I1:-:Path1=A1,Path2=A1")
DEFIMP	(RENAME_subr,	"RENAME_subr",	RENAME,,,	"--:-:Path1=A1,Path2=A1,Status=?I1w")
DEFIMP	(RSHIFT,	"RSHIFT",	,,,		"I=:0:I=I*,Shift=I*")
DEFIMP	(SECNDS,	"SECNDS",	SECNDS,,,	"R1:-:T=R1")
DEFIMP	(SECOND_func,	"SECOND_func",	SECOND,SECOND,,	"R1:-:")
DEFIMP	(SECOND_subr,	"SECOND_subr",	SECOND,,,	"--:-:Seconds=R*w")
DEFIMP	(SHORT,		"SHORT",	,,,		"I6:-:A=I*")
DEFIMP	(SIGNAL_func,	"SIGNAL_func",	L_SIGNAL,,,	"I7:-:Number=I*,Handler=s*")
DEFIMP	(SIGNAL_subr,	"SIGNAL_subr",	L_SIGNAL,,,	"--:-:Number=I*,Handler=s*,Status=?I7w")
DEFIMP	(SLEEP,		"SLEEP",	SLEEP,,,	"--:-:Seconds=I1")
DEFIMP	(SRAND,		"SRAND",	SRAND,,,	"--:-:Seed=I*")
DEFIMP	(STAT_func,	"STAT_func",	STAT,,,		"I1:-:File=A1,SArray=I1(13)w")
DEFIMP	(STAT_subr,	"STAT_subr",	STAT,,,		"--:-:File=A1,SArray=I1(13)w,Status=?I1w")
DEFIMP	(SYMLNK_func,	"SYMLNK_func",	SYMLNK,,,	"I1:-:Path1=A1,Path2=A1")
DEFIMP	(SYMLNK_subr,	"SYMLNK_subr",	SYMLNK,,,	"--:-:Path1=A1,Path2=A1,Status=?I1w")
DEFIMP	(SYSTEM_func,	"SYSTEM_func",	SYSTEM,SYSTEM,SYSTEM,"I1:-:Command=A1")
DEFIMP	(SYSTEM_subr,	"SYSTEM_subr",	SYSTEM,,,	"--:-:Command=A1,Status=?I1w")
DEFIMP	(SYSTEM_CLOCK,	"SYSTEM_CLOCK",	SYSTEM_CLOCK,,,	"--:-:Count=I1w,Rate=?I1w,Max=?I1w")
DEFIMP	(TIME8,		"TIME8",	TIME,,,		"I2:-:")
DEFIMP	(TIME_unix,	"TIME_unix",	TIME,,,		"I1:-:")
DEFIMP	(TIME_vxt,	"TIME_vxt",	VXTTIME,,,	"--:-:Time=A1[8]w")
DEFIMP	(TTYNAM_func,	"TTYNAM_func",	TTYNAM,,,	"A1*:-:Unit=I*")
DEFIMP	(TTYNAM_subr,	"TTYNAM_subr",	TTYNAM,,,	"--:-:Unit=I*,Name=A1w")
DEFIMP	(UMASK_func,	"UMASK_func",	UMASK,,,	"I1:-:Mask=I*")
DEFIMP	(UMASK_subr,	"UMASK_subr",	UMASK,,,	"--:-:Mask=I*,Old=?I1w")
DEFIMP	(UNLINK_func,	"UNLINK_func",	UNLINK,,,	"I1:-:File=A1")
DEFIMP	(UNLINK_subr,	"UNLINK_subr",	UNLINK,,,	"--:-:File=A1,Status=?I1w")
DEFIMP	(XOR,		"XOR",		,,,		"B=:*:I=B*,J=B*")
DEFIMP	(NONE,		"none",		,,,		"")
