/* 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	("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",	genNONE,	specCHDIR)	/* UNIX */
DEFNAME	("CHMOD",	"chmod",	"ChMod",	genNONE,	specCHMOD)	/* 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	("CSHIFT",	"cshift",	"CShift",	genNONE,	specCSHIFT)	/* F90 */
DEFNAME	("CSIN",	"csin",	"CSin",	genNONE,	specCSIN)
DEFNAME	("CSQRT",	"csqrt",	"CSqRt",	genNONE,	specCSQRT)
DEFNAME	("CTIME",	"ctime",	"CTime",	genNONE,	specCTIME)	/* 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",	genNONE,	specDTIME)	/* 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",	genNONE,	specETIME)	/* 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",	genNONE,	specFDATE)	/* UNIX */
DEFNAME	("FGETC",	"fgetc",	"FGetC",	genNONE,	specFGETC)	/* 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	("FPUTC",	"fputc",	"FPutC",	genNONE,	specFPUTC)	/* UNIX */
DEFNAME	("FRACTION",	"fraction",	"Fraction",	genNONE,	specFRACTION)	/* F90 */
DEFNAME	("FSEEK",	"fseek",	"FSeek",	genNONE,	specFSEEK)	/* UNIX */
DEFNAME	("FSTAT",	"fstat",	"FStat",	genNONE,	specFSTAT)	/* UNIX */
DEFNAME	("FTELL",	"ftell",	"FTell",	genNONE,	specFTELL)	/* UNIX */
DEFNAME	("GERROR",	"gerror",	"GError",	genNONE,	specGERROR)	/* UNIX */
DEFNAME	("GETARG",	"getarg",	"GetArg",	genNONE,	specGETARG)	/* UNIX */
DEFNAME	("GETCWD",	"getcwd",	"GetCWD",	genNONE,	specGETCWD)	/* 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",	genNONE,	specHOSTNM)	/* 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	("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",		genNONE,	specKILL)	/* 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",	genNONE,	specLINK)	/* 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",	genNONE,	specLSTAT)	/* 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	("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",	genNONE,	specRENAME)	/* 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",	genNONE,	specSIGNAL)	/* 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",	genNONE,	specSTAT)	/* UNIX */
DEFNAME	("SUM",	"sum",	"Sum",	genNONE,	specSUM)	/* F90 */
DEFNAME	("SYMLNK",	"symlnk",	"SymLnk",	genNONE,	specSYMLNK)	/* UNIX */
DEFNAME	("SYSTEM",	"system",	"System",	genNONE,	specSYSTEM)	/* 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	("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",	genNONE,	specTTYNAM)	/* UNIX */
DEFNAME	("UBOUND",	"ubound",	"UBound",	genNONE,	specUBOUND)	/* F90 */
DEFNAME	("UMASK",	"umask",	"UMask",	genNONE,	specUMASK)	/* UNIX */
DEFNAME	("UNLINK",	"unlink",	"Unlink",	genNONE,	specUNLINK)	/* 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 (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 (IDATE, "IDATE (UNIX or VXT)",	/* UNIX/VXT */
    FFEINTRIN_specIDATE,
    FFEINTRIN_specIDATEVXT
  )
DEFGEN (SECOND, "SECOND (function or subroutine)",	/* UNIX/CRAY */
    FFEINTRIN_specSECONDFUNC,
    FFEINTRIN_specSECONDSUBR
  )
DEFGEN (TIME, "TIME (UNIX or VXT)",	/* UNIX/VXT */
    FFEINTRIN_specTIME,
    FFEINTRIN_specTIMEVXT
  )
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_impINT
  )
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 (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,
    "CHDIR",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCHDIR
)
DEFSPEC (CHMOD,
    "CHMOD",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCHMOD
)
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 (CTIME,
    "CTIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impCTIME
)
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_impNONE
  )
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,
    "DTIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDTIME
)
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,
    "ETIME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impETIME
)
DEFSPEC (EXIT,
    "EXIT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impEXIT
  )
DEFSPEC (EXPONENT,
    "EXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FDATE,
    "FDATE",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFDATE
)
DEFSPEC (FGETC,
    "FGETC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFGETC
)
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 (FPUTC,
    "FPUTC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFPUTC
)
DEFSPEC (FRACTION,
    "FRACTION",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FSEEK,
    "FSEEK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFSEEK
  )
