module Hat.PreludeBuiltin (T.Fun(),Bool(True,False),aTrue,aFalse,Char(),Int(),Integer(),Float(),Double() ,IOError(),T.List(T.Cons,T.List),T.aCons,T.aList,IO(),T.Tuple0(T.Tuple0) ,T.aTuple0,T.Tuple2(T.Tuple2),T.aTuple2,T.Tuple3(T.Tuple3),T.aTuple3 ,T.Tuple4(T.Tuple4),T.aTuple4,T.Tuple5(T.Tuple5),T.aTuple5 ,T.Tuple6(T.Tuple6),T.aTuple6,T.Tuple7(T.Tuple7),T.aTuple7 ,T.Tuple8(T.Tuple8),T.aTuple8,T.Tuple9(T.Tuple9),T.aTuple9 ,T.Tuple10(T.Tuple10),T.aTuple10,T.Tuple11(T.Tuple11),T.aTuple11 ,T.Tuple12(T.Tuple12),T.aTuple12,T.Tuple13(T.Tuple13),T.aTuple13 ,T.Tuple14(T.Tuple14),T.aTuple14,T.Tuple15(T.Tuple15),T.aTuple15,String() ,gerror,aerror,herror,gundefined,gseq,aseq,hseq,gisAscii,aisAscii,hisAscii ,gisLatin1,aisLatin1,hisLatin1,gisControl,aisControl,hisControl,gisPrint ,aisPrint,hisPrint,gisSpace,aisSpace,hisSpace,gisUpper,aisUpper,hisUpper ,gisLower,aisLower,hisLower,gisAlpha,aisAlpha,hisAlpha,gisDigit,aisDigit ,hisDigit,gisOctDigit,aisOctDigit,hisOctDigit,gisHexDigit,aisHexDigit ,hisHexDigit,gisAlphaNum,aisAlphaNum,hisAlphaNum,gtoUpper,atoUpper,htoUpper ,gtoLower,atoLower,htoLower,gprimIntToChar,aprimIntToChar,hprimIntToChar ,gprimCharToInt,aprimCharToInt,hprimCharToInt,gprimUnicodeMaxBound ,gprimIntMinBound,gprimIntMaxBound,gprimIntEq,aprimIntEq,hprimIntEq ,gprimIntNe,aprimIntNe,hprimIntNe,gprimIntLt,aprimIntLt,hprimIntLt ,gprimIntLe,aprimIntLe,hprimIntLe,gprimIntGt,aprimIntGt,hprimIntGt ,gprimIntGe,aprimIntGe,hprimIntGe,gprimIntQuot,aprimIntQuot,hprimIntQuot ,gprimIntRem,aprimIntRem,hprimIntRem,gprimIntPlus,aprimIntPlus,hprimIntPlus ,gprimIntMinus,aprimIntMinus,hprimIntMinus,gprimIntTimes,aprimIntTimes ,hprimIntTimes,gprimIntNegate,aprimIntNegate,hprimIntNegate,gprimIntAbs ,aprimIntAbs,hprimIntAbs,gprimIntSignum,aprimIntSignum,hprimIntSignum ,gprimIntegerFromInt,aprimIntegerFromInt,hprimIntegerFromInt ,gprimIntFromInteger,aprimIntFromInteger,hprimIntFromInteger,gprimIntegerEq ,aprimIntegerEq,hprimIntegerEq,gprimIntegerNe,aprimIntegerNe,hprimIntegerNe ,gprimIntegerLt,aprimIntegerLt,hprimIntegerLt,gprimIntegerLe,aprimIntegerLe ,hprimIntegerLe,gprimIntegerGt,aprimIntegerGt,hprimIntegerGt,gprimIntegerGe ,aprimIntegerGe,hprimIntegerGe,gprimIntegerQuot,aprimIntegerQuot ,hprimIntegerQuot,gprimIntegerRem,aprimIntegerRem,hprimIntegerRem ,gprimIntegerQuotRem,aprimIntegerQuotRem,hprimIntegerQuotRem,gprimIntegerAdd ,aprimIntegerAdd,hprimIntegerAdd,gprimIntegerSub,aprimIntegerSub ,hprimIntegerSub,gprimIntegerMul,aprimIntegerMul,hprimIntegerMul ,gprimIntegerNeg,aprimIntegerNeg,hprimIntegerNeg,gprimFloatFromInteger ,aprimFloatFromInteger,hprimFloatFromInteger,gprimFloatRadix,aprimFloatRadix ,hprimFloatRadix,gprimFloatDigits,aprimFloatDigits,hprimFloatDigits ,gprimFloatRange,aprimFloatRange,hprimFloatRange,gprimDecodeFloat ,aprimDecodeFloat,hprimDecodeFloat,gprimEncodeFloat,aprimEncodeFloat ,hprimEncodeFloat,gprimFloatIsNaN,aprimFloatIsNaN,hprimFloatIsNaN ,gprimFloatIsInfinite,aprimFloatIsInfinite,hprimFloatIsInfinite ,gprimFloatIsDenormalized,aprimFloatIsDenormalized,hprimFloatIsDenormalized ,gprimFloatIsNegativeZero,aprimFloatIsNegativeZero,hprimFloatIsNegativeZero ,gprimFloatIsIEEE,aprimFloatIsIEEE,hprimFloatIsIEEE,gprimFloatEq ,aprimFloatEq,hprimFloatEq,gprimFloatNe,aprimFloatNe,hprimFloatNe ,gprimFloatLt,aprimFloatLt,hprimFloatLt,gprimFloatLe,aprimFloatLe ,hprimFloatLe,gprimFloatGt,aprimFloatGt,hprimFloatGt,gprimFloatGe ,aprimFloatGe,hprimFloatGe,gprimFloatPi,gprimFloatExp,aprimFloatExp ,hprimFloatExp,gprimFloatLog,aprimFloatLog,hprimFloatLog,gprimFloatSqrt ,aprimFloatSqrt,hprimFloatSqrt,gprimFloatSin,aprimFloatSin,hprimFloatSin ,gprimFloatCos,aprimFloatCos,hprimFloatCos,gprimFloatTan,aprimFloatTan ,hprimFloatTan,gprimFloatAsin,aprimFloatAsin,hprimFloatAsin,gprimFloatAcos ,aprimFloatAcos,hprimFloatAcos,gprimFloatAtan,aprimFloatAtan,hprimFloatAtan ,gprimFloatDiv,aprimFloatDiv,hprimFloatDiv,gprimFloatAdd,aprimFloatAdd ,hprimFloatAdd,gprimFloatSub,aprimFloatSub,hprimFloatSub,gprimFloatMul ,aprimFloatMul,hprimFloatMul,gprimFloatAbs,aprimFloatAbs,hprimFloatAbs ,gprimFloatSignum,aprimFloatSignum,hprimFloatSignum,gprimDoubleFromInteger ,aprimDoubleFromInteger,hprimDoubleFromInteger,gprimDoubleRadix ,aprimDoubleRadix,hprimDoubleRadix,gprimDoubleDigits,aprimDoubleDigits ,hprimDoubleDigits,gprimDoubleRange,aprimDoubleRange,hprimDoubleRange ,gprimDecodeDouble,aprimDecodeDouble,hprimDecodeDouble,gprimEncodeDouble ,aprimEncodeDouble,hprimEncodeDouble,gprimDoubleIsNaN,aprimDoubleIsNaN ,hprimDoubleIsNaN,gprimDoubleIsInfinite,aprimDoubleIsInfinite ,hprimDoubleIsInfinite,gprimDoubleIsDenormalized,aprimDoubleIsDenormalized ,hprimDoubleIsDenormalized,gprimDoubleIsNegativeZero ,aprimDoubleIsNegativeZero,hprimDoubleIsNegativeZero,gprimDoubleIsIEEE ,aprimDoubleIsIEEE,hprimDoubleIsIEEE,gprimDoubleEq,aprimDoubleEq ,hprimDoubleEq,gprimDoubleNe,aprimDoubleNe,hprimDoubleNe,gprimDoubleLt ,aprimDoubleLt,hprimDoubleLt,gprimDoubleLe,aprimDoubleLe,hprimDoubleLe ,gprimDoubleGt,aprimDoubleGt,hprimDoubleGt,gprimDoubleGe,aprimDoubleGe ,hprimDoubleGe,gprimDoublePi,gprimDoubleExp,aprimDoubleExp,hprimDoubleExp ,gprimDoubleLog,aprimDoubleLog,hprimDoubleLog,gprimDoubleSqrt ,aprimDoubleSqrt,hprimDoubleSqrt,gprimDoubleSin,aprimDoubleSin ,hprimDoubleSin,gprimDoubleCos,aprimDoubleCos,hprimDoubleCos,gprimDoubleTan ,aprimDoubleTan,hprimDoubleTan,gprimDoubleAsin,aprimDoubleAsin ,hprimDoubleAsin,gprimDoubleAcos,aprimDoubleAcos,hprimDoubleAcos ,gprimDoubleAtan,aprimDoubleAtan,hprimDoubleAtan,gprimDoubleDiv ,aprimDoubleDiv,hprimDoubleDiv,gprimDoubleAdd,aprimDoubleAdd,hprimDoubleAdd ,gprimDoubleSub,aprimDoubleSub,hprimDoubleSub,gprimDoubleMul,aprimDoubleMul ,hprimDoubleMul,gprimDoubleAbs,aprimDoubleAbs,hprimDoubleAbs ,gprimDoubleSignum,aprimDoubleSignum,hprimDoubleSignum,gprimIOBind ,aprimIOBind,hprimIOBind,gprimIOReturn,aprimIOReturn,hprimIOReturn,gioError ,aioError,hioError,guserError,auserError,huserError,gcatch,acatch,hcatch ,gputChar,aputChar,hputChar,ggetChar,ggetContents,greadFile,areadFile ,hreadFile,gwriteFile,awriteFile,hwriteFile,gappendFile,aappendFile ,happendFile,gprimIOErrorShow,aprimIOErrorShow,hprimIOErrorShow) where import qualified Prelude import Hat.Hack import qualified Hat.Hat as T import Hat.Hat (WrapVal(wrapVal)) import Hat.PreludeBuiltinTypes import Hat.Hat import qualified Prelude import qualified System.IO.Error import qualified Data.Char as Char gseq :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun a (T.Fun b b)) gseq pseq p = T.ufun2 aseq pseq p hseq hseq z1seq z2seq kseq = T.fromId kseq (Prelude.seq (T.toId kseq z1seq) (T.toId kseq z2seq)) gisAscii :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisAscii pisAscii p = T.ufun1 aisAscii pisAscii p hisAscii hisAscii z1isAscii kisAscii = fromBool kisAscii (Char.isAscii (T.toChar kisAscii z1isAscii)) gisLatin1 :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisLatin1 pisLatin1 p = T.ufun1 aisLatin1 pisLatin1 p hisLatin1 hisLatin1 z1isLatin1 kisLatin1 = fromBool kisLatin1 (Char.isLatin1 (T.toChar kisLatin1 z1isLatin1)) gisControl :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisControl pisControl p = T.ufun1 aisControl pisControl p hisControl hisControl z1isControl kisControl = fromBool kisControl (Char.isControl (T.toChar kisControl z1isControl)) gisPrint :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisPrint pisPrint p = T.ufun1 aisPrint pisPrint p hisPrint hisPrint z1isPrint kisPrint = fromBool kisPrint (Char.isPrint (T.toChar kisPrint z1isPrint)) gisSpace :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisSpace pisSpace p = T.ufun1 aisSpace pisSpace p hisSpace hisSpace z1isSpace kisSpace = fromBool kisSpace (Char.isSpace (T.toChar kisSpace z1isSpace)) gisUpper :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisUpper pisUpper p = T.ufun1 aisUpper pisUpper p hisUpper hisUpper z1isUpper kisUpper = fromBool kisUpper (Char.isUpper (T.toChar kisUpper z1isUpper)) gisLower :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisLower pisLower p = T.ufun1 aisLower pisLower p hisLower hisLower z1isLower kisLower = fromBool kisLower (Char.isLower (T.toChar kisLower z1isLower)) gisAlpha :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisAlpha pisAlpha p = T.ufun1 aisAlpha pisAlpha p hisAlpha hisAlpha z1isAlpha kisAlpha = fromBool kisAlpha (Char.isAlpha (T.toChar kisAlpha z1isAlpha)) gisDigit :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisDigit pisDigit p = T.ufun1 aisDigit pisDigit p hisDigit hisDigit z1isDigit kisDigit = fromBool kisDigit (Char.isDigit (T.toChar kisDigit z1isDigit)) gisOctDigit :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisOctDigit pisOctDigit p = T.ufun1 aisOctDigit pisOctDigit p hisOctDigit hisOctDigit z1isOctDigit kisOctDigit = fromBool kisOctDigit (Char.isOctDigit (T.toChar kisOctDigit z1isOctDigit)) gisHexDigit :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisHexDigit pisHexDigit p = T.ufun1 aisHexDigit pisHexDigit p hisHexDigit hisHexDigit z1isHexDigit kisHexDigit = fromBool kisHexDigit (Char.isHexDigit (T.toChar kisHexDigit z1isHexDigit)) gisAlphaNum :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Bool) gisAlphaNum pisAlphaNum p = T.ufun1 aisAlphaNum pisAlphaNum p hisAlphaNum hisAlphaNum z1isAlphaNum kisAlphaNum = fromBool kisAlphaNum (Char.isAlphaNum (T.toChar kisAlphaNum z1isAlphaNum)) gtoUpper :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Char) gtoUpper ptoUpper p = T.ufun1 atoUpper ptoUpper p htoUpper htoUpper z1toUpper ktoUpper = T.fromChar ktoUpper (Char.toUpper (T.toChar ktoUpper z1toUpper)) gtoLower :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Char) gtoLower ptoLower p = T.ufun1 atoLower ptoLower p htoLower htoLower z1toLower ktoLower = T.fromChar ktoLower (Char.toLower (T.toChar ktoLower z1toLower)) gprimCharToInt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char Int) gprimCharToInt pprimCharToInt p = T.ufun1 aprimCharToInt pprimCharToInt p hprimCharToInt hprimCharToInt z1primCharToInt kprimCharToInt = T.fromInt kprimCharToInt (Char.ord (T.toChar kprimCharToInt z1primCharToInt)) gprimIntToChar :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int Char) gprimIntToChar pprimIntToChar p = T.ufun1 aprimIntToChar pprimIntToChar p hprimIntToChar hprimIntToChar z1primIntToChar kprimIntToChar = T.fromChar kprimIntToChar (Char.chr (T.toInt kprimIntToChar z1primIntToChar)) gprimUnicodeMaxBound :: T.RefSrcPos -> T.RefExp -> T.R Char gprimUnicodeMaxBound pprimUnicodeMaxBound p = T.uconstUse pprimUnicodeMaxBound p sprimUnicodeMaxBound sprimUnicodeMaxBound = T.uconstDef T.mkRoot aprimUnicodeMaxBound (\ p -> T.fromChar p Prelude.maxBound) gprimIntMinBound :: T.RefSrcPos -> T.RefExp -> T.R Int gprimIntMinBound pprimIntMinBound p = T.uconstUse pprimIntMinBound p sprimIntMinBound sprimIntMinBound = T.uconstDef T.mkRoot aprimIntMinBound (\ p -> T.fromInt p Prelude.minBound) gprimIntMaxBound :: T.RefSrcPos -> T.RefExp -> T.R Int gprimIntMaxBound pprimIntMaxBound p = T.uconstUse pprimIntMaxBound p sprimIntMaxBound sprimIntMaxBound = T.uconstDef T.mkRoot aprimIntMaxBound (\ p -> T.fromInt p Prelude.maxBound) gprimIntEq :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntEq pprimIntEq p = T.ufun2 aprimIntEq pprimIntEq p hprimIntEq hprimIntEq z1primIntEq z2primIntEq kprimIntEq = fromBool kprimIntEq ((T.toInt kprimIntEq z1primIntEq) Prelude.== (T.toInt kprimIntEq z2primIntEq)) gprimIntNe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntNe pprimIntNe p = T.ufun2 aprimIntNe pprimIntNe p hprimIntNe hprimIntNe z1primIntNe z2primIntNe kprimIntNe = fromBool kprimIntNe ((T.toInt kprimIntNe z1primIntNe) Prelude./= (T.toInt kprimIntNe z2primIntNe)) gprimIntLt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntLt pprimIntLt p = T.ufun2 aprimIntLt pprimIntLt p hprimIntLt hprimIntLt z1primIntLt z2primIntLt kprimIntLt = fromBool kprimIntLt ((T.toInt kprimIntLt z1primIntLt) Prelude.< (T.toInt kprimIntLt z2primIntLt)) gprimIntLe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntLe pprimIntLe p = T.ufun2 aprimIntLe pprimIntLe p hprimIntLe hprimIntLe z1primIntLe z2primIntLe kprimIntLe = fromBool kprimIntLe ((T.toInt kprimIntLe z1primIntLe) Prelude.<= (T.toInt kprimIntLe z2primIntLe)) gprimIntGt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntGt pprimIntGt p = T.ufun2 aprimIntGt pprimIntGt p hprimIntGt hprimIntGt z1primIntGt z2primIntGt kprimIntGt = fromBool kprimIntGt ((T.toInt kprimIntGt z1primIntGt) Prelude.> (T.toInt kprimIntGt z2primIntGt)) gprimIntGe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Bool)) gprimIntGe pprimIntGe p = T.ufun2 aprimIntGe pprimIntGe p hprimIntGe hprimIntGe z1primIntGe z2primIntGe kprimIntGe = fromBool kprimIntGe ((T.toInt kprimIntGe z1primIntGe) Prelude.>= (T.toInt kprimIntGe z2primIntGe)) gprimIntQuot :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Int)) gprimIntQuot pprimIntQuot p = T.ufun2 aprimIntQuot pprimIntQuot p hprimIntQuot hprimIntQuot z1primIntQuot z2primIntQuot kprimIntQuot = T.fromInt kprimIntQuot (Prelude.quot (T.toInt kprimIntQuot z1primIntQuot) (T.toInt kprimIntQuot z2primIntQuot)) gprimIntRem :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Int)) gprimIntRem pprimIntRem p = T.ufun2 aprimIntRem pprimIntRem p hprimIntRem hprimIntRem z1primIntRem z2primIntRem kprimIntRem = T.fromInt kprimIntRem (Prelude.rem (T.toInt kprimIntRem z1primIntRem) (T.toInt kprimIntRem z2primIntRem)) gprimIntPlus :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Int)) gprimIntPlus pprimIntPlus p = T.ufun2 aprimIntPlus pprimIntPlus p hprimIntPlus hprimIntPlus z1primIntPlus z2primIntPlus kprimIntPlus = T.fromInt kprimIntPlus ((T.toInt kprimIntPlus z1primIntPlus) Prelude.+ (T.toInt kprimIntPlus z2primIntPlus)) gprimIntMinus :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Int)) gprimIntMinus pprimIntMinus p = T.ufun2 aprimIntMinus pprimIntMinus p hprimIntMinus hprimIntMinus z1primIntMinus z2primIntMinus kprimIntMinus = T.fromInt kprimIntMinus ((T.toInt kprimIntMinus z1primIntMinus) Prelude.- (T.toInt kprimIntMinus z2primIntMinus)) gprimIntTimes :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int (T.Fun Int Int)) gprimIntTimes pprimIntTimes p = T.ufun2 aprimIntTimes pprimIntTimes p hprimIntTimes hprimIntTimes z1primIntTimes z2primIntTimes kprimIntTimes = T.fromInt kprimIntTimes ((T.toInt kprimIntTimes z1primIntTimes) Prelude.* (T.toInt kprimIntTimes z2primIntTimes)) gprimIntNegate :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int Int) gprimIntNegate pprimIntNegate p = T.ufun1 aprimIntNegate pprimIntNegate p hprimIntNegate hprimIntNegate z1primIntNegate kprimIntNegate = T.fromInt kprimIntNegate (Prelude.negate (T.toInt kprimIntNegate z1primIntNegate)) gprimIntAbs :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int Int) gprimIntAbs pprimIntAbs p = T.ufun1 aprimIntAbs pprimIntAbs p hprimIntAbs hprimIntAbs z1primIntAbs kprimIntAbs = T.fromInt kprimIntAbs (Prelude.abs (T.toInt kprimIntAbs z1primIntAbs)) gprimIntSignum :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int Int) gprimIntSignum pprimIntSignum p = T.ufun1 aprimIntSignum pprimIntSignum p hprimIntSignum hprimIntSignum z1primIntSignum kprimIntSignum = T.fromInt kprimIntSignum (Prelude.signum (T.toInt kprimIntSignum z1primIntSignum)) gprimIntegerFromInt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Int Integer) gprimIntegerFromInt pprimIntegerFromInt p = T.ufun1 aprimIntegerFromInt pprimIntegerFromInt p hprimIntegerFromInt hprimIntegerFromInt z1primIntegerFromInt kprimIntegerFromInt = T.fromInteger kprimIntegerFromInt (Prelude.toInteger (T.toInt kprimIntegerFromInt z1primIntegerFromInt)) gprimIntFromInteger :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer Int) gprimIntFromInteger pprimIntFromInteger p = T.ufun1 aprimIntFromInteger pprimIntFromInteger p hprimIntFromInteger hprimIntFromInteger z1primIntFromInteger kprimIntFromInteger = T.fromInt kprimIntFromInteger (Prelude.fromInteger (T.toInteger kprimIntFromInteger z1primIntFromInteger)) gprimIntegerEq :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerEq pprimIntegerEq p = T.ufun2 aprimIntegerEq pprimIntegerEq p hprimIntegerEq hprimIntegerEq z1primIntegerEq z2primIntegerEq kprimIntegerEq = fromBool kprimIntegerEq ((T.toInteger kprimIntegerEq z1primIntegerEq) Prelude.== (T.toInteger kprimIntegerEq z2primIntegerEq)) gprimIntegerNe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerNe pprimIntegerNe p = T.ufun2 aprimIntegerNe pprimIntegerNe p hprimIntegerNe hprimIntegerNe z1primIntegerNe z2primIntegerNe kprimIntegerNe = fromBool kprimIntegerNe ((T.toInteger kprimIntegerNe z1primIntegerNe) Prelude./= (T.toInteger kprimIntegerNe z2primIntegerNe)) gprimIntegerLt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerLt pprimIntegerLt p = T.ufun2 aprimIntegerLt pprimIntegerLt p hprimIntegerLt hprimIntegerLt z1primIntegerLt z2primIntegerLt kprimIntegerLt = fromBool kprimIntegerLt ((T.toInteger kprimIntegerLt z1primIntegerLt) Prelude.< (T.toInteger kprimIntegerLt z2primIntegerLt)) gprimIntegerLe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerLe pprimIntegerLe p = T.ufun2 aprimIntegerLe pprimIntegerLe p hprimIntegerLe hprimIntegerLe z1primIntegerLe z2primIntegerLe kprimIntegerLe = fromBool kprimIntegerLe ((T.toInteger kprimIntegerLe z1primIntegerLe) Prelude.<= (T.toInteger kprimIntegerLe z2primIntegerLe)) gprimIntegerGt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerGt pprimIntegerGt p = T.ufun2 aprimIntegerGt pprimIntegerGt p hprimIntegerGt hprimIntegerGt z1primIntegerGt z2primIntegerGt kprimIntegerGt = fromBool kprimIntegerGt ((T.toInteger kprimIntegerGt z1primIntegerGt) Prelude.> (T.toInteger kprimIntegerGt z2primIntegerGt)) gprimIntegerGe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Bool)) gprimIntegerGe pprimIntegerGe p = T.ufun2 aprimIntegerGe pprimIntegerGe p hprimIntegerGe hprimIntegerGe z1primIntegerGe z2primIntegerGe kprimIntegerGe = fromBool kprimIntegerGe ((T.toInteger kprimIntegerGe z1primIntegerGe) Prelude.>= (T.toInteger kprimIntegerGe z2primIntegerGe)) gprimIntegerQuot :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Integer)) gprimIntegerQuot pprimIntegerQuot p = T.ufun2 aprimIntegerQuot pprimIntegerQuot p hprimIntegerQuot hprimIntegerQuot z1primIntegerQuot z2primIntegerQuot kprimIntegerQuot = T.fromInteger kprimIntegerQuot (Prelude.quot (T.toInteger kprimIntegerQuot z1primIntegerQuot) (T.toInteger kprimIntegerQuot z2primIntegerQuot)) gprimIntegerRem :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Integer)) gprimIntegerRem pprimIntegerRem p = T.ufun2 aprimIntegerRem pprimIntegerRem p hprimIntegerRem hprimIntegerRem z1primIntegerRem z2primIntegerRem kprimIntegerRem = T.fromInteger kprimIntegerRem (Prelude.rem (T.toInteger kprimIntegerRem z1primIntegerRem) (T.toInteger kprimIntegerRem z2primIntegerRem)) gprimIntegerQuotRem :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer (T.Tuple2 Integer Integer))) gprimIntegerQuotRem pprimIntegerQuotRem p = T.ufun2 aprimIntegerQuotRem pprimIntegerQuotRem p hprimIntegerQuotRem hprimIntegerQuotRem z1primIntegerQuotRem z2primIntegerQuotRem kprimIntegerQuotRem = (T.fromTuple2 T.fromInteger T.fromInteger) kprimIntegerQuotRem (Prelude.quotRem (T.toInteger kprimIntegerQuotRem z1primIntegerQuotRem) (T.toInteger kprimIntegerQuotRem z2primIntegerQuotRem)) gprimIntegerAdd :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Integer)) gprimIntegerAdd pprimIntegerAdd p = T.ufun2 aprimIntegerAdd pprimIntegerAdd p hprimIntegerAdd hprimIntegerAdd z1primIntegerAdd z2primIntegerAdd kprimIntegerAdd = T.fromInteger kprimIntegerAdd ((T.toInteger kprimIntegerAdd z1primIntegerAdd) Prelude.+ (T.toInteger kprimIntegerAdd z2primIntegerAdd)) gprimIntegerSub :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Integer)) gprimIntegerSub pprimIntegerSub p = T.ufun2 aprimIntegerSub pprimIntegerSub p hprimIntegerSub hprimIntegerSub z1primIntegerSub z2primIntegerSub kprimIntegerSub = T.fromInteger kprimIntegerSub ((T.toInteger kprimIntegerSub z1primIntegerSub) Prelude.- (T.toInteger kprimIntegerSub z2primIntegerSub)) gprimIntegerMul :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Integer Integer)) gprimIntegerMul pprimIntegerMul p = T.ufun2 aprimIntegerMul pprimIntegerMul p hprimIntegerMul hprimIntegerMul z1primIntegerMul z2primIntegerMul kprimIntegerMul = T.fromInteger kprimIntegerMul ((T.toInteger kprimIntegerMul z1primIntegerMul) Prelude.* (T.toInteger kprimIntegerMul z2primIntegerMul)) gprimIntegerNeg :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer Integer) gprimIntegerNeg pprimIntegerNeg p = T.ufun1 aprimIntegerNeg pprimIntegerNeg p hprimIntegerNeg hprimIntegerNeg z1primIntegerNeg kprimIntegerNeg = T.fromInteger kprimIntegerNeg (Prelude.negate (T.toInteger kprimIntegerNeg z1primIntegerNeg)) gprimFloatFromInteger :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer Float) gprimFloatFromInteger pprimFloatFromInteger p = T.ufun1 aprimFloatFromInteger pprimFloatFromInteger p hprimFloatFromInteger hprimFloatFromInteger z1primFloatFromInteger kprimFloatFromInteger = T.fromFloat kprimFloatFromInteger (Prelude.fromInteger (T.toInteger kprimFloatFromInteger z1primFloatFromInteger)) gprimFloatRadix :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Integer) gprimFloatRadix pprimFloatRadix p = T.ufun1 aprimFloatRadix pprimFloatRadix p hprimFloatRadix hprimFloatRadix z1primFloatRadix kprimFloatRadix = T.fromInteger kprimFloatRadix (Prelude.floatRadix (T.toFloat kprimFloatRadix z1primFloatRadix)) gprimFloatDigits :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Int) gprimFloatDigits pprimFloatDigits p = T.ufun1 aprimFloatDigits pprimFloatDigits p hprimFloatDigits hprimFloatDigits z1primFloatDigits kprimFloatDigits = T.fromInt kprimFloatDigits (Prelude.floatDigits (T.toFloat kprimFloatDigits z1primFloatDigits)) gprimFloatRange :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Tuple2 Int Int)) gprimFloatRange pprimFloatRange p = T.ufun1 aprimFloatRange pprimFloatRange p hprimFloatRange hprimFloatRange z1primFloatRange kprimFloatRange = (T.fromTuple2 T.fromInt T.fromInt) kprimFloatRange (Prelude.floatRange (T.toFloat kprimFloatRange z1primFloatRange)) gprimDecodeFloat :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Tuple2 Integer Int)) gprimDecodeFloat pprimDecodeFloat p = T.ufun1 aprimDecodeFloat pprimDecodeFloat p hprimDecodeFloat hprimDecodeFloat z1primDecodeFloat kprimDecodeFloat = (T.fromTuple2 T.fromInteger T.fromInt) kprimDecodeFloat (Prelude.decodeFloat (T.toFloat kprimDecodeFloat z1primDecodeFloat)) gprimEncodeFloat :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Int Float)) gprimEncodeFloat pprimEncodeFloat p = T.ufun2 aprimEncodeFloat pprimEncodeFloat p hprimEncodeFloat hprimEncodeFloat z1primEncodeFloat z2primEncodeFloat kprimEncodeFloat = T.fromFloat kprimEncodeFloat (Prelude.encodeFloat (T.toInteger kprimEncodeFloat z1primEncodeFloat) (T.toInt kprimEncodeFloat z2primEncodeFloat)) gprimFloatIsNaN :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Bool) gprimFloatIsNaN pprimFloatIsNaN p = T.ufun1 aprimFloatIsNaN pprimFloatIsNaN p hprimFloatIsNaN hprimFloatIsNaN z1primFloatIsNaN kprimFloatIsNaN = fromBool kprimFloatIsNaN (Prelude.isNaN (T.toFloat kprimFloatIsNaN z1primFloatIsNaN)) gprimFloatIsInfinite :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Bool) gprimFloatIsInfinite pprimFloatIsInfinite p = T.ufun1 aprimFloatIsInfinite pprimFloatIsInfinite p hprimFloatIsInfinite hprimFloatIsInfinite z1primFloatIsInfinite kprimFloatIsInfinite = fromBool kprimFloatIsInfinite (Prelude.isInfinite (T.toFloat kprimFloatIsInfinite z1primFloatIsInfinite)) gprimFloatIsDenormalized :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Bool) gprimFloatIsDenormalized pprimFloatIsDenormalized p = T.ufun1 aprimFloatIsDenormalized pprimFloatIsDenormalized p hprimFloatIsDenormalized hprimFloatIsDenormalized z1primFloatIsDenormalized kprimFloatIsDenormalized = fromBool kprimFloatIsDenormalized (Prelude.isDenormalized (T.toFloat kprimFloatIsDenormalized z1primFloatIsDenormalized)) gprimFloatIsNegativeZero :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Bool) gprimFloatIsNegativeZero pprimFloatIsNegativeZero p = T.ufun1 aprimFloatIsNegativeZero pprimFloatIsNegativeZero p hprimFloatIsNegativeZero hprimFloatIsNegativeZero z1primFloatIsNegativeZero kprimFloatIsNegativeZero = fromBool kprimFloatIsNegativeZero (Prelude.isNegativeZero (T.toFloat kprimFloatIsNegativeZero z1primFloatIsNegativeZero)) gprimFloatIsIEEE :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Bool) gprimFloatIsIEEE pprimFloatIsIEEE p = T.ufun1 aprimFloatIsIEEE pprimFloatIsIEEE p hprimFloatIsIEEE hprimFloatIsIEEE z1primFloatIsIEEE kprimFloatIsIEEE = fromBool kprimFloatIsIEEE (Prelude.isIEEE (T.toFloat kprimFloatIsIEEE z1primFloatIsIEEE)) gprimFloatEq :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatEq pprimFloatEq p = T.ufun2 aprimFloatEq pprimFloatEq p hprimFloatEq hprimFloatEq z1primFloatEq z2primFloatEq kprimFloatEq = fromBool kprimFloatEq ((T.toFloat kprimFloatEq z1primFloatEq) Prelude.== (T.toFloat kprimFloatEq z2primFloatEq)) gprimFloatNe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatNe pprimFloatNe p = T.ufun2 aprimFloatNe pprimFloatNe p hprimFloatNe hprimFloatNe z1primFloatNe z2primFloatNe kprimFloatNe = fromBool kprimFloatNe ((T.toFloat kprimFloatNe z1primFloatNe) Prelude./= (T.toFloat kprimFloatNe z2primFloatNe)) gprimFloatLt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatLt pprimFloatLt p = T.ufun2 aprimFloatLt pprimFloatLt p hprimFloatLt hprimFloatLt z1primFloatLt z2primFloatLt kprimFloatLt = fromBool kprimFloatLt ((T.toFloat kprimFloatLt z1primFloatLt) Prelude.< (T.toFloat kprimFloatLt z2primFloatLt)) gprimFloatLe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatLe pprimFloatLe p = T.ufun2 aprimFloatLe pprimFloatLe p hprimFloatLe hprimFloatLe z1primFloatLe z2primFloatLe kprimFloatLe = fromBool kprimFloatLe ((T.toFloat kprimFloatLe z1primFloatLe) Prelude.<= (T.toFloat kprimFloatLe z2primFloatLe)) gprimFloatGt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatGt pprimFloatGt p = T.ufun2 aprimFloatGt pprimFloatGt p hprimFloatGt hprimFloatGt z1primFloatGt z2primFloatGt kprimFloatGt = fromBool kprimFloatGt ((T.toFloat kprimFloatGt z1primFloatGt) Prelude.> (T.toFloat kprimFloatGt z2primFloatGt)) gprimFloatGe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Bool)) gprimFloatGe pprimFloatGe p = T.ufun2 aprimFloatGe pprimFloatGe p hprimFloatGe hprimFloatGe z1primFloatGe z2primFloatGe kprimFloatGe = fromBool kprimFloatGe ((T.toFloat kprimFloatGe z1primFloatGe) Prelude.>= (T.toFloat kprimFloatGe z2primFloatGe)) gprimFloatPi :: T.RefSrcPos -> T.RefExp -> T.R Float gprimFloatPi pprimFloatPi p = T.uconstUse pprimFloatPi p sprimFloatPi sprimFloatPi = T.uconstDef T.mkRoot aprimFloatPi (\ p -> T.fromFloat p Prelude.pi) gprimFloatExp :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatExp pprimFloatExp p = T.ufun1 aprimFloatExp pprimFloatExp p hprimFloatExp hprimFloatExp z1primFloatExp kprimFloatExp = T.fromFloat kprimFloatExp (Prelude.exp (T.toFloat kprimFloatExp z1primFloatExp)) gprimFloatLog :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatLog pprimFloatLog p = T.ufun1 aprimFloatLog pprimFloatLog p hprimFloatLog hprimFloatLog z1primFloatLog kprimFloatLog = T.fromFloat kprimFloatLog (Prelude.log (T.toFloat kprimFloatLog z1primFloatLog)) gprimFloatSqrt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatSqrt pprimFloatSqrt p = T.ufun1 aprimFloatSqrt pprimFloatSqrt p hprimFloatSqrt hprimFloatSqrt z1primFloatSqrt kprimFloatSqrt = T.fromFloat kprimFloatSqrt (Prelude.sqrt (T.toFloat kprimFloatSqrt z1primFloatSqrt)) gprimFloatSin :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatSin pprimFloatSin p = T.ufun1 aprimFloatSin pprimFloatSin p hprimFloatSin hprimFloatSin z1primFloatSin kprimFloatSin = T.fromFloat kprimFloatSin (Prelude.sin (T.toFloat kprimFloatSin z1primFloatSin)) gprimFloatCos :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatCos pprimFloatCos p = T.ufun1 aprimFloatCos pprimFloatCos p hprimFloatCos hprimFloatCos z1primFloatCos kprimFloatCos = T.fromFloat kprimFloatCos (Prelude.cos (T.toFloat kprimFloatCos z1primFloatCos)) gprimFloatTan :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatTan pprimFloatTan p = T.ufun1 aprimFloatTan pprimFloatTan p hprimFloatTan hprimFloatTan z1primFloatTan kprimFloatTan = T.fromFloat kprimFloatTan (Prelude.tan (T.toFloat kprimFloatTan z1primFloatTan)) gprimFloatAsin :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatAsin pprimFloatAsin p = T.ufun1 aprimFloatAsin pprimFloatAsin p hprimFloatAsin hprimFloatAsin z1primFloatAsin kprimFloatAsin = T.fromFloat kprimFloatAsin (Prelude.asin (T.toFloat kprimFloatAsin z1primFloatAsin)) gprimFloatAcos :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatAcos pprimFloatAcos p = T.ufun1 aprimFloatAcos pprimFloatAcos p hprimFloatAcos hprimFloatAcos z1primFloatAcos kprimFloatAcos = T.fromFloat kprimFloatAcos (Prelude.acos (T.toFloat kprimFloatAcos z1primFloatAcos)) gprimFloatAtan :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatAtan pprimFloatAtan p = T.ufun1 aprimFloatAtan pprimFloatAtan p hprimFloatAtan hprimFloatAtan z1primFloatAtan kprimFloatAtan = T.fromFloat kprimFloatAtan (Prelude.atan (T.toFloat kprimFloatAtan z1primFloatAtan)) gprimFloatDiv :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Float)) gprimFloatDiv pprimFloatDiv p = T.ufun2 aprimFloatDiv pprimFloatDiv p hprimFloatDiv hprimFloatDiv z1primFloatDiv z2primFloatDiv kprimFloatDiv = T.fromFloat kprimFloatDiv ((T.toFloat kprimFloatDiv z1primFloatDiv) Prelude./ (T.toFloat kprimFloatDiv z2primFloatDiv)) gprimFloatAdd :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Float)) gprimFloatAdd pprimFloatAdd p = T.ufun2 aprimFloatAdd pprimFloatAdd p hprimFloatAdd hprimFloatAdd z1primFloatAdd z2primFloatAdd kprimFloatAdd = T.fromFloat kprimFloatAdd ((T.toFloat kprimFloatAdd z1primFloatAdd) Prelude.+ (T.toFloat kprimFloatAdd z2primFloatAdd)) gprimFloatSub :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Float)) gprimFloatSub pprimFloatSub p = T.ufun2 aprimFloatSub pprimFloatSub p hprimFloatSub hprimFloatSub z1primFloatSub z2primFloatSub kprimFloatSub = T.fromFloat kprimFloatSub ((T.toFloat kprimFloatSub z1primFloatSub) Prelude.- (T.toFloat kprimFloatSub z2primFloatSub)) gprimFloatMul :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float (T.Fun Float Float)) gprimFloatMul pprimFloatMul p = T.ufun2 aprimFloatMul pprimFloatMul p hprimFloatMul hprimFloatMul z1primFloatMul z2primFloatMul kprimFloatMul = T.fromFloat kprimFloatMul ((T.toFloat kprimFloatMul z1primFloatMul) Prelude.* (T.toFloat kprimFloatMul z2primFloatMul)) gprimFloatAbs :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatAbs pprimFloatAbs p = T.ufun1 aprimFloatAbs pprimFloatAbs p hprimFloatAbs hprimFloatAbs z1primFloatAbs kprimFloatAbs = T.fromFloat kprimFloatAbs (Prelude.abs (T.toFloat kprimFloatAbs z1primFloatAbs)) gprimFloatSignum :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Float Float) gprimFloatSignum pprimFloatSignum p = T.ufun1 aprimFloatSignum pprimFloatSignum p hprimFloatSignum hprimFloatSignum z1primFloatSignum kprimFloatSignum = T.fromFloat kprimFloatSignum (Prelude.signum (T.toFloat kprimFloatSignum z1primFloatSignum)) gprimDoubleFromInteger :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer Double) gprimDoubleFromInteger pprimDoubleFromInteger p = T.ufun1 aprimDoubleFromInteger pprimDoubleFromInteger p hprimDoubleFromInteger hprimDoubleFromInteger z1primDoubleFromInteger kprimDoubleFromInteger = T.fromDouble kprimDoubleFromInteger (Prelude.fromInteger (T.toInteger kprimDoubleFromInteger z1primDoubleFromInteger)) gprimDoubleRadix :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Integer) gprimDoubleRadix pprimDoubleRadix p = T.ufun1 aprimDoubleRadix pprimDoubleRadix p hprimDoubleRadix hprimDoubleRadix z1primDoubleRadix kprimDoubleRadix = T.fromInteger kprimDoubleRadix (Prelude.floatRadix (T.toDouble kprimDoubleRadix z1primDoubleRadix)) gprimDoubleDigits :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Int) gprimDoubleDigits pprimDoubleDigits p = T.ufun1 aprimDoubleDigits pprimDoubleDigits p hprimDoubleDigits hprimDoubleDigits z1primDoubleDigits kprimDoubleDigits = T.fromInt kprimDoubleDigits (Prelude.floatDigits (T.toDouble kprimDoubleDigits z1primDoubleDigits)) gprimDoubleRange :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Tuple2 Int Int)) gprimDoubleRange pprimDoubleRange p = T.ufun1 aprimDoubleRange pprimDoubleRange p hprimDoubleRange hprimDoubleRange z1primDoubleRange kprimDoubleRange = (T.fromTuple2 T.fromInt T.fromInt) kprimDoubleRange (Prelude.floatRange (T.toDouble kprimDoubleRange z1primDoubleRange)) gprimDecodeDouble :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Tuple2 Integer Int)) gprimDecodeDouble pprimDecodeDouble p = T.ufun1 aprimDecodeDouble pprimDecodeDouble p hprimDecodeDouble hprimDecodeDouble z1primDecodeDouble kprimDecodeDouble = (T.fromTuple2 T.fromInteger T.fromInt) kprimDecodeDouble (Prelude.decodeFloat (T.toDouble kprimDecodeDouble z1primDecodeDouble)) gprimEncodeDouble :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Integer (T.Fun Int Double)) gprimEncodeDouble pprimEncodeDouble p = T.ufun2 aprimEncodeDouble pprimEncodeDouble p hprimEncodeDouble hprimEncodeDouble z1primEncodeDouble z2primEncodeDouble kprimEncodeDouble = T.fromDouble kprimEncodeDouble (Prelude.encodeFloat (T.toInteger kprimEncodeDouble z1primEncodeDouble) (T.toInt kprimEncodeDouble z2primEncodeDouble)) gprimDoubleIsNaN :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Bool) gprimDoubleIsNaN pprimDoubleIsNaN p = T.ufun1 aprimDoubleIsNaN pprimDoubleIsNaN p hprimDoubleIsNaN hprimDoubleIsNaN z1primDoubleIsNaN kprimDoubleIsNaN = fromBool kprimDoubleIsNaN (Prelude.isNaN (T.toDouble kprimDoubleIsNaN z1primDoubleIsNaN)) gprimDoubleIsInfinite :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Bool) gprimDoubleIsInfinite pprimDoubleIsInfinite p = T.ufun1 aprimDoubleIsInfinite pprimDoubleIsInfinite p hprimDoubleIsInfinite hprimDoubleIsInfinite z1primDoubleIsInfinite kprimDoubleIsInfinite = fromBool kprimDoubleIsInfinite (Prelude.isInfinite (T.toDouble kprimDoubleIsInfinite z1primDoubleIsInfinite)) gprimDoubleIsDenormalized :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Bool) gprimDoubleIsDenormalized pprimDoubleIsDenormalized p = T.ufun1 aprimDoubleIsDenormalized pprimDoubleIsDenormalized p hprimDoubleIsDenormalized hprimDoubleIsDenormalized z1primDoubleIsDenormalized kprimDoubleIsDenormalized = fromBool kprimDoubleIsDenormalized (Prelude.isDenormalized (T.toDouble kprimDoubleIsDenormalized z1primDoubleIsDenormalized)) gprimDoubleIsNegativeZero :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Bool) gprimDoubleIsNegativeZero pprimDoubleIsNegativeZero p = T.ufun1 aprimDoubleIsNegativeZero pprimDoubleIsNegativeZero p hprimDoubleIsNegativeZero hprimDoubleIsNegativeZero z1primDoubleIsNegativeZero kprimDoubleIsNegativeZero = fromBool kprimDoubleIsNegativeZero (Prelude.isNegativeZero (T.toDouble kprimDoubleIsNegativeZero z1primDoubleIsNegativeZero)) gprimDoubleIsIEEE :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Bool) gprimDoubleIsIEEE pprimDoubleIsIEEE p = T.ufun1 aprimDoubleIsIEEE pprimDoubleIsIEEE p hprimDoubleIsIEEE hprimDoubleIsIEEE z1primDoubleIsIEEE kprimDoubleIsIEEE = fromBool kprimDoubleIsIEEE (Prelude.isIEEE (T.toDouble kprimDoubleIsIEEE z1primDoubleIsIEEE)) gprimDoubleEq :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleEq pprimDoubleEq p = T.ufun2 aprimDoubleEq pprimDoubleEq p hprimDoubleEq hprimDoubleEq z1primDoubleEq z2primDoubleEq kprimDoubleEq = fromBool kprimDoubleEq ((T.toDouble kprimDoubleEq z1primDoubleEq) Prelude.== (T.toDouble kprimDoubleEq z2primDoubleEq)) gprimDoubleNe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleNe pprimDoubleNe p = T.ufun2 aprimDoubleNe pprimDoubleNe p hprimDoubleNe hprimDoubleNe z1primDoubleNe z2primDoubleNe kprimDoubleNe = fromBool kprimDoubleNe ((T.toDouble kprimDoubleNe z1primDoubleNe) Prelude./= (T.toDouble kprimDoubleNe z2primDoubleNe)) gprimDoubleLt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleLt pprimDoubleLt p = T.ufun2 aprimDoubleLt pprimDoubleLt p hprimDoubleLt hprimDoubleLt z1primDoubleLt z2primDoubleLt kprimDoubleLt = fromBool kprimDoubleLt ((T.toDouble kprimDoubleLt z1primDoubleLt) Prelude.< (T.toDouble kprimDoubleLt z2primDoubleLt)) gprimDoubleLe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleLe pprimDoubleLe p = T.ufun2 aprimDoubleLe pprimDoubleLe p hprimDoubleLe hprimDoubleLe z1primDoubleLe z2primDoubleLe kprimDoubleLe = fromBool kprimDoubleLe ((T.toDouble kprimDoubleLe z1primDoubleLe) Prelude.<= (T.toDouble kprimDoubleLe z2primDoubleLe)) gprimDoubleGt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleGt pprimDoubleGt p = T.ufun2 aprimDoubleGt pprimDoubleGt p hprimDoubleGt hprimDoubleGt z1primDoubleGt z2primDoubleGt kprimDoubleGt = fromBool kprimDoubleGt ((T.toDouble kprimDoubleGt z1primDoubleGt) Prelude.> (T.toDouble kprimDoubleGt z2primDoubleGt)) gprimDoubleGe :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Bool)) gprimDoubleGe pprimDoubleGe p = T.ufun2 aprimDoubleGe pprimDoubleGe p hprimDoubleGe hprimDoubleGe z1primDoubleGe z2primDoubleGe kprimDoubleGe = fromBool kprimDoubleGe ((T.toDouble kprimDoubleGe z1primDoubleGe) Prelude.>= (T.toDouble kprimDoubleGe z2primDoubleGe)) gprimDoublePi :: T.RefSrcPos -> T.RefExp -> T.R Double gprimDoublePi pprimDoublePi p = T.uconstUse pprimDoublePi p sprimDoublePi sprimDoublePi = T.uconstDef T.mkRoot aprimDoublePi (\ p -> T.fromDouble p Prelude.pi) gprimDoubleExp :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleExp pprimDoubleExp p = T.ufun1 aprimDoubleExp pprimDoubleExp p hprimDoubleExp hprimDoubleExp z1primDoubleExp kprimDoubleExp = T.fromDouble kprimDoubleExp (Prelude.exp (T.toDouble kprimDoubleExp z1primDoubleExp)) gprimDoubleLog :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleLog pprimDoubleLog p = T.ufun1 aprimDoubleLog pprimDoubleLog p hprimDoubleLog hprimDoubleLog z1primDoubleLog kprimDoubleLog = T.fromDouble kprimDoubleLog (Prelude.log (T.toDouble kprimDoubleLog z1primDoubleLog)) gprimDoubleSqrt :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleSqrt pprimDoubleSqrt p = T.ufun1 aprimDoubleSqrt pprimDoubleSqrt p hprimDoubleSqrt hprimDoubleSqrt z1primDoubleSqrt kprimDoubleSqrt = T.fromDouble kprimDoubleSqrt (Prelude.sqrt (T.toDouble kprimDoubleSqrt z1primDoubleSqrt)) gprimDoubleSin :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleSin pprimDoubleSin p = T.ufun1 aprimDoubleSin pprimDoubleSin p hprimDoubleSin hprimDoubleSin z1primDoubleSin kprimDoubleSin = T.fromDouble kprimDoubleSin (Prelude.sin (T.toDouble kprimDoubleSin z1primDoubleSin)) gprimDoubleCos :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleCos pprimDoubleCos p = T.ufun1 aprimDoubleCos pprimDoubleCos p hprimDoubleCos hprimDoubleCos z1primDoubleCos kprimDoubleCos = T.fromDouble kprimDoubleCos (Prelude.cos (T.toDouble kprimDoubleCos z1primDoubleCos)) gprimDoubleTan :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleTan pprimDoubleTan p = T.ufun1 aprimDoubleTan pprimDoubleTan p hprimDoubleTan hprimDoubleTan z1primDoubleTan kprimDoubleTan = T.fromDouble kprimDoubleTan (Prelude.tan (T.toDouble kprimDoubleTan z1primDoubleTan)) gprimDoubleAsin :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleAsin pprimDoubleAsin p = T.ufun1 aprimDoubleAsin pprimDoubleAsin p hprimDoubleAsin hprimDoubleAsin z1primDoubleAsin kprimDoubleAsin = T.fromDouble kprimDoubleAsin (Prelude.asin (T.toDouble kprimDoubleAsin z1primDoubleAsin)) gprimDoubleAcos :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleAcos pprimDoubleAcos p = T.ufun1 aprimDoubleAcos pprimDoubleAcos p hprimDoubleAcos hprimDoubleAcos z1primDoubleAcos kprimDoubleAcos = T.fromDouble kprimDoubleAcos (Prelude.acos (T.toDouble kprimDoubleAcos z1primDoubleAcos)) gprimDoubleAtan :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleAtan pprimDoubleAtan p = T.ufun1 aprimDoubleAtan pprimDoubleAtan p hprimDoubleAtan hprimDoubleAtan z1primDoubleAtan kprimDoubleAtan = T.fromDouble kprimDoubleAtan (Prelude.atan (T.toDouble kprimDoubleAtan z1primDoubleAtan)) gprimDoubleDiv :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Double)) gprimDoubleDiv pprimDoubleDiv p = T.ufun2 aprimDoubleDiv pprimDoubleDiv p hprimDoubleDiv hprimDoubleDiv z1primDoubleDiv z2primDoubleDiv kprimDoubleDiv = T.fromDouble kprimDoubleDiv ((T.toDouble kprimDoubleDiv z1primDoubleDiv) Prelude./ (T.toDouble kprimDoubleDiv z2primDoubleDiv)) gprimDoubleAdd :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Double)) gprimDoubleAdd pprimDoubleAdd p = T.ufun2 aprimDoubleAdd pprimDoubleAdd p hprimDoubleAdd hprimDoubleAdd z1primDoubleAdd z2primDoubleAdd kprimDoubleAdd = T.fromDouble kprimDoubleAdd ((T.toDouble kprimDoubleAdd z1primDoubleAdd) Prelude.+ (T.toDouble kprimDoubleAdd z2primDoubleAdd)) gprimDoubleSub :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Double)) gprimDoubleSub pprimDoubleSub p = T.ufun2 aprimDoubleSub pprimDoubleSub p hprimDoubleSub hprimDoubleSub z1primDoubleSub z2primDoubleSub kprimDoubleSub = T.fromDouble kprimDoubleSub ((T.toDouble kprimDoubleSub z1primDoubleSub) Prelude.- (T.toDouble kprimDoubleSub z2primDoubleSub)) gprimDoubleMul :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double (T.Fun Double Double)) gprimDoubleMul pprimDoubleMul p = T.ufun2 aprimDoubleMul pprimDoubleMul p hprimDoubleMul hprimDoubleMul z1primDoubleMul z2primDoubleMul kprimDoubleMul = T.fromDouble kprimDoubleMul ((T.toDouble kprimDoubleMul z1primDoubleMul) Prelude.* (T.toDouble kprimDoubleMul z2primDoubleMul)) gprimDoubleAbs :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleAbs pprimDoubleAbs p = T.ufun1 aprimDoubleAbs pprimDoubleAbs p hprimDoubleAbs hprimDoubleAbs z1primDoubleAbs kprimDoubleAbs = T.fromDouble kprimDoubleAbs (Prelude.abs (T.toDouble kprimDoubleAbs z1primDoubleAbs)) gprimDoubleSignum :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Double Double) gprimDoubleSignum pprimDoubleSignum p = T.ufun1 aprimDoubleSignum pprimDoubleSignum p hprimDoubleSignum hprimDoubleSignum z1primDoubleSignum kprimDoubleSignum = T.fromDouble kprimDoubleSignum (Prelude.signum (T.toDouble kprimDoubleSignum z1primDoubleSignum)) gprimIOBind :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun (IO a) (T.Fun (T.Fun a (IO b)) (IO b))) gprimIOBind pprimIOBind p = T.ufun2 aprimIOBind pprimIOBind p hprimIOBind hprimIOBind z1primIOBind z2primIOBind kprimIOBind = (T.fromIO T.fromId) kprimIOBind (((T.toIO T.toId) kprimIOBind z1primIOBind) Prelude.>>= ((toFun T.fromId (T.toIO T.toId)) kprimIOBind z2primIOBind)) gprimIOReturn :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun a (IO a)) gprimIOReturn pprimIOReturn p = T.ufun1 aprimIOReturn pprimIOReturn p hprimIOReturn hprimIOReturn z1primIOReturn kprimIOReturn = (T.fromIO T.fromId) kprimIOReturn (Prelude.return (T.toId kprimIOReturn z1primIOReturn)) gprimIOErrorShow :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun IOError String) gprimIOErrorShow pprimIOErrorShow p = T.ufun1 aprimIOErrorShow pprimIOErrorShow p hprimIOErrorShow hprimIOErrorShow z1primIOErrorShow kprimIOErrorShow = fromString kprimIOErrorShow (Prelude.show (toIOError kprimIOErrorShow z1primIOErrorShow)) gioError :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun IOError (IO a)) gioError pioError p = T.ufun1 aioError pioError p hioError hioError z1ioError kioError = (T.fromIO T.fromId) kioError (Prelude.ioError (toIOError kioError z1ioError)) guserError :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun String IOError) guserError puserError p = T.ufun1 auserError puserError p huserError huserError z1userError kuserError = fromIOError kuserError (Prelude.userError (toString kuserError z1userError)) gcatch :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun (IO a) (T.Fun (T.Fun IOError (IO a)) (IO a))) gcatch pcatch p = T.ufun2 acatch pcatch p hcatch hcatch z1catch z2catch kcatch = (T.fromIO T.fromId) kcatch (System.IO.Error.catchIOError ((T.toIO T.toId) kcatch z1catch) ((toFun fromIOError (T.toIO T.toId)) kcatch z2catch)) gputChar :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun Char (IO T.Tuple0)) gputChar pputChar p = T.ufun1 aputChar pputChar p hputChar hputChar z1putChar kputChar = (T.fromIO T.fromTuple0) kputChar ((\_ c -> T.outputTrace kputChar [c] Prelude.>> Prelude.putChar c) Prelude.True (T.toChar kputChar z1putChar)) ggetChar :: T.RefSrcPos -> T.RefExp -> T.R (IO Char) ggetChar pgetChar p = T.uconstUse pgetChar p sgetChar sgetChar = T.uconstDef T.mkRoot agetChar (\ p -> (T.fromIO T.fromChar) p Prelude.getChar) ggetContents :: T.RefSrcPos -> T.RefExp -> T.R (IO String) ggetContents pgetContents p = T.uconstUse pgetContents p sgetContents sgetContents = T.uconstDef T.mkRoot agetContents (\ p -> (T.fromIO fromString) p Prelude.getContents) greadFile :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun String (IO String)) greadFile preadFile p = T.ufun1 areadFile preadFile p hreadFile hreadFile z1readFile kreadFile = (T.fromIO fromString) kreadFile (Prelude.readFile (toString kreadFile z1readFile)) gwriteFile :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun String (T.Fun String (IO T.Tuple0))) gwriteFile pwriteFile p = T.ufun2 awriteFile pwriteFile p hwriteFile hwriteFile z1writeFile z2writeFile kwriteFile = (T.fromIO T.fromTuple0) kwriteFile ((\_ n s -> T.outputTrace kwriteFile s Prelude.>> Prelude.writeFile n s) Prelude.True (toString kwriteFile z1writeFile) (toString kwriteFile z2writeFile)) gappendFile :: T.RefSrcPos -> T.RefExp -> T.R (T.Fun String (T.Fun String (IO T.Tuple0))) gappendFile pappendFile p = T.ufun2 aappendFile pappendFile p happendFile happendFile z1appendFile z2appendFile kappendFile = (T.fromIO T.fromTuple0) kappendFile ((\_ n s -> T.outputTrace kappendFile s Prelude.>> Prelude.appendFile n s) Prelude.True (toString kappendFile z1appendFile) (toString kappendFile z2appendFile)) tPreludeBuiltin = T.mkModule "Prelude" "PreludeBuiltin.hs" Prelude.False aseq = T.mkVariable tPreludeBuiltin 680001 690020 1 2 "seq" Prelude.False aisAscii = T.mkVariable tPreludeBuiltin 710001 720025 3 1 "isAscii" Prelude.False aisLatin1 = T.mkVariable tPreludeBuiltin 730001 740026 3 1 "isLatin1" Prelude.False aisControl = T.mkVariable tPreludeBuiltin 750001 760027 3 1 "isControl" Prelude.False aisPrint = T.mkVariable tPreludeBuiltin 770001 780025 3 1 "isPrint" Prelude.False aisSpace = T.mkVariable tPreludeBuiltin 790001 800025 3 1 "isSpace" Prelude.False aisUpper = T.mkVariable tPreludeBuiltin 810001 820025 3 1 "isUpper" Prelude.False aisLower = T.mkVariable tPreludeBuiltin 830001 840025 3 1 "isLower" Prelude.False aisAlpha = T.mkVariable tPreludeBuiltin 850001 860025 3 1 "isAlpha" Prelude.False aisDigit = T.mkVariable tPreludeBuiltin 870001 880025 3 1 "isDigit" Prelude.False aisOctDigit = T.mkVariable tPreludeBuiltin 890001 900028 3 1 "isOctDigit" Prelude.False aisHexDigit = T.mkVariable tPreludeBuiltin 910001 920028 3 1 "isHexDigit" Prelude.False aisAlphaNum = T.mkVariable tPreludeBuiltin 930001 940028 3 1 "isAlphaNum" Prelude.False atoUpper = T.mkVariable tPreludeBuiltin 960001 970025 3 1 "toUpper" Prelude.False atoLower = T.mkVariable tPreludeBuiltin 980001 990025 3 1 "toLower" Prelude.False aprimCharToInt = T.mkVariable tPreludeBuiltin 1020001 1030030 3 1 "primCharToInt" Prelude.False aprimIntToChar = T.mkVariable tPreludeBuiltin 1040001 1050031 3 1 "primIntToChar" Prelude.False aprimUnicodeMaxBound = T.mkVariable tPreludeBuiltin 1070001 1080029 3 0 "primUnicodeMaxBound" Prelude.False aprimIntMinBound = T.mkVariable tPreludeBuiltin 1140001 1150024 3 0 "primIntMinBound" Prelude.False aprimIntMaxBound = T.mkVariable tPreludeBuiltin 1160001 1170024 3 0 "primIntMaxBound" Prelude.False aprimIntEq = T.mkVariable tPreludeBuiltin 1190001 1200033 3 2 "primIntEq" Prelude.False aprimIntNe = T.mkVariable tPreludeBuiltin 1210001 1220033 3 2 "primIntNe" Prelude.False aprimIntLt = T.mkVariable tPreludeBuiltin 1230001 1240033 3 2 "primIntLt" Prelude.False aprimIntLe = T.mkVariable tPreludeBuiltin 1250001 1260033 3 2 "primIntLe" Prelude.False aprimIntGt = T.mkVariable tPreludeBuiltin 1270001 1280033 3 2 "primIntGt" Prelude.False aprimIntGe = T.mkVariable tPreludeBuiltin 1290001 1300033 3 2 "primIntGe" Prelude.False aprimIntQuot = T.mkVariable tPreludeBuiltin 1310001 1320036 3 2 "primIntQuot" Prelude.False aprimIntRem = T.mkVariable tPreludeBuiltin 1330001 1340036 3 2 "primIntRem" Prelude.False aprimIntPlus = T.mkVariable tPreludeBuiltin 1350001 1360036 3 2 "primIntPlus" Prelude.False aprimIntMinus = T.mkVariable tPreludeBuiltin 1370001 1380036 3 2 "primIntMinus" Prelude.False aprimIntTimes = T.mkVariable tPreludeBuiltin 1390001 1400036 3 2 "primIntTimes" Prelude.False aprimIntNegate = T.mkVariable tPreludeBuiltin 1410001 1420029 3 1 "primIntNegate" Prelude.False aprimIntAbs = T.mkVariable tPreludeBuiltin 1430001 1440029 3 1 "primIntAbs" Prelude.False aprimIntSignum = T.mkVariable tPreludeBuiltin 1450001 1460029 3 1 "primIntSignum" Prelude.False aprimIntegerFromInt = T.mkVariable tPreludeBuiltin 1480001 1490038 3 1 "primIntegerFromInt" Prelude.False aprimIntFromInteger = T.mkVariable tPreludeBuiltin 1500001 1510038 3 1 "primIntFromInteger" Prelude.False aprimIntegerEq = T.mkVariable tPreludeBuiltin 1530001 1540045 3 2 "primIntegerEq" Prelude.False aprimIntegerNe = T.mkVariable tPreludeBuiltin 1550001 1560045 3 2 "primIntegerNe" Prelude.False aprimIntegerLt = T.mkVariable tPreludeBuiltin 1570001 1580045 3 2 "primIntegerLt" Prelude.False aprimIntegerLe = T.mkVariable tPreludeBuiltin 1590001 1600045 3 2 "primIntegerLe" Prelude.False aprimIntegerGt = T.mkVariable tPreludeBuiltin 1610001 1620045 3 2 "primIntegerGt" Prelude.False aprimIntegerGe = T.mkVariable tPreludeBuiltin 1630001 1640045 3 2 "primIntegerGe" Prelude.False aprimIntegerQuot = T.mkVariable tPreludeBuiltin 1650001 1660053 3 2 "primIntegerQuot" Prelude.False aprimIntegerRem = T.mkVariable tPreludeBuiltin 1670001 1680053 3 2 "primIntegerRem" Prelude.False aprimIntegerQuotRem = T.mkVariable tPreludeBuiltin 1690001 1700062 3 2 "primIntegerQuotRem" Prelude.False aprimIntegerAdd = T.mkVariable tPreludeBuiltin 1710001 1720053 3 2 "primIntegerAdd" Prelude.False aprimIntegerSub = T.mkVariable tPreludeBuiltin 1730001 1740053 3 2 "primIntegerSub" Prelude.False aprimIntegerMul = T.mkVariable tPreludeBuiltin 1750001 1760053 3 2 "primIntegerMul" Prelude.False aprimIntegerNeg = T.mkVariable tPreludeBuiltin 1770001 1780042 3 1 "primIntegerNeg" Prelude.False aprimFloatFromInteger = T.mkVariable tPreludeBuiltin 1800001 1810043 3 1 "primFloatFromInteger" Prelude.False aprimFloatRadix = T.mkVariable tPreludeBuiltin 1820001 1830043 3 1 "primFloatRadix" Prelude.False aprimFloatDigits = T.mkVariable tPreludeBuiltin 1840001 1850039 3 1 "primFloatDigits" Prelude.False aprimFloatRange = T.mkVariable tPreludeBuiltin 1860001 1870044 3 1 "primFloatRange" Prelude.False aprimDecodeFloat = T.mkVariable tPreludeBuiltin 1880001 1890048 3 1 "primDecodeFloat" Prelude.False aprimEncodeFloat = T.mkVariable tPreludeBuiltin 1900001 1910050 3 2 "primEncodeFloat" Prelude.False aprimFloatIsNaN = T.mkVariable tPreludeBuiltin 1920001 1930035 3 1 "primFloatIsNaN" Prelude.False aprimFloatIsInfinite = T.mkVariable tPreludeBuiltin 1940001 1950040 3 1 "primFloatIsInfinite" Prelude.False aprimFloatIsDenormalized = T.mkVariable tPreludeBuiltin 1960001 1970044 3 1 "primFloatIsDenormalized" Prelude.False aprimFloatIsNegativeZero = T.mkVariable tPreludeBuiltin 1980001 1990044 3 1 "primFloatIsNegativeZero" Prelude.False aprimFloatIsIEEE = T.mkVariable tPreludeBuiltin 2000001 2010036 3 1 "primFloatIsIEEE" Prelude.False aprimFloatEq = T.mkVariable tPreludeBuiltin 2030001 2040039 3 2 "primFloatEq" Prelude.False aprimFloatNe = T.mkVariable tPreludeBuiltin 2050001 2060039 3 2 "primFloatNe" Prelude.False aprimFloatLt = T.mkVariable tPreludeBuiltin 2070001 2080039 3 2 "primFloatLt" Prelude.False aprimFloatLe = T.mkVariable tPreludeBuiltin 2090001 2100039 3 2 "primFloatLe" Prelude.False aprimFloatGt = T.mkVariable tPreludeBuiltin 2110001 2120039 3 2 "primFloatGt" Prelude.False aprimFloatGe = T.mkVariable tPreludeBuiltin 2130001 2140039 3 2 "primFloatGe" Prelude.False aprimFloatPi = T.mkVariable tPreludeBuiltin 2150001 2160022 3 0 "primFloatPi" Prelude.False aprimFloatExp = T.mkVariable tPreludeBuiltin 2170001 2180033 3 1 "primFloatExp" Prelude.False aprimFloatLog = T.mkVariable tPreludeBuiltin 2190001 2200033 3 1 "primFloatLog" Prelude.False aprimFloatSqrt = T.mkVariable tPreludeBuiltin 2210001 2220033 3 1 "primFloatSqrt" Prelude.False aprimFloatSin = T.mkVariable tPreludeBuiltin 2230001 2240033 3 1 "primFloatSin" Prelude.False aprimFloatCos = T.mkVariable tPreludeBuiltin 2250001 2260033 3 1 "primFloatCos" Prelude.False aprimFloatTan = T.mkVariable tPreludeBuiltin 2270001 2280033 3 1 "primFloatTan" Prelude.False aprimFloatAsin = T.mkVariable tPreludeBuiltin 2290001 2300033 3 1 "primFloatAsin" Prelude.False aprimFloatAcos = T.mkVariable tPreludeBuiltin 2310001 2320033 3 1 "primFloatAcos" Prelude.False aprimFloatAtan = T.mkVariable tPreludeBuiltin 2330001 2340033 3 1 "primFloatAtan" Prelude.False aprimFloatDiv = T.mkVariable tPreludeBuiltin 2350001 2360042 3 2 "primFloatDiv" Prelude.False aprimFloatAdd = T.mkVariable tPreludeBuiltin 2370001 2380042 3 2 "primFloatAdd" Prelude.False aprimFloatSub = T.mkVariable tPreludeBuiltin 2390001 2400042 3 2 "primFloatSub" Prelude.False aprimFloatMul = T.mkVariable tPreludeBuiltin 2410001 2420042 3 2 "primFloatMul" Prelude.False aprimFloatAbs = T.mkVariable tPreludeBuiltin 2430001 2440035 3 1 "primFloatAbs" Prelude.False aprimFloatSignum = T.mkVariable tPreludeBuiltin 2450001 2460035 3 1 "primFloatSignum" Prelude.False aprimDoubleFromInteger = T.mkVariable tPreludeBuiltin 2480001 2490044 3 1 "primDoubleFromInteger" Prelude.False aprimDoubleRadix = T.mkVariable tPreludeBuiltin 2500001 2510040 3 1 "primDoubleRadix" Prelude.False aprimDoubleDigits = T.mkVariable tPreludeBuiltin 2520001 2530036 3 1 "primDoubleDigits" Prelude.False aprimDoubleRange = T.mkVariable tPreludeBuiltin 2540001 2550041 3 1 "primDoubleRange" Prelude.False aprimDecodeDouble = T.mkVariable tPreludeBuiltin 2560001 2570044 3 1 "primDecodeDouble" Prelude.False aprimEncodeDouble = T.mkVariable tPreludeBuiltin 2580001 2590046 3 2 "primEncodeDouble" Prelude.False aprimDoubleIsNaN = T.mkVariable tPreludeBuiltin 2600001 2610037 3 1 "primDoubleIsNaN" Prelude.False aprimDoubleIsInfinite = T.mkVariable tPreludeBuiltin 2620001 2630042 3 1 "primDoubleIsInfinite" Prelude.False aprimDoubleIsDenormalized = T.mkVariable tPreludeBuiltin 2640001 2650046 3 1 "primDoubleIsDenormalized" Prelude.False aprimDoubleIsNegativeZero = T.mkVariable tPreludeBuiltin 2660001 2670046 3 1 "primDoubleIsNegativeZero" Prelude.False aprimDoubleIsIEEE = T.mkVariable tPreludeBuiltin 2680001 2690038 3 1 "primDoubleIsIEEE" Prelude.False aprimDoubleEq = T.mkVariable tPreludeBuiltin 2710001 2720042 3 2 "primDoubleEq" Prelude.False aprimDoubleNe = T.mkVariable tPreludeBuiltin 2730001 2740042 3 2 "primDoubleNe" Prelude.False aprimDoubleLt = T.mkVariable tPreludeBuiltin 2750001 2760042 3 2 "primDoubleLt" Prelude.False aprimDoubleLe = T.mkVariable tPreludeBuiltin 2770001 2780042 3 2 "primDoubleLe" Prelude.False aprimDoubleGt = T.mkVariable tPreludeBuiltin 2790001 2800042 3 2 "primDoubleGt" Prelude.False aprimDoubleGe = T.mkVariable tPreludeBuiltin 2810001 2820042 3 2 "primDoubleGe" Prelude.False aprimDoublePi = T.mkVariable tPreludeBuiltin 2830001 2840024 3 0 "primDoublePi" Prelude.False aprimDoubleExp = T.mkVariable tPreludeBuiltin 2850001 2860036 3 1 "primDoubleExp" Prelude.False aprimDoubleLog = T.mkVariable tPreludeBuiltin 2870001 2880036 3 1 "primDoubleLog" Prelude.False aprimDoubleSqrt = T.mkVariable tPreludeBuiltin 2890001 2900036 3 1 "primDoubleSqrt" Prelude.False aprimDoubleSin = T.mkVariable tPreludeBuiltin 2910001 2920036 3 1 "primDoubleSin" Prelude.False aprimDoubleCos = T.mkVariable tPreludeBuiltin 2930001 2940036 3 1 "primDoubleCos" Prelude.False aprimDoubleTan = T.mkVariable tPreludeBuiltin 2950001 2960036 3 1 "primDoubleTan" Prelude.False aprimDoubleAsin = T.mkVariable tPreludeBuiltin 2970001 2980036 3 1 "primDoubleAsin" Prelude.False aprimDoubleAcos = T.mkVariable tPreludeBuiltin 2990001 3000036 3 1 "primDoubleAcos" Prelude.False aprimDoubleAtan = T.mkVariable tPreludeBuiltin 3010001 3020036 3 1 "primDoubleAtan" Prelude.False aprimDoubleDiv = T.mkVariable tPreludeBuiltin 3030001 3040046 3 2 "primDoubleDiv" Prelude.False aprimDoubleAdd = T.mkVariable tPreludeBuiltin 3050001 3060046 3 2 "primDoubleAdd" Prelude.False aprimDoubleSub = T.mkVariable tPreludeBuiltin 3070001 3080046 3 2 "primDoubleSub" Prelude.False aprimDoubleMul = T.mkVariable tPreludeBuiltin 3090001 3100046 3 2 "primDoubleMul" Prelude.False aprimDoubleAbs = T.mkVariable tPreludeBuiltin 3110001 3120038 3 1 "primDoubleAbs" Prelude.False aprimDoubleSignum = T.mkVariable tPreludeBuiltin 3130001 3140038 3 1 "primDoubleSignum" Prelude.False aprimIOBind = T.mkVariable tPreludeBuiltin 3190001 3200041 3 2 "primIOBind" Prelude.False aprimIOReturn = T.mkVariable tPreludeBuiltin 3210001 3220025 3 1 "primIOReturn" Prelude.False aprimIOErrorShow = T.mkVariable tPreludeBuiltin 3250001 3260038 3 1 "primIOErrorShow" Prelude.False aioError = T.mkVariable tPreludeBuiltin 3340001 3350027 3 1 "ioError" Prelude.False auserError = T.mkVariable tPreludeBuiltin 3370001 3380033 3 1 "userError" Prelude.False acatch = T.mkVariable tPreludeBuiltin 3400001 3410043 3 2 "catch" Prelude.False aputChar = T.mkVariable tPreludeBuiltin 3460001 3480023 3 1 "putChar" Prelude.False agetChar = T.mkVariable tPreludeBuiltin 3500001 3510024 3 0 "getChar" Prelude.False agetContents = T.mkVariable tPreludeBuiltin 3530001 3540024 3 0 "getContents" Prelude.False areadFile = T.mkVariable tPreludeBuiltin 3560001 3570034 3 1 "readFile" Prelude.False awriteFile = T.mkVariable tPreludeBuiltin 3590001 3600044 3 2 "writeFile" Prelude.False aappendFile = T.mkVariable tPreludeBuiltin 3620001 3630044 3 2 "appendFile" Prelude.False