/* intrin.def -- Public #include File (module.h template V1.0)
   Copyright (C) 1995 Free Software Foundation, Inc.
   Contributed by James Craig Burley (burley@gnu.ai.mit.edu).

This file is part of GNU Fortran.

GNU Fortran is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Fortran is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Fortran; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

   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	("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	("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	("CLOG",	"clog",	"CLog",	genNONE,	specCLOG)
DEFNAME	("CMPLX",	"cmplx",	"Cmplx",	genNONE,	specCMPLX)
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	("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_AND_TIME",	"date_and_time",	"Date_and_Time",	genNONE,	specDATE_AND_TIME)	/* F90 */
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)	/* 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	("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	("EXIT",	"exit",	"Exit",	genNONE,	specEXIT)	/* UNIX */
DEFNAME	("EXP",	"exp",	"Exp",	genNONE,	specEXP)
DEFNAME	("EXPONENT",	"exponent",	"Exponent",	genNONE,	specEXPONENT)	/* F90 */
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	("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	("FRACTION",	"fraction",	"Fraction",	genNONE,	specFRACTION)	/* F90 */
DEFNAME	("GETARG",	"getarg",	"GetArg",	genNONE,	specGETARG)	/* UNIX */
DEFNAME	("GETENV",	"getenv",	"GetEnv",	genNONE,	specGETENV)	/* 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	("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	("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	("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	("ISHFT",	"ishft",	"IShft",	genNONE,	specISHFT)	/* F90 */
DEFNAME	("ISHFTC",	"ishftc",	"IShftC",	genNONE,	specISHFTC)	/* F90,	VXT */
DEFNAME	("ISIGN",	"isign",	"ISign",	genNONE,	specISIGN)
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	("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	("LLE",	"lle",	"LLe",	genNONE,	specLLE)
DEFNAME	("LLT",	"llt",	"LLt",	genNONE,	specLLT)
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	("LSHIFT",	"lshift",	"LShift",	genNONE,	specLSHIFT)	/* F2C */
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	("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	("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	("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	("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	("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	("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	("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	("SUM",	"sum",	"Sum",	genNONE,	specSUM)	/* F90 */
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	("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	("UBOUND",	"ubound",	"UBound",	genNONE,	specUBOUND)	/* F90 */
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 (FFEINTRIN_genFPABSP, "FPABSP",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genFPEXPN, "FPEXPN",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genFPFRAC, "FPFRAC",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genFPMAKE, "FPMAKE",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genFPRRSP, "FPRRSP",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genFPSCAL, "FPSCAL",	/* F2C */
    FFEINTRIN_specNONE,
    FFEINTRIN_specNONE
  )
DEFGEN (FFEINTRIN_genNONE, "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 (FFEINTRIN_specABS,
    "ABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impABS
  )
DEFSPEC (FFEINTRIN_specACOS,
    "ACOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impACOS
  )
DEFSPEC (FFEINTRIN_specAIMAG,
    "AIMAG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAIMAG
  )
DEFSPEC (FFEINTRIN_specAINT,
    "AINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAINT
  )
DEFSPEC (FFEINTRIN_specALOG,
    "ALOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impALOG
  )
DEFSPEC (FFEINTRIN_specALOG10,
    "ALOG10",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impALOG10
  )
DEFSPEC (FFEINTRIN_specAMAX0,
    "AMAX0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMAX0
  )
DEFSPEC (FFEINTRIN_specAMAX1,
    "AMAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMAX1
  )
DEFSPEC (FFEINTRIN_specAMIN0,
    "AMIN0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMIN0
  )
DEFSPEC (FFEINTRIN_specAMIN1,
    "AMIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMIN1
  )
DEFSPEC (FFEINTRIN_specAMOD,
    "AMOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impAMOD
  )
DEFSPEC (FFEINTRIN_specANINT,
    "ANINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impANINT
  )
DEFSPEC (FFEINTRIN_specASIN,
    "ASIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impASIN
  )
DEFSPEC (FFEINTRIN_specATAN,
    "ATAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impATAN
  )
DEFSPEC (FFEINTRIN_specATAN2,
    "ATAN2",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impATAN2
  )
DEFSPEC (FFEINTRIN_specCABS,
    "CABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCABS
  )
DEFSPEC (FFEINTRIN_specCCOS,
    "CCOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCCOS
  )
DEFSPEC (FFEINTRIN_specCEXP,
    "CEXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCEXP
  )
DEFSPEC (FFEINTRIN_specCHAR,
    "CHAR",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCHAR
  )
DEFSPEC (FFEINTRIN_specCLOG,
    "CLOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCLOG
  )
DEFSPEC (FFEINTRIN_specCMPLX,
    "CMPLX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCMPLX
  )
DEFSPEC (FFEINTRIN_specCONJG,
    "CONJG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCONJG
  )
DEFSPEC (FFEINTRIN_specCOS,
    "COS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCOS
  )
DEFSPEC (FFEINTRIN_specCOSH,
    "COSH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCOSH
  )
DEFSPEC (FFEINTRIN_specCSIN,
    "CSIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCSIN
  )
DEFSPEC (FFEINTRIN_specCSQRT,
    "CSQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impCSQRT
  )
DEFSPEC (FFEINTRIN_specDABS,
    "DABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDABS
  )
DEFSPEC (FFEINTRIN_specDACOS,
    "DACOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDACOS
  )
DEFSPEC (FFEINTRIN_specDASIN,
    "DASIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDASIN
  )
DEFSPEC (FFEINTRIN_specDATAN,
    "DATAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDATAN
  )
DEFSPEC (FFEINTRIN_specDATAN2,
    "DATAN2",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDATAN2
  )
DEFSPEC (FFEINTRIN_specDBLE,
    "DBLE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDBLE
  )
DEFSPEC (FFEINTRIN_specDCOS,
    "DCOS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDCOS
  )
DEFSPEC (FFEINTRIN_specDCOSH,
    "DCOSH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDCOSH
  )
DEFSPEC (FFEINTRIN_specDDIM,
    "DDIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDDIM
  )
DEFSPEC (FFEINTRIN_specDEXP,
    "DEXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDEXP
  )
DEFSPEC (FFEINTRIN_specDIM,
    "DIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDIM
  )
DEFSPEC (FFEINTRIN_specDINT,
    "DINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDINT
  )
DEFSPEC (FFEINTRIN_specDLOG,
    "DLOG",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDLOG
  )
DEFSPEC (FFEINTRIN_specDLOG10,
    "DLOG10",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDLOG10
  )
DEFSPEC (FFEINTRIN_specDMAX1,
    "DMAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMAX1
  )
DEFSPEC (FFEINTRIN_specDMIN1,
    "DMIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMIN1
  )
DEFSPEC (FFEINTRIN_specDMOD,
    "DMOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDMOD
  )
DEFSPEC (FFEINTRIN_specDNINT,
    "DNINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDNINT
  )
DEFSPEC (FFEINTRIN_specDPROD,
    "DPROD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDPROD
  )
DEFSPEC (FFEINTRIN_specDSIGN,
    "DSIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSIGN
  )
DEFSPEC (FFEINTRIN_specDSIN,
    "DSIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSIN
  )
DEFSPEC (FFEINTRIN_specDSINH,
    "DSINH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSINH
  )
DEFSPEC (FFEINTRIN_specDSQRT,
    "DSQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDSQRT
  )
DEFSPEC (FFEINTRIN_specDTAN,
    "DTAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDTAN
  )
DEFSPEC (FFEINTRIN_specDTANH,
    "DTANH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impDTANH
  )
DEFSPEC (FFEINTRIN_specEXP,
    "EXP",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impEXP
  )
DEFSPEC (FFEINTRIN_specFLOAT,
    "FLOAT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impREAL
  )
DEFSPEC (FFEINTRIN_specIABS,
    "IABS",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIABS
  )
DEFSPEC (FFEINTRIN_specICHAR,
    "ICHAR",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impICHAR
  )
DEFSPEC (FFEINTRIN_specIDIM,
    "IDIM",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIDIM
  )
DEFSPEC (FFEINTRIN_specIDINT,
    "IDINT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specIDNINT,
    "IDNINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impIDNINT
  )
DEFSPEC (FFEINTRIN_specIFIX,
    "IFIX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specINDEX,
    "INDEX",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINDEX
  )
DEFSPEC (FFEINTRIN_specINT,
    "INT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specISIGN,
    "ISIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impISIGN
  )
DEFSPEC (FFEINTRIN_specLEN,
    "LEN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLEN
  )
DEFSPEC (FFEINTRIN_specLGE,
    "LGE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLGE
  )
DEFSPEC (FFEINTRIN_specLGT,
    "LGT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLGT
  )
DEFSPEC (FFEINTRIN_specLLE,
    "LLE",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLLE
  )
DEFSPEC (FFEINTRIN_specLLT,
    "LLT",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLLT
  )
DEFSPEC (FFEINTRIN_specLOG,
    "LOG",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLOG
  )
DEFSPEC (FFEINTRIN_specLOG10,
    "LOG10",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impLOG10
  )
DEFSPEC (FFEINTRIN_specMAX,
    "MAX",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX
  )
DEFSPEC (FFEINTRIN_specMAX0,
    "MAX0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX0
  )
DEFSPEC (FFEINTRIN_specMAX1,
    "MAX1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMAX1
  )
DEFSPEC (FFEINTRIN_specMIN,
    "MIN",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN
  )
DEFSPEC (FFEINTRIN_specMIN0,
    "MIN0",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN0
  )
DEFSPEC (FFEINTRIN_specMIN1,
    "MIN1",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMIN1
  )
DEFSPEC (FFEINTRIN_specMOD,
    "MOD",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impMOD
  )
DEFSPEC (FFEINTRIN_specNINT,
    "NINT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impNINT
  )
DEFSPEC (FFEINTRIN_specREAL,
    "REAL",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impREAL
  )
DEFSPEC (FFEINTRIN_specSIGN,
    "SIGN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSIGN
  )
DEFSPEC (FFEINTRIN_specSIN,
    "SIN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSIN
  )
DEFSPEC (FFEINTRIN_specSINH,
    "SINH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSINH
  )
DEFSPEC (FFEINTRIN_specSNGL,
    "SNGL",
    FALSE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impREAL
  )
DEFSPEC (FFEINTRIN_specSQRT,
    "SQRT",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impSQRT
  )
DEFSPEC (FFEINTRIN_specTAN,
    "TAN",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impTAN
  )
DEFSPEC (FFEINTRIN_specTANH,
    "TANH",
    TRUE,
    FFEINTRIN_familyF77,
    FFEINTRIN_impTANH
  )

DEFSPEC (FFEINTRIN_specABORT,
    "ABORT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impABORT
  )
DEFSPEC (FFEINTRIN_specACHAR,
    "ACHAR",
    FALSE,
    FFEINTRIN_familyASC,
    FFEINTRIN_impACHAR
  )
DEFSPEC (FFEINTRIN_specACOSD,
    "ACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specADJUSTL,
    "ADJUSTL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specADJUSTR,
    "ADJUSTR",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specAIMAX0,
    "AIMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specAIMIN0,
    "AIMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specAJMAX0,
    "AJMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impAMAX0
  )
DEFSPEC (FFEINTRIN_specAJMIN0,
    "AJMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impAMIN0
  )
DEFSPEC (FFEINTRIN_specALL,
    "ALL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specALLOCATED,
    "ALLOCATED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specAND,
    "AND",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impIAND
  )
DEFSPEC (FFEINTRIN_specANY,
    "ANY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specASIND,
    "ASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specASSOCIATED,
    "ASSOCIATED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specATAN2D,
    "ATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specATAND,
    "ATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specBIT_SIZE,
    "BIT_SIZE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impBIT_SIZE
  )
DEFSPEC (FFEINTRIN_specBITEST,
    "BITEST",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specBJTEST,
    "BJTEST",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impBTEST
  )
DEFSPEC (FFEINTRIN_specBTEST,
    "BTEST",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impBTEST
  )
DEFSPEC (FFEINTRIN_specCDABS,
    "CDABS",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDABS
  )
DEFSPEC (FFEINTRIN_specCDCOS,
    "CDCOS",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDCOS
  )
DEFSPEC (FFEINTRIN_specCDEXP,
    "CDEXP",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDEXP
  )
DEFSPEC (FFEINTRIN_specCDLOG,
    "CDLOG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDLOG
  )
DEFSPEC (FFEINTRIN_specCDSIN,
    "CDSIN",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDSIN
  )
DEFSPEC (FFEINTRIN_specCDSQRT,
    "CDSQRT",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impCDSQRT
  )
DEFSPEC (FFEINTRIN_specCEILING,
    "CEILING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specCOSD,
    "COSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specCOUNT,
    "COUNT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specCSHIFT,
    "CSHIFT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDACOSD,
    "DACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDASIND,
    "DASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDATAN2D,
    "DATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDATAND,
    "DATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDATE_AND_TIME,
    "DATE_AND_TIME",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDBLEQ,
    "DBLEQ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDCMPLX,
    "DCMPLX",
    FALSE,
    FFEINTRIN_familyDCP,
    FFEINTRIN_impDCMPLX
  )
DEFSPEC (FFEINTRIN_specDCONJG,
    "DCONJG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDCONJG
  )
DEFSPEC (FFEINTRIN_specDCOSD,
    "DCOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDERF,
    "DERF",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDERF
  )
DEFSPEC (FFEINTRIN_specDERFC,
    "DERFC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impDERFC
  )
DEFSPEC (FFEINTRIN_specDFLOAT,
    "DFLOAT",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impDBLE
  )
DEFSPEC (FFEINTRIN_specDFLOTI,
    "DFLOTI",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDFLOTJ,
    "DFLOTJ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impDBLE
  )
DEFSPEC (FFEINTRIN_specDIGITS,
    "DIGITS",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDIMAG,
    "DIMAG",
    TRUE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDIMAG
  )
DEFSPEC (FFEINTRIN_specDOT_PRODUCT,
    "DOT_PRODUCT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDREAL,
    "DREAL",
    FALSE,
    FFEINTRIN_familyFVZ,
    FFEINTRIN_impDBLE
  )
DEFSPEC (FFEINTRIN_specDSIND,
    "DSIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specDTAND,
    "DTAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specEOSHIFT,
    "EOSHIFT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specEPSILON,
    "EPSILON",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specERF,
    "ERF",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impERF
  )
DEFSPEC (FFEINTRIN_specERFC,
    "ERFC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impERFC
  )
DEFSPEC (FFEINTRIN_specEXIT,
    "EXIT",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impEXIT
  )
DEFSPEC (FFEINTRIN_specEXPONENT,
    "EXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specFLOATI,
    "FLOATI",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specFLOATJ,
    "FLOATJ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impREAL
  )
DEFSPEC (FFEINTRIN_specFLOOR,
    "FLOOR",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specFLUSH,
    "FLUSH",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impFLUSH
  )
DEFSPEC (FFEINTRIN_specFRACTION,
    "FRACTION",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specGETARG,
    "GETARG",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETARG
  )
DEFSPEC (FFEINTRIN_specGETENV,
    "GETENV",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impGETENV
  )
DEFSPEC (FFEINTRIN_specHUGE,
    "HUGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIACHAR,
    "IACHAR",
    FALSE,
    FFEINTRIN_familyASC,
    FFEINTRIN_impIACHAR
  )
DEFSPEC (FFEINTRIN_specIAND,
    "IAND",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIAND
  )
DEFSPEC (FFEINTRIN_specIARGC,
    "IARGC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impIARGC
  )
DEFSPEC (FFEINTRIN_specIBCLR,
    "IBCLR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBCLR
  )
DEFSPEC (FFEINTRIN_specIBITS,
    "IBITS",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBITS
  )
DEFSPEC (FFEINTRIN_specIBSET,
    "IBSET",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIBSET
  )
DEFSPEC (FFEINTRIN_specIEOR,
    "IEOR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIEOR
  )
DEFSPEC (FFEINTRIN_specIIABS,
    "IIABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIAND,
    "IIAND",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIBCLR,
    "IIBCLR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIBITS,
    "IIBITS",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIBSET,
    "IIBSET",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIDIM,
    "IIDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIDINT,
    "IIDINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIDNNT,
    "IIDNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIEOR,
    "IIEOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIFIX,
    "IIFIX",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIINT,
    "IINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIOR,
    "IIOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIQINT,
    "IIQINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIIQNNT,
    "IIQNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIISHFT,
    "IISHFT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIISHFTC,
    "IISHFTC",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIISIGN,
    "IISIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIMAG,
    "IMAG",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impAIMAG
  )
DEFSPEC (FFEINTRIN_specIMAX0,
    "IMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIMAX1,
    "IMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIMIN0,
    "IMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIMIN1,
    "IMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIMOD,
    "IMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specININT,
    "ININT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specINOT,
    "INOT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specIOR,
    "IOR",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impIOR
  )
DEFSPEC (FFEINTRIN_specISHFT,
    "ISHFT",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impISHFT
  )
DEFSPEC (FFEINTRIN_specISHFTC,
    "ISHFTC",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impISHFTC
  )
DEFSPEC (FFEINTRIN_specIZEXT,
    "IZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specJIABS,
    "JIABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIABS
  )
DEFSPEC (FFEINTRIN_specJIAND,
    "JIAND",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIAND
  )
DEFSPEC (FFEINTRIN_specJIBCLR,
    "JIBCLR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIBCLR
  )
DEFSPEC (FFEINTRIN_specJIBITS,
    "JIBITS",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIBITS
  )
DEFSPEC (FFEINTRIN_specJIBSET,
    "JIBSET",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIBSET
  )
DEFSPEC (FFEINTRIN_specJIDIM,
    "JIDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIDIM
  )
DEFSPEC (FFEINTRIN_specJIDINT,
    "JIDINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specJIDNNT,
    "JIDNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIDNINT
  )
DEFSPEC (FFEINTRIN_specJIEOR,
    "JIEOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIEOR
  )
DEFSPEC (FFEINTRIN_specJIFIX,
    "JIFIX",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specJINT,
    "JINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impINT
  )
DEFSPEC (FFEINTRIN_specJIOR,
    "JIOR",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impIOR
  )
DEFSPEC (FFEINTRIN_specJIQINT,
    "JIQINT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specJIQNNT,
    "JIQNNT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specJISHFT,
    "JISHFT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impISHFT
  )
DEFSPEC (FFEINTRIN_specJISHFTC,
    "JISHFTC",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impISHFTC
  )
DEFSPEC (FFEINTRIN_specJISIGN,
    "JISIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impISIGN
  )
DEFSPEC (FFEINTRIN_specJMAX0,
    "JMAX0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impMAX0
  )
DEFSPEC (FFEINTRIN_specJMAX1,
    "JMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impMAX1
  )
DEFSPEC (FFEINTRIN_specJMIN0,
    "JMIN0",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impMIN0
  )
DEFSPEC (FFEINTRIN_specJMIN1,
    "JMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impMIN1
  )
DEFSPEC (FFEINTRIN_specJMOD,
    "JMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impMOD
  )
DEFSPEC (FFEINTRIN_specJNINT,
    "JNINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNINT
  )
DEFSPEC (FFEINTRIN_specJNOT,
    "JNOT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNOT
  )
DEFSPEC (FFEINTRIN_specJZEXT,
    "JZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specKIND,
    "KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specLBOUND,
    "LBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specLEN_TRIM,
    "LEN_TRIM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specLOC,
    "LOC",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impLOC
  )
DEFSPEC (FFEINTRIN_specLOGICAL,
    "LOGICAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specLSHIFT,
    "LSHIFT",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impLSHIFT
  )
DEFSPEC (FFEINTRIN_specMATMUL,
    "MATMUL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMAXEXPONENT,
    "MAXEXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMAXLOC,
    "MAXLOC",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMAXVAL,
    "MAXVAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMERGE,
    "MERGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMINEXPONENT,
    "MINEXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMINLOC,
    "MINLOC",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMINVAL,
    "MINVAL",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMODULO,
    "MODULO",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specMVBITS,
    "MVBITS",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impMVBITS
  )
DEFSPEC (FFEINTRIN_specNEAREST,
    "NEAREST",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specNOT,
    "NOT",
    FALSE,
    FFEINTRIN_familyMIL,
    FFEINTRIN_impNOT
  )
DEFSPEC (FFEINTRIN_specOR,
    "OR",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impIOR
  )
DEFSPEC (FFEINTRIN_specPACK,
    "PACK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specPRECISION,
    "PRECISION",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specPRESENT,
    "PRESENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specPRODUCT,
    "PRODUCT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQABS,
    "QABS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQACOS,
    "QACOS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQACOSD,
    "QACOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQASIN,
    "QASIN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQASIND,
    "QASIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQATAN,
    "QATAN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQATAN2,
    "QATAN2",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQATAN2D,
    "QATAN2D",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQATAND,
    "QATAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQCOS,
    "QCOS",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQCOSD,
    "QCOSD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQCOSH,
    "QCOSH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQDIM,
    "QDIM",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQEXP,
    "QEXP",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQEXT,
    "QEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQEXTD,
    "QEXTD",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQFLOAT,
    "QFLOAT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQINT,
    "QINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQLOG,
    "QLOG",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQLOG10,
    "QLOG10",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQMAX1,
    "QMAX1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQMIN1,
    "QMIN1",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQMOD,
    "QMOD",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQNINT,
    "QNINT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQSIGN,
    "QSIGN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQSIN,
    "QSIN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQSIND,
    "QSIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQSINH,
    "QSINH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQSQRT,
    "QSQRT",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQTAN,
    "QTAN",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQTAND,
    "QTAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specQTANH,
    "QTANH",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRADIX,
    "RADIX",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRANDOM_NUMBER,
    "RANDOM_NUMBER",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRANDOM_SEED,
    "RANDOM_SEED",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRANGE,
    "RANGE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specREPEAT,
    "REPEAT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRESHAPE,
    "RESHAPE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRRSPACING,
    "RRSPACING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specRSHIFT,
    "RSHIFT",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impRSHIFT
  )
DEFSPEC (FFEINTRIN_specSCALE,
    "SCALE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSCAN,
    "SCAN",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSEL_INT_KIND,
    "SEL_INT_KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSEL_REAL_KIND,
    "SEL_REAL_KIND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSET_EXPONENT,
    "SET_EXPONENT",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSHAPE,
    "SHAPE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSIGNAL,
    "SIGNAL",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSIGNAL
  )
DEFSPEC (FFEINTRIN_specSIND,
    "SIND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSNGLQ,
    "SNGLQ",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSPACING,
    "SPACING",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSPREAD,
    "SPREAD",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSUM,
    "SUM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specSYSTEM,
    "SYSTEM",
    FALSE,
    FFEINTRIN_familyF2U,
    FFEINTRIN_impSYSTEM
  )
DEFSPEC (FFEINTRIN_specSYSTEM_CLOCK,
    "SYSTEM_CLOCK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specTAND,
    "TAND",
    TRUE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specTINY,
    "TINY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specTRANSFER,
    "TRANSFER",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specTRANSPOSE,
    "TRANSPOSE",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specTRIM,
    "TRIM",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specUBOUND,
    "UBOUND",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specUNPACK,
    "UNPACK",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specVERIFY,
    "VERIFY",
    FALSE,
    FFEINTRIN_familyF90,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specXOR,
    "XOR",
    FALSE,
    FFEINTRIN_familyF2C,
    FFEINTRIN_impIEOR
  )
DEFSPEC (FFEINTRIN_specZABS,
    "ZABS",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDABS
  )
DEFSPEC (FFEINTRIN_specZCOS,
    "ZCOS",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDCOS
  )
DEFSPEC (FFEINTRIN_specZEXP,
    "ZEXP",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDEXP
  )
DEFSPEC (FFEINTRIN_specZEXT,
    "ZEXT",
    FALSE,
    FFEINTRIN_familyVXT,
    FFEINTRIN_impNONE
  )
DEFSPEC (FFEINTRIN_specZLOG,
    "ZLOG",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDLOG
  )
DEFSPEC (FFEINTRIN_specZSIN,
    "ZSIN",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDSIN
  )
DEFSPEC (FFEINTRIN_specZSQRT,
    "ZSQRT",
    TRUE,
    FFEINTRIN_familyF2Z,
    FFEINTRIN_impCDSQRT
  )
DEFSPEC (FFEINTRIN_specNONE,
    "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).  */

/* The control string has the following format:

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

   <return-type> is:

     <return-base-type><return-kind-type>

   <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
     0    Decided by COL
     1    (Default)
     2    (COMPLEX*16, INTEGER*1, LOGICAL*1, REAL*8)
     3    (INTEGER*2, LOGICAL*2)
     C    Like 1 (F77), except (F90), if COL is COMPLEX, uses kind type of COL

   <arglist-info> is:

     <COL-spec>

   <COL-spec> is:

     -    No COL
     *    All arguments form COL
     1    Argument 1 forms COL

   <argitem-info> is:

     <name>=[<optionality>]<arg-base-type><arg-kind-type>[<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 may be specified
     n    Numbered names for arguments, one or more may be specified
     p    Like n, but two or more may be specified

   <arg-base-type> is:

     -    Any is valid (but see arg-kind-type)
     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; C mapped to R)

   <arg-kind-type> is:

     0    Any is valid
     1    (Default)
     2    (COMPLEX*16, INTEGER*1, LOGICAL*1, REAL*8)
     3    (INTEGER*2, LOGICAL*2)
     A    Same as first argument
     s    Signal handler (INTEGER FUNCTION, SUBROUTINE or dummy/global
          default INTEGER variable) (arg-base-type * only)

   <arg-extra> is:

     &    Arg can have its address taken (LOC(), for example)
     w    Arg is INTENT(OUT)
     x    Arg is INTENT(INOUT)

*/

DEFIMP	(ABS,		"ABS",		ABS,		"S0:*:A=N0")
DEFIMP	(ACOS,		"ACOS",		ACOS,		"R0:*:X=R0")
DEFIMP	(AIMAG,		"AIMAG",	AIMAG,		"R0:*:Z=C0")
DEFIMP	(AINT,		"AINT",		AINT,		"R0:*:A=R0")
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,		"R0:*:A=R0")
DEFIMP	(ASIN,		"ASIN",		ASIN,		"R0:*:X=R0")
DEFIMP	(ATAN,		"ATAN",		ATAN,		"R0:*:X=R0")
DEFIMP	(ATAN2,		"ATAN2",	ATAN2,		"R0:*:Y=R0,X=R0")
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=I0")
DEFIMQ	(CLOG,		"CLOG",		CLOG,		"C1:-:X=C1",
	LOG)
DEFIMP	(CMPLX,		"CMPLX",	,		"C1:*:X=N0,Y=!S0")
DEFIMP	(CONJG,		"CONJG",	CONJG,		"C0:*:Z=C0")
DEFIMP	(COS,		"COS",		COS,		"F0:*:X=F0")
DEFIMP	(COSH,		"COSH",		COSH,		"R0:*:X=R0")
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=N0")
DEFIMQ	(DCMPLX,	"DCMPLX",	,		"C2:*:X=N0,Y=!S0",
	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,		"S0:*:X=S0,Y=S0")
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,		"F0:*:X=F0")
DEFIMQ	(IABS,		"IABS",		IABS,		"I1:-:A=I1",
	ABS)
DEFIMP	(ICHAR,		"ICHAR",	,		"I1:-:C=A0")
DEFIMQ	(IDIM,		"IDIM",		IDIM,		"I1:*:X=I1,Y=I1",
	DIM)
DEFIMQ	(IDNINT,	"IDNINT",	IDNINT,		"I1:-:A=R2",
	NINT)
DEFIMP	(INDEX,		"INDEX",	INDEX,		"I1:*:String=A0,Substring=A0")
DEFIMP	(INT,		"INT",		,		"I1:-:A=N0")
DEFIMQ	(ISIGN,		"ISIGN",	ISIGN,		"I1:*:A=I1,B=I1",
	SIGN)
DEFIMP	(LEN,		"LEN",		LEN,		"I1:-:String=A0")
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",		,		"F0:*:X=F0")
DEFIMP	(LOG10,		"LOG10",	,		"R0:*:X=R0")
DEFIMP	(MAX,		"MAX",		,		"S0:*:A=pS0")
DEFIMP	(MIN,		"MIN",		,		"S0:*:A=pS0")
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,		"S0:*:A=S0,P=S0")
DEFIMP	(NINT,		"NINT",		NINT,		"I1:-:A=R0")
DEFIMP	(REAL,		"REAL",		,		"RC:*:A=N0")
DEFIMP	(SIGN,		"SIGN",		SIGN,		"S0:*:A=S0,B=S0")
DEFIMP	(SIN,		"SIN",		SIN,		"F0:*:X=F0")
DEFIMP	(SINH,		"SINH",		SINH,		"R0:*:X=R0")
DEFIMP	(SQRT,		"SQRT",		SQRT,		"F0:*:X=F0")
DEFIMP	(TAN,		"TAN",		TAN,		"R0:*:X=R0")
DEFIMP	(TANH,		"TANH",		TANH,		"R0:*:X=R0")

DEFIMP	(ABORT,		"ABORT",	ABORT,		"--:-:")
DEFIMP	(ACHAR,		"ACHAR",	,		"A1:-:I=I0")
DEFIMP	(AND,		"AND",		,		"B0:*:I=B0,J=B0")
DEFIMP	(BIT_SIZE,	"BIT_SIZE",	,		"I0:*:I=I0")
DEFIMP	(BTEST,		"BTEST",	,		"L1:*:I=I0,Pos=I0")
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)
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	(DIMAG,		"DIMAG",	DIMAG,		"R2:-:Z=C2",
	AIMAG)
DEFIMP	(ERF,		"ERF",		ERF,		"R0:-:X=R0")
DEFIMP	(ERFC,		"ERFC",		ERFC,		"R0:-:X=R0")
DEFIMP	(EXIT,		"EXIT",		EXIT,		"--:-:Status=?I0")
DEFIMP	(FLUSH,		"FLUSH",	FLUSH,		"--:-:Unit=?I0")
DEFIMP	(GETARG,	"GETARG",	GETARG,		"--:-:Pos=I0,Value=A1w")
DEFIMP	(GETENV,	"GETENV",	GETENV,		"--:-:Name=A1,Value=A1w")
DEFIMP	(IACHAR,	"IACHAR",	,		"I1:-:C=A0")
DEFIMP	(IAND,		"IAND",		,		"I0:*:I=I0,J=I0")
DEFIMP	(IARGC,		"IARGC",	IARGC,		"I1:-:")
DEFIMP	(IBCLR,		"IBCLR",	,		"I0:1:I=I0,Pos=I0")
DEFIMP	(IBITS,		"IBITS",	,		"I0:1:I=I0,Pos=I0,Len=I0")
DEFIMP	(IBSET,		"IBSET",	,		"I0:1:I=I0,Pos=I0")
DEFIMP	(IEOR,		"IEOR",		,		"I0:*:I=I0,J=I0")
DEFIMP	(IOR,		"IOR",		,		"I0:*:I=I0,J=I0")
DEFIMP	(ISHFT,		"ISHFT",	,		"I0:1:I=I0,Shift=I0")
DEFIMP	(ISHFTC,	"ISHFTC",	,		"I0:1:I=I0,Shift=I0,Size=I0")
DEFIMP	(LOC,		"LOC",		,		"I1:-:Variable=-0&")
DEFIMP	(LSHIFT,	"LSHIFT",	,		"I0:1:I=I0,Shift=I0")
DEFIMP	(MVBITS,	"MVBITS",	,		"--:-:From=I0,FromPos=I0,Len=I0,TO=IAx,ToPos=I0")
DEFIMP	(NOT,		"NOT",		,		"I0:*:I=I0")
DEFIMP	(OR,		"OR",		,		"B0:*:I=B0,J=B0")
DEFIMP	(RSHIFT,	"RSHIFT",	,		"I0:1:I=I0,Shift=I0")
DEFIMP	(SIGNAL,	"SIGNAL",	,		"--:-:Number=I0,Handler=-s")
DEFIMP	(SYSTEM,	"SYSTEM",	,		"--:-:Command=A1,Status=?I1")
DEFIMP	(XOR,		"XOR",		,		"B0:*:I=B0,J=B0")
DEFIMP	(NONE,		"none",		,		"")