DEFSPEC (FSTAT,
    "FSTAT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFSTAT
)
DEFSPEC (FTELL,
    "FTELL",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFTELL
  )
DEFSPEC (GERROR,
    "GERROR",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGERROR
)
DEFSPEC (GETARG,
    "GETARG",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETARG
  )
DEFSPEC (GETCWD,
    "GETCWD",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETCWD
)
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,
    "HOSTNM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impHOSTNM
)
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,
    "IDATE (UNIX)",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIDATE
)
DEFSPEC (IDATEVXT,
    "IDATE (VXT)",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIDATEVXT
)
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 (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,
    "KILL",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impKILL
)
DEFSPEC (KIND,
    "KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (LBOUND,
    "LBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (LINK,
    "LINK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLINK
)
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,
    "LSTAT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLSTAT
)
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 (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,
    "RENAME",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impRENAME
)
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 (SECONDFUNC,
    "SECOND (function)",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSECONDFUNC
)
DEFSPEC (SECONDSUBR,
    "SECOND (subroutine)",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSECONDSUBR
)
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,
    "SIGNAL",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSIGNAL
  )
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,
    "STAT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSTAT
)
DEFSPEC (SUM,
    "SUM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (SYMLNK,
    "SYMLNK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSYMLNK
)
DEFSPEC (SYSTEM,
    "SYSTEM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSYSTEM
  )
DEFSPEC (SYSTEM_CLOCK,
    "SYSTEM_CLOCK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impSYSTEM_CLOCK
  )
DEFSPEC (TAND,
    "TAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (TIME,
    "TIME (UNIX)",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTIME
)
DEFSPEC (TIMEVXT,
    "TIME (VXT)",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impTIMEVXT
)
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,
    "TTYNAM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impTTYNAM
)
DEFSPEC (UBOUND,
    "UBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (UMASK,
    "UMASK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impUMASK
)
DEFSPEC (UNLINK,
    "UNLINK",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impUNLINK
)
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.

   This list corresponds to actual implementations
   of specific intrinsics, so there is no redundancy -- e.g. instead
   of FLOAT and REAL, there is only _REAL_I.  We use this non-
   redundancy when determining which specific intrinsic is meant
   by a generic -- REAL(I) can match either specific REAL or FLOAT,
   but rather than complain about that, we see that the implementations
   are the same.  This approach should allow lots of extensions in
   the form of possibly conflicting intrinsic sets with complaints
   arising only when those sets are enabled and the potentially
   conflicting intrinsics are actually referenced.

   DEFIMQ defines an implementation that, while it might be implemented
   differently at run time, is implemented by the same code at compile
   time, and that code handles checking various possible inputs.  So,
   no need to complain about ambiguity if two different-typed intrinsic
   run-time implementations have the same compile-time implementation,
   as long as there's a straightforward way of determining which was
   meant (done by ffeintrin_fulfill_generic).  (Here `the same code at
   compile time' may be the default dispatch defined by the
   DEFIMP/DEFIMQ signatures -- see com.c.)  Fixme: Note that
   currently, DEFIMQs have to be a subroutine or function to match
   what the corresponding DEFIMP of the same name is. */

/* 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)
     C    Like 1 (F77), except (F90), if COL is COMPLEX, uses kind type of COL
     p    ffecom_pointer_kind_

   <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",		ACOS,		"R=:0:X=R*")
DEFIMP	(AIMAG,		"AIMAG",	AIMAG,		"RC:0:Z=C*")
DEFIMP	(AINT,		"AINT",		AINT,		"R=:0:A=R*")
DEFIMQ	(ALOG,		"ALOG",		ALOG,		"R1:-:X=R1",
	LOG)
DEFIMQ	(ALOG10,	"ALOG10",	ALOG10,		"R1:-:X=R1",
	LOG10)
DEFIMQ	(AMAX0,		"AMAX0",	,		"R1:*:A=pI1",
	MAX)
DEFIMQ	(AMAX1,		"AMAX1",	,		"R1:*:A=pR1",
	MAX)
DEFIMQ	(AMIN0,		"AMIN0",	,		"R1:*:A=pI1",
	MIN)
DEFIMQ	(AMIN1,		"AMIN1",	,		"R1:*:A=pR1",
	MIN)
DEFIMQ	(AMOD,		"AMOD",		AMOD,		"R1:*:A=R1,P=R1",
	MOD)
DEFIMP	(ANINT,		"ANINT",	ANINT,		"R=:0:A=R*")
DEFIMP	(ASIN,		"ASIN",		ASIN,		"R=:0:X=R*")
DEFIMP	(ATAN,		"ATAN",		ATAN,		"R=:0:X=R*")
DEFIMP	(ATAN2,		"ATAN2",	ATAN2,		"R=:*:Y=R*,X=R*")
DEFIMQ	(CABS,		"CABS",		CABS,		"R1:-:A=C1",
	ABS)
DEFIMQ	(CCOS,		"CCOS",		CCOS,		"C1:-:X=C1",
	COS)
DEFIMQ	(CEXP,		"CEXP",		CEXP,		"C1:-:X=C1",
	EXP)
DEFIMP	(CHAR,		"CHAR",		,		"A1:-:I=I*")
DEFIMQ	(CLOG,		"CLOG",		CLOG,		"C1:-:X=C1",
	LOG)
DEFIMP	(CMPLX,		"CMPLX",	,		"C1:*:X=N*,Y=!S*")
DEFIMP	(CONJG,		"CONJG",	CONJG,		"C=:0:Z=C*")
DEFIMP	(COS,		"COS",		COS,		"F=:0:X=F*")
DEFIMP	(COSH,		"COSH",		COSH,		"R=:0:X=R*")
DEFIMQ	(CSIN,		"CSIN",		CSIN,		"C1:-:X=C1",
	SIN)
DEFIMQ	(CSQRT,		"CSQRT",	CSQRT,		"C1:-:X=C1",
	SQRT)
DEFIMQ	(DABS,		"DABS",		DABS,		"R2:-:A=R2",
	ABS)
DEFIMQ	(DACOS,		"DACOS",	DACOS,		"R2:-:X=R2",
	ACOS)
DEFIMQ	(DASIN,		"DASIN",	DASIN,		"R2:-:X=R2",
	ASIN)
DEFIMQ	(DATAN,		"DATAN",	DATAN,		"R2:-:X=R2",
	ATAN)
DEFIMQ	(DATAN2,	"DATAN2",	DATAN2,		"R2:*:Y=R2,X=R2",
	ATAN2)
DEFIMP	(DBLE,		"DBLE",		,		"R2:-:A=N*")
DEFIMQ	(DCMPLX,	"DCMPLX",	,		"C2:*:X=N*,Y=!S*",
	CMPLX)
DEFIMQ	(DCOS,		"DCOS",		DCOS,		"R2:-:X=R2",
	COS)
DEFIMQ	(DCOSH,		"DCOSH",	DCOSH,		"R2:-:X=R2",
	COSH)
DEFIMQ	(DDIM,		"DDIM",		DDIM,		"R2:*:X=R2,Y=R2",
	DIM)
DEFIMQ	(DEXP,		"DEXP",		DEXP,		"R2:-:X=R2",
	EXP)
DEFIMP	(DIM,		"DIM",		DIM,		"S=:*:X=S*,Y=S*")
DEFIMQ	(DINT,		"DINT",		DINT,		"R2:-:A=R2",
	AINT)
DEFIMQ	(DLOG,		"DLOG",		DLOG,		"R2:-:X=R2",
	LOG)
DEFIMQ	(DLOG10,	"DLOG10",	DLOG10,		"R2:-:X=R2",
	LOG10)
DEFIMQ	(DMAX1,		"DMAX1",	,		"R2:*:A=pR2",
	MAX)
DEFIMQ	(DMIN1,		"DMIN1",	,		"R2:*:A=pR2",
	MIN)
DEFIMQ	(DMOD,		"DMOD",		DMOD,		"R2:*:A=R2,P=R2",
	MOD)
DEFIMQ	(DNINT,		"DNINT",	DNINT,		"R2:-:A=R2",
	ANINT)
DEFIMP	(DPROD,		"DPROD",	DPROD,		"R2:*:X=R1,Y=R1")
DEFIMQ	(DSIGN,		"DSIGN",	DSIGN,		"R2:*:A=R2,B=R2",
	SIGN)
DEFIMQ	(DSIN,		"DSIN",		DSIN,		"R2:-:X=R2",
	SIN)
DEFIMQ	(DSINH,		"DSINH",	DSINH,		"R2:-:X=R2",
	SINH)
DEFIMQ	(DSQRT,		"DSQRT",	DSQRT,		"R2:-:X=R2",
	SQRT)
DEFIMQ	(DTAN,		"DTAN",		DTAN,		"R2:-:X=R2",
	TAN)
DEFIMQ	(DTANH,		"DTANH",	DTANH,		"R2:-:X=R2",
	TANH)
DEFIMP	(EXP,		"EXP",		EXP,		"F=:0:X=F*")
DEFIMQ	(FLOAT,		"FLOAT",	,		"R1:-:A=I*",
	REAL)
DEFIMQ	(IABS,		"IABS",		IABS,		"I1:-:A=I1",
	ABS)
DEFIMP	(ICHAR,		"ICHAR",	,		"I1:-:C=A*")
DEFIMQ	(IDIM,		"IDIM",		IDIM,		"I1:*:X=I1,Y=I1",
	DIM)
DEFIMQ	(IDINT,		"IDINT",	,		"I1:-:A=R2",
	INT)
DEFIMQ	(IDNINT,	"IDNINT",	IDNINT,		"I1:-:A=R2",
	NINT)
DEFIMP	(INDEX,		"INDEX",	INDEX,		"I1:*:String=A*,Substring=A*")
DEFIMP	(INT,		"INT",		,		"I1:-:A=N*")
DEFIMQ	(ISIGN,		"ISIGN",	ISIGN,		"I1:*:A=I1,B=I1",
	SIGN)
DEFIMP	(LEN,		"LEN",		LEN,		"I1:-:String=A*i")
DEFIMP	(LGE,		"LGE",		LGE,		"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LGT,		"LGT",		LGT,		"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LLE,		"LLE",		LLE,		"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LLT,		"LLT",		LLT,		"L1:*:String_A=A1,String_B=A1")
DEFIMP	(LOG,		"LOG",		,		"F=:0:X=F*")
DEFIMP	(LOG10,		"LOG10",	,		"R=:0:X=R*")
DEFIMP	(LONG,		"LONG",		,		"I1:-:A=I*")
DEFIMP	(MAX,		"MAX",		,		"S=:*:A=pS*")
DEFIMP	(MIN,		"MIN",		,		"S=:*:A=pS*")
DEFIMQ	(MAX0,		"MAX0",		,		"I1:*:A=pI1",
	MAX)
DEFIMQ	(MAX1,		"MAX1",		,		"I1:*:A=pR1",
	MAX)
DEFIMQ	(MIN0,		"MIN0",		,		"I1:*:A=pI1",
	MIN)
DEFIMQ	(MIN1,		"MIN1",		,		"I1:*:A=pR1",
	MIN)
DEFIMP	(MOD,		"MOD",		MOD,		"S=:*:A=S*,P=S*")
DEFIMP	(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",		SIN,		"F=:0:X=F*")
DEFIMP	(SINH,		"SINH",		SINH,		"R=:0:X=R*")
DEFIMQ	(SNGL,		"SNGL",		,		"R1:-:A=R2",
	REAL)
DEFIMP	(SQRT,		"SQRT",		SQRT,		"F=:0:X=F*")
DEFIMP	(TAN,		"TAN",		TAN,		"R=:0:X=R*")
DEFIMP	(TANH,		"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	(AND,		"AND",		,		"B=:*:I=B*,J=B*")
DEFIMP	(BESJ0,		"BESJ0",	BESJ0,		"R=:0:X=R*")
DEFIMP	(BESJ1,		"BESJ1",	BESJ1,		"R=:0:X=R*")
DEFIMP	(BESJN,		"BESJN",	BESJN,		"R=:1:N=I*,X=R*")
DEFIMP	(BESY0,		"BESY0",	BESY0,		"R=:0:X=R*")
DEFIMP	(BESY1,		"BESY1",	BESY1,		"R=:0:X=R*")
DEFIMP	(BESYN,		"BESYN",	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*")
DEFIMQ	(CDABS,		"CDABS",	CDABS,		"R2:-:A=C2",
	ABS)
DEFIMQ	(CDCOS,		"CDCOS",	CDCOS,		"C2:-:X=C2",
	COS)
DEFIMQ	(CDEXP,		"CDEXP",	CDEXP,		"C2:-:X=C2",
	EXP)
DEFIMQ	(CDLOG,		"CDLOG",	CDLOG,		"C2:-:X=C2",
	LOG)
DEFIMQ	(CDSIN,		"CDSIN",	CDSIN,		"C2:-:X=C2",
	SIN)
DEFIMQ	(CDSQRT,	"CDSQRT",	CDSQRT,		"C2:-:X=C2",
	SQRT)
DEFIMP	(CHDIR,		"CHDIR",	CHDIR,		"--:-:Dir=A1,Status=?I1w")
DEFIMP	(CHMOD,		"CHMOD",	CHMOD,		"--:-:Name=A1,Mode=A1,Status=?I*w")
DEFIMP	(COMPLEX,	"COMPLEX",	,		"C=:*:Real=S*,Imag=S*")
DEFIMP  (CTIME,		"CTIME",	CTIME,		"A1*:-:STime=I2")
DEFIMP  (DATE,		"DATE",		DATE,		"--:-:Date=A1w")
DEFIMQ	(DBESJ0,	"DBESJ0",	DBESJ0,		"R2:-:X=R2",
         BESJ0)
DEFIMQ	(DBESJ1,	"DBESJ1",	DBESJ1,		"R2:-:X=R2",
         BESJ1)
DEFIMQ	(DBESJN,	"DBESJN",	DBESJN,		"R2:-:N=I*,X=R2",
         BESJN)
DEFIMQ	(DBESY0,	"DBESY0",	DBESY0,		"R2:-:X=R2",
         BESY0)
DEFIMQ	(DBESY1,	"DBESY1",	DBESY1,		"R2:-:X=R2",
         BESY1)
DEFIMQ	(DBESYN,	"DBESYN",	DBESYN,		"R2:-:N=I*,X=R2",
         BESYN)
DEFIMQ	(DCONJG,	"DCONJG",	DCONJG,		"C2:-:Z=C2",
	CONJG)
DEFIMQ	(DERF,		"DERF",		DERF,		"R2:-:X=R2",
	ERF)
DEFIMQ	(DERFC,		"DERFC",	DERFC,		"R2:-:X=R2",
	ERFC)
DEFIMQ	(DFLOAT,	"DFLOAT",	,		"R2:-:A=I*",
	REAL)
DEFIMQ	(DIMAG,		"DIMAG",	DIMAG,		"R2:-:Z=C2",
	AIMAG)
DEFIMQ	(DREAL,		"DREAL",	,		"R2:-:A=N*",
	REAL)
DEFIMP  (DTIME,		"DTIME",	DTIME,		"R1:-:TArray=R1(2)w")
DEFIMP	(ERF,		"ERF",		ERF,		"R=:0:X=R*")
DEFIMP	(ERFC,		"ERFC",		ERFC,		"R=:0:X=R*")
DEFIMP  (ETIME,		"ETIME",	ETIME,		"R1:-:TArray=R1(2)w")
DEFIMP	(EXIT,		"EXIT",		EXIT,		"--:-:Status=?I*")
DEFIMP  (FDATE,		"FDATE",	FDATE,		"A1*:-:")
DEFIMP  (FGET,		"FGET",		FGET,		"--:-:C=A1w,Status=?I*w")
DEFIMP  (FGETC,		"FGETC",	FGETC,		"--:-:Unit=I*,C=A1w,Status=I*w")
DEFIMP	(FLUSH,		"FLUSH",	FLUSH,		"--:-:Unit=?I*")
DEFIMP  (FNUM,		"FNUM",		FNUM,		"I1:-:Unit=I*")
DEFIMP  (FPUT,		"FPUT",		FPUT,		"--:-:C=A1,Status=?I*w")
DEFIMP  (FPUTC,		"FPUTC",	FPUTC,		"--:-:Unit=I*,C=A1,Status=I*w")
DEFIMP	(FSEEK,		"FSEEK",	FSEEK,		"--:-:Unit=I*,Offset=I*,Whence=I*,ErrLab=?g*")
DEFIMP  (FSTAT,		"FSTAT",	FSTAT,		"I1:-:Unit=I*,SArray=I1(13)w")
DEFIMP	(FTELL,		"FTELL",	FTELL,		"I1:-:Unit=I*")
DEFIMP	(GERROR,	"GERROR",	GERROR,		"--:-:Message=A1w")
DEFIMP	(GETARG,	"GETARG",	GETARG,		"--:-:Pos=I*,Value=A1w")
DEFIMP	(GETCWD,	"GETCWD",	GETCWD,		"I1:-:Name=A1w")
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,	"HOSTNM",	HOSTNM,		"I1:-:Name=A1w")
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,		"IDATE (UNIX)",	IDATE,		"--:-:TArray=I1(3)w")
DEFIMP  (IDATEVXT,	"IDATE (VXT)",	VXTIDATE,	"--:-:D=I1w,M=I1w,Y=I1w")
DEFIMP	(IEOR,		"IEOR",		,		"I=:*:I=I*,J=I*")
DEFIMP	(IOR,		"IOR",		,		"I=:*:I=I*,J=I*")
DEFIMP  (IERRNO,	"IERRNO",	IERRNO,		"I1:-:")
DEFIMQ	(IMAGPART,	"IMAGPART",	,		"R=:0:Z=C*",
	AIMAG)
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,		"KILL",		KILL,		"--:-:Pid=I*,Signal=I*,Status=?I*w")
DEFIMP  (LINK,		"LINK",		LINK,		"--:-:Path1=A1,Path2=A1,Status=?I*w")
DEFIMP  (LNBLNK,	"LNBLNK",	LNBLNK,		"I1:-:String=A1")
DEFIMP  (LSTAT,		"LSTAT",	LSTAT,		"I1:-:File=A1,SArray=I1(13)w")
DEFIMP  (LTIME,		"LTIME",	LTIME,		"--:-:STime=I1,TArray=I1(9)w")
DEFIMP	(LOC,		"LOC",		,		"Ip:-:Entity=-*&&")
DEFIMP	(LSHIFT,	"LSHIFT",	,		"I=:0:I=I*,Shift=I*")
DEFIMP  (MCLOCK,	"MCLOCK",	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,	"RENAME",	RENAME,		"--:-:Path1=A1,Path2=A1,Status=?I*w")
DEFIMP	(RSHIFT,	"RSHIFT",	,		"I=:0:I=I*,Shift=I*")
DEFIMP  (SECNDS,	"SECNDS",	SECNDS,		"R1:-:T=R1")
DEFIMP  (SECONDFUNC,	"SECOND (function)",	SECOND,		"R1:-:")
DEFIMP  (SECONDSUBR,	"SECOND (subroutine)",	SECOND,		"--:-:Seconds=R1w")
DEFIMP	(SHORT,		"SHORT",	,		"I6:-:A=I*")
DEFIMP	(SIGNAL,	"SIGNAL",	,		"--:-:Number=I*,Handler=s*")
DEFIMP	(SLEEP,		"SLEEP",	SLEEP,		"--:-:Seconds=I1")
DEFIMP  (SRAND,		"SRAND",	SRAND,		"--:-:Seed=I*")
DEFIMP  (STAT,		"STAT",		STAT,		"I1:-:File=A1,SArray=I1(13)w")
DEFIMP  (SYMLNK,	"SYMLNK",	SYMLNK,		"--:-:Path1=A1,Path2=A1,Status=?I*w")
DEFIMP	(SYSTEM,	"SYSTEM",	SYSTEM,		"--:-:Command=A1,Status=?I1")
DEFIMP	(SYSTEM_CLOCK,	"SYSTEM_CLOCK",	SYSTEM_CLOCK,	"--:-:Count=I1w,Rate=I1w,Max=I1w")
DEFIMP	(TIME,		"TIME (UNIX)",	TIME,		"I2:-:")
DEFIMP	(TIMEVXT,	"TIME (VXT)",	VXTTIME,	"--:-:Time=A1[8]w")
DEFIMP  (TTYNAM,	"TTYNAM",	TTYNAM,		"A1*:-:Unit=I*")
DEFIMP  (UMASK,		"UMASK",	UMASK,		"--:-:Mask=I*,Old=?I*w")
DEFIMP	(UNLINK,	"UNLINK",	UNLINK,		"--:-:File=A1,Status=?I1w")
DEFIMP	(XOR,		"XOR",		,		"B=:*:I=B*,J=B*")
DEFIMP	(NONE,		"none",		,		"")