|4@      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU V WXYZ[ \ ] ^ _ ` a b c d e f g h i jklmnopqrstu v w x yz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456 789 : ;< = > ?  TrustworthyL/8Strict (call-by-value) application, defined in terms of .0The 03 function establishes a handler that receives any ;# raised in the action protected by 0. An ; is caught by the most recent handler established by one of the exception handling functions. These handlers are not selective: all ;s are caught. Exception propagation must be explicitly provided in a handler by re-raising any unwanted exceptions. For example, in Df = catch g (\e -> if IO.isEOFError e then return [] else ioError e) the function f returns []% when an end-of-file exception (cf.  ) occurs in gD; otherwise, the exception is propagated to the next outer handler.aWhen an exception propagates outside the main program, the Haskell system prints the associated ; value and exits the program.QNon-I/O exceptions are not caught by this variant; to catch all exceptions, use   from Control.Exception.11 x y6 is the greatest (positive) integer that divides both x and y; for example 1 (-3) 6 = 3, 1 (-3) (-6) = 3, 1 0 4 = 4. 1 0 0 raises a runtime error.22 n xs( returns a tuple where first element is xs prefix of length n1 and second element is the remainder of the list: splitAt 6 "Hello World!" == ("Hello ","World!") splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5]) splitAt 1 [1,2,3] == ([1],[2,3]) splitAt 3 [1,2,3] == ([1,2,3],[]) splitAt 4 [1,2,3] == ([1,2,3],[]) splitAt 0 [1,2,3] == ([],[1,2,3]) splitAt (-1) [1,2,3] == ([],[1,2,3])It is equivalent to ( n xs,  n xs). 2$ is an instance of the more general  , in which n may be of any integral type./012  !%&'()*+,-./01236789:?@BDLMNOPQRSTyz{|}~9:;<=>\]^_cdefghijklmnopqrstuvwxyz{|}~     %&'()*+,-./0126NO()*   LPQ>@RST7M   '%.&+,'-.&%:?98B-0!* )(tsrqponmlkjihgfedc21~}|{zyxwvu 1+, / 23/_^=]<\D~9}|{yz;:0/012/SafeLC?@ABCAB@?SafeL4WXYZ4WXYZSafeL@7M     Z[ !"#$@7M $!"#     [ZSafeL:;<=>:;<=>SafeLABjABjSafeLEFGHIEFGHISafeLJKCDEFGHIJKJKJIHGKFEDCSafeL     SafeLLMNOPQRSTUVWXY`abNRMLQPObaSXVWUTY`SafeLSafeL3Errors of type 3 are used by the D/ monad. This is an abstract type; the module System.IO.ErrorA provides functions to interrogate and construct values of type 3.4The 42 function establishes a handler that receives any 3$ raised in the action protected by 4. An 36 is caught by the most recent handler established by 4*. These handlers are not selective: all 3s are caught. Exception propagation must be explicitly provided in a handler by re-raising any unwanted exceptions. For example, in Df = catch g (\e -> if IO.isEOFError e then return [] else ioError e) the function f returns []% when an end-of-file exception (cf.  ) occurs in gD; otherwise, the exception is propagated to the next outer handler.aWhen an exception propagates outside the main program, the Haskell system prints the associated 3 value and exits the program.5The construct 5 compV exposes IO errors which occur within a computation, and which are not fully handled.345:3453:45345SafeL 012345678 876543210SafeL !"#$%&'()*+,-./#$%& ,-./'(!")*+ SafeL6 Computation 6 code# terminates the program, returning codeo to the program's caller. The caller may interpret the return code as it wishes, but the program should return  to mean normal completion, and  n\ to mean that the program encountered a problem from which it could not recover. The value f is equal to 6 ( exitfail), where exitfail is implementation-dependent. 6K bypasses the error handling in the I/O monad and cannot be intercepted by 0 from the Prelude.6ef66fe6SafeL}~~}SafeL stuvwxyz{| {|zyxwvutsSafeL75Convert an array of given length into a Haskell list.7`abcdefghijklmnopqr7rqponm7lkjihgefdcba`7SafeLCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_\][ZYXWVUSTQROPNMLKJI^_HGFEDCSafeL8Discard the return value of an D action8>?@AB8BA@?>88SafeL      !"#$%&'()*+,-./0123456789:;<==<;:9876543210/.-,+*)('&%$#"!      SafeL klmnopqrst tsrqonmlkp SafeLghiihg NoneL9"Allocate some memory and return a U= to it. The memory will be released automatically when the U is discarded.9 is equivalent to 4 do { p <- malloc; newForeignPtr finalizerFree p }galthough it may be implemented differently internally: you may not assume that the memory returned by 9 has been allocated with !.:This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. In particular  does a :$ after it executes the user action.ZNote that this function should not be used to express dependencies between finalizers on U)s. For example, if the finalizer for a U F1 calls : on a second U F25, then the only guarantee is that the finalizer for F2+ is never started before the finalizer for F17. They might be started together if for example both F1 and F2 are otherwise unreachable.In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation between finalizers.9:U9:U:99:NoneL;|Sometimes an external entity is a pure function, except that it passes arguments and/or results via pointers. The function unsafeLocalState: permits the packaging of such entities as pure functions.:The only IO operations allowed in the IO action passed to unsafeLocalState are (a) local allocation (alloca,  allocaBytes and derived operations such as  withArray and  withCString), and (b) pointer operations (Foreign.Storable and  Foreign.Ptr) on the pointers to local storage, and (c) foreign functions whose only observable effect is to read and/or write the locally allocated memory. Passing an IO operation that does not obey these rules results in undefined behaviour.TIt is expected that this operation will be replaced in a future revision of Haskell.;->?@AB`abcdefghijklmnopqrstuvwxyz{|}~78;;;"NoneL{:;<=>CEFGHIJKU>?@AB`abcdefghijklmnopqrstuvwxyz{|}~012345678?@ABCDEFGHIJK789:;#SafeL      !"#$%&'()*+,-./0123456789:;<=CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ !"#$%&'()*+,-./SafeLo 2o 2 SafeL< Computation <  file mode> allocates and returns a new, open handle to manage the file file. It manages input if mode is  , output if mode is  or (, and both input and output if mode is .aIf the file does not exist and it is opened for output, it should be created as a new file. If mode is  and the file already exists, then it should be truncated to zero length. Some operating systems delete empty files, so there is no guarantee that the file will exist following an < with mode h unless it is subsequently written to successfully. The handle is positioned at the end of the file if mode is , and otherwise at the beginning (in which case its internal position is 0). The initial buffer mode is implementation-dependent.This operation may fail with:isAlreadyInUseError4 if the file is already open and cannot be reopened;isDoesNotExistError if the file does not exist; orisPermissionError7 if the user does not have permission to open the file.= Computation = hdl t+ waits until input is available on handle hdl. It returns O" as soon as input is available on hdl, or N! if no input is available within t milliseconds. Note that = waits until one or more full  characterse are available, which means that it needs to do decoding, and hence may fail with a decoding error.If t is less than zero, then  hWaitForInput waits indefinitely.This operation may fail with: isEOFError% if the end of file has been reached.ba decoding error, if the input begins with an invalid byte sequence in this Handle's encoding.<=CDVuvwxyz{|}~9<=CDu9Vv<}|{=xw~yz<=SafeL("#$+,5(,+5$"#  TrustworthyL>jConstruct an array with the specified bounds and containing values for given indices within these bounds.The array is undefined (i.e. bottom) if any index in the list is out of bounds. If any two associations in the list have the same index, the value at that index is undefined (i.e. bottom).6Because the indices must be checked for these errors, > is strict in the bounds argument and in the indices of the association list, but non-strict in the values. Thus, recurrences such as the following are possible: >a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]])Not every index within the bounds of the array need appear in the association list, but the values associated with indices that do not appear will be undefined (i.e. bottom).If, in any dimension, the lower bound is greater than the upper bound, then the array is legal, but empty. Indexing an empty array always gives an array-bounds error, but \? still yields the bounds with which the array was constructed.?Constructs an array identical to the first argument except that it has been updated by the associations in the right argument. For example, if m is a 1-origin, n by n matrix, then m//[((i,i), 0) | i <- [1..n]]4is the same matrix, except with the diagonal zeroed.<Repeated indices in the association list are handled as for >2: the resulting array is undefined (i.e. bottom),> a pair of bounds, each of the index type of the array. These bounds are the lowest and highest indices in the array, in that order. For example, a one-origin vector of length '10' has bounds '(1,10)', and a one-origin '10' by '10' matrix has bounds '((1,1),(10,10))'. a list of  associations of the form (index, value). Typically, this list will be expressed as a comprehension. An association '(i, x)' defines the value of the array at index i to be x.?4WXYZ[\]^_`abcd>? [>]b^\_`a?cd>?@$%&$'($%)*+,$-.$-/$-0$12$ 3$45$46$%7$%8$%9$':$;<$;=$>?$@A$@B$@C$@D*EF*EG$;H$%I$%J$%K$%L$%M$>N$>O$>P$>Q$R$S$T$@U$@V*EW$XY$>Z$>[$%\$%]$;^*E_$`a$>b$Xc$>d$ef$gh$i*jk*jl*jm*jn*jo$pq$pr$ps$ptuvw*jx$>y$>z$1{*j|*j}$~$~$~$~$$$$%*j*j$$*j*j*j$$$g$g$g$g$g$g$g$g$g$g$g$g$g$g$ $ $ $ $ $$$$$$$$$$$$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$RS$RT$RU$RV$RW$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${|$}$~$$$$1$1$1$1$$$$$$$$$$$$$$$$$$$$$$$`$`$`$`$`$`$`$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$X$$$$$$$$$$$$$$$$$$$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$>$@$@$@$@$@$@$$$e$e$e$e$e$e$e$e$e$e$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$- $-!$-"$-#$-$$-%$-&$-'$-($-)$-*$-+$-,$--$-.$-/$-0$-1$-2$-3$-4$-5$-6$-7$-8$-9$-:$-;$-<$-=$->$-?$-@$-A$-B$-C$-D$E$F$G$H$I$J$K$L$M$N$O$P$4Q$4R$;S$;T$;U$;V$;W$%X$%Y$%Z$%[$%\$%]$%^$R_$R`$Ra$Rb$Rc$Rd$Re$Rf$Rg$Rh$Ri$Rj*Ek*El*Em*En*Eo*Ep*Eq*Er*Es*Etu vw~ x yz { |} ~   haskell2010-1.1.2.0PreludeForeign.StablePtr Control.MonadData.IxData.Int Data.Ratio Data.Word Foreign.PtrForeign.ForeignPtr System.IO Data.Array System.ExitSystem.Environment Data.ComplexSystem.IO.ErrorForeign.C.ErrorForeign.Marshal.ErrorForeign.C.StringForeign.Marshal.ArrayForeign.Marshal.UtilsForeign.Marshal.Alloc Data.List Data.CharForeign.C.TypesForeign.StorableNumeric Data.Bits Data.MaybeForeign.Marshal isEOFErrorControl.ExceptioncatchmallocForeign Foreign.CbaseGHC.Base++GHC.Errerrorfoldrghc-primGHC.PrimseqGHC.Listconcatfilterzip GHC.Stable newStablePtrprint Data.Tuplefstsnd otherwisemap$ undefinedGHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturn fromIntegral realToFrac toInteger toRationalguardliftMjoinBoundedEnumEq GHC.FloatFloating FractionalIntegralMonadFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowGHC.ArrIx MonadPlus GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerOrderingRatioRational StablePtrIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtr Data.EitherEitherStringFalseTrueLeftRightLTEQGTGHC.ForeignPtr ForeignPtrGHC.IO.Handle.TypesHandlerangeindexinRange rangeSizeArraybounds listArray!indiceselemsassocs accumArrayaccumixmap exitSuccess exitFailuregetEnv getProgNamegetArgsapproxRationalphase magnitudepolarcismkPolar conjugateimagPartrealPart:+ComplexfixIOwithFilehPrinthReadyreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.Handle.FDisEOFstderrstdin GHC.IO.HandlehShowhIsTerminalDevicehGetEchohSetEcho hIsSeekable hGetBuffering hIsWritable hIsReadable hIsClosedhIsOpenhTellhSeekhSetPosnhGetPosn hSetBuffering hLookAheadhIsEOF hSetFileSize hFileSizehClose HandlePosnGHC.IO.Handle.Text hPutStrLnhPutStrhPutChar hGetContentshGetLinehGetCharannotateIOErrorioeGetFileName ioeGetHandleioeGetErrorString userErrorTypepermissionErrorTypeillegalOperationErrorType eofErrorType fullErrorTypealreadyInUseErrorTypedoesNotExistErrorTypealreadyExistsErrorType isUserErrorisPermissionErrorisIllegalOperation isFullErrorisAlreadyInUseErrorisDoesNotExistErrorisAlreadyExistsError mkIOError GHC.IO.IOModeReadMode WriteMode AppendMode ReadWriteModeIOModestdouthFlusherrnoToIOErrorthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfNullthrowErrnoPathIf_throwErrnoPathIfthrowErrnoPaththrowErrnoIfNullRetryMayBlockthrowErrnoIfNullRetrythrowErrnoIfNull throwErrnoIfMinus1RetryMayBlock_throwErrnoIfMinus1RetryMayBlockthrowErrnoIfMinus1Retry_throwErrnoIfMinus1RetrythrowErrnoIfMinus1_throwErrnoIfMinus1throwErrnoIfRetryMayBlock_throwErrnoIfRetry_throwErrnoIfRetryMayBlockthrowErrnoIfRetry throwErrnoIf_ throwErrnoIf throwErrno resetErrnogetErrno isValidErrnoeXDEV eWOULDBLOCKeUSERSeTXTBSY eTOOMANYREFS eTIMEDOUTeTIMEeSTALEeSRMNTeSRCHeSPIPEeSOCKTNOSUPPORT eSHUTDOWNeRREMOTE eRPCMISMATCHeROFSeREMOTEeREMCHGeRANGE ePROTOTYPEePROTONOSUPPORTePROTO ePROGUNAVAIL ePROGMISMATCH ePROCUNAVAILePROCLIMePIPE ePFNOSUPPORTePERM eOPNOTSUPPeNXIOeNOTTYeNOTSOCK eNOTEMPTYeNOTDIReNOTCONNeNOTBLKeNOSYSeNOSTReNOSReNOSPC eNOPROTOOPTeNONETeNOMSGeNOMEMeNOLINKeNOLCKeNOEXECeNOENTeNODEVeNODATAeNOBUFSeNFILE eNETUNREACH eNETRESETeNETDOWN eNAMETOOLONG eMULTIHOPeMSGSIZEeMLINKeMFILEeLOOPeISDIReISCONNeIOeINVALeINTR eINPROGRESSeILSEQeIDRM eHOSTUNREACH eHOSTDOWNeFTYPEeFBIGeFAULTeEXISTeDQUOTeDOMeDIRTY eDESTADDRREQeDEADLK eCONNRESET eCONNREFUSED eCONNABORTEDeCOMMeCHILDeBUSYeBADRPCeBADMSGeBADFeALREADYeAGAIN eAFNOSUPPORTeADV eADDRNOTAVAIL eADDRINUSEeACCESe2BIGeOKErrno throwIfNull throwIfNeg_ throwIfNegthrowIf_throwIfwithCWStringLen withCWStringnewCWStringLen newCWStringpeekCWStringLen peekCWStringwithCAStringLen withCAStringnewCAStringLen newCAStringpeekCAStringLen peekCAStringcastCharToCSCharcastCSCharToCharcastCharToCUCharcastCUCharToCharcastCharToCCharcastCCharToCharcharIsRepresentablewithCStringLen withCString newCStringLen newCStringpeekCStringLen peekCStringCString CStringLenCWString CWStringLen advancePtr lengthArray0 moveArray copyArray withArrayLen0 withArray0 withArrayLen withArray newArray0newArray pokeArray0 pokeArray peekArray0 reallocArray0 reallocArray allocaArray0 allocaArray mallocArray0 mallocArray moveBytes copyByteswithMany maybePeek maybeWithmaybeNewtoBoolfromBoolwithnewfree reallocBytesrealloc allocaBytesalloca mallocBytes finalizerFreeGHC.IO.ExceptionioError ExitSuccess ExitFailureExitCode IOErrorType NoBuffering LineBufferingBlockBuffering BufferMode GHC.IO.Device AbsoluteSeek RelativeSeek SeekFromEndSeekModeForeign.ForeignPtr.ImpmallocForeignPtrArray0mallocForeignPtrArraynewForeignPtrEnvwithForeignPtr newForeignPtr intPtrToPtr ptrToIntPtr wordPtrToPtr ptrToWordPtrfreeHaskellFunPtrWordPtrIntPtrfinalizeForeignPtrcastForeignPtrunsafeForeignPtrToPtrnewForeignPtr_addForeignPtrFinalizerEnvaddForeignPtrFinalizermallocForeignPtrBytes FinalizerPtrFinalizerEnvPtrunwordswordsunlineslinesproductsumfoldl1'foldl1foldl'unfoldrsortBysort permutations subsequencestailsinitsgroupBygroupdeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLength minimumBy maximumByminimummaximuminsertByinsert mapAccumR mapAccumL partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBydeletenubBynub isInfixOf isSuffixOf isPrefixOf findIndices findIndexfind elemIndices elemIndex stripPrefix isSeparatorisSymbol isPunctuationisNumberisMarkisLettergeneralCategory digitToIntUppercaseLetterLowercaseLetterTitlecaseLetterModifierLetter OtherLetterNonSpacingMarkSpacingCombiningMark EnclosingMark DecimalNumber LetterNumber OtherNumberConnectorPunctuationDashPunctuationOpenPunctuationClosePunctuation InitialQuote FinalQuoteOtherPunctuation MathSymbolCurrencySymbolModifierSymbol OtherSymbolSpace LineSeparatorParagraphSeparatorControlFormat Surrogate PrivateUse NotAssignedGeneralCategory GHC.UnicodetoTitletoUppertoLower isAsciiUpper isAsciiLowerCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTimeCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxpokepeek pokeByteOff peekByteOff pokeElemOff peekElemOff alignmentsizeOfStorableGHC.IOFilePath userErrorIOError Text.ReadreadreadseithercastPtrToStablePtrcastStablePtrToPtrdeRefStablePtr freeStablePtrcastPtrToFunPtrcastFunPtrToPtr castFunPtr nullFunPtrminusPtralignPtrplusPtrcastPtrnullPtrshowOctshowHex showIntAtBase showGFloat showFFloat showEFloatshowInt readSigned readFloatreadHexreadDecreadOctreadInt lexDigits readLitChar lexLitCharlex readParenreadList readsPrecfromRat floatToDigits showFloatacoshatanhasinhcoshtanhsinhacosatanasincostansinlogBase**logsqrtexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadixrotateRrotateLshiftRshiftLisSignedbitSizetestBit complementBitclearBitsetBitbitrotateshift complementxor.|..&.Bitslcm^^^oddeven showSigned denominator numerator%divModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsuccGHC.CharchrText.ParserCombinators.ReadPReadS intToDigit showLitChar showParen showStringshowCharshowsShowSshowListshow showsPrecapliftM5liftM4liftM3liftM2unlesswhen replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMvoidforever<=<>=>msumforM_forMfilterMmapM_mapM sequence_sequence=<<mplusmzerounzip3unzipzipWith3zipWithzip3!! concatMaplookupnotElemelemallanyorandreversebreakspandroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrfoldr1scanl1scanlfoldllengthnullinitlasttailheadmapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybeNothingJustMaybeuncurrycurrysubtractsignumabs*+asTypeOfuntilflip.constidordisAsciiisLatin1 isControlisPrintisSpaceisUpperisLowerisAlphaisDigit isOctDigit isHexDigit isAlphaNum/=compare<=&&||not<>maxmin$!gcdsplitAttryexitWith peekArraymallocForeignPtrtouchForeignPtrunsafeLocalStateopenFile hWaitForInputarray//