h."YY.      !"#$% &'( )*+ ,-. /01 2 3 4 5 6 789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh ij!k"l#m#no$p$q$rstu%vwxy&z{|}~'$()*****+++!,-.....+/01223333344567--89**************************"+999+ ++++++++++++++:;//#<55=++++***************** ;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ;;;;;;;>>??  @@@@@@>>>>AAABBBBBBBBBCBBBBBBBBBBBBBBBBBBBBBBBDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFGGGG<<HIIJ7$$$$$$$KK66$$$,    <$$$$$$KKILLM NO/////////PPPPP,PPPP,P           Q7RRRRRRRRRRRRRRRRRRRRRRSS,TTTTTT############000####%#########UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVV1VVWW1''X''XX'X'X>>>>>>>>>>>>>>>>3>>>>>>3>>>>>>33333YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY    %%%%%%%%%%%%%%%%%%%%%%                     %   % %                                                                               %%%%%%%%%   ZZZZZZZZZZZZZZZZZZZZZZ[\[[[]]]^^"+____````aaaaaaaaaabb   ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,ccccccccccccccccccccccccccccccccccdeeeeeeeeddddddddddddddfffffffffffffffffeeee,,%eggeggggggee%%%%%%%%%%%%%%%%%%444444444hhhhhhhhhhhhhhihhhhhiijhklkkkkkkkkklh::===UUUUUUUUUUUUUUUUUU@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnoooooooooooooooo22222222222222pppppppppqqqqq55555555ee++++++rrr+++r+r+++++++++++++++++++++++++++++++++sssssssssssssssssssssssssssssssssssssssssssssssssssssssNNNNN4444444449999999888898899999999999988888888888888888888888888**********************************************************KKK((((((((((((((((((((((((((((((((((((((((((((((((((tttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvHHHww<1<WW<<<<<<xyxxxyyyyyyxzz{{{{{{{{{z{{zz{{{{zz{zz{z|zzzzzzz}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~HHHHHHHHHHHHHHHH                                    xx x x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~                  h h h h     i i i h i i h h h i  i h h h h h i h i h h h h h h h h h h h h h h h                                             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!k!k!k!k!k!k!k!k!k!!!!!!1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!H!!H!!!!!H!!!!!!!!!!!!H!H!H!H!H!H!H!!H!H!H!N!H!!!!!!!!!!!!!!!!!!!!""""""""""i"""""""""""""""""""""""""""""""""""""H"H"w"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"H"""""""N"""N"""""N"N"N"N"N"N"N"N"="="="""")")""")"")")")")")")")")")")"u"L"L"L#L#L###################&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#$#$#$### # # # # ##########################$$$$$$$$$$$$$$$$$$$$$$$[$[$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$7$7$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % %i%i%i%i%i%i%,%,%,%,%,%%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%u%u%u%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''0'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7'7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(7(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++K+K+K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,,,,,,,,,,,,,,,,,---------------------------------------------------------------------------------------------]---------------i-i-i-i-i----------------................................................................(c) Ross Paterson 20024BSD-style (see the LICENSE file in the distribution)libraries@haskell.org provisionalportableSafe %%%%%%$$%%%JL%%M%%%%N%O%%%%%%%%%(%%%JL%%%%%%%%%%%$$%%%%%%%%%%N%%%%%M%%%%O(c) Ashley Yakeley 20074BSD-style (see the LICENSE file in the distribution)ashley@semantic.orgstableportableSafe$$$$$$$$$$k"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstablenon-portable (concurrency)Safe!!!!!!!!!!!!!!!!!!"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable"non-portable (extended exceptions) Trustworthy" !! !!     !!!  !" v((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)None'(c) The University of Glasgow 1994-2023see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None $$$$$$$$$$ $$$$$$$$$$"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable"non-portable (extended exceptions)Safe"          "    ((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Nonegg"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe,n$$$$$$$V$$$$$$$"zExDCFH""1zExCDFH"""$$$n$$$$$$$$$V$$(C) 2015 David Luposchainsky, (C) 2015 Herbert Valerio Riedel BSD-style (see the file LICENSE)libraries@haskell.org provisionalportableSafeHH(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafeGG(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)R.Paterson@city.ac.ukstableportable Trustworthy$$$$"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable TrustworthyzExDCF zExDCF1"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable:non-portable (requires universal quantification for runST)Safe!!"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)Safe%%%%%$$%%%%%"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST) Trustworthy%%%%%$$%%%%%"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)Unsafe%%%%"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable:non-portable (requires universal quantification for runST) Trustworthy!!"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)Safe!W"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable:non-portable (requires universal quantification for runST)Unsafe(c) Nils Schweinsberg 2011, (c) George Giorgidze 2011 (c) University Tuebingen 2011/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe$$W$$$W$$$$U"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe1"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe!!,"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable TrustworthyT%Convert a single digit  to the corresponding 6. This function fails unless its argument satisfies , but recognises both upper- and lower-case hexadecimal digits (that is, '0'..'9', 'a'..'f', 'A'..'F').Examples Characters '0' through '9' are converted properly to 0..9:map digitToInt ['0'..'9'][0,1,2,3,4,5,6,7,8,9]Both upper- and lower-case 'A' through 'F' are converted as well, to 10..15.map digitToInt ['a'..'f'][10,11,12,13,14,15]map digitToInt ['A'..'F'][10,11,12,13,14,15]"Anything else throws an exception:digitToInt 'G'/*** Exception: Char.digitToInt: not a digit 'G'digitToInt 'L'3*** Exception: Char.digitToInt: not a digit '\9829'%Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to ,.This function returns + if its argument has one of the following s, or  otherwise:"These classes are defined in the  http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Letter".Examples Basic usage: isLetter 'a'True isLetter 'A'True isLetter ''True isLetter '0'False isLetter '%'False isLetter 'L'FalseisLetter '\31'False Ensure that % and  are equivalent.let chars = [(chr 0)..] let letters = map isLetter charslet alphas = map isAlpha charsletters == alphasTrue%Selects Unicode mark characters, for example accents and the like, which combine with preceding characters.This function returns + if its argument has one of the following s, or  otherwise:"These classes are defined in the  http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Mark".Examples Basic usage: isMark 'a'False isMark '0'FalseCombining marks such as accent characters usually need to follow another character before they become printable:map isMark "o" [False,True]#Puns are not necessarily supported: isMark 'N'False%Selects Unicode numeric characters, including digits from various scripts, Roman numerals, et cetera.This function returns + if its argument has one of the following s, or  otherwise:"These classes are defined in the  http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Number".Examples Basic usage: isNumber 'a'False isNumber '%'False isNumber '3'TrueASCII '0' through '9' are all numbers:and $ map isNumber ['0'..'9']True-Unicode Roman numerals are "numbers" as well: isNumber 'B'True%/Selects Unicode space and separator characters.This function returns + if its argument has one of the following s, or  otherwise:"These classes are defined in the  http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Separator".Examples Basic usage:isSeparator 'a'FalseisSeparator '6'FalseisSeparator ' 'TrueWarning: newlines and tab characters are not considered separators.isSeparator '\n'FalseisSeparator '\t'False1But some more exotic characters are (like HTML's  ):isSeparator '\160'True%%%%%%%%%%"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableNone88"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe _ _5"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe  ((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orgstablenon-portable (GHC extensions)Safe$%base,Returns a list of all values of an enum type% is often used to list all values of a custom enum data structure, such as a custom Color enum below: data Color = Yellow | Red | Blue deriving (Enum, Bounded, Show) allColors :: [Color] allColors = enumerate -- Result: [Yellow, Red, Blue] !Note that you need to derive the r type class as well, only s is not enough. s* allows for sequential enumeration, while r provides the  and  values.% is commonly used together with the TypeApplications syntax. Here is an example of using % to retrieve all values of the Ordering type: > enumerate @Ordering  LT, EQ, GTThe @ symbol here is provided by the TypeApplications language extension. %rs<=?>s<=?>r%"(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafet@t@(Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportableSafe&7 Nils Anders Danielsson 2006 , Alexander Berntsen 20144BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportableSafe . .`"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafezE zEt$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportableSafe(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology 2001 BSD-style (see the file LICENSE)ross@soi.city.ac.ukstableportableSafe""""""x"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe     ."(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe'"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe-4BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstable not portable Trustworthy/"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe  (c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe#bca`&bca`"(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe|A|Aq4BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportableSafe["(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable$non-portable (uses Control.Monad.ST)Safe$$$$"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional+non-portable (uses Control.Monad.ST.Strict)Safe$$"(c) The University of Glasgow 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafePP)$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportableSafe """""""""""""""""""""""""""";"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe  _4BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstable not portableSafep4BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstable not portableNone  24BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstable not portableSafeo4BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstable not portableSafe8-(c) The University of Glasgow, CWI 2001--2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe((&-(c) The University of Glasgow, CWI 2001--2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable-non-portable (local universal quantification)Safe#####################################y########################y########################################################################"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portableSafe$$$$$$L"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable6non-portable (local universal quantification in ReadP)Safe##""""""##6(C) 2008-2014 Edward Kmett/BSD-style (see the file libraries/base/LICENSE)Edward Kmett  provisionalportableSafe3"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe   "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableNone##+###+#####:(c) GHC Developers/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafes(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Safe-Inferred77(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe"(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisional#non-portable (requires concurrency)Safe$$$$z"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy|"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableNone(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe  (c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe$$$$$$$$$$$$(c) Sven Panne 2002-2004/BSD-style (see the file libraries/base/LICENSE)sven.panne@aedion.de provisionalportableSafe$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$(c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableNone$$(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe  (c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe$$$$$$$$$$$$$$$$$$$$$(c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe$$$$$$$$$$$$$$$$$$$$$4(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafen(c) The FFI task force 2001see libraries/base/LICENSEffi@haskell.org provisionalportableSafe (c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe$$$$$$$$$$$$$$$$$$$$$(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe$$$$$$$$$$$$$$$$$$$$$Y((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None<Zsee libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None ."n-!&7,*.'0)  8                       #                      ]                                     $                               qopzExDCFbca`t@|A           8                       #                      ]                                     $                               t@|A,0')*7`bcazEqopnxDCF-!".&"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe.F((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe?Safeb5BSD-style (see the file LICENSE in this distribution)internalportableSafe((c) The University of Glasgow, 1994-2023see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Unsafe"""""""""!!    !!    """""""  !!!!"" ((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions) Safe-Inferred """""""""" """"""""""Safe!!!!!!!!!!h((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None              None#(c) The University of Glasgow, 2007see libraries/base/LICENSEghc-devs@haskell.orgdeprecated ()non-portable (GHC extensions)SafeKQ%%K%%Q((c) The University of Glasgow, 1994-2023see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None  T((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safers<=?>rs<=?>((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orgstablenon-portable (GHC extensions)SaferrSafe$$J((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)SafeSafe!!!!!!!!"!!!!!!!!!!!!!!!!"!!!!!!!!!!!!!!!!(c) Tamar Christina 2018/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portableNoneI((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe',G((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Safe'(c) The University of Glasgow 2013-2015see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None $$########$# ########$#$$"(c) The University of Glasgow 2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None #/######7,*. i'0)  8                       #                      ]                                     $                               P###Y#Z[\                                  #                      ]                                     $                               *##Y#Z[\####P# ,0')/7###8i#=Safe""""""((c) The University of Glasgow, 1994-2023see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe (c) The University of Glasgow 1994-2002 Portions obtained from hbc (c) Lennart Augusstsonsee libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe214365uu135246S(c) Daniel Fischer 2010see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)SafeR(c) Daniel Fischer 2010see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe((c) The University of Glasgow, 2008-2011see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  {((c) The University of Glasgow, 1992-2003see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None"(c) The University of Glasgow 2012see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)NoneX$X$(c) The GHC Developerssee libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe$$$$$$*(c) Universiteit Utrecht 2010-2011, University of Oxford 2012-2014see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe$$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.orgstableportable Trustworthy9:?% One or none.It is useful for modelling any computation that is allowed to fail.Examples Using the  instance of Control.Monad.Except, the following functions:import Control.Monad.Except5canFail = throwError "it failed" :: Except String Int5final = return 42 :: Except String Int7Can be combined by allowing the first function to fail:runExcept $ canFail *> finalLeft "it failed"%runExcept $ optional canFail *> finalRight 42%base%base%base%base%base%base%base%base%base.base.base.base.base%%%%%%%qop###$qop%%%%%%###% % % 3% /% 5% 1% -%'.%'/%%,%%-%%*%&%$<'(c) The University of Glasgow 1994-2023see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None##}"(c) The University of Glasgow 2008see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe,,"(c) The University of Glasgow 2008see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe  ((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe(~((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe-  .  ((c) The University of Glasgow, 2008-2011see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  ((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  ((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe #(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  #(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  #(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe #(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe((((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe""""""""""""""""""""""""""""""H((c) The University of Glasgow, 1994-2009see libraries/base/LICENSElibraries@haskell.org provisional non-portableSafe""""""""""""""""""""""""""""!!!""!!!!!!!!!!!"""!!"""""""""""""!""""""""""""""""""""!!!!!!!!!!!((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe """""""""""" """"""""""""((c) The University of Glasgow, 1994-2001see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe-!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!-!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!wNone""""""((c) The University of Glasgow, 1992-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe!!!!!!!!!!!!!!!!!!!!!!!!!!!!((c) The University of Glasgow, 1994-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe>?((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe#(c) The University of Glasgow, 2017see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe """""""" """"""""a#(c) The University of Glasgow, 2017see libraries/base/LICENSElibraries@haskell.orginternal non-portableSafe  ^'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None"(c) The University of Glasgow 2008see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Noney"(c) The University of Glasgow 2008see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None  "(c) The University of Glasgow 2011see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe$##########################$##@'(c) The University of Glasgow 1997-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe--ENone++DNone"(c) The University of Glasgow 2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)SafeY#Z[\Y#Z[\#X((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None '(c) The University of Glasgow 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe=-=-u"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe%baseThe % function returns all non-empty initial segments of the argument, shortest first.Laziness Note that %) has the following strictness property: %inits1 (xs ++ _|_) = inits1 xs ++ _|_In particular, inits1 _|_ = _|_Examples inits1 "abc""['a' :| "",'a' :| "b",'a' :| "bc"] inits1 [][]'inits1 is productive on infinite lists:take 3 $ inits1 [1..][1 :| [],1 :| [2],1 :| [2,3]]%base\mathcal{O}(n). The % function returns all non-empty final segments of the argument, longest first.Laziness Note that %) has the following strictness property: tails1 _|_ = _|_tails1 undefined *** Exception: Prelude.undefined!drop 1 (tails1 [undefined, 1, 2])[1 :| [2],2 :| []]Examples tails1 "abc""['a' :| "bc",'b' :| "c",'c' :| ""]tails1 [1, 2, 3][1 :| [2,3],2 :| [3],3 :| []] tails1 [][]%baseUse % xs n' as a safer and faster alternative to compare ( xs) n#. Similarly, it's better to write compareLength xs 10 == LT instead of length xs < 10.While / would force and traverse the entire spine of xs (which could even diverge if xs is infinite), % traverses at most n" elements to determine its result.compareLength [] 0EQcompareLength [] 1LTcompareLength ['a'] 1EQcompareLength ['a', 'b'] 1GTcompareLength [0..] 100GTcompareLength undefined (-1)GT!compareLength ('a' : undefined) 0GT%%%-"""%-""%%"l"(c) The University of Glasgow 2008see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None  '(c) The University of Glasgow 1997-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions) Safe-InferredBSafe"$None...........................................................//////////////////////////////////////////////////////////////////////////////None//////////////////////////////////////////////////00000000000000000000000000000000000000000000000000000None00000000000000000000000000000000000000000000000000000000000000000000000000011111111O'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None//////////////////////////////////////////////////00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111{:9B00011 {:9B"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe-11111(c) Adam Gundry 2015-2016see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None$I$ISafe$$$$$$$$$$!(c) The FFI Task Force, 2000-2002see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions)None  g((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe}}#((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe>RmlSv;wT~U~UwTv;RSlm!(c) Adam Gundry 2015-2016see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safejj BSD-style (see the file LICENSE)libraries@haskell.orginternalportableSafe$$$$$$$$V((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None  \((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)NoneP((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safej((c) The University of Glasgow, 1992-2004see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions)None"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portableSafe$$$$$$$$$$"(c) The University of Glasgow 2011see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe$  de $  d e "(c) The University of Glasgow 2011see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe  None ########### ###########A"(c) The University of Glasgow 2015see libraries/ghc-prim/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safedede(C) 2014 I/O Tweagsee libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)None$$$$$$f$$$$$$$$$$$$$$$$fm!(c) The FFI task force, 2000-2002see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions)Safe   ((c) The University of Glasgow, 2001-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe %%%%%%% %%%%%% %"Safe k k+SaferSafeM#(c) The University of Glasgow, 2003see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe66((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)NoneNone%Run a batch of finalizers from the garbage collector. Given an array of finalizers and the length of the array, just call each one in turn.This is an internal detail of the GHC RTS weak pointer finaliser mechanism. It should no longer be exported from base. There is no good reason to use it. It will be removed in the next major version of base (4.23.*).See >https://github.com/haskell/core-libraries-committee/issues/342%%% Deprecated: This function is internal to GHC. It will not be exported in future.>((c) The University of Glasgow, 1997-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC Extensions)Safe11%"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe.u7uC(C) 2014 Herbert Valerio Riedel, (C) 2011 Edward Kmettsee libraries/base/LICENSElibraries@haskell.org provisionalportableSafe"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy.-!RS""""""""""""qopzExDCFbca`t@|AH""""rs<=?>u{:9B}v;wT~U!t@|As<=>?r{:B9~UwTv;uRS`abczEpoqxCDFH"""""""".-}""""""""""""((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe&'? P6%9Statistics about a single GC. This is a mirror of the C struct GCDetails in RtsAPI.h, with the field prefixed with gc_ to avoid collisions with %.%The time elapsed during the post-mark pause phase of the concurrent nonmoving GC.%The CPU time used during the post-mark pause phase of the concurrent nonmoving GC.%!The time elapsed during GC itself%"The CPU time used during GC itself%1The time elapsed during synchronisation before GC%baseThe amount of memory lost due to block fragmentation in bytes. Block fragmentation is the difference between the amount of blocks retained by the RTS and the blocks that are in use. This occurs when megablocks are only sparsely used, eg, when data that cannot be moved retains a megablock.%In parallel GC, the amount of balanced data copied by all threads%In parallel GC, the max amount of data copied by any one thread. Deprecated.%*Total amount of data copied during this GC%(Total amount of memory in use by the RTS%$Total amount of slop (wasted memory)%,Total amount of live data in compact regions%*Total amount of live data in large objects%Total amount of live data in the heap (includes large + compact data). Updated after every GC. Data in uncollected generations (in minor GCs) are considered live.%/Number of bytes allocated since the previous GC%!Number of threads used in this GC% The generation number of this GC%base Statistics about runtime activity since the start of the program. This is a mirror of the C struct RTSStats in RtsAPI.h% Details about the most recent GC%7The maximum time elapsed during any nonmoving GC cycle.%The total time elapsed during which there is a nonmoving GC active.%,The total CPU time used by the nonmoving GC.%The maximum elapsed length of any post-mark pause phase of the concurrent nonmoving GC.%The total time elapsed during the post-mark pause phase of the concurrent nonmoving GC.%The total CPU time used during the post-mark pause phase of the concurrent nonmoving GC.%'Total elapsed time (at the previous GC)%#Total CPU time (at the previous GC)%!Total elapsed time used by the GC%Total CPU time used by the GC%&Total elapsed time used by the mutator%"Total CPU time used by the mutator%?Total elapsed time used by the init phase @since base-4.12.0.0%;Total CPU time used by the init phase @since base-4.12.0.0%8Sum of par_balanced_copied bytes across all parallel GCs%Sum of par_max_copied_bytes across all parallel GCs. Deprecated.%+Sum of copied_bytes across all parallel GCs%"Sum of copied_bytes across all GCs%Sum of live bytes across all major GCs. Divided by major_gcs gives the average live data over the lifetime of the program.% Maximum memory in use by the RTS% Maximum slop%$Maximum live data in compact regions&"Maximum live data in large objects&Maximum live data (including large objects + compact regions) in the heap. Updated after a major GC.&Total bytes allocated&-Total number of major (oldest generation) GCs&Total number of GCs&Time values from the RTS, using a fixed resolution of nanoseconds.&base &base &base &base 1base1base4&&%%%%%%%%%%%%%%%%%%%%%&%%%%%%%%%&%%&%&&%%%%%%%%%%%&4%%&%%%%%%%%%&%%&%&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)None&'? &base Parameters of the runtime system&base7Parameters pertaining to Haskell program coverage (HPC)&Controls whether the  program.tix< file should be written after the execution of the program.&Controls whether a  program.tix file is read at the start of execution to initialize the RTS internal HPC datastructures.&base$Parameters pertaining to parallelism&base-Parameters pertaining to ticky-ticky profiler&base&Parameters pertaining to event tracing&-trace user events (emitted from Haskell code)&"trace spark events 100% accurately&&trace spark events by a sampled method&&trace nonmoving GC heap census samples&trace GC events&trace scheduler events&show timestamp in stderr output&baseIs event tracing enabled?& no tracing&$send tracing events to the event log&send tracing events to stderr&base&Parameters of the cost-center profiler&base&base&base&ticks between samples (derived)&time between samples&base,What sort of heap profile are we collecting?&base&base2Parameters pertaining to the cost-center profiler.&base-Should the RTS produce a cost-center summary?&baseFlags to control debugging output & extra checking in various subsystems.& r&c coverage&z# stack squeezing & lazy blackholing& m& a&l the object linker& p& t& S& b& n& g& G& w& i& s&base& Unix only, non-threaded RTS only&!cross-platform, threaded RTS only& Windows only&#Windows only, non-threaded RTS only&baseMiscellaneous parameters':address to ask the OS for memory for the linker, 0 ==> off'base'Parameters concerning context switching'base$Parameters of the garbage collector.' address to ask the OS for memory'use "mostly mark-sweep" instead of copying for the oldest generation'True  = "compact all the time"'baseShould we produce a summary of the garbage collector statistics after the program has exited?'base' is defined as a  StgWord64 in  stg/Types.h'base'base'base'base'base'base'base'base'base'base'base'base'base'base'base1base1base1base1base1base1base1base1base1base1base1base1base1base1base1base'''''''''''&&&&&''''&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''&&&&&&&&&&&&''''''''''&'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'&&&&&&&&&&&&&&'&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''&&''''''''''&'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''!''''''''''''''''''''''''' ''''''''Safe(c) The University of Glasgowsee libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (GHC extensions)Safe"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable)non-portable (uses Control.Monad.ST.Lazy)Safe''''''''0"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafe''), applied to two real fractional numbers x and epsilon/, returns the simplest rational number within epsilon of x. A rational number y is said to be simpler than another y' if ( y) <=  ( y'), and y <=  y'.Any real interval contains a unique simplest rational; in particular, note that 0/1! is the simplest rational of all.''7(C) 2011-2015 Edward Kmett, (C) 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy $'Number of elements in  list.'baseUse ' xs n' as a safer and faster alternative to  (' xs) n#. Similarly, it's better to write compareLength xs 10 == LT instead of length xs < 10.While '/ would force and traverse the entire spine of xs (which could even diverge if xs is infinite), ' traverses at most n" elements to determine its result.compareLength ('a' :| []) 1EQcompareLength ('a' :| ['b']) 3LTcompareLength (0 :| [1..]) 100GTcompareLength undefined 0GT(compareLength ('a' :| 'b' : undefined) 1GT'.Compute n-ary logic exclusive OR operation on  list.'' produces a new stream by repeatedly applying the unfolding function to the seed value to produce an element of type b= and a new seed value. When the unfolding function returns / instead of a new seed value, the stream ends.''( efficiently turns a normal list into a  stream, producing  if the input is empty.'' produces the first element of the stream, and a stream of the remaining elements, if any.'The ' function is analogous to  Data.List's  operation.'(Extract the first element of the stream.'.Extract the possibly-empty tail of the stream.''Extract the last element of the stream.'9Extract everything except the last element of the stream.'base Construct a  list from a single element.'!Prepend an element to the stream.' Synonym for '.'Sort a stream.'baseSort a 5 on a user-supplied projection of its elements. See  for more detailed information.Examples5sortOn fst $ (2, "world") :| [(4, "!"), (1, "Hello")]$(1,"Hello") :| [(2,"world"),(4,"!")]sortOn List.length ("jim" :| ["creed", "pam", "michael", "dwight", "kevin"])3"jim" :| ["pam","creed","kevin","dwight","michael"]Performance notesThis function minimises the projections performed, by materialising the projections in an intermediate list.1For trivial projections, you should prefer using ( with , for example:3sortBy (comparing fst) $ (3, 1) :| [(2, 2), (1, 3)](1,3) :| [(2,2),(3,1)]Or, for the exact same API as '#, you can use `sortBy . comparing`:5(sortBy . comparing) fst $ (3, 1) :| [(2, 2), (1, 3)](1,3) :| [(2,2),(3,1)](& is an alias for `sortBy . comparing`.'Converts a normal list to a  stream.'Raises an error if given an empty list.'.Convert a stream to a normal list efficiently.1"Lift list operations to work on a  stream.Beware: If the provided function returns an empty list, this will raise an error.'The ' function takes a stream xs) and returns all the finite prefixes of xs-, starting with the shortest. The result is  because the result always contains the empty list as the first element. inits [1,2,3] == [] :| [[1], [1,2], [1,2,3]] inits [1] == [] :| [[1]] inits [] == [] :| []'baseThe ' function takes a  stream xs and returns all the  finite prefixes of xs, starting with the shortest. inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]] inits1 (1 :| []) == (1 :| []) :| []'The ' function takes a stream xs" and returns all the suffixes of xs+, starting with the longest. The result is  because the result always contains the empty list as the last element. tails [1,2,3] == [1,2,3] :| [[2,3], [3], []] tails [1] == [1] :| [[]] tails [] == [] :| []'baseThe ' function takes a  stream xs, and returns all the non-empty suffixes of xs, starting with the longest. tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []] tails1 (1 :| []) == (1 :| []) :| []'' x xs inserts x into the last position in xs where it is still less than or equal to the next element. In particular, if the list is sorted beforehand, the result will also be sorted.'' x sequences x one or more times.'' is similar to , but returns a stream of successive reduced values from the left: scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs.'' is the right-to-left dual of ' . Note that $head (scanr f z xs) == foldr f z xs.'' is a variant of '% that has no starting value argument: scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...](( is a variant of '% that has no starting value argument.('intersperse x xs' alternates elements of the list with copies of x. ,intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3](( f x= produces the infinite sequence of repeated applications of f to x. %iterate f x = x :| [f x, f (f x), ..](( xs$ returns the infinite repetition of xs: )cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...](( a finite NonEmpty stream.(( x= returns a constant stream, where all elements are equal to x.(( n xs returns the first n elements of xs.(( n xs drops the first n) elements off the front of the sequence xs.(( n xs, returns a pair consisting of the prefix of xs of length n< and the remaining stream immediately following this prefix. 'splitAt' n xs == ('take' n xs, 'drop' n xs) xs == ys ++ zs where (ys, zs) = 'splitAt' n xs(( p xs+ returns the longest prefix of the stream xs for which the predicate p holds.(( p xs% returns the suffix remaining after ( p xs.(( p xs returns the longest prefix of xs that satisfies p,, together with the remainder of the stream. 'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs) xs == ys ++ zs where (ys, zs) = 'span' p xs(The ( p function is equivalent to ( (not . p).(( p xs removes any elements from xs that do not satisfy p.(The ( function takes a predicate p and a stream xs, and returns a pair of lists. The first list corresponds to the elements of xs for which p3 holds; the second corresponds to the elements of xs for which p does not hold. 9'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)(The ( function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements, and consecutive equal elements of the input end up in the same stream of the output list. For example, in list notation:group "Mississippi"['M' :| "",'i' :| "",'s' :| "s",'i' :| "",'s' :| "s",'i' :| "",'p' :| "p",'i' :| ""](( operates like (7, but uses the provided equality predicate instead of @.(( operates like (?, but uses the provided projection when comparing for equality(( operates like (, but sorts the list first so that each equivalence class has, at most, one list in the output(( operates like (, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.(( is to ( as ( is to (.(( is to ( as ( is to ((( is to ( as ( is to ((baseThe (? function returns the list of all permutations of the argument.(base( operates like (, but uses the knowledge that its input is non-empty to produce output where every element is non-empty. 5permutations1 = fmap fromList . permutations . toList(The ( function returns 2 if the first argument is a prefix of the second.(xs !! n# returns the element of the stream xs at index n/. Note that the head of the stream has index 0.Beware8: a negative or out-of-bounds index will cause an error.(The ( function is the inverse of the $ function.(The ( function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name (, means 'essence'.) It is a special case of (, which allows the programmer to supply their own inequality test.(The ( function behaves just like (, except it uses a user-supplied equality predicate instead of the overloaded @ function.(( for , behaves the same as  The rows/columns need not be the same length, in which case > transpose . transpose /= id(( for , behaves the same as (( for , behaves the same as: sortBy . comparing(baseA monomorphic version of ` for .append (1 :| []) (2 :| [3]) 1 :| [2,3](baseAttach a list at the end of a .appendList (1 :| [2,3]) [] 1 :| [2,3]appendList (1 :| [2,3]) [4,5]1 :| [2,3,4,5](base$Attach a list at the beginning of a .prependList [] (1 :| [2,3]) 1 :| [2,3]'prependList [negate 1, 0] (1 :| [2, 3])-1 :| [0,1,2,3]('(((''(((('(((((((('''''((('''(((((((('''('''('((('''(('('''('$$('''(((('''''''''''''(''''(((((('''((((((((((((((((((((((($$('''''( ' Deprecated:  Use unfoldr#(c) Ashley Yakeley 2005, 2006, 2009/BSD-style (see the file libraries/base/LICENSE)$Ashley Yakeley stableportable Trustworthy2a(($Resolution of 10^-12 = .000000000001Examples!show (MkFixed 12345 :: Fixed E12)"0.000000012345"show (MkFixed 12345 :: Pico)"0.000000012345"($Resolution of 10^-12 = .000000000001( Resolution of 10^-9 = .000000001Examples show (MkFixed 12345 :: Fixed E9) "0.000012345"show (MkFixed 12345 :: Nano) "0.000012345"( Resolution of 10^-9 = .000000001(Resolution of 10^-6 = .000001Examples show (MkFixed 12345 :: Fixed E6) "0.012345"show (MkFixed 12345 :: Micro) "0.012345"(Resolution of 10^-6 = .000001(Resolution of 10^-3 = .001Examples show (MkFixed 12345 :: Fixed E3)"12.345"show (MkFixed 12345 :: Milli)"12.345"(Resolution of 10^-3 = .001(>Resolution of 10^-2 = .01, useful for many monetary currenciesExamples show (MkFixed 12345 :: Fixed E2)"123.45"show (MkFixed 12345 :: Centi)"123.45"(>Resolution of 10^-2 = .01, useful for many monetary currencies(Resolution of 10^-1 = .1Examples show (MkFixed 12345 :: Fixed E1)"1234.5"show (MkFixed 12345 :: Deci)"1234.5"(Resolution of 10^-1 = .1(0Resolution of 1, this works the same as Integer.Examples show (MkFixed 12345 :: Fixed E0) "12345.0"show (MkFixed 12345 :: Uni) "12345.0"(0Resolution of 1, this works the same as Integer.(8Types which can be used as a resolution argument to the (% type constructor must implement the ( typeclass.(;Provide the resolution for a fixed-point fractional number.(The type of fixed-point fractional numbers. The type parameter specifies the number of digits of the fractional part and should be an instance of the ( typeclass.Examples  MkFixed 12345 :: Fixed E3 (Generalisation of  to any instance of ~(Generalisation of  to any instance of ~(Generalisation of  to any instance of ~(/First arg is whether to chop off trailing zerosExamples+showFixed True (MkFixed 10000 :: Fixed E3)"10"+showFixed False (MkFixed 10000 :: Fixed E3)"10.000"(base(base(base(base(base(base(base(base(base(base(base(base(base2Multiplication is not associative or distributive:.(0.2 * 0.6 :: Deci) * 0.9 == 0.2 * (0.6 * 0.9)False2(0.1 + 0.1 :: Deci) * 0.5 == 0.1 * 0.5 + 0.1 * 0.5False(base Recall that, for numeric types,  and  typically add and subtract 10, respectively. This is not true in the case of (, whose successor and predecessor functions intuitively return the "next" and "previous" values in the enumeration. The results of these functions thus depend on the resolution of the (< value. For example, when enumerating values of resolution 10^-3 of type Milli = Fixed E3,succ (0.000 :: Milli)0.001 and likewisepred (0.000 :: Milli)-0.001In other words,  and  increment and decrement a fixed-precision value by the least amount such that the value's resolution is unchanged. For example, 10^-12 is the smallest (positive) amount that can be added to a value of type Pico = Fixed E12( without changing its resolution, and sosucc (0.000000000000 :: Pico)0.000000000001 and similarlypred (0.000000000000 :: Pico)-0.000000000001,This is worth bearing in mind when defining ( arithmetic sequences. In particular, you may be forgiven for thinking the sequence  [1..10] :: [Pico]  evaluates to )[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico].However, this is not true. On the contrary, similarly to the above implementations of  and , $enumFromTo :: Pico -> Pico -> [Pico] has a "step size" of 10^-12. Hence, the list [1..10] :: [Pico] has the form  [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000]  and contains  9 * 10^12 + 1 values.( For example,  Fixed 1000 will give you a ( with a resolution of 1000.(base(base(base(base((((((((((((((((((((((((((((((((((((((((((((( ( ( ( ( ( ( ( -( -( 1( 3( -( ,( ( '( ( :(("(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthy:<=>? ()A data type representing complex numbers.#You can read about complex numbers  ,https://en.wikipedia.org/wiki/Complex_number on wikipedia./In haskell, complex numbers are represented as a :+ b* which can be thought of as representing a + bi. For a complex number z,  z is a number with the ( of z8, but oriented in the positive real direction, whereas  z has the ( of z , but unit (. Apart from the loss of precision due to IEEE754 floating point numbers, it holds that z ==  z *  z. Note that ('s instances inherit the deficiencies from the type parameter's. For example,  Complex Float's t# instance has similar problems to 's.$As can be seen in the examples, the  and ( instances traverse the real part first.Examples(5.0 :+ 2.5) + 6.5 11.5 :+ 2.5abs (1.0 :+ 1.0) - sqrt 2.0 0.0 :+ 0.0abs (signum (4.0 :+ 3.0)) 1.0 :+ 0.0foldr (:) [] (1 :+ 2)[1,2]mapM print (1 :+ 2)12() :+ ()(forms a complex number from its real and imaginary rectangular components.(+Extracts the real part of a complex number.ExamplesrealPart (5.0 :+ 3.0)5.0&realPart ((5.0 :+ 3.0) * (2.0 :+ 3.0))1.0(0Extracts the imaginary part of a complex number.ExamplesimagPart (5.0 :+ 3.0)3.0&imagPart ((5.0 :+ 3.0) * (2.0 :+ 3.0))21.0(The ( of a complex number.conjugate (conjugate x) = xExamplesconjugate (3.0 :+ 3.0) 3.0 :+ (-3.0)'conjugate ((3.0 :+ 3.0) * (2.0 :+ 2.0))0.0 :+ (-12.0)(Form a complex number from ( components of ( and (.ExamplesmkPolar 1 (pi / 4)(0.7071067811865476 :+ 0.7071067811865475 mkPolar 1 0 1.0 :+ 0.0(( t is a complex value with ( 1 and ( t (modulo 2*). ( = ( 1 Examplescis 0 1.0 :+ 0.05The following examples are not perfectly zero due to &https://en.wikipedia.org/wiki/IEEE_754IEEE 754cis pi (-1.0) :+ 1.2246467991473532e-16cis (4 * pi) - cis (2 * pi) 0.0 :+ (-2.4492935982947064e-16)( The function (( takes a complex number and returns a ((, () pair in canonical form: the ( is non-negative, and the ( in the range (-, ] ; if the ( is zero, then so is the (. ( z = (( z, ( z)Examplespolar (1.0 :+ 1.0)'(1.4142135623730951,0.7853981633974483)polar ((-1.0) :+ 0.0)(1.0,3.141592653589793)polar (0.0 :+ 0.0) (0.0,0.0)(The non-negative ( of a complex number.Examplesmagnitude (1.0 :+ 1.0)1.4142135623730951magnitude (1.0 + 0.0)1.0magnitude (0.0 :+ (-5.0))5.0(The (# of a complex number, in the range (-, ] . If the ( is zero, then so is the (.Examplesphase (0.5 :+ 0.5) / pi0.25phase (0 :+ 4) / pi0.5(base(base(base (base (base(base(base(base(base(base(base(base(base (base (base 1base 1base (((((((((( (((((((((((( ( ( ( ( ,( 0( 2( +((((((((((c) Ross Paterson 2013 BSD-style (see the file LICENSE)libraries@haskell.orgstableportableSafe 52(base Lifting of the # class to binary type constructors.(base ? function for an application of the type constructor based on  and " functions for the argument types.(base ? function for an application of the type constructor based on  and  functions for the argument types. The default implementation using standard list syntax is correct for most types.(base Lifting of the }# class to binary type constructors.Both ( and (/ exist to match the interface provided in the }1 type class, but it is recommended to implement ( instances using ( as opposed to (, since the former is more efficient than the latter. For example:  instance ( T where ( = ... ( = ) 9For more information, refer to the documentation for the } class.(base ? function for an application of the type constructor based on  and " functions for the argument types.(base ? function for an application of the type constructor based on  and  functions for the argument types. The default implementation using standard list syntax is correct for most types.(base ? function for an application of the type constructor based on  and " functions for the argument types.(base ? function for an application of the type constructor based on  and " functions for the argument types.The default definition uses (. Instances that define ( should also define ( as ).(base Lifting of the |# class to binary type constructors.(base Lift ( functions through the type constructor.The function will usually be applied to comparison functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.(base Lifting of the t# class to binary type constructors.(base 1Lift equality tests through the type constructor.The function will usually be applied to equality functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.(base Lifting of the " class to unary type constructors.Any instance should be subject to the following laws that canonicity is preserved: liftShowsPrec showsPrec showList = liftShowList showsPrec showList = 6This class therefore represents the generalization of  by decomposing it's methods into a canonical lifting on a canonical inner method, so that the lifting can be reused for other arguments than the canonical one.(base ? function for an application of the type constructor based on  and ! functions for the argument type.(base ? function for an application of the type constructor based on  and  functions for the argument type. The default implementation using standard list syntax is correct for most types.(base Lifting of the }" class to unary type constructors.Any instance should be subject to the following laws that canonicity is preserved: liftReadsPrec readsPrec readList = liftReadList readsPrec readList = "liftReadPrec readPrec readListPrec = &liftReadListPrec readPrec readListPrec = 6This class therefore represents the generalization of } by decomposing it's methods into a canonical lifting on a canonical inner method, so that the lifting can be reused for other arguments than the canonical one.Both ( and (/ exist to match the interface provided in the }1 type class, but it is recommended to implement ( instances using ( as opposed to (, since the former is more efficient than the latter. For example:  instance ( T where ( = ... ( = ) 9For more information, refer to the documentation for the } class.(base ? function for an application of the type constructor based on  and ! functions for the argument type.(base ? function for an application of the type constructor based on  and  functions for the argument type. The default implementation using standard list syntax is correct for most types.(base ? function for an application of the type constructor based on  and ! functions for the argument type.(base ? function for an application of the type constructor based on  and ! functions for the argument type.The default definition uses (. Instances that define ( should also define ( as ).(base Lifting of the |" class to unary type constructors.Any instance should be subject to the following law that canonicity is preserved:liftCompare compare = 6This class therefore represents the generalization of | by decomposing its main method into a canonical lifting on a canonical inner method, so that the lifting can be reused for other arguments than the canonical one.(base Lift a ' function through the type constructor.The function will usually be applied to a comparison function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.(base Lifting of the t" class to unary type constructors.Any instance should be subject to the following law that canonicity is preserved: liftEq (==) = (==)6This class therefore represents the generalization of t by decomposing its main method into a canonical lifting on a canonical inner method, so that the lifting can be reused for other arguments than the canonical one.(base 3Lift an equality test through the type constructor.The function will usually be applied to an equality function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.)base Lift the standard (@)' function through the type constructor.)base Lift the standard ' function through the type constructor.)base Lift the standard  and ) functions through the type constructor.)base Lift the standard  and ) functions through the type constructor.)base *A possible replacement definition for the (" method. This is only needed for ( instances where ( isn't defined as ).)base *A possible replacement definition for the ( method, defined using (.)base Lift the standard  and ) functions through the type constructor.)base Lift the standard (@)' function through the type constructor.)base Lift the standard ' function through the type constructor.)base Lift the standard ' function through the type constructor.)base Lift the standard ' function through the type constructor.)base *A possible replacement definition for the (" method. This is only needed for ( instances where ( isn't defined as ).)base *A possible replacement definition for the ( method, defined using (.)base Lift the standard ' function through the type constructor.)base ) p d is a parser for datatypes where each alternative begins with a data constructor. It parses the constructor and passes it to p=. Parsers for various constructors can be constructed with ), ) and ), and combined with mappend from the Monoid class.)base ) p is a parser for datatypes where each alternative begins with a data constructor. It parses the constructor and passes it to p=. Parsers for various constructors can be constructed with ) and ), and combined with  from the  class.)base ) rp n c n' matches the name of a unary data constructor and then parses its argument using rp.)base ) rp n c' matches the name of a unary data constructor and then parses its argument using rp.)base ) rp1 rp2 n c n' matches the name of a binary data constructor and then parses its arguments using rp1 and rp2 respectively.)base ) rp1 rp2 n c' matches the name of a binary data constructor and then parses its arguments using rp1 and rp2 respectively.)base ) sp n d x produces the string representation of a unary data constructor with name n and argument x, in precedence context d.)base ) sp1 sp2 n d x y produces the string representation of a binary data constructor with name n and arguments x and y, in precedence context d.)base ) n c n' matches the name of a unary data constructor and then parses its argument using .)base ) n c n' matches the name of a unary data constructor and then parses its argument using ).)base ) n c n' matches the name of a binary data constructor and then parses its arguments using ).)base ) n d x produces the string representation of a unary data constructor with name n and argument x, in precedence context d.)base ) n d x produces the string representation of a unary data constructor with name n and argument x, in precedence context d.)base ) n d x y produces the string representation of a binary data constructor with name n and arguments x and y, in precedence context d.)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)base)baseshowsPrec1 0 (2 :+ 3) """2 :+ 3")basereadPrec_to_S readPrec1 0 "(2 % 3) :+ (3 % 4)" :: [(Complex Rational, String)][(2 % 3 :+ 3 % 4,"")])baseeq1 (1 :+ 2) (1 :+ 2)Trueeq1 (1 :+ 2) (1 :+ 3)False)base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base )base)base*base*base*base*base*base4showsPrec2 0 ('x', True, 2 :: Int, 4.5 :: Double) """('x',True,2,4.5)"*basereadPrec_to_S readPrec2 0 "('x', True, 2, 4.5)" :: [((Char, Bool, Int, Double), String)][(('x',True,2,4.5),"")]*base;compare2 ('x', True, "str", 2) ('x', True, "str", 3 :: Int)LT*base6eq2 ('x', True, "str", 2) ('x', True, "str", 2 :: Int)True*base*base*base*base*base%showsPrec2 0 ('x', True, 2 :: Int) """('x',True,2)"*basereadPrec_to_S readPrec2 0 "('x', True, 2)" :: [((Char, Bool, Int), String)][(('x',True,2),"")]*base.compare2 ('x', True, "aaa") ('x', True, "zzz")LT*base)eq2 ('x', True, "str") ('x', True, "str")True*base *base*base *base*base *base*base *base*base *base *base *base *base *base *base *base *base *base *base *base *base *base *base *base )))))))))))))4))))))))))))))))))))))))))))(((((((((((((((((((((((((())(())((((())))))))((()))(()(()((((())))))))((())))))))))))))))) Deprecated: Use ) to define () Deprecated: Use ) to define () Deprecated: Use ) to define () Deprecated: Use ) to define () Deprecated: Use ) to define () Deprecated: Use ) to define () ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) /) /) ,) )) /) /) ,) )) /) /) ,) )) %) %) #) !) ") ") ) ) #) #) !) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) %) %) #) !) ) ) ) ) ) ) ) ) &) &) $) ") ) ) ) ) >) <* 9* 9* 5* 1* /* /* ,* )* .* .* +* (* "* "*  * * #* * #* * !* * * * * * * * * * * * * * * * * * * (c) Ross Paterson 2014 BSD-style (see the file LICENSE)libraries@haskell.orgstableportableSafe29:?*Lifted sum of functors.Examples-fmap (+1) (InL (Just 1)) :: Sum Maybe [] Int InL (Just 2)-fmap (+1) (InR [1, 2, 3]) :: Sum Maybe [] Int InR [2,3,4]*base *base *base *base *base *base *base *base *base*base*base*base1base 1base ******* * 8* 5* /* /* ,*; ;)*,,*--*..*88?*66?*44<*229(c) Ross Paterson 2010 BSD-style (see the file LICENSE)libraries@haskell.orgstableportableSafe29:?*Lifted product of functors.Examples#fmap (+1) (Pair [1, 2, 3] (Just 0))Pair [2,3,4] (Just 1)5Pair "Hello, " (Left 'x') <> Pair "World" (Right 'y')Pair "Hello, World" (Right 'y')*base*base*base *base *base *base *base *base *base *base *base *base *base *base *base *base *base*base*base*base1base 1base ***** * * <* <* ?* 3* * * * <* 9* 3* 3* 0*> >-*//*00*11*;;*99*77*55=(c) Ross Paterson 2010 BSD-style (see the file LICENSE)libraries@haskell.orgstableportable Trustworthy +,29:?*Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.Examples,fmap (subtract 1) (Compose (Just [1, 2, 3]))Compose (Just [0,1,2])+Compose (Just [1, 2, 3]) <> Compose NothingCompose (Just [1,2,3])Compose (Just [(++ "World"), (++ "Haskell")]) <*> Compose (Just ["Hello, "])0Compose (Just ["Hello, World","Hello, Haskell"])*base)The deduction (via generativity) that if  g x :~: g y then x :~: y.*base *base *base *base *base *base *base *base *base *base*base*base *base*base*base*base*base*base*base*base*base*base*base*base*base1base 1base ******* * * 8* * * * <* 9* 3* 3* 0* -* 0* 0*==*>>*??********9*7*?*9*7*5(C) 2007-2015 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy59>*Dual function arrows.*2This data type represents an equivalence relation.9Equivalence relations are expected to satisfy three laws:  Reflexivity* f a a = TrueSymmetry* f a b = * f b a TransitivityIf * f a b and * f b c are both  then so is * f a c.The types alone do not enforce these laws, so you'll have to check them yourself.**Defines a total ordering on a type as per .This condition is not checked by the types. You must ensure that the supplied values are valid total orderings yourself.*$The class of contravariant functors.'Whereas in Haskell, one can think of a z as containing or producing values, a contravariant functor is a functor that can be thought of as  consuming values.9As an example, consider the type of predicate functions  a -> Bool. One such predicate might be negative x = x < 0, which classifies integers as to whether they are negative. However, given this predicate, we can re-use it in other situations, providing we have a way to map values to( integers. For instance, we can use the negative predicate on a person's bank balance to work out if they are currently overdrawn: newtype Predicate a = Predicate { getPredicate :: a -> Bool } instance Contravariant Predicate where contramap :: (a' -> a) -> (Predicate a -> Predicate a') contramap f (Predicate p) = Predicate (p . f) | `- First, map the input... `----- then apply the predicate. overdrawn :: Predicate Person overdrawn = contramap personBankBalance negative 5Any instance should be subject to the following laws: Identity* $ = $ Composition* (g . f) = * f . * gNote, that the second law follows from the free theorem of the type of * and the first law, so you need only check that the former condition holds.*Replace all locations in the output with the same value. The default definition is * . <, but this may be overridden with a more efficient version.*If f is both z and * then by the time you factor in the laws of each of those classes, it can't actually use its argument in any meaningful capacity.This method is surprisingly useful. Where both instances exist and are lawful we have the following laws: E f D * * f D * +This is * with its arguments flipped.+This is an infix alias for *.+This is an infix version of * with the arguments flipped.+Compare using .+Check for equivalence with @.Note: The instances for  and  violate reflexivity for NaN.+Equivalence relations are *, because you can apply the contramapped function to each input to the equivalence relation.+A * is a * z , because * can apply its function argument to each input of the comparison function.+(`)( on predicates uses logical conjunction ()/ on the results. Without newtypes this equals  (&&). (<>) :: Predicate a -> Predicate a -> Predicate a Predicate pred <> Predicate pred' = Predicate a -> pred a && pred' a +a on predicates always returns True . Without newtypes this equals p True. )mempty :: Predicate a mempty = _ -> True +A * is a * z , because * can apply its function argument to the input of the predicate.Without newtypes * f equals precomposing with f (= (. f)). contramap :: (a' -> a) -> (Predicate a -> Predicate a') contramap f (Predicate g) = Predicate (g . f) +(` ) @(Op a b) without newtypes is (` ) @(b->a) = liftA2 (`). This lifts the  operation (`) over the output of a. (<>) :: Op a b -> Op a b -> Op a b Op f <> Op g = Op a -> f a <> g a +a @(Op a b) without newtypes is mempty @(b->a) =  _ -> mempty. )mempty :: Op a b mempty = Op _ -> mempty +(`)* on equivalences uses logical conjunction ()/ on the results. Without newtypes this equals  ( (&&)). (<>) :: Equivalence a -> Equivalence a -> Equivalence a Equivalence equiv <> Equivalence equiv' = Equivalence a b -> equiv a b && equiv' a b +a on equivalences always returns True . Without newtypes this equals p (p True). 9mempty :: Equivalence a mempty = Equivalence _ _ -> True +(`)& on comparisons combines results with (` ) @Ordering. Without newtypes this equals  ( (`)). (<>) :: Comparison a -> Comparison a -> Comparison a Comparison cmp <> Comparison cmp' = Comparison a a' -> cmp a a' <> cmp a a' +a on comparisons always returns EQ . Without newtypes this equals p (p EQ). 5mempty :: Comparison a mempty = Comparison _ _ -> EQ +++++++*******************+*+++******+***++****++++ )+ -+ + + + #+ "+ + + !+ %+ + + + +  + + ++ +++ ++ ++ +++(C) 2008-2014 Edward Kmett, BSD-style (see the file LICENSE)libraries@haskell.org provisionalportableSafe +baseA bifunctor is a type constructor that takes two type arguments and is a functor in both" arguments. That is, unlike with z, a type constructor such as . does not need to be partially applied for a + instance, and the methods in this class permit mapping functions over the  value or the " value, or both at the same time.Formally, the class + represents a bifunctor from Hask -> Hask.Intuitively it is a bifunctor where both the first and second arguments are covariant.The class definition of a + p uses the  https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/quantified_constraints.htmlQuantifiedConstraints? language extension to quantify over the first type argument a+ in its context. The context requires that p a must be a z for all a&. In other words a partially applied + must be a z . This makes z a superclass of + such that a function with a + constraint may use E in its implementation. z& has been a quantified superclass of + since base-4.18.0.0.You can define a + by either defining + or by defining both + and +. The + method must agree with E: + D EFrom this it follows that: +  D If you supply +, you should ensure that: +   D If you supply + and + , ensure: +  D  +  D  +If you supply both, you should also ensure: + f g D + f  + gThese ensure by parametricity: + (f  g) (h  i) D + f h  + g i + (f  g) D + f  + g + (f  g) D + f  + g +)Map over both arguments at the same time. + f g D + f  + gExamplesbimap toUpper (+1) ('j', 3)('J',4)bimap toUpper (+1) (Left 'j')Left 'J'bimap toUpper (+1) (Right 3)Right 4+(Map covariantly over the first argument. + f D + f Examplesfirst toUpper ('j', 3)('J',3)first toUpper (Left 'j')Left 'J'+)Map covariantly over the second argument. + D + Examplessecond (+1) ('j', 3)('j',4)second (+1) (Right 3)Right 4+base +base+base+base+base+base+base+base+base6Class laws for tuples hold only up to laziness. Both +  and +  are lazier than  (and E ):,first id (undefined :: (Int, Word)) `seq` ()()-second id (undefined :: (Int, Word)) `seq` ()() [Either a b] yielding a list of all elements of a structure in order, the following would hold: + f g z D  ( f g) z . toEitherListExamples Basic usage: > bifoldr (+) (*) 3 (5, 7) 26 -- 5 + (7 * 3) > bifoldr (+) (*) 3 (7, 5) 22 -- 7 + (5 * 3) > bifoldr (+) (*) 3 (Right 5) 15 -- 5 * 3 > bifoldr (+) (*) 3 (Left 5) 8 -- 5 + 3 +base Combines the elements of a structure in a left associative manner. Given a hypothetical function %toEitherList :: p a b -> [Either a b] yielding a list of all elements of a structure in order, the following would hold: + f g z D  (acc -> " (f acc) (g acc)) z . toEitherListNote that if you want an efficient left-fold, you probably want to use + instead of +. The reason is that the latter does not force the "inner" results, resulting in a thunk chain which then must be evaluated from the outside-in.Examples Basic usage: > bifoldl (+) (*) 3 (5, 7) 56 -- (5 + 3) * 7 > bifoldl (+) (*) 3 (7, 5) 50 -- (7 + 3) * 5 > bifoldl (+) (*) 3 (Right 5) 15 -- 5 * 3 > bifoldl (+) (*) 3 (Left 5) 8 -- 5 + 3 +base As +, but strict in the result of the reduction functions at each step.+base  A variant of + that has no base case, and thus may only be applied to non-empty structures.Examples Basic usage:bifoldr1 (+) (5, 7)12bifoldr1 (+) (Right 7)7bifoldr1 (+) (Left 5)5 >> bifoldr1 (+) (BiList [1, 2] [3, 4]) 10 -- 1 + (2 + (3 + 4)) bifoldr1 (+) (BiList [1, 2] [])37On empty structures, this function throws an exception:bifoldr1 (+) (BiList [] [])(*** Exception: bifoldr1: empty structure...+base 2Right associative monadic bifold over a structure.+base As +, but strict in the result of the reduction functions at each step.This ensures that each step of the bifold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single, monolithic result (e.g., +).+base  A variant of + that has no base case, and thus may only be applied to non-empty structures.Examples Basic usage:bifoldl1 (+) (5, 7)12bifoldl1 (+) (Right 7)7bifoldl1 (+) (Left 5)5 >> bifoldl1 (+) (BiList [1, 2] [3, 4]) 10 -- ((1 + 2) + 3) + 4 bifoldl1 (+) (BiList [1, 2] [])37On empty structures, this function throws an exception:bifoldl1 (+) (BiList [] [])(*** Exception: bifoldl1: empty structure...+base 1Left associative monadic bifold over a structure.Examples Basic usage:bifoldlM (\a b -> print b >> pure a) (\a c -> print (show c) >> pure a) 42 ("Hello", True)"Hello""True"42bifoldlM (\a b -> print b >> pure a) (\a c -> print (show c) >> pure a) 42 (Right True)"True"42bifoldlM (\a b -> print b >> pure a) (\a c -> print (show c) >> pure a) 42 (Left "Hello")"Hello"42+base Map each element of a structure using one of two actions, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see .Examples Basic usage:0bitraverse_ print (print . show) ("Hello", True)"Hello""True"-bitraverse_ print (print . show) (Right True)"True"/bitraverse_ print (print . show) (Left "Hello")"Hello"+base As +, but with the structure as the primary argument. For a version that doesn't ignore the results, see .Examples Basic usage:+bifor_ ("Hello", True) print (print . show)"Hello""True"(bifor_ (Right True) print (print . show)"True"*bifor_ (Left "Hello") print (print . show)"Hello"+base  Alias for +.+base  Alias for +.+base  Alias for +.+base Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see .Examples Basic usage:*bisequence_ (print "Hello", print "World")"Hello""World""bisequence_ (Left (print "Hello"))"Hello"#bisequence_ (Right (print "World"))"World"+base 1The sum of a collection of actions, generalizing +.Examples Basic usage:biasum (Nothing, Nothing)Nothingbiasum (Nothing, Just 42)Just 42biasum (Just 18, Nothing)Just 18biasum (Just 18, Just 42)Just 18+base  Alias for +.+base Collects the list of elements of a structure, from left to right.Examples Basic usage:biList (18, 42)[18,42]biList (Left 18)[18]+base $Test whether the structure is empty.Examples Basic usage:binull (18, 42)Falsebinull (Right 42)Falsebinull (BiList [] [])True+base 4Returns the size/length of a finite structure as an .Examples Basic usage:bilength (True, 42)2bilength (Right 42)1bilength (BiList [1,2,3] [4,5])5bilength (BiList [] [])0,On infinite structures, this function hangs: /> bilength (BiList [1..] []) * Hangs forever * +base (Does the element occur in the structure?Examples Basic usage:bielem 42 (17, 42)Truebielem 42 (17, 43)Falsebielem 42 (Left 42)Truebielem 42 (Right 13)False"bielem 42 (BiList [1..5] [1..100])True!bielem 42 (BiList [1..5] [1..41])False+base Reduces a structure of lists to the concatenation of those lists.Examples Basic usage:biconcat ([1, 2, 3], [4, 5]) [1,2,3,4,5]biconcat (Left [1, 2, 3])[1,2,3]4biconcat (BiList [[1, 2, 3, 4, 5], [6, 7, 8]] [[9]])[1,2,3,4,5,6,7,8,9]+base The largest element of a non-empty structure. This function is equivalent to + , and its behavior on structures with multiple largest elements depends on the relevant implementation of %. For the default implementation of  (!max x y = if x <= y then y else x), structure order is used as a tie-breaker: if there are multiple largest elements, the rightmost of them is chosen (this is equivalent to + ).Examples Basic usage:bimaximum (42, 17)42bimaximum (Right 42)42)bimaximum (BiList [13, 29, 4] [18, 1, 7])29!bimaximum (BiList [13, 29, 4] [])297On empty structures, this function throws an exception:bimaximum (BiList [] []))*** Exception: bimaximum: empty structure...+base The least element of a non-empty structure. This function is equivalent to + , and its behavior on structures with multiple least elements depends on the relevant implementation of %. For the default implementation of  (!min x y = if x <= y then x else y), structure order is used as a tie-breaker: if there are multiple least elements, the leftmost of them is chosen (this is equivalent to + ).Examples Basic usage:biminimum (42, 17)17biminimum (Right 42)42)biminimum (BiList [13, 29, 4] [18, 1, 7])1!biminimum (BiList [13, 29, 4] [])47On empty structures, this function throws an exception:biminimum (BiList [] []))*** Exception: biminimum: empty structure...+base The +9 function computes the sum of the numbers of a structure.Examples Basic usage:bisum (42, 17)59bisum (Right 42)42%bisum (BiList [13, 29, 4] [18, 1, 7])72bisum (BiList [13, 29, 4] [])46bisum (BiList [] [])0+base The +> function computes the product of the numbers of a structure.Examples Basic usage:biproduct (42, 17)714biproduct (Right 42)42)biproduct (BiList [13, 29, 4] [18, 1, 7])190008!biproduct (BiList [13, 29, 4] [])1508biproduct (BiList [] [])1+base Given a means of mapping the elements of a structure to lists, computes the concatenation of all such lists in order.Examples Basic usage:4biconcatMap (take 3) (fmap digitToInt) ([1..], "89") [1,2,3,8,9]3biconcatMap (take 3) (fmap digitToInt) (Left [1..])[1,2,3]3biconcatMap (take 3) (fmap digitToInt) (Right "89")[8,9]+base + returns the conjunction of a container of Bools. For the result to be  , the container must be finite; , however, results from a & value finitely far from the left end.Examples Basic usage:biand (True, False)Falsebiand (True, True)Truebiand (Left True)TrueEmpty structures yield :biand (BiList [] [])TrueA - value finitely far from the left end yields  (short circuit):6biand (BiList [True, True, False, True] (repeat True))FalseA . value infinitely far from the left end hangs: 9> biand (BiList (repeat True) [False]) * Hangs forever * An infinitely  value hangs: 4> biand (BiList (repeat True) []) * Hangs forever * +base + returns the disjunction of a container of Bools. For the result to be  , the container must be finite; , however, results from a & value finitely far from the left end.Examples Basic usage:bior (True, False)Truebior (False, False)Falsebior (Left True)TrueEmpty structures yield :bior (BiList [] [])FalseA - value finitely far from the left end yields  (short circuit):8bior (BiList [False, False, True, False] (repeat False))TrueA . value infinitely far from the left end hangs: 8> bior (BiList (repeat False) [True]) * Hangs forever * An infinitely  value hangs: 4> bior (BiList (repeat False) []) * Hangs forever * +base Determines whether any element of the structure satisfies its appropriate predicate argument. Empty structures yield .Examples Basic usage:biany even isDigit (27, 't')Falsebiany even isDigit (27, '8')Truebiany even isDigit (26, 't')Truebiany even isDigit (Left 27)Falsebiany even isDigit (Left 26)True/biany even isDigit (BiList [27, 53] ['t', '8'])TrueEmpty structures yield :!biany even isDigit (BiList [] [])False+base Determines whether all elements of the structure satisfy their appropriate predicate argument. Empty structures yield .Examples Basic usage:biall even isDigit (27, 't')Falsebiall even isDigit (26, '8')Truebiall even isDigit (Left 27)Falsebiall even isDigit (Left 26)True/biall even isDigit (BiList [26, 52] ['3', '8'])TrueEmpty structures yield :!biall even isDigit (BiList [] [])True+base The largest element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple largest elements, the rightmost of them is chosen.Examples Basic usage:bimaximumBy compare (42, 17)42bimaximumBy compare (Left 17)172bimaximumBy compare (BiList [42, 17, 23] [-5, 18])427On empty structures, this function throws an exception:"bimaximumBy compare (BiList [] [])(*** Exception: bifoldr1: empty structure...+base The least element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple least elements, the leftmost of them is chosen.Examples Basic usage:biminimumBy compare (42, 17)17biminimumBy compare (Left 17)172biminimumBy compare (BiList [42, 17, 23] [-5, 18])-57On empty structures, this function throws an exception:"biminimumBy compare (BiList [] [])(*** Exception: bifoldr1: empty structure...+base + is the negation of +.Examples Basic usage:binotElem 42 (17, 42)FalsebinotElem 42 (17, 43)TruebinotElem 42 (Left 42)FalsebinotElem 42 (Right 13)True%binotElem 42 (BiList [1..5] [1..100])False$binotElem 42 (BiList [1..5] [1..41])True+base The + function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or  if there is no such element.Examples Basic usage:bifind even (27, 53)Nothingbifind even (27, 52)Just 52bifind even (26, 52)Just 26Empty structures always yield :bifind even (BiList [] [])Nothing+base +base +base +base +base +base +base +base +base Class laws for tuples hold only up to laziness. The Bifoldable methods are lazier than their Foldable counterparts. For example the law + ( ) D 4 does not hold for tuples if laziness is exploited:?bifoldr (flip const) (:) [] (undefined :: (Int, Word)) `seq` ()()foldr (:) [] (errorWithoutStackTrace "error!" :: (Int, Word)) `seq` ()*** Exception: error!++++%+++++++++++++++++++++++++++++++++++++)+++++++++++++++++++++++++++++++++++++++++ + + )+ &+ #+  + + + + (C) 2011-2016 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy+base + identifies bifunctorial data structures whose elements can be traversed in order, performing  or x actions at each element, and collecting a result structure with the same shape.As opposed to  data structures, which have one variety of element on which an action can be performed, +6 data structures have two such varieties of elements.A definition of +! must satisfy the following laws:  Naturality+ (t . f) (t . g) D t . + f g) for every applicative transformation tIdentity+ " " D " Composition . E (+ g1 g2) . + f1 f2 D + ( . E g1 . f1) ( . E g2 . f2) where an applicative transformation is a function t :: ( f,  g) => f a -> g apreserving the  operations: t (p x) D p x t (f o x) D t f o t x and the identity functor " and composition functors  are from Data.Functor.Identity and Data.Functor.Compose.Some simple examples are  and (,): instance Bitraversable Either where bitraverse f _ (Left x) = Left <$> f x bitraverse _ g (Right y) = Right <$> g y instance Bitraversable (,) where bitraverse f g (x, y) = (,) <$> f x <*> g y+3 relates to its superclasses in the following ways: + f g D " . + (" . f) (" . g) + f g D  . + ( . f) ( . g) These are available as + and + respectively.#If the type is also an instance of ), then it must satisfy (up to laziness): " D + p +base Evaluates the relevant functions at each element in the structure, running the action, and builds a new structure with the same shape, using the results produced from sequencing the actions. + f g D + . + f g,For a version that ignores the results, see +.Examples Basic usage:+bitraverse listToMaybe (find odd) (Left [])Nothing2bitraverse listToMaybe (find odd) (Left [1, 2, 3]) Just (Left 1)0bitraverse listToMaybe (find odd) (Right [4, 5])Just (Right 5)5bitraverse listToMaybe (find odd) ([1, 2, 3], [4, 5]) Just (1,5).bitraverse listToMaybe (find odd) ([], [4, 5])Nothing+base  Alias for +.+base  Alias for +.+base Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see +. + D +  Examples Basic usage:bisequence (Just 4, Nothing)Nothingbisequence (Just 4, Just 5) Just (4,5)bisequence ([1, 2, 3], [4, 5])%[(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)]+'Traverses only over the first argument. + f D + f p+base(Traverses only over the second argument. + f D + p fExamples Basic usage:secondA (find odd) (Left [])Just (Left [])#secondA (find odd) (Left [1, 2, 3])Just (Left [1,2,3])!secondA (find odd) (Right [4, 5])Just (Right 5)&secondA (find odd) ([1, 2, 3], [4, 5])Just ([1,2,3],5)!secondA (find odd) ([1,2,3], [4])Nothing+base + is + with the structure as the first argument. For a version that ignores the results, see +.Examples Basic usage:'bifor (Left []) listToMaybe (find even)Nothing.bifor (Left [1, 2, 3]) listToMaybe (find even) Just (Left 1),bifor (Right [4, 5]) listToMaybe (find even)Just (Right 4)1bifor ([1, 2, 3], [4, 5]) listToMaybe (find even) Just (1,4)*bifor ([], [4, 5]) listToMaybe (find even)Nothing+base  Alias for +.+base The +( function behaves like a combination of + and +; it traverses a structure from left to right, threading a state of type a and using the given actions to compute new elements for the structure.Examples Basic usage:bimapAccumL (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo")(8,("True","oof"))+base The +( function behaves like a combination of + and +; it traverses a structure from right to left, threading a state of type a and using the given actions to compute new elements for the structure.Examples Basic usage:bimapAccumR (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo")(7,("True","oof"))+base A default definition of + in terms of the + operations. + f g D " . + (" . f) (" . g)+base A default definition of + in terms of the + operations. + f g D  . + ( . f) ( . g)+base +base +base +base +base +base +base +base +base Class laws for tuples hold only up to laziness. The Bitraversable methods are lazier than their Traversable counterparts. For example the law + p D "4 does not hold for tuples if laziness is exploited:;(bitraverse pure pure undefined :: IO (Int, Word)) `seq` ()()(traverse pure (errorWithoutStackTrace "error!") :: IO (Int, Word)) `seq` ()*** Exception: error! +++++++++++++ +++++++++++++ + + + + ,+ )+ &+ #+  + K(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy2:?+,Provide a Semigroup for an arbitrary Monoid.NOTE#: This is not needed anymore since  became a superclass of  in  base-4.11< and this newtype be deprecated at some point in the future., Beware that Data.Semigroup., is different from  Data.Monoid.0. The former simply returns the last value, so >x <> Data.Semigroup.Last Nothing = Data.Semigroup.Last Nothing#. The latter returns the last non-, thus !x <> Data.Monoid.Last Nothing = x.ExamplesLast 0 <> Last 10Last {getLast = 10}*sconcat $ Last 1 :| [ Last n | n <- [2..]]* Hangs forever *, Beware that Data.Semigroup., is different from  Data.Monoid.1. The former simply returns the first value, so Data.Semigroup.First Nothing <> x = Data.Semigroup.First Nothing$. The latter returns the first non-, thus "Data.Monoid.First Nothing <> x = x.ExamplesFirst 0 <> First 10First {getFirst = 0}.sconcat $ First 1 :| [ First n | n <- [2 ..] ]First {getFirst = 1},Examples Max (Arg 0 ()) <> Max (Arg 1 ())Max {getMax = Arg 1 ()}maximum [ Arg (length name) name | name <- ["violencia", "lea", "pixie"]]Arg 9 "violencia",Examples Min (Arg 0 ()) <> Min (Arg 1 ())Min {getMin = Arg 0 ()}minimum [ Arg (length name) name | name <- ["violencia", "lea", "pixie"]] Arg 3 "lea",, isn't itself a 0 in its own right, but it can be placed inside , and , to compute an arg min or arg max. In the event of ties, the leftmost qualifying ,+ is chosen; contrast with the behavior of  and  for many other types, where ties are broken by considering elements to the left in the structure to be less than elements to the right.Examples,minimum [ Arg (x * x) x | x <- [-10 .. 10] ]Arg 0 0;maximum [ Arg (-0.2*x^2 + 1.5*x + 1) x | x <- [-10 .. 10] ] Arg 3.8 4.0;minimum [ Arg (-0.2*x^2 + 1.5*x + 1) x | x <- [-10 .. 10] ]Arg (-34.0) (-10.0),The ,  and - always choose the bigger element as by the | instance and  of the contained type.ExamplesMax 42 <> Max 3Max {getMax = 42}-sconcat $ Max 1 :| [ Max n | n <- [2 .. 100]]Max {getMax = 100},The ,  and . always choose the smaller element as by the | instance and  of the contained type.ExamplesMin 42 <> Min 3Min {getMin = 3}-sconcat $ Min 1 :| [ Min n | n <- [2 .. 100]]Min {getMin = 1},A generalization of  to an arbitrary <. May fail to terminate for some values in some semigroups.Examplestake 10 $ cycle1 [1, 2, 3][1,2,3,1,2,3,1,2,3,1]cycle1 (Right 1)Right 1cycle1 (Left 1)* Hangs forever *,)This lets you use a difference list of a  as a .Exampleslet hello = diff "Hello, "appEndo hello "World!""Hello, World!""appEndo (hello <> mempty) "World!""Hello, World!""appEndo (mempty <> hello) "World!""Hello, World!"let world = diff "World"let excl = diff "!")appEndo (hello <> (world <> excl)) mempty"Hello, World!")appEndo ((hello <> world) <> excl) mempty"Hello, World!",Repeat a value n times. ?mtimesDefault n a = a <> a <> ... <> a -- using <> (n-1) timesIn many cases,  0 a for a  will produce a. However, there are situations when it cannot do so. In particular, the following situation is fairly common: data T a = ... class Constraint1 a class Constraint1 a => Constraint2 a  instance Constraint1 a => ! (T a) instance Constraint2 a =>  (T a) Since  Constraint1 is insufficient to implement a,  for T a cannot do so.When working with such a type, or when working polymorphically with  instances,  mtimesDefault should be used when the multiplier might be zero. It is implemented using % when the multiplier is nonzero and a when it is zero.ExamplesmtimesDefault 0 "bark"""mtimesDefault 3 "meow""meowmeowmeow",base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base  Note that ,'s | instance has  and  implementations that differ from the tie-breaking conventions of the default implementation of  and  in class |; ,? breaks ties by favoring the first argument in both functions.,base  Note that ,'s t* instance does not satisfy extensionality:Arg 0 0 == Arg 0 1True1let f (Arg _ x) = x in f (Arg 0 0) == f (Arg 0 1)False,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base ,base 1base 1base 1base 1base 1base 1base 1base 1base 1base 1base 1base 1base ,%The argument used for comparisons in t and |.The "value" exposed via the z,  etc. instances./,,,,,,,,,,,,,,,,,,,+++`2`,,,,,,,,,,,,,+++,,,,,,, *, ., 1, , , , , , , , !, , , , , , , , ", , , ,  , , , , , , , , , , , , ., $,  , , , , , , , , ., $,  ,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,Edward Kmett, Oleg Grenrus BSD-3-Clause Trustworthy 2971"Used to implement intercalate1/Map17Strict maybe, used to implement default foldlMap1' etc.1,Used for foldrMap1 and foldlMap1 definitions1+Used for default toNonEmpty implementation.,base-Non-empty data structures that can be folded.,base0Given a structure with elements whose type is a $, combine them via the semigroup's (`) operator. This fold is right-associative and lazy in the accumulator. When you need a strict left-associative fold, use , instead, with  as the map.,baseMap each element of the structure to a semigroup, and combine the results with (`). This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider , instead.foldMap1 (:[]) (1 :| [2, 3, 4]) [1,2,3,4],baseA left-associative variant of , that is strict in the accumulator. Use this for strict reduction when partial results are merged via (`).foldMap1' Sum (1 :| [2, 3, 4])Sum {getSum = 10},base5 list of elements of a structure, from left to right.toNonEmpty (Identity 2)2 :| [],baseThe largest element of a non-empty structure. This function is equivalent to , , and its behavior on structures with multiple largest elements depends on the relevant implementation of $. For the default implementation of  ("max x y = if x <= y then y else x), structure order is used as a tie-breaker: if there are multiple largest elements, the rightmost of them is chosen (this is equivalent to - ). maximum (32 :| [64, 8, 128, 16])128,baseThe least element of a non-empty structure. This function is equivalent to , , and its behavior on structures with multiple largest elements depends on the relevant implementation of $. For the default implementation of  ("min x y = if x <= y then x else y), structure order is used as a tie-breaker: if there are multiple least elements, the leftmost of them is chosen (this is equivalent to - ). minimum (32 :| [64, 8, 128, 16])8,base+The first element of a non-empty structure.head (1 :| [2, 3, 4])1,base*The last element of a non-empty structure.last (1 :| [2, 3, 4])4,base?Right-associative fold of a structure, lazy in the accumulator. In case of  lists, ,, when given a function f, a binary operator g%, and a list, reduces the list using g from right to left applying f to the rightmost element: foldrMap1 f g (x1 :| [x2, ..., xn1, xn]) == x1 `g` (x2 `g` ... (xn1 `g` (f xn))...)Note that since the head of the resulting expression is produced by an application of g& to the first element of the list, if g! is lazy in its right argument, ,> can produce a terminating expression from an unbounded list.For a general ,5 structure this should be semantically identical to:  foldrMap1 f g = foldrMap1 f g . ,,baseLeft-associative fold of a structure but with strict application of the operator.This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result.For a general ,5 structure this should be semantically identical to: "foldlMap1' f z = foldlMap1' f z . ,,baseLeft-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In case of  lists, ,, when given a function f, a binary operator g%, and a list, reduces the list using g from left to right applying f to the leftmost element: foldlMap1 f g (x1 :| [x2, ..., xn]) == (...(((f x1) `g` x2) `g`...) `g` xnNote that to produce the outermost application of the operator the entire input list must be traversed. This means that ,) will diverge if given an infinite list.If you want an efficient strict left-fold, you probably want to use , instead of ,=. The reason for this is that the latter does not force the inner results (e.g.  (f x1) `g` x2 in the above example) before applying them to the operator (e.g. to (`g` x3)!). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in.For a general ,5 structure this should be semantically identical to:  foldlMap1 f g = foldlMap1 f g . ,,base, is a variant of , that performs strict reduction from right to left, i.e. starting with the right-most element. The input structure must be finite, otherwise , runs out of space (diverges).If you want a strict right fold in constant space, you need a structure that supports faster than O(n)" access to the right-most element.This method does not run in constant space for structures such as  lists that don't support efficient right-to-left iteration and so require O(n) space to perform right-to-left reduction. Use of this method with such a structure is a hint that the chosen structure may be a poor fit for the task at hand. If the order in which the elements are combined is not important, use , instead.,base A variant of ,, where the rightmost element maps to itself.,base A variant of ,, where the rightmost element maps to itself.,base A variant of ,+ where the leftmost element maps to itself.,base A variant of ,+ where the leftmost element maps to itself.-base Insert an m between each pair of t m.4intercalate1 ", " $ "hello" :| ["how", "are", "you"]"hello, how, are, you"!intercalate1 ", " $ "hello" :| []"hello"3intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"] "IAmFineYou?"-baseMonadic fold over the elements of a non-empty structure, associating to the right, i.e. from right to left.-baseMap variant of -.-baseMonadic fold over the elements of a non-empty structure, associating to the left, i.e. from left to right.-baseMap variant of -.-baseThe largest element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple largest elements, the rightmost of them is chosen.-baseThe least element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple least elements, the leftmost of them is chosen.1"Create dlist with a single element1#Convert a dlist to a non-empty list-base-base-6It would be enough for either half of a product to be ,. Other could be .-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base-base ------------,,--,,-----,,,,,,,,,,,,,$,,,,,,,,,,,,,------------,,,,-------- ?- - - - ;- ;- ;- - - - - - - - - - - - - - - /- !- %-6-4-8-9Edward Kmett, Oleg Grenrus BSD-3-ClauseSafe---------/ /-+ +$-' '!-# #- - -  (c) Roman Leshchinskiy 2009-2012 BSD-stylelibraries@haskell.org non-portable Trustworthy  r-baseLifted wrapper for .Since . is an unlifted type and not a member of kind -, things like [MutableByteArray#] or IO MutableByteArray# are ill-typed. To work around this inconvenience this module provides a standard lifted wrapper, inhabiting -. Clients are expected to use -, in higher-level APIs, but wrap and unwrap -3 internally as they please and use functions from GHC.Exts.-baseLifted wrapper for .Since . is an unlifted type and not a member of kind -, things like  [ByteArray#] or  IO ByteArray# are ill-typed. To work around this inconvenience this module provides a standard lifted wrapper, inhabiting -. Clients are expected to use -, in higher-level APIs, but wrap and unwrap -3 internally as they please and use functions from GHC.Exts.The memory representation of a - is: JJJJJJJJJJJJJJJJJJJ JJJJJJJJJJJJJJJJJJJJJJJJJJJ J Constructor J * JJKJ Header J Size J Payload J JJJJJJJJJJJJJJJJJJJ JJJJJJJJJJJJJJJJJJJJJJJJJJJ"And its overhead is the following:- constructor: 1 word Pointer to : 1 word Header: 1 word Size: 1 wordWhere a word is the unit of heap allocation, measuring 8 bytes on 64-bit systems, and 4 bytes on 32-bit systems.1?Create a new mutable byte array of the specified size in bytes.Note:; this function does not check if the input is non-negative.1Convert a mutable byte array to an immutable one without copying. The array should not be modified after the conversion.1 Size of the byte array in bytes.1Read byte at specific index.1Write byte at specific index.1Explode - into a list of bytes.1 Create a - from a list of a known length. If the length of the list does not match the given length, this throws an exception.1Copy a slice of an immutable byte array to a mutable byte array.Note:6 this function does not do bounds or overlap checking.1Copy a slice from one mutable byte array to another or to the same mutable byte array.Note:6 this function does not do bounds or overlap checking.1!Compare prefixes of given length.1*Do two byte arrays share the same pointer?1Append two byte arrays.1Concatenate a list of -s.1Dump immutable -3s into a mutable one, starting from a given offset.1An array of zero length.1 do forkIO (print r) return (...).In this case, the child thread will receive a NonTermination0 exception instead of waiting for the value of r to be computed.--"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable TrustworthyM-The - constant is the smallest measurable difference in CPU time that the implementation can record, and is given as an integral number of picoseconds.- Computation - returns the number of picoseconds CPU time used by the current program. The precision of this result is implementation-dependent.----"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstablenon-portable (concurrency) Trustworthy-- is a quantity semaphore in which the resource is acquired and released in arbitrary amounts. It provides guaranteed FIFO ordering for satisfying blocked - calls. The pattern ,bracket_ (waitQSemN n) (signalQSemN n) (...),is safe; it never loses any of the resource.- Build a new - with a supplied initial quantity. The initial quantity must be at least 0.-4Wait for the specified quantity to become available.-7Signal that a given quantity is now available from the -.--------"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstablenon-portable (concurrency) Trustworthy2--< is an abstract type representing an unbounded FIFO channel.-#Build and return a new instance of -.-Write a value to a -.-Read the next value from the -. Blocks when the channel is empty. Since the read end of a channel is an 2, this operation inherits fairness guarantees of s (e.g. threads blocked in this operation are woken up in FIFO order).Throws  when the channel is empty and no other thread holds a reference to the channel.- Duplicate a -: the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.(Note that a duplicated channel is not equal to its original. So: fmap (c /=) $ dupChan c returns True for all c.)->Return a lazy list representing the contents of the supplied - , much like .-#Write an entire list of items to a -.-base---------------6 6i"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstablenon-portable (concurrency) Trustworthy-baseFork a thread and call the supplied function when the thread is about to terminate, with an exception or a returned value. The function is called with asynchronous exceptions masked. forkFinally action and_then = mask $ \restore -> forkIO $ try (restore action) >>= and_thenThis function is useful for informing the parent when a child terminates, for example.-Block the current thread until data is available to read on the given file descriptor (GHC only).This will throw an  if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with -, use .-Block the current thread until data can be written to the given file descriptor (GHC only).This will throw an  if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with -, use .-baseReturns an STM action that can be used to wait for data to read from a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.-baseReturns an STM action that can be used to wait until data can be written to a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.;-----------------%%%%%%"  !!!!!!!!!---- "----%%%%%% "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafec-The version of -> with which the program was compiled or is being interpreted.Example ghci> compilerVersion Version {versionBranch = [8,8], versionTags = []}-The full version of - with which the program was compiled or is being interpreted. It includes the major, minor, revision and an additional identifier, generally in the form " year month day".-The operating system on which the program is running. Common values include:"darwin" @ macOS "freebsd""linux""linux-android""mingw32" @ Windows"netbsd" "openbsd"-The machine architecture on which the program is running. Common values include: "aarch64""alpha""arm""hppa" "hppa1_1""i386""ia64""m68k""mips""mipseb""mipsel""nios2" "powerpc" "powerpc64" "powerpc64le" "riscv32" "riscv64" "loongarch32" "loongarch64""rs6000""s390""s390x""sh4""sparc" "sparc64""vax""x86_64"-The Haskell implementation with which the program was compiled or is being interpreted. On the GHC platform, the value is "ghc".----------"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe $$$$$$$$ "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portableSafe$$$$$$$$"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portable Trustworthy9-A specialised version of 3, where the key and the value are the same object: 2mkWeakPtr key finalizer = mkWeak key key finalizer-A specialised version of - , where the  object returned is simply thrown away (however the finalizer will be remembered by the garbage collector, and will still be run when the key becomes unreachable).Note: adding a finalizer to a z using -+ won't work; use the specialised version $ instead. For discussion see the  type. .-A specialised version of  where the value is actually a pair of the key and value passed to -: =mkWeakPair key val finalizer = mkWeak key (key,val) finalizer:The advantage of this is that the key can be retrieved by  in addition to the value. --- ---((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEghc-devs@haskell.orginternalnon-portable (requires POSIX)Safe111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred=2222222222222222222222222222222222222222222333333333333333333"(c) The University of Glasgow 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable non-portable Trustworthy U-base#An exception thrown to a thread by -' to interrupt a timed-out computation.-Wrap an $ computation to time out and return Nothing( in case no result is available within n microseconds (1/10^6 seconds). In case a result is available before the timeout expires, Just a is returned. A negative timeout interval means "wait indefinitely". When specifying long timeouts, be careful not to exceed maxBound :: Int, which on 32-bit machines is only 2147483647 s, less than 36 minutes. Consider using "Control.Concurrent.Timeout.timeout from unbounded-delays package.=timeout 1000000 (threadDelay 1000 *> pure "finished on time")Just "finished on time"=timeout 10000 (threadDelay 100000 *> pure "finished on time")Nothing?The design of this combinator was guided by the objective that  timeout n f$ should behave exactly the same as f as long as f$ doesn't time out. This means that f has the same < it would have without the timeout wrapper. Any exceptions f might throw cancel the timeout and propagate further up. It also possible for f7 to receive exceptions thrown to it by another thread.A tricky implementation detail is the question of how to abort an IO computation. This combinator relies on asynchronous exceptions internally (namely throwing the computation the - exception). The technique works very well for computations executing inside of the Haskell runtime system, but it doesn't work at all for non-Haskell code. Foreign function calls, for example, cannot be timed out with this combinator simply because an arbitrary C function cannot receive asynchronous exceptions. When timeout is used to wrap an FFI call that blocks, no timeout event can be delivered until the FFI call returns, which pretty much negates the purpose of the combinator. In practice, however, this limitation is less severe than it may sound. Standard I/O functions like , , Network.Socket.accept, or  appear to be blocking, but they really don't because the runtime system uses scheduling mechanisms like  select(2) to perform asynchronous I/O, so it is possible to interrupt standard socket I/O or file I/O using this combinator.-base-base-----7 7-2 2-/+/-c"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional-non-portable (local universal quantification)Safe##f"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP)Safe+(c) Lennart Augustsson and Bart Massey 20135BSD-style (see the file LICENSE in this distribution)Bart Massey  provisionalportableSafe#_;-baseType of a function that will parse modifier characters from the format string.-baseThis is the type of a field formatter reified over its argument.-baseThe "format parser" walks over argument-type-specific modifier characters to find the primary format character. This is the type of its result..Rest of the format string..Primary format character..Any modifiers found..base$Description of field formatting for . . See UNIX  printf(3)2 for a description of how field formatting works..The format character . was invoked with. . should fail unless this character matches the type. It is normal to handle many different format characters for a single type..6Characters that appeared immediately to the left of .1 in the format and were accepted by the type's .. Normally the empty string..'Indicates an "alternate format". See  printf(3)0 for the details, which vary by argument spec..8Whether to insist on a plus sign for positive numbers..)Kind of filling or padding to be done.. Secondary field width specifier..Total width of the field..baseHow to handle the sign of a numeric field. These are mutually exclusive, with . taking precedence..baseWhether to left-adjust or zero-pad a field. These are mutually exclusive, with . taking precedence..This class, with only the one instance, is used as a workaround for the fact that , as a concrete type, is not allowable as a typeclass instance. .) is exported for backward-compatibility..base.base. Typeclass of .-formattable values. The . method takes a value and a field format descriptor and either fails due to a bad descriptor or produces a  as the result. The default . expects no modifiers: this is the normal case. Minimal instance: ...base.base.The .1 class provides the variable argument magic for .. Its implementation is intentionally not visible from this module..The .1 class provides the variable argument magic for .. Its implementation is intentionally not visible from this module. If you attempt to pass an argument of a type which is not an instance of this class to . or .=, then the compiler will report it as a missing instance of ...Format a variable number of arguments with the C-style formatting string.$printf "%s, %d, %.4f" "hello" 123 pihello, 123, 3.1416The return value is either  or ( a) (which should be ( ())., but Haskell's type system makes this hard).7The format string consists of ordinary characters and conversion specifications7, which specify how to format one of the arguments to . in the output string. A format specification is introduced by the % character; this character can be self-escaped into the format string using %%&. A format specification ends with a format character that provides the primary information about how to format the value. The rest of the conversion specification is optional. In order, one may have flag characters, a width specifier, a precision specifier, and type-specific modifier characters. Unlike C  printf(3), the formatting of this . is driven by the argument type; formatting is type specific. The types formatted by . "out of the box" are:w types, including  types.6 is also extensible to support other types: see below.6A conversion specification begins with the character %2, followed by zero or more of the following flags: - left adjust (default is right adjust) + always use a sign (+ or -) for signed conversions space leading space for positive numbers in signed conversions 0 pad with zeros rather than spaces # use an \"alternate form\": see belowWhen both flags are given, - overrides 0 and +3 overrides space. A negative width specifier in a * conversion is treated as positive but implies the left adjust flag.The "alternate form" for unsigned radix conversions is as in C  printf(3): %o prefix with a leading 0 if needed %x prefix with a leading 0x if nonzero %X prefix with a leading 0X if nonzero %b prefix with a leading 0b if nonzero %[eEfFgG] ensure that the number contains a decimal point3Any flags are followed optionally by a field width: >num field width * as num, but taken from argument listThe field width is a minimum, not a maximum: it will be expanded as needed to avoid mutilating a value.6Any field width is followed optionally by a precision: .num precision . same as .0 .* as num, but taken from argument listNegative precision is taken as 0. The meaning of the precision depends on the conversion type. Integral minimum number of digits to show RealFloat number of digits after the decimal point String maximum number of charactersThe precision for Integral types is accomplished by zero-padding. If both precision and zero-pad are given for an Integral field, the zero-pad is ignored.Any precision is followed optionally for Integral types by a width modifier; the only use of this modifier being to set the implicit size of the operand for conversion of a negative operand to unsigned: ?hh Int8 h Int16 l Int32 ll Int64 L Int64/The specification ends with a format character: c character Integral d decimal Integral o octal Integral x hexadecimal Integral X hexadecimal Integral b binary Integral u unsigned decimal Integral f floating point RealFloat F floating point RealFloat g general format float RealFloat G general format float RealFloat e exponent format float RealFloat E exponent format float RealFloat s string String v default format any typeThe "%v" specifier is provided for all built-in types, and should be provided for user-defined type formatters as well. It picks a "best" representation for the given type. For the built-in types the "%v" specifier is converted as follows: c Char u other unsigned Integral d other signed Integral g RealFloat s StringMismatch between the argument types and the format string, as well as any other syntactic or semantic errors in the format string, will cause an exception to be thrown at runtime.Note that the formatting for 4 types is currently a bit different from that of C  printf(3), conforming instead to ,  and  (and their alternate versions  and ). This is hard to fix: the fixed versions would format in a backward-incompatible way. In any case the Haskell behavior is generally more sensible than the C behavior. A brief summary of some key differences:Haskell . never uses the default "6-digit" precision used by C printf.Haskell . treats the "precision" specifier as indicating the number of digits after the decimal point.Haskell . prints the exponent of e-format numbers without a gratuitous plus sign, and with the minimum possible number of digits.Haskell .: will place a zero after a decimal point when possible.. Similar to .+, except that output is via the specified $. The return type is restricted to ( a)..baseSubstitute a 'v' format character with the given default format character in the .. A convenience for user-implemented types, which should support "%v"..baseFormatter for  values..baseFormatter for  values..baseFormatter for  values..baseFormatter for  values..baseFormatter for  values..base Raises an 6 with a printf-specific prefix on the message string..baseCalls .8 to indicate an unknown format letter for a given type..baseCalls .1 to indicate that the format string ended early..baseCalls . to indicate that there is a missing argument in the argument list..baseCalls . to indicate that there is a type error or similar in the given argument..base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.base.+......................-...-...........-....,......-................--.................... . . . . . . . . . . . . . . . %. . >. <. (. '. &e"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP)Safe)}}d"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP)SafeQ"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe  "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe.base. 9-(c) The University of Glasgow, CWI 2001--2017/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstable2non-portable (requires GADTs and compiler support)Safe""-(c) The University of Glasgow, CWI 2001--2015/BSD-style (see the file libraries/base/LICENSE)None^$$^ Noneihhi3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""  """""""  """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#"#"#"#"#"#"#"#"#"#"#"#"#"#"#"#"#"#"####"###"############################################################################################################################################################# #####################################$##$#$#$#$#$##$#$#$#$#$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''',',',',',''$'$'$''$'$'$''$$'$'$'$'$'$'$'$'$'$'$'$'$'u'u'u''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''('('('('(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((('(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((('(((((((())))))))))))))))))))))))))))))))))))%0)77'77)7)77777777)7)777777'77'77)777777777777777777777%7)7)7)7)7)77)77777777%7)7)7))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,K,K,K,,KKKKKKK,K,K,K,KKK,KKK,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K-K--------------------------------------------------......................................]...............i.i#i#i#i#........................................................................................//$/$/$/$///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111$$11111111111111111711111111K1K1K1K1K1K1K1K1K1K1K1K111111111111111111111111.1222.1.12.1222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222#333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333base-4.22.0.0-0f76GHC.ExtsGHC.ListControl.Exception.BaseGHC.BaseForeign.StablePtrPrelude Data.BoolControl.ExceptionGHC.TopHandlerGHC.IO.Exception Debug.Trace Data.Function GHC.Float Data.Coerce Data.EnumData.EqData.Ord Control.MonadControl.Monad.FixGHC.OverloadedLabels Control.Arrow GHC.Desugar Data.StringControl.Monad.ZipGHC.GHCiType.Reflection.Unsafe Data.Dynamic Data.Monoid GHC.Stack GHC.StaticPtrControl.Exception.Context Unsafe.Coerce GHC.Records GHC.TypeErrorGHC.RealControl.ApplicativeNumeric Data.DataData.Ix Data.FoldableData.Traversable GHC.Generics GHC.TypeLits Data.Char Data.KindData.Int Data.Maybe Data.RatioControl.Monad.STData.Type.Equality Data.Word Foreign.Ptr Data.Either Data.VoidData.List.NonEmpty Data.TypeableType.ReflectionForeign.C.ConstPtr Data.TupleGHC.IOGHC.FingerprintGHC.WordGHC.CharGHC.IntGHC.Stack.Types GHC.NaturalNumeric.NaturalGHC.Integer.Logarithms GHC.Integer GHC.ByteOrderGHC.Exception.Type GHC.IO.Handle GHC.ExceptionGHC.ErrData.Semigroup Data.Version GHC.Unicode System.IOGHC.NumGHC.Show Text.ShowGHC.Float.RealFracMethodsGHC.Float.ConversionUtilsGHC.Enum Data.BitsGHC.STControl.Monad.ST.UnsafeGHC.IxGHC.ArrGHC.ArrayArray Data.STRef GHC.STRefSystem.IO.Unsafe GHC.IO.UnsafeData.Type.Bool Data.FunctorGHC.IO.SubSystem GHC.ClockText.ParserCombinators.ReadP Text.Read.Lex Text.ReadText.ParserCombinators.ReadPrecGHC.Read GHC.Conc.SyncControl.Concurrent GHC.StableControl.Concurrent.MVarGHC.MVar GHC.StorableForeign.Storable Data.Type.OrdData.Type.Coercion Data.Proxy GHC.TypeNatsForeign.C.TypesData.Functor.Const Data.ListControl.Exception.AnnotationGHC.IO.Handle.Lock Data.IORef GHC.IORefForeign.ForeignPtrGHC.ForeignPtrForeign.ForeignPtr.Unsafe GHC.IO.BufferGHC.IO.EncodingGHC.IO.Encoding.Types GHC.IO.DeviceGHC.IO.BufferedIOGHC.IO.Handle.TypesGHC.IO.StdHandlesGHC.IO.Handle.FDSystem.IO.Error System.ExitGHC.IO.Encoding.FailureGHC.IO.Encoding.UTF8GHC.IO.Encoding.UTF32GHC.IO.Encoding.UTF16GHC.IO.Encoding.Latin1Foreign.Marshal.AllocForeign.Marshal.UtilsForeign.Marshal.ArrayForeign.C.String GHC.ForeignForeign.C.ErrorGHC.IO.Encoding.Iconv GHC.IOArray GHC.EventGHC.Event.TimeOutGHC.Encoding.UTF8GHC.Weak.FinalizeSystem.Mem.WeakGHC.Weak System.MemGHC.Conc.SignalGHC.IO.Handle.InternalsGHC.IO.Handle.Text GHC.Conc.IO GHC.IO.FDData.Functor.IdentityGHC.Stack.CloneStack GHC.InfoProvGHC.ExecutionStackControl.Exception.Backtrace GHC.ProfilingControl.Monad.IO.ClassGHC.StableNameForeign.Marshal.UnsafeControl.CategoryForeign.Concurrent Data.UniqueForeign.Marshal.ErrorForeign.Marshal.PoolGHC.EnvironmentSystem.EnvironmentGHC.GHCi.HelpersSystem.Environment.BlankGHC.ResponseFileControl.Monad.ST.LazyControl.Monad.ST.Lazy.Unsafe GHC.Stats GHC.RTS.FlagsData.STRef.Lazy Data.Fixed Data.ComplexData.Functor.ClassesData.Functor.SumData.Functor.ProductData.Functor.ComposeData.Functor.ContravariantData.BifunctorData.BifoldableData.BitraversableData.Foldable1Data.Bifoldable1Data.Array.ByteControl.Concurrent.QSemSystem.Console.GetOptSystem.CPUTimeControl.Concurrent.QSemNControl.Concurrent.Chan System.InfoSystem.Timeout Text.PrintfText.Show.FunctionsControl.Monad.FailControl.Monad.InstancesControl.Monad.ST.Lazy.SafeControl.Monad.ST.SafeControl.Monad.ST.StrictisAlphaData.STRef.Strict Foreign.CForeign.ForeignPtr.SafeForeign.Marshal.SafeForeign.Marshal Foreign.SafeForeignGHC.BitsGHC.Conc GHC.Constants Data.BoundedGHC.Fingerprint.Type)libraries/base/src/Control/Applicative.hs GHC.IO.IOMode GHC.IsList GHC.MaybeGHC.Num.BigNatGHC.Num.IntegerGHC.Num.Natural GHC.OldListGHC.Ptr GHC.Stack.CCSlibraries/base/src/GHC/Stats.hs#libraries/base/src/GHC/RTS/Flags.hsGHC.IO.Encoding.CodePageGHC.ConsoleHandlerGHC.Internal.Data.ListunfoldrListsortOn transposesortBy libraries/base/src/Data/Fixed.hs"libraries/base/src/Data/Complex.hs$dmliftCompare $dmliftEq$dmliftReadList$dmliftReadList2$dmliftReadListPrec$dmliftReadListPrec2$dmliftReadPrec$dmliftReadPrec2$dmliftReadsPrec$dmliftReadsPrec2$dmliftShowList$dmliftShowList2$dmliftShowsPrec*libraries/base/src/Data/Functor/Classes.hs&libraries/base/src/Data/Functor/Sum.hs*libraries/base/src/Data/Functor/Product.hs*libraries/base/src/Data/Functor/Compose.hs$dm>$0libraries/base/src/Data/Functor/Contravariant.hs$dmbimap$dmfirst $dmsecond$libraries/base/src/Data/Bifunctor.hs Bifunctorbimap bitraversebifor bisequence $dmbifold $dmbifoldMap $dmbifoldl $dmbifoldr%libraries/base/src/Data/Bifoldable.hsCompose(libraries/base/src/Data/Bitraversable.hsLastFirstcycle$libraries/base/src/Data/Semigroup.hsmaxcomparemin$dmfold1 $dmfoldMap1 $dmfoldMap1' $dmfoldlMap1 $dmfoldlMap1' $dmfoldrMap1 $dmfoldrMap1'$dmhead$dmlast $dmmaximum $dmminimum $dmtoNonEmpty$libraries/base/src/Data/Foldable1.hs $dmbifold1&libraries/base/src/Data/Bifoldable1.hsType%libraries/base/src/Data/Array/Byte.hsSystem.CPUTime.UnsupportedSystem.CPUTime.UtilsSystem.CPUTime.Posix.TimesSystem.CPUTime.Posix.RUsage!System.CPUTime.Posix.ClockGetTimeGHC.Internal.System.EnvironmentgetArgs+libraries/base/src/System/Console/GetOpt.hsGHC.Internal.System.IOfixIOBlockedIndefinitelyOnMVar hGetContents-libraries/base/src/Control/Concurrent/Chan.hs closeFdWithSystem.Mem.StableName ForeignPtrGHC.Internal.Foreign.ForeignPtraddForeignPtrFinalizerSystem.Posix.InternalsSystem.Posix.TypeshGetBufhPutBuf hWaitForInput$libraries/base/src/System/Timeout.hsGHC.Internal.Numeric showEFloat showFFloat showGFloat showFFloatAlt showGFloatAlt$dmparseFormat!libraries/base/src/Text/Printf.hs)libraries/base/src/Text/Show/Functions.hs ghc-internalGHC.Internal.Baseaugment++buildfoldr#GHC.Internal.Control.Exception.Base recSelErrorGHC.Internal.PrimseqeqStringnoMethodBindingErrornonExhaustiveGuardsErrorimpossibleErrorimpossibleConstraintErrorpatError realWorld# recConErrorGHC.Internal.CStringunpackCStringUtf8#unpackAppendCStringUtf8#unpackFoldrCStringUtf8#unpackCString#unpackAppendCString#unpackFoldrCString#void# typeErrorGHC.Internal.ClassesdivInt#modInt#cstringLength#GHC.Internal.ListconcatfilterzipbindIOreturnIOGHC.Internal.Stable newStablePtrprint nullAddr# otherwiseassert leftSection rightSectionGHC.Internal.TopHandler runMainIOthenIOGHC.Internal.MagiclazyGHC.Internal.IO.Exception assertErroroneShotrunRW#GHC.Internal.Debug.Tracetraceinlinemap$GHC.Internal.ExtsconsiderAccessiblenoinlineGHC.Internal.FloatintegerToFloat#integerToDouble#naturalToFloat#naturalToDouble#rationalToFloatrationalToDoubleGHC.Internal.IOseq#coerceGHC.Internal.Num fromInteger-GHC.Internal.Real fromRationalGHC.Internal.EnumenumFrom enumFromThen enumFromToenumFromThenTo==>=negate>>=>>fmapreturnGHC.Internal.Control.Monad.FixmfixGHC.Internal.Control.Monad.FailfailGHC.Internal.OverloadedLabels fromLabelGHC.Internal.Control.ArrowarrGHC.Internal.Desugar>>>firstapp|||loopGHC.Internal.Data.String fromStringtoAnnotationWrapper fromIntegral realToFrac toInteger toRationalGHC.Internal.Control.MonadguardGHC.Internal.Control.Monad.ZipmzipGHC.Internal.GHCi ghciStepIOGHC.Internal.IsListIsListfromList fromListNtoListproxy##GHC.Internal.Data.Typeable.InternalmkTrConGHC.Internal.Data.DynamictoDyn<>memptymappendmconcatGHC.Internal.Stack.TypesemptyCallStack pushCallStackGHC.Internal.StaticPtr fromStaticPtrGHC.Internal.Exception.ContextemptyExceptionContextGHC.Internal.Unsafe.CoerceunsafeEqualityProof unsafeCoerce#GHC.Internal.RecordsgetFieldGHC.Internal.TypeError unsatisfiablemkRationalBase2mkRationalBase10join<*>pure*>BoundedEnumEqFloating FractionalIntegralMonadGHC.Internal.Data.DataDataFunctorNumOrdGHC.Internal.ReadReadReal RealFloatRealFracGHC.Internal.ShowShowGHC.Internal.IxIxTypeableGHC.Internal.Magic.DictWithDict DataToTagMonadFix MonadFailIsString ApplicativeGHC.Internal.Data.FoldableFoldableGHC.Internal.Data.Traversable TraversableGHC.Internal.GenericsGenericGeneric1Datatype ConstructorSelectorGHC.Internal.TypeNatsKnownNatGHC.Internal.TypeLits KnownSymbol KnownChar GHCiSandboxIO SemigroupMonoidIPHasFieldAddr#Array#GHC.Internal.TypesBool ByteArray#StringChar#CharDouble#DoubleFloat#FloatFUNInt#IntInt8#GHC.Internal.IntInt8Int16#Int16Int32#Int32Int64#Int64GHC.Internal.Bignum.IntegerIntegerGHC.Internal.Bignum.NaturalNaturalGHC.Internal.MaybeMaybeWeak# MutableArray#MutableByteArray#OrderingMVar#RatioRational RealWorld StablePtr# StablePtr~~~State# StableName#MutVar#IOWord#WordWord8#GHC.Internal.WordWord8Word16#Word16Word32#Word32Word64#Word64 ThreadId#BCOGHC.Internal.PtrPtrFunPtrTVar#Compact#StackSnapshot# PromptTag#GHC.Internal.Data.EitherEitherVoidNonEmpty UnliftedTypeTYPE CONSTRAINT ConstraintLevity RuntimeRepVecCountVecElem LiftedRep UnliftedRep ZeroBitRep ZeroBitTypeTyConModuleTrNameKindRep TypeLitSortV1U1Par1Rec1K1M1:+::*::.:RDCSRec0D1C1S1RepRep1URecUAddrUCharUDoubleUFloatUIntUWord UnsatisfiableAny TypeError CoercibleProxy#SPEC SmallArray#SmallMutableArray# StaticPtr CallStackTypeRep SomeTypeRep AppendSymbolUnsafeEquality MultiplicityInt8X16#Int16X8#Int32X4#Int64X2#Int8X32# Int16X16#Int32X8#Int64X4#Int8X64# Int16X32# Int32X16#Int64X8# Word8X16# Word16X8# Word32X4# Word64X2# Word8X32# Word16X16# Word32X8# Word64X4# Word8X64# Word16X32# Word32X16# Word64X8#FloatX4# DoubleX2#FloatX8# DoubleX4# FloatX16# DoubleX8#Symbol+*^GHC.Internal.TypeLits.Internal CmpSymbolGHC.Internal.TypeNats.InternalCmpNatCmpCharDivModLog2 ConsSymbol UnconsSymbol CharToNat NatToCharGHC.Internal.Foreign.C.ConstPtrConstPtrExceptionContextGHC.Internal.TupleSoloC#D#FalseF#I#NothingJust:%TrueW#LeftRightLTEQGT StaticPtrInfoGHC.Internal.Fingerprint.Type FingerprintSrcLocTrNameSTrNameDText:<>::$$:ShowTypePrefixIInfixILeftAssociativeRightAssociativeNotAssociative SourceUnpackSourceNoUnpackNoSourceUnpackedness SourceLazy SourceStrictNoSourceStrictness DecidedLazy DecidedStrict DecidedUnpackMetaDataMetaConsMetaSelVecRepTupleRepSumRepBoxedRepIntRepInt8RepInt16RepInt32RepInt64RepWordRepWord8Rep Word16Rep Word32Rep Word64RepAddrRepFloatRep DoubleRepLiftedUnliftedVec2Vec4Vec8Vec16Vec32Vec64 Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRepKindRepTyConApp KindRepVar KindRepApp KindRepFun KindRepTYPEKindRepTypeLitSKindRepTypeLitD TypeLitSymbol TypeLitNat TypeLitChar UnsafeReflOneManyMkSologtChar#geChar#eqChar#neChar#ltChar#leChar#ord# int8ToInt# intToInt8# negateInt8# plusInt8#subInt8# timesInt8# quotInt8#remInt8# quotRemInt8#uncheckedShiftLInt8#uncheckedShiftRAInt8#uncheckedShiftRLInt8# int8ToWord8#eqInt8#geInt8#gtInt8#leInt8#ltInt8#neInt8# word8ToWord# wordToWord8# plusWord8# subWord8# timesWord8# quotWord8# remWord8# quotRemWord8# andWord8#orWord8# xorWord8# notWord8#uncheckedShiftLWord8#uncheckedShiftRLWord8# word8ToInt8#eqWord8#geWord8#gtWord8#leWord8#ltWord8#neWord8# int16ToInt# intToInt16# negateInt16# plusInt16# subInt16# timesInt16# quotInt16# remInt16# quotRemInt16#uncheckedShiftLInt16#uncheckedShiftRAInt16#uncheckedShiftRLInt16#int16ToWord16#eqInt16#geInt16#gtInt16#leInt16#ltInt16#neInt16# word16ToWord# wordToWord16# plusWord16# subWord16# timesWord16# quotWord16# remWord16#quotRemWord16# andWord16# orWord16# xorWord16# notWord16#uncheckedShiftLWord16#uncheckedShiftRLWord16#word16ToInt16# eqWord16# geWord16# gtWord16# leWord16# ltWord16# neWord16# int32ToInt# intToInt32# negateInt32# plusInt32# subInt32# timesInt32# quotInt32# remInt32# quotRemInt32#uncheckedShiftLInt32#uncheckedShiftRAInt32#uncheckedShiftRLInt32#int32ToWord32#eqInt32#geInt32#gtInt32#leInt32#ltInt32#neInt32# word32ToWord# wordToWord32# plusWord32# subWord32# timesWord32# quotWord32# remWord32#quotRemWord32# andWord32# orWord32# xorWord32# notWord32#uncheckedShiftLWord32#uncheckedShiftRLWord32#word32ToInt32# eqWord32# geWord32# gtWord32# leWord32# ltWord32# neWord32# int64ToInt# intToInt64# negateInt64# plusInt64# subInt64# timesInt64# quotInt64# remInt64#uncheckedIShiftL64#uncheckedIShiftRA64#uncheckedIShiftRL64#int64ToWord64#eqInt64#geInt64#gtInt64#leInt64#ltInt64#neInt64# word64ToWord# wordToWord64# plusWord64# subWord64# timesWord64# quotWord64# remWord64#and64#or64#xor64#not64#uncheckedShiftL64#uncheckedShiftRL64#word64ToInt64# eqWord64# geWord64# gtWord64# leWord64# ltWord64# neWord64#+#-#*# timesInt2#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# addWordC# subWordC# plusWord2# minusWord# timesWord# timesWord2# quotWord#remWord# quotRemWord# quotRemWord2#and#or#xor#not#uncheckedShiftL#uncheckedShiftRL# word2Int#gtWord#geWord#eqWord#neWord#ltWord#leWord#popCnt8# popCnt16# popCnt32# popCnt64#popCnt#pdep8#pdep16#pdep32#pdep64#pdep#pext8#pext16#pext32#pext64#pext#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# bitReverse8# bitReverse16# bitReverse32# bitReverse64# bitReverse# narrow8Int# narrow16Int# narrow32Int# narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble# fabsDouble# double2Int# double2Float# expDouble# expm1Double# logDouble# log1pDouble# sqrtDouble# sinDouble# cosDouble# tanDouble# asinDouble# acosDouble# atanDouble# sinhDouble# coshDouble# tanhDouble# asinhDouble# acoshDouble# atanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#castDoubleToWord64#castWord64ToDouble#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat# minusFloat# timesFloat# divideFloat# negateFloat# fabsFloat# float2Int# expFloat# expm1Float# logFloat# log1pFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat# asinhFloat# acoshFloat# atanhFloat# powerFloat# float2Double#decodeFloat_Int#castFloatToWord32#castWord32ToFloat# fmaddFloat# fmsubFloat# fnmaddFloat# fnmsubFloat# fmaddDouble# fmsubDouble# fnmaddDouble# fnmsubDouble# newArray# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#shrinkSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#getSizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#mutableByteArrayContents#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#unsafeThawByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexWord8Array#indexInt16Array#indexWord16Array#indexInt32Array#indexWord32Array#indexInt64Array#indexWord64Array#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsInt#indexWord8ArrayAsWord#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsWord16#indexWord8ArrayAsInt32#indexWord8ArrayAsWord32#indexWord8ArrayAsInt64#indexWord8ArrayAsWord64#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readWord8Array#readInt16Array#readWord16Array#readInt32Array#readWord32Array#readInt64Array#readWord64Array#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsInt#readWord8ArrayAsWord#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsWord16#readWord8ArrayAsInt32#readWord8ArrayAsWord32#readWord8ArrayAsInt64#readWord8ArrayAsWord64#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeWord8Array#writeInt16Array#writeWord16Array#writeInt32Array#writeWord32Array#writeInt64Array#writeWord64Array#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsInt#writeWord8ArrayAsWord#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsWord16#writeWord8ArrayAsInt32#writeWord8ArrayAsWord32#writeWord8ArrayAsInt64#writeWord8ArrayAsWord64#compareByteArrays#copyByteArray#copyMutableByteArray##copyMutableByteArrayNonOverlapping#copyByteArrayToAddr#copyMutableByteArrayToAddr#copyAddrToByteArray#copyAddrToAddr#copyAddrToAddrNonOverlapping# setByteArray# setAddrRange#atomicReadIntArray#atomicWriteIntArray# casIntArray# casInt8Array#casInt16Array#casInt32Array#casInt64Array#fetchAddIntArray#fetchSubIntArray#fetchAndIntArray#fetchNandIntArray#fetchOrIntArray#fetchXorIntArray# plusAddr# minusAddr#remAddr# addr2Int# int2Addr#gtAddr#geAddr#eqAddr#neAddr#ltAddr#leAddr#indexCharOffAddr#indexWideCharOffAddr#indexIntOffAddr#indexWordOffAddr#indexAddrOffAddr#indexFloatOffAddr#indexDoubleOffAddr#indexStablePtrOffAddr#indexInt8OffAddr#indexWord8OffAddr#indexInt16OffAddr#indexWord16OffAddr#indexInt32OffAddr#indexWord32OffAddr#indexInt64OffAddr#indexWord64OffAddr#indexWord8OffAddrAsChar#indexWord8OffAddrAsWideChar#indexWord8OffAddrAsInt#indexWord8OffAddrAsWord#indexWord8OffAddrAsAddr#indexWord8OffAddrAsFloat#indexWord8OffAddrAsDouble#indexWord8OffAddrAsStablePtr#indexWord8OffAddrAsInt16#indexWord8OffAddrAsWord16#indexWord8OffAddrAsInt32#indexWord8OffAddrAsWord32#indexWord8OffAddrAsInt64#indexWord8OffAddrAsWord64#readCharOffAddr#readWideCharOffAddr#readIntOffAddr#readWordOffAddr#readAddrOffAddr#readFloatOffAddr#readDoubleOffAddr#readStablePtrOffAddr#readInt8OffAddr#readWord8OffAddr#readInt16OffAddr#readWord16OffAddr#readInt32OffAddr#readWord32OffAddr#readInt64OffAddr#readWord64OffAddr#readWord8OffAddrAsChar#readWord8OffAddrAsWideChar#readWord8OffAddrAsInt#readWord8OffAddrAsWord#readWord8OffAddrAsAddr#readWord8OffAddrAsFloat#readWord8OffAddrAsDouble#readWord8OffAddrAsStablePtr#readWord8OffAddrAsInt16#readWord8OffAddrAsWord16#readWord8OffAddrAsInt32#readWord8OffAddrAsWord32#readWord8OffAddrAsInt64#readWord8OffAddrAsWord64#writeCharOffAddr#writeWideCharOffAddr#writeIntOffAddr#writeWordOffAddr#writeAddrOffAddr#writeFloatOffAddr#writeDoubleOffAddr#writeStablePtrOffAddr#writeInt8OffAddr#writeWord8OffAddr#writeInt16OffAddr#writeWord16OffAddr#writeInt32OffAddr#writeWord32OffAddr#writeInt64OffAddr#writeWord64OffAddr#writeWord8OffAddrAsChar#writeWord8OffAddrAsWideChar#writeWord8OffAddrAsInt#writeWord8OffAddrAsWord#writeWord8OffAddrAsAddr#writeWord8OffAddrAsFloat#writeWord8OffAddrAsDouble#writeWord8OffAddrAsStablePtr#writeWord8OffAddrAsInt16#writeWord8OffAddrAsWord16#writeWord8OffAddrAsInt32#writeWord8OffAddrAsWord32#writeWord8OffAddrAsInt64#writeWord8OffAddrAsWord64#atomicExchangeAddrAddr#atomicExchangeWordAddr#atomicCasAddrAddr#atomicCasWordAddr#atomicCasWord8Addr#atomicCasWord16Addr#atomicCasWord32Addr#atomicCasWord64Addr#fetchAddWordAddr#fetchSubWordAddr#fetchAndWordAddr#fetchNandWordAddr#fetchOrWordAddr#fetchXorWordAddr#atomicReadWordAddr#atomicWriteWordAddr# newMutVar# readMutVar# writeMutVar#atomicSwapMutVar#atomicModifyMutVar2#atomicModifyMutVar_# casMutVar#catch#raise#raiseUnderflow#raiseOverflow# raiseDivZero#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# newPromptTag#prompt# control0# atomically#retry# catchRetry# catchSTM#newTVar# readTVar# readTVarIO# writeTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# isEmptyMVar#delay# waitRead# waitWrite#fork#forkOn# killThread#yield# myThreadId# labelThread#isCurrentThreadBound# noDuplicate# threadLabel# threadStatus# listThreads#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark# getSpark# numSparks# keepAlive# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure# closureSize#getApStackVal# getCCSOf#getCurrentCCS# clearCCS#annotateStack# traceEvent#traceBinaryEvent# traceMarker#setThreadAllocationCounter# setOtherThreadAllocationCounter#broadcastInt8X16#broadcastInt16X8#broadcastInt32X4#broadcastInt64X2#broadcastInt8X32#broadcastInt16X16#broadcastInt32X8#broadcastInt64X4#broadcastInt8X64#broadcastInt16X32#broadcastInt32X16#broadcastInt64X8#broadcastWord8X16#broadcastWord16X8#broadcastWord32X4#broadcastWord64X2#broadcastWord8X32#broadcastWord16X16#broadcastWord32X8#broadcastWord64X4#broadcastWord8X64#broadcastWord16X32#broadcastWord32X16#broadcastWord64X8#broadcastFloatX4#broadcastDoubleX2#broadcastFloatX8#broadcastDoubleX4#broadcastFloatX16#broadcastDoubleX8# packInt8X16# packInt16X8# packInt32X4# packInt64X2# packInt8X32# packInt16X16# packInt32X8# packInt64X4# packInt8X64# packInt16X32# packInt32X16# packInt64X8# packWord8X16# packWord16X8# packWord32X4# packWord64X2# packWord8X32#packWord16X16# packWord32X8# packWord64X4# packWord8X64#packWord16X32#packWord32X16# packWord64X8# packFloatX4# packDoubleX2# packFloatX8# packDoubleX4# packFloatX16# packDoubleX8#unpackInt8X16#unpackInt16X8#unpackInt32X4#unpackInt64X2#unpackInt8X32#unpackInt16X16#unpackInt32X8#unpackInt64X4#unpackInt8X64#unpackInt16X32#unpackInt32X16#unpackInt64X8#unpackWord8X16#unpackWord16X8#unpackWord32X4#unpackWord64X2#unpackWord8X32#unpackWord16X16#unpackWord32X8#unpackWord64X4#unpackWord8X64#unpackWord16X32#unpackWord32X16#unpackWord64X8#unpackFloatX4#unpackDoubleX2#unpackFloatX8#unpackDoubleX4#unpackFloatX16#unpackDoubleX8#insertInt8X16#insertInt16X8#insertInt32X4#insertInt64X2#insertInt8X32#insertInt16X16#insertInt32X8#insertInt64X4#insertInt8X64#insertInt16X32#insertInt32X16#insertInt64X8#insertWord8X16#insertWord16X8#insertWord32X4#insertWord64X2#insertWord8X32#insertWord16X16#insertWord32X8#insertWord64X4#insertWord8X64#insertWord16X32#insertWord32X16#insertWord64X8#insertFloatX4#insertDoubleX2#insertFloatX8#insertDoubleX4#insertFloatX16#insertDoubleX8# plusInt8X16# plusInt16X8# plusInt32X4# plusInt64X2# plusInt8X32# plusInt16X16# plusInt32X8# plusInt64X4# plusInt8X64# plusInt16X32# plusInt32X16# plusInt64X8# plusWord8X16# plusWord16X8# plusWord32X4# plusWord64X2# plusWord8X32#plusWord16X16# plusWord32X8# plusWord64X4# plusWord8X64#plusWord16X32#plusWord32X16# plusWord64X8# plusFloatX4# plusDoubleX2# plusFloatX8# plusDoubleX4# plusFloatX16# plusDoubleX8# minusInt8X16# minusInt16X8# minusInt32X4# minusInt64X2# minusInt8X32#minusInt16X16# minusInt32X8# minusInt64X4# minusInt8X64#minusInt16X32#minusInt32X16# minusInt64X8#minusWord8X16#minusWord16X8#minusWord32X4#minusWord64X2#minusWord8X32#minusWord16X16#minusWord32X8#minusWord64X4#minusWord8X64#minusWord16X32#minusWord32X16#minusWord64X8# minusFloatX4#minusDoubleX2# minusFloatX8#minusDoubleX4#minusFloatX16#minusDoubleX8# timesInt8X16# timesInt16X8# timesInt32X4# timesInt64X2# timesInt8X32#timesInt16X16# timesInt32X8# timesInt64X4# timesInt8X64#timesInt16X32#timesInt32X16# timesInt64X8#timesWord8X16#timesWord16X8#timesWord32X4#timesWord64X2#timesWord8X32#timesWord16X16#timesWord32X8#timesWord64X4#timesWord8X64#timesWord16X32#timesWord32X16#timesWord64X8# timesFloatX4#timesDoubleX2# timesFloatX8#timesDoubleX4#timesFloatX16#timesDoubleX8#divideFloatX4#divideDoubleX2#divideFloatX8#divideDoubleX4#divideFloatX16#divideDoubleX8# quotInt8X16# quotInt16X8# quotInt32X4# quotInt64X2# quotInt8X32# quotInt16X16# quotInt32X8# quotInt64X4# quotInt8X64# quotInt16X32# quotInt32X16# quotInt64X8# quotWord8X16# quotWord16X8# quotWord32X4# quotWord64X2# quotWord8X32#quotWord16X16# quotWord32X8# quotWord64X4# quotWord8X64#quotWord16X32#quotWord32X16# quotWord64X8# remInt8X16# remInt16X8# remInt32X4# remInt64X2# remInt8X32# remInt16X16# remInt32X8# remInt64X4# remInt8X64# remInt16X32# remInt32X16# remInt64X8# remWord8X16# remWord16X8# remWord32X4# remWord64X2# remWord8X32# remWord16X16# remWord32X8# remWord64X4# remWord8X64# remWord16X32# remWord32X16# remWord64X8#negateInt8X16#negateInt16X8#negateInt32X4#negateInt64X2#negateInt8X32#negateInt16X16#negateInt32X8#negateInt64X4#negateInt8X64#negateInt16X32#negateInt32X16#negateInt64X8#negateFloatX4#negateDoubleX2#negateFloatX8#negateDoubleX4#negateFloatX16#negateDoubleX8#indexInt8X16Array#indexInt16X8Array#indexInt32X4Array#indexInt64X2Array#indexInt8X32Array#indexInt16X16Array#indexInt32X8Array#indexInt64X4Array#indexInt8X64Array#indexInt16X32Array#indexInt32X16Array#indexInt64X8Array#indexWord8X16Array#indexWord16X8Array#indexWord32X4Array#indexWord64X2Array#indexWord8X32Array#indexWord16X16Array#indexWord32X8Array#indexWord64X4Array#indexWord8X64Array#indexWord16X32Array#indexWord32X16Array#indexWord64X8Array#indexFloatX4Array#indexDoubleX2Array#indexFloatX8Array#indexDoubleX4Array#indexFloatX16Array#indexDoubleX8Array#readInt8X16Array#readInt16X8Array#readInt32X4Array#readInt64X2Array#readInt8X32Array#readInt16X16Array#readInt32X8Array#readInt64X4Array#readInt8X64Array#readInt16X32Array#readInt32X16Array#readInt64X8Array#readWord8X16Array#readWord16X8Array#readWord32X4Array#readWord64X2Array#readWord8X32Array#readWord16X16Array#readWord32X8Array#readWord64X4Array#readWord8X64Array#readWord16X32Array#readWord32X16Array#readWord64X8Array#readFloatX4Array#readDoubleX2Array#readFloatX8Array#readDoubleX4Array#readFloatX16Array#readDoubleX8Array#writeInt8X16Array#writeInt16X8Array#writeInt32X4Array#writeInt64X2Array#writeInt8X32Array#writeInt16X16Array#writeInt32X8Array#writeInt64X4Array#writeInt8X64Array#writeInt16X32Array#writeInt32X16Array#writeInt64X8Array#writeWord8X16Array#writeWord16X8Array#writeWord32X4Array#writeWord64X2Array#writeWord8X32Array#writeWord16X16Array#writeWord32X8Array#writeWord64X4Array#writeWord8X64Array#writeWord16X32Array#writeWord32X16Array#writeWord64X8Array#writeFloatX4Array#writeDoubleX2Array#writeFloatX8Array#writeDoubleX4Array#writeFloatX16Array#writeDoubleX8Array#indexInt8X16OffAddr#indexInt16X8OffAddr#indexInt32X4OffAddr#indexInt64X2OffAddr#indexInt8X32OffAddr#indexInt16X16OffAddr#indexInt32X8OffAddr#indexInt64X4OffAddr#indexInt8X64OffAddr#indexInt16X32OffAddr#indexInt32X16OffAddr#indexInt64X8OffAddr#indexWord8X16OffAddr#indexWord16X8OffAddr#indexWord32X4OffAddr#indexWord64X2OffAddr#indexWord8X32OffAddr#indexWord16X16OffAddr#indexWord32X8OffAddr#indexWord64X4OffAddr#indexWord8X64OffAddr#indexWord16X32OffAddr#indexWord32X16OffAddr#indexWord64X8OffAddr#indexFloatX4OffAddr#indexDoubleX2OffAddr#indexFloatX8OffAddr#indexDoubleX4OffAddr#indexFloatX16OffAddr#indexDoubleX8OffAddr#readInt8X16OffAddr#readInt16X8OffAddr#readInt32X4OffAddr#readInt64X2OffAddr#readInt8X32OffAddr#readInt16X16OffAddr#readInt32X8OffAddr#readInt64X4OffAddr#readInt8X64OffAddr#readInt16X32OffAddr#readInt32X16OffAddr#readInt64X8OffAddr#readWord8X16OffAddr#readWord16X8OffAddr#readWord32X4OffAddr#readWord64X2OffAddr#readWord8X32OffAddr#readWord16X16OffAddr#readWord32X8OffAddr#readWord64X4OffAddr#readWord8X64OffAddr#readWord16X32OffAddr#readWord32X16OffAddr#readWord64X8OffAddr#readFloatX4OffAddr#readDoubleX2OffAddr#readFloatX8OffAddr#readDoubleX4OffAddr#readFloatX16OffAddr#readDoubleX8OffAddr#writeInt8X16OffAddr#writeInt16X8OffAddr#writeInt32X4OffAddr#writeInt64X2OffAddr#writeInt8X32OffAddr#writeInt16X16OffAddr#writeInt32X8OffAddr#writeInt64X4OffAddr#writeInt8X64OffAddr#writeInt16X32OffAddr#writeInt32X16OffAddr#writeInt64X8OffAddr#writeWord8X16OffAddr#writeWord16X8OffAddr#writeWord32X4OffAddr#writeWord64X2OffAddr#writeWord8X32OffAddr#writeWord16X16OffAddr#writeWord32X8OffAddr#writeWord64X4OffAddr#writeWord8X64OffAddr#writeWord16X32OffAddr#writeWord32X16OffAddr#writeWord64X8OffAddr#writeFloatX4OffAddr#writeDoubleX2OffAddr#writeFloatX8OffAddr#writeDoubleX4OffAddr#writeFloatX16OffAddr#writeDoubleX8OffAddr#indexInt8ArrayAsInt8X16#indexInt16ArrayAsInt16X8#indexInt32ArrayAsInt32X4#indexInt64ArrayAsInt64X2#indexInt8ArrayAsInt8X32#indexInt16ArrayAsInt16X16#indexInt32ArrayAsInt32X8#indexInt64ArrayAsInt64X4#indexInt8ArrayAsInt8X64#indexInt16ArrayAsInt16X32#indexInt32ArrayAsInt32X16#indexInt64ArrayAsInt64X8#indexWord8ArrayAsWord8X16#indexWord16ArrayAsWord16X8#indexWord32ArrayAsWord32X4#indexWord64ArrayAsWord64X2#indexWord8ArrayAsWord8X32#indexWord16ArrayAsWord16X16#indexWord32ArrayAsWord32X8#indexWord64ArrayAsWord64X4#indexWord8ArrayAsWord8X64#indexWord16ArrayAsWord16X32#indexWord32ArrayAsWord32X16#indexWord64ArrayAsWord64X8#indexFloatArrayAsFloatX4#indexDoubleArrayAsDoubleX2#indexFloatArrayAsFloatX8#indexDoubleArrayAsDoubleX4#indexFloatArrayAsFloatX16#indexDoubleArrayAsDoubleX8#readInt8ArrayAsInt8X16#readInt16ArrayAsInt16X8#readInt32ArrayAsInt32X4#readInt64ArrayAsInt64X2#readInt8ArrayAsInt8X32#readInt16ArrayAsInt16X16#readInt32ArrayAsInt32X8#readInt64ArrayAsInt64X4#readInt8ArrayAsInt8X64#readInt16ArrayAsInt16X32#readInt32ArrayAsInt32X16#readInt64ArrayAsInt64X8#readWord8ArrayAsWord8X16#readWord16ArrayAsWord16X8#readWord32ArrayAsWord32X4#readWord64ArrayAsWord64X2#readWord8ArrayAsWord8X32#readWord16ArrayAsWord16X16#readWord32ArrayAsWord32X8#readWord64ArrayAsWord64X4#readWord8ArrayAsWord8X64#readWord16ArrayAsWord16X32#readWord32ArrayAsWord32X16#readWord64ArrayAsWord64X8#readFloatArrayAsFloatX4#readDoubleArrayAsDoubleX2#readFloatArrayAsFloatX8#readDoubleArrayAsDoubleX4#readFloatArrayAsFloatX16#readDoubleArrayAsDoubleX8#writeInt8ArrayAsInt8X16#writeInt16ArrayAsInt16X8#writeInt32ArrayAsInt32X4#writeInt64ArrayAsInt64X2#writeInt8ArrayAsInt8X32#writeInt16ArrayAsInt16X16#writeInt32ArrayAsInt32X8#writeInt64ArrayAsInt64X4#writeInt8ArrayAsInt8X64#writeInt16ArrayAsInt16X32#writeInt32ArrayAsInt32X16#writeInt64ArrayAsInt64X8#writeWord8ArrayAsWord8X16#writeWord16ArrayAsWord16X8#writeWord32ArrayAsWord32X4#writeWord64ArrayAsWord64X2#writeWord8ArrayAsWord8X32#writeWord16ArrayAsWord16X16#writeWord32ArrayAsWord32X8#writeWord64ArrayAsWord64X4#writeWord8ArrayAsWord8X64#writeWord16ArrayAsWord16X32#writeWord32ArrayAsWord32X16#writeWord64ArrayAsWord64X8#writeFloatArrayAsFloatX4#writeDoubleArrayAsDoubleX2#writeFloatArrayAsFloatX8#writeDoubleArrayAsDoubleX4#writeFloatArrayAsFloatX16#writeDoubleArrayAsDoubleX8#indexInt8OffAddrAsInt8X16#indexInt16OffAddrAsInt16X8#indexInt32OffAddrAsInt32X4#indexInt64OffAddrAsInt64X2#indexInt8OffAddrAsInt8X32#indexInt16OffAddrAsInt16X16#indexInt32OffAddrAsInt32X8#indexInt64OffAddrAsInt64X4#indexInt8OffAddrAsInt8X64#indexInt16OffAddrAsInt16X32#indexInt32OffAddrAsInt32X16#indexInt64OffAddrAsInt64X8#indexWord8OffAddrAsWord8X16#indexWord16OffAddrAsWord16X8#indexWord32OffAddrAsWord32X4#indexWord64OffAddrAsWord64X2#indexWord8OffAddrAsWord8X32#indexWord16OffAddrAsWord16X16#indexWord32OffAddrAsWord32X8#indexWord64OffAddrAsWord64X4#indexWord8OffAddrAsWord8X64#indexWord16OffAddrAsWord16X32#indexWord32OffAddrAsWord32X16#indexWord64OffAddrAsWord64X8#indexFloatOffAddrAsFloatX4#indexDoubleOffAddrAsDoubleX2#indexFloatOffAddrAsFloatX8#indexDoubleOffAddrAsDoubleX4#indexFloatOffAddrAsFloatX16#indexDoubleOffAddrAsDoubleX8#readInt8OffAddrAsInt8X16#readInt16OffAddrAsInt16X8#readInt32OffAddrAsInt32X4#readInt64OffAddrAsInt64X2#readInt8OffAddrAsInt8X32#readInt16OffAddrAsInt16X16#readInt32OffAddrAsInt32X8#readInt64OffAddrAsInt64X4#readInt8OffAddrAsInt8X64#readInt16OffAddrAsInt16X32#readInt32OffAddrAsInt32X16#readInt64OffAddrAsInt64X8#readWord8OffAddrAsWord8X16#readWord16OffAddrAsWord16X8#readWord32OffAddrAsWord32X4#readWord64OffAddrAsWord64X2#readWord8OffAddrAsWord8X32#readWord16OffAddrAsWord16X16#readWord32OffAddrAsWord32X8#readWord64OffAddrAsWord64X4#readWord8OffAddrAsWord8X64#readWord16OffAddrAsWord16X32#readWord32OffAddrAsWord32X16#readWord64OffAddrAsWord64X8#readFloatOffAddrAsFloatX4#readDoubleOffAddrAsDoubleX2#readFloatOffAddrAsFloatX8#readDoubleOffAddrAsDoubleX4#readFloatOffAddrAsFloatX16#readDoubleOffAddrAsDoubleX8#writeInt8OffAddrAsInt8X16#writeInt16OffAddrAsInt16X8#writeInt32OffAddrAsInt32X4#writeInt64OffAddrAsInt64X2#writeInt8OffAddrAsInt8X32#writeInt16OffAddrAsInt16X16#writeInt32OffAddrAsInt32X8#writeInt64OffAddrAsInt64X4#writeInt8OffAddrAsInt8X64#writeInt16OffAddrAsInt16X32#writeInt32OffAddrAsInt32X16#writeInt64OffAddrAsInt64X8#writeWord8OffAddrAsWord8X16#writeWord16OffAddrAsWord16X8#writeWord32OffAddrAsWord32X4#writeWord64OffAddrAsWord64X2#writeWord8OffAddrAsWord8X32#writeWord16OffAddrAsWord16X16#writeWord32OffAddrAsWord32X8#writeWord64OffAddrAsWord64X4#writeWord8OffAddrAsWord8X64#writeWord16OffAddrAsWord16X32#writeWord32OffAddrAsWord32X16#writeWord64OffAddrAsWord64X8#writeFloatOffAddrAsFloatX4#writeDoubleOffAddrAsDoubleX2#writeFloatOffAddrAsFloatX8#writeDoubleOffAddrAsDoubleX4#writeFloatOffAddrAsFloatX16#writeDoubleOffAddrAsDoubleX8#prefetchByteArray3#prefetchMutableByteArray3#prefetchAddr3#prefetchValue3#prefetchByteArray2#prefetchMutableByteArray2#prefetchAddr2#prefetchValue2#prefetchByteArray1#prefetchMutableByteArray1#prefetchAddr1#prefetchValue1#prefetchByteArray0#prefetchMutableByteArray0#prefetchAddr0#prefetchValue0#WordBox MkWordBoxIntBoxMkIntBoxFloatBox MkFloatBox DoubleBox MkDoubleBoxDictBox MkDictBoxKindBndrVoid#SPEC2MultMulisTrue#getSoloGHC.Internal.Data.TuplefstsndcurryuncurryswapGHC.Internal.Prim.PtrEqreallyUnsafePtrEqualityunsafePtrEquality# sameArray#sameMutableArray#sameSmallArray#sameSmallMutableArray#sameByteArray#sameMutableByteArray# sameMutVar# sameTVar# sameMVar#samePromptTag# eqStableName#withDict dataToTag# unpackNBytes#<<=>/=ipeqWordneWordeqCharneChareqFloateqDoubleeqIntneIntgtIntgeIntltIntleInt compareInt compareInt#gtWordgeWordltWordleWord compareWord compareWord#&&||notdivInt8# divInt16# divInt32#modInt8# modInt16# modInt32# divModInt# divModInt8# divModInt16# divModInt32#$dm==$dm/= $dmcompare$dm<$dm<=$dm>$dm>=$dmmax$dmmin srcLocEndCol srcLocEndLinesrcLocStartColsrcLocStartLine srcLocFile srcLocModule srcLocPackageEmptyCallStack PushCallStackFreezeCallStack HasCallStack getCallStackfromCallSiteListfreezeCallStackGHC.Internal.Bignum.BigNatBigNatBN#unBigNatGHC.Internal.NaturalNatJ#NatS# mkNaturalisValidNatural plusNatural minusNaturalminusNaturalMaybe timesNatural negateNatural signumNaturalquotRemNatural remNatural quotNatural gcdNatural lcmNatural andNatural orNatural xorNatural bitNaturaltestBitNaturalpopCountNatural shiftLNatural shiftRNaturalnaturalToInteger naturalToWordnaturalFromInteger wordToNaturalnaturalToWordMaybewordToNatural# powModNaturalGHC.Internal.Integer.Logarithms wordLog2# integerLog2#integerLogBase#GHC.Internal.Integer smallInteger integerToInt wordToInteger integerToWordencodeFloatIntegerencodeDoubleIntegerdecodeDoubleInteger plusInteger minusInteger timesInteger negateInteger absInteger signumInteger divModInteger divInteger modIntegerquotRemInteger quotInteger remInteger eqInteger neqInteger leInteger gtInteger ltInteger geIntegercompareInteger eqInteger# neqInteger# leInteger# gtInteger# ltInteger# geInteger# andInteger orInteger xorIntegercomplementInteger shiftLInteger shiftRIntegertestBitInteger hashInteger bitIntegerpopCountIntegerGHC.Internal.ByteOrder ByteOrder BigEndian LittleEndiantargetByteOrderGHC.Internal.Exception.Type SomeException ExceptiondivZeroExceptionoverflowExceptionratioZeroDenomExceptionunderflowExceptionthrowIO mkUserErrormplusIOGHC.Internal.IO.Handle.TypesHandleGHC.Internal.ExceptionerrorCallWithCallStackExceptionerrorCallExceptionGHC.Internal.ErrerrorerrorWithoutStackTrace undefined absentErrabssignum$dm- $dmnegatequotremdivmodquotRemdivMod$dmquot$dmrem$dmdiv$dmmod $dmdivModOpaqueO:| MonadPlusmzeromplus Alternativeempty<|>somemanyliftA2<*<$sconcatstimesabsurdvacuous<**>liftAliftA3=<<whensequencemapMliftMliftM2liftM3liftM4liftM5apmapFB unsafeChrordminIntmaxIntid breakpointbreakpointCondconst.flip$!untilasTypeOffailIOunIOgetTagquotIntremIntdivIntmodInt quotRemInt divModInt shift_maskshiftL#shiftRL#iShiftL# iShiftRA# iShiftRL#$dm<$$dm<*> $dmliftA2$dm*>$dm<*$dm>> $dmreturn$dmsome$dmmany$dmmzero$dmmplus$dm<> $dmsconcat $dmstimes $dmmempty $dmmappend $dmmconcatGHC.Internal.StackwithFrozenCallStack prettySrcLocprettyCallStackprettyCallStackLinesGHC.Internal.Data.VersionVersion makeVersionGHC.Internal.Unicode.VersionunicodeVersionIOError IOExceptionunsupportedOperation userErrorGHC.Internal.IO.Handle.Text hPutStrLnsubtractGHC.Internal.Data.MaybemaybeisJust isNothingfromJust fromMaybe maybeToList listToMaybe catMaybesmapMaybeheadunconsunsnoctaillastinitnulllengthfoldlfoldl'foldl1foldl1'sumproductscanlscanl1scanl'foldr'foldr1scanrscanr1maximumminimumiterateiterate'repeat replicate takeWhile dropWhiletakedropsplitAtspanbreakreverseandoranyallelemnotElemlookup concatMap!!!?zip3zipWithzipWith3unzipunzip3errorEmptyList showsPrecshowshowListShowS showList__appPrecappPrec1showsshowChar showString showParen showSpaceshowCommaSpace showLitChar showLitStringshowMultiLineString protectEscasciiTab intToDigit showSignedInt $dmshowsPrec$dmshow $dmshowList traceMarkerIO traceMarker traceEventIO traceEvent traceStack traceShowMtraceM traceShowId traceShowtraceIdtraceIOGHC.Internal.Text.Show showListWithGHC.Internal.Data.NonEmpty"GHC.Internal.Float.RealFracMethodsproperFractionFloatInt floorFloatIntceilingFloatInt roundFloatIntproperFractionFloatIntegertruncateFloatIntegerfloorFloatIntegerceilingFloatIntegerroundFloatIntegerproperFractionDoubleIntfloorDoubleIntceilingDoubleIntroundDoubleIntproperFractionDoubleIntegertruncateDoubleIntegerfloorDoubleIntegerceilingDoubleIntegerroundDoubleInteger double2Int int2Double float2Int int2Float"GHC.Internal.Float.ConversionUtilselimZerosInteger elimZerosInt#GHC.Internal.CharchrsuccpredtoEnumfromEnumminBoundmaxBoundboundedEnumFromboundedEnumFromThen toEnumError fromEnumError succError predError$dmsucc$dmpred $dmenumFrom$dmenumFromThen $dmenumFromTo$dmenumFromThenToFractionalExponentBaseBase2Base10properFractiontruncateroundceilingfloor/recip divZeroErrorratioZeroDenominatorError overflowErrorunderflowError ratioPrec ratioPrec1infinity notANumberreduce% numerator denominatornumericEnumFromnumericEnumFromThennumericEnumFromTonumericEnumFromThenTo showSignedevenoddpowImpl powImplAcc^^^%^^^%^^gcdlcmintegralEnumFromintegralEnumFromThenintegralEnumFromTointegralEnumFromThenTomkRationalWithExponentBase$dm/$dmrecip $dmtruncate$dmround $dmceiling$dmfloorGHC.Internal.Bits FiniteBits finiteBitSizecountLeadingZeroscountTrailingZerosBits.&..|.xor complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSignedshiftL unsafeShiftLshiftR unsafeShiftRrotateLrotateRpopCount bitDefaulttestBitDefaultpopCountDefaulttoIntegralSized$dmshift $dmrotate $dmzeroBits $dmsetBit $dmclearBit$dmcomplementBit $dmbitSize $dmshiftL$dmunsafeShiftL $dmshiftR$dmunsafeShiftR $dmrotateL $dmrotateR$dmcountLeadingZeros$dmcountTrailingZerosGHC.Internal.STSTretSTRepSTliftSTunsafeInterleaveSTunsafeDupableInterleaveSTrunSTrangeindex unsafeIndexinRange rangeSizeunsafeRangeSize indexError$dmindex$dmunsafeIndex $dmrangeSize$dmunsafeRangeSizeW64#W32#W16#W8#eqWord8neWord8gtWord8geWord8ltWord8leWord8eqWord16neWord16gtWord16geWord16ltWord16leWord16 byteSwap16eqWord32neWord32gtWord32geWord32ltWord32leWord32 byteSwap32eqWord64neWord64gtWord64geWord64ltWord64leWord64 byteSwap64 bitReverse8 bitReverse16 bitReverse32 bitReverse64GHC.Internal.ArrSTArrayArray arrEleBottomarray unsafeArray unsafeArray'filldone listArray! safeRangeSizenegRange safeIndex lessSafeIndex badSafeIndexunsafeAtbounds numElementsindiceselems foldrElems foldlElems foldrElems' foldlElems' foldl1Elems foldr1Elemsassocs accumArrayunsafeAccumArrayunsafeAccumArray'adjust// unsafeReplaceaccum unsafeAccumamapixmapeqArraycmpArray cmpIntArray newSTArray boundsSTArraynumElementsSTArray readSTArrayunsafeReadSTArray writeSTArrayunsafeWriteSTArray freezeSTArrayunsafeFreezeSTArray thawSTArrayunsafeThawSTArrayFFFormat FFExponentFFFixed FFGeneric floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhlog1pexpm1log1pexplog1mexpisDoubleFiniteisDoubleNegativeZeroisDoubleDenormalizedisDoubleInfinite isDoubleNaN isFloatFiniteisFloatNegativeZeroisFloatDenormalizedisFloatInfinite isFloatNaN log1mexpOrd floorFloat ceilingFloat truncateFloat roundFloatproperFractionFloat floorDouble ceilingDoubletruncateDouble roundDoubleproperFractionDouble showFloatformatRealFloatformatRealFloatAltroundTo floatToDigitsintegerToBinaryFloat'fromRatfromRat'minExptmaxExptexptexpts maxExpt10expts10 fromRat'' roundingMode# plusFloat minusFloat timesFloat divideFloat negateFloatgtFloatgeFloatltFloatleFloatexpFloat expm1FloatlogFloat log1pFloat sqrtFloat fabsFloatsinFloatcosFloattanFloat asinFloat acosFloat atanFloat sinhFloat coshFloat tanhFloat asinhFloat acoshFloat atanhFloat powerFloat plusDouble minusDouble timesDouble divideDouble negateDoublegtDoublegeDoubleltDoubleleDouble double2Float float2Double expDouble expm1Double logDouble log1pDouble sqrtDouble fabsDouble sinDouble cosDouble tanDouble asinDouble acosDouble atanDouble sinhDouble coshDouble tanhDouble asinhDouble acoshDouble atanhDouble powerDouble word2Double word2FloatshowSignedFloatclampstgDoubleToWord64stgWord64ToDoublestgFloatToWord32stgWord32ToFloatcastWord32ToFloatcastFloatToWord32castWord64ToDoublecastDoubleToWord64$dmsqrt$dm** $dmlogBase$dmtan$dmtanh$dmlog1p$dmexpm1 $dmlog1pexp $dmlog1mexp $dmexponent$dmsignificand $dmscaleFloat$dmatan2 unsafeCoerceunsafeCoerceUnliftedunsafeCoerceAddrGHC.Internal.ArrayArrayMutableArrayArray# ArrayArray#newArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray#sameArrayArray#sameMutableArrayArray#GHC.Internal.STRefSTRefnewSTRef readSTRef writeSTRefGHC.Internal.IO.UnsafeunsafePerformIOunsafeDupablePerformIOunsafeInterleaveIOunsafeDupableInterleaveIO noDuplicateGHC.Internal.Data.BoolboolAssert ErrorMessageGHC.Internal.Data.Type.BoolNotIfGHC.Internal.Data.Functor<$><&>$>voidGHC.Internal.IO.SubSystem IoSubSystemIoPOSIXIoNative conditionalisWindowsNativeIO ioSubSystemwithIoSubSystemwithIoSubSystem'whenIoSubSystemGHC.Internal.ClockgetMonotonicTimeNSecgetMonotonicTimeGHC.Internal.Data.Functionfixon& applyWhenGHC.Internal.UnicodeGeneralCategoryUppercaseLetterLowercaseLetterTitlecaseLetterModifierLetter OtherLetterNonSpacingMarkSpacingCombiningMark EnclosingMark DecimalNumber LetterNumber OtherNumberConnectorPunctuationDashPunctuationOpenPunctuationClosePunctuation InitialQuote FinalQuoteOtherPunctuation MathSymbolCurrencySymbolModifierSymbol OtherSymbolSpace LineSeparatorParagraphSeparatorControlFormat Surrogate PrivateUse NotAssignedgeneralCategoryisAsciiisLatin1 isAsciiLower isAsciiUpper isControlisPrintisSpaceisUpper isUpperCaseisLower isLowerCase isAlphaNumisDigit isOctDigit isHexDigit isPunctuationisSymboltoUppertoLowertoTitle)GHC.Internal.Text.ParserCombinators.ReadPReadPReadSgetlookpfail+++<++gathersatisfychareofstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTill readP_to_S readS_to_PGHC.Internal.Text.Read.LexNumberLexemePuncIdentEOFnumberToInteger numberToFixednumberToRangedRationalnumberToRationallexexpecthsLex isSymbolCharlexCharreadIntPreadBinPreadOctPreadDecPreadHexP,GHC.Internal.Text.ParserCombinators.ReadPrecPrecReadPrecminPrecliftstepresetprec readPrec_to_P readP_to_Prec readPrec_to_S readS_to_Prec readsPrecreadListreadPrec readListPrec readParenreadListDefaultreadListPrecDefault lexLitChar readLitChar lexDigitslexPexpectPparenparenslistchoose readField readFieldHash readSymField readNumber $dmreadsPrec $dmreadList $dmreadPrec$dmreadListPrecreadIntreadBinreadOctreadDecreadHex readFloat readSignedshowInt showHFloat showIntAtBaseshowHexshowOctshowBinnullPtrcastPtrplusPtralignPtrminusPtr nullFunPtr castFunPtrcastFunPtrToPtrcastPtrToFunPtrGHC.Internal.Conc.Sync ThreadStatus ThreadRunningThreadFinished ThreadBlocked ThreadDied BlockReason BlockedOnMVarBlockedOnBlackHoleBlockedOnException BlockedOnSTMBlockedOnForeignCallBlockedOnOtherTVarThreadIdlabelThreadByteArray# sharedCAF threadStatus showThreadId myThreadIdforkIO freeStablePtrdeRefStablePtrcastStablePtrToPtrcastPtrToStablePtrGHC.Internal.MVarPrimMVarMVar newEmptyMVarnewMVartakeMVarreadMVarputMVar tryTakeMVar tryPutMVar tryReadMVar isEmptyMVaraddMVarFinalizernewStablePtrPrimMVar unConstPtrGHC.Internal.FingerprintfingerprintStringfingerprintFingerprintsGHC.Internal.Data.BitsIffgetIffXorgetXorIorgetIorAndgetAndoneBits.^..>>..<<.!>>.!<<.I64#I32#I16#I8#eqInt8neInt8gtInt8geInt8ltInt8leInt8eqInt16neInt16gtInt16geInt16ltInt16leInt16eqInt32neInt32gtInt32geInt32ltInt32leInt32eqInt64neInt64gtInt64geInt64ltInt64leInt64 shiftRLInt8# shiftRLInt16# shiftRLInt32#GHC.Internal.StorablereadWideCharOffPtr readIntOffPtrreadWordOffPtr readPtrOffPtrreadFunPtrOffPtrreadFloatOffPtrreadDoubleOffPtrreadStablePtrOffPtrreadInt8OffPtrreadWord8OffPtrreadInt16OffPtrreadWord16OffPtrreadInt32OffPtrreadWord32OffPtrreadInt64OffPtrreadWord64OffPtrwriteWideCharOffPtrwriteIntOffPtrwriteWordOffPtrwritePtrOffPtrwriteFunPtrOffPtrwriteFloatOffPtrwriteDoubleOffPtrwriteStablePtrOffPtrwriteInt8OffPtrwriteWord8OffPtrwriteInt16OffPtrwriteWord16OffPtrwriteInt32OffPtrwriteWord32OffPtrwriteInt64OffPtrwriteWord64OffPtrGHC.Internal.Foreign.StorableStorablesizeOf alignment peekElemOff pokeElemOff peekByteOff pokeByteOffpeekpoke$dmpeekElemOff$dmpokeElemOff$dmpeekByteOff$dmpokeByteOff$dmpeek$dmpokeGHC.Internal.Data.OrdDowngetDown comparingGHC.Internal.Data.Type.OrdOrdCondMinMax>?=?<=? OrderingILTIEQIGTICompareGHC.Internal.Data.Type.Equality TestEquality testEquality:~~:HRefl:~:ReflsymtranscastWith gcastWithapplyinnerouterGHC.Internal.Data.Type.Coercion TestCoercion testCoercionCoercion coerceWith gcoerceWithreprGHC.Internal.Data.ProxyKProxyProxy asProxyTypeOfeitherleftsrightspartitionEithersisLeftisRightfromLeft fromRightGHC.Internal.Text.Readreads readEither readMaybereadSNatSomeNatnatSingNatnatValnatVal' someNatValsameNat decideNatcmpNatfromSNat withKnownNat withSomeSNatSCharSSymbolSomeCharcharSing SomeSymbol symbolSing symbolVal symbolVal'charValcharVal' someSymbolVal someCharVal sameSymbol decideSymbolsameChar decideChar cmpSymbolcmpChar fromSSymbolwithKnownSymbolwithSomeSSymbol fromSChar withKnownChar withSomeSCharGHC.Internal.Foreign.C.TypesCUIntMaxCIntMaxCUIntPtrCIntPtrCJmpBufCFposCFile CSUSeconds CUSecondsCTimeCClock CSigAtomicCWcharCSizeCPtrdiffCDoubleCFloatCBoolCULLongCLLongCULongCLongCUIntCIntCUShortCShortCUCharCSCharCCharGHC.Internal.IO.IOModeIOModeReadMode WriteMode AppendMode ReadWriteModeGHC.Internal.Foreign.PtrIntPtrWordPtrfreeHaskellFunPtr ptrToWordPtr wordPtrToPtr ptrToIntPtr intPtrToPtrKindRepTypeLitCon'ConAppFun modulePackage moduleName tyConPackage tyConModule tyConNametyConFingerprint tyConKindArgs tyConKindRep rnfModulernfTyContypeRepFingerprint trLiftedRep withTypeablesomeTypeRepTyCon typeRepTyCon eqTypeRep decTypeRep typeRepKindtypeReptypeOf someTypeRepsomeTypeRepFingerprint splitApps rnfTypeReprnfSomeTypeRepmkTyConGHC.Internal.Data.Typeable showsTypeRepcasteqTdecTheqThdecTgcastgcast1gcast2 funResultTymkFunTy splitTyConApp typeRepArgstypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7Meta Generically1 Genericallyfrom1to1fromtoselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessDecidedStrictnessSourceStrictnessSourceUnpackedness AssociativityFixityIFixityPrefixInfixconName conFixity conIsRecord datatypeName packageName isNewtypeComp1unComp1L1R1unM1unK1unRec1unPar1uWord#uInt#uFloat#uDouble#uChar#uAddr# $dmisNewtype $dmconFixity$dmconIsRecord$GHC.Internal.Data.Semigroup.InternalAltgetAltProduct getProductSumgetSumgetAnyAllgetAllEndoappEndoDualgetDualstimesIdempotentstimesIdempotentMonoid stimesMonoidGHC.Internal.Data.MonoidApgetApgetLastgetFirstfoldfoldMapfoldMap'foldrMfoldlM traverse_for_mapM_forM_ sequenceA_ sequence_asummsum maximumBy minimumByfind$dmfold $dmfoldMap $dmfoldMap'$dmfoldr $dmfoldr'$dmfoldl $dmfoldl' $dmfoldr1 $dmfoldl1 $dmtoList$dmnull $dmlength$dmelem$dmsum $dmproductGHC.Internal.Data.Functor.ConstConstgetConstGHC.Internal.Data.OldList dropWhileEnd stripPrefix elemIndex elemIndices findIndex findIndices isPrefixOf isSuffixOf isInfixOfnubnubBydeletedeleteBy\\unionunionBy intersect intersectBy intersperse intercalate partitioninsertinsertBy genericLength genericTake genericDropgenericSplitAt genericIndexgenericReplicatezip4zip5zip6zip7zipWith4zipWith5zipWith6zipWith7unzip4unzip5unzip6unzip7deleteFirstsBygroupgroupByinitstails subsequences permutationssort singletonlinesunlineswordsunwordsExceptionAnnotationdisplayExceptionAnnotationSomeExceptionAnnotationaddExceptionAnnotationgetExceptionAnnotationsgetAllExceptionAnnotationsdisplayExceptionContext$dmdisplayExceptionAnnotationArithExceptionOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominatorExceptionWithContext NoBacktrace toException fromExceptiondisplayExceptionbacktraceDesired WhileHandlingsomeExceptionContextaddExceptionContextdisplayExceptionWithInfo$dmtoException$dmfromException$dmdisplayException$dmbacktraceDesired ErrorCallErrorCallWithLocationthrowDynamicfromDyn fromDynamicdynApplydynApp dynTypeRep"GHC.Internal.IO.Handle.Lock.CommonLockMode SharedLock ExclusiveLockFileLockingNotSupported MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleFilePathliftIOstToIOioToST unsafeIOToST unsafeSTToIOcatchExceptioncatchcatchNoPropagatecatchAny annotateIO rethrowIO unsafeUnmask interruptiblegetMaskingState onExceptionmask_maskuninterruptibleMask_uninterruptibleMaskbracketfinallyevaluateGHC.Internal.IORefIORefnewIORef readIORef writeIORefatomicModifyIORef2LazyatomicModifyIORef2atomicModifyIORefPatomicModifyIORefLazy_atomicModifyIORef'_atomicSwapIORefatomicModifyIORef'GHC.Internal.ForeignPtrFinalizerEnvPtr FinalizerPtrForeignPtrContentsPlainForeignPtrFinalPtr MallocPtrPlainPtr Finalizers NoFinalizers CFinalizersHaskellFinalizersnewConcForeignPtrmallocForeignPtrmallocForeignPtrBytesmallocForeignPtrAlignedBytesmallocPlainForeignPtrmallocPlainForeignPtrBytes!mallocPlainForeignPtrAlignedBytesaddForeignPtrFinalizerEnvaddForeignPtrConcFinalizernewForeignPtr_withForeignPtrunsafeWithForeignPtrtouchForeignPtrunsafeForeignPtrToPtrcastForeignPtrplusForeignPtrfinalizeForeignPtr#GHC.Internal.Foreign.ForeignPtr.Imp newForeignPtrnewForeignPtrEnvmallocForeignPtrArraymallocForeignPtrArray0GHC.Internal.IO.Buffer BufferState ReadBuffer WriteBuffer CharBufferBufferbufRbufL bufOffsetbufSizebufStatebufRaw RawCharBuffer CharBufElem RawBuffer readWord8Buf writeWord8Buf peekCharBuf readCharBuf writeCharBufreadCharBufPtrwriteCharBufPtrcharSize withBuffer withRawBuffer isEmptyBuffer isFullBufferisFullCharBuffer isWriteBuffer bufferElemsbufferAvailable bufferRemove bufferAdjustL bufferAdd bufferOffsetbufferAdjustOffsetbufferAddOffset emptyBuffer newByteBuffer newCharBuffer newBuffer slideContents summaryBuffer checkBufferGHC.Internal.IO.Encoding.TypesCodingProgressInputUnderflowOutputUnderflowInvalidSequence TextEncoding mkTextEncoder mkTextDecodertextEncodingName TextEncoder TextDecoderEncodingBuffer#DecodingBuffer# EncodeBuffer# DecodeBuffer# EncodeBuffer DecodeBuffer CodeBuffer BufferCodec BufferCodec# setState# getState#close#recover#encode#encoderecoverclosegetStatesetStateGHC.Internal.IO.EncodinggetLocaleEncodinggetFileSystemEncodinggetForeignEncodingGHC.Internal.IO.DeviceSeekMode AbsoluteSeek RelativeSeek SeekFromEnd IODeviceType DirectoryStream RegularFile RawDeviceIODeviceready isTerminal isSeekableseektellgetSizesetSizesetEchogetEchosetRawdevTypedupdup2RawIOreadNonBlockingwritewriteNonBlocking $dmisTerminal $dmisSeekable$dmseek$dmtell $dmgetSize $dmsetSize $dmsetEcho $dmgetEcho $dmsetRaw$dmdup$dmdup2GHC.Internal.IO.BufferedIO BufferedIOfillReadBufferfillReadBuffer0emptyWriteBufferflushWriteBufferflushWriteBuffer0readBufreadBufNonBlockingwriteBufwriteBufNonBlocking$dmemptyWriteBuffer NewlineModeoutputNLinputNLNewlineLFCRLF BufferMode NoBuffering LineBufferingBlockBuffering HandleType ClosedHandleSemiClosedHandle ReadHandle WriteHandle AppendHandleReadWriteHandle BufferList BufferListNilBufferListConsHandle__ haOtherSide haOutputNL haInputNLhaCodec haDecoder haEncoder haBuffers haCharBuffer haLastDecode haBufferMode haByteBufferhaTypehaDevice FileHandle DuplexHandleisReadableHandleTypeisWritableHandleTypeisReadWriteHandleTypeisAppendHandleTypecheckHandleInvariants nativeNewlineuniversalNewlineModenativeNewlineModenoNewlineTranslation showHandleGHC.Internal.IO.StdHandlesstdoutGHC.Internal.IO.Handle.FDGHC.Internal.IO.HandlehFlush IOErrorType AlreadyExists NoSuchThing ResourceBusyResourceExhaustedIllegalOperationPermissionDenied UserErrorUnsatisfiedConstraints SystemError ProtocolError OtherErrorInvalidArgumentInappropriateType HardwareFaultUnsupportedOperation TimeExpiredResourceVanished Interrupted ioe_filename ioe_errnoioe_description ioe_locationioe_type ioe_handleExitCode ExitSuccess ExitFailureFixIOExceptionArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionAssertionFailedCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMblockedIndefinitelyOnMVarblockedIndefinitelyOnSTMallocationLimitExceededcannotCompactFunctioncannotCompactPinnedcannotCompactMutableasyncExceptionToExceptionasyncExceptionFromException stackOverflow heapOverflow ioExceptionioErroruntangle GHC.Internal.IO.Encoding.FailureCodingFailureModeErrorOnCodingFailureIgnoreCodingFailureTransliterateCodingFailureRoundtripFailurecodingFailureModeSuffix isSurrogaterecoverDecode# recoverDecoderecoverEncode# recoverEncodeGHC.Internal.IO.Encoding.UTF8utf8mkUTF8utf8_bom mkUTF8_bomGHC.Internal.IO.Encoding.UTF32utf32mkUTF32 utf32_encode utf32_decodeutf32be mkUTF32beutf32le mkUTF32leutf32be_decodeutf32le_decodeutf32be_encodeutf32le_encodeGHC.Internal.IO.Encoding.UTF16utf16mkUTF16 utf16_encode utf16_decodeutf16be mkUTF16beutf16le mkUTF16leutf16be_decodeutf16le_decodeutf16be_encodeutf16le_encodeGHC.Internal.IO.Encoding.Latin1latin1mkLatin1latin1_checkedmkLatin1_checkedasciimkAscii latin1_decode ascii_decode latin1_encodelatin1_checked_encode ascii_encode"GHC.Internal.Foreign.Marshal.Alloc finalizerFreemalloccalloc mallocBytes callocBytesalloca allocaBytesallocaBytesAlignedrealloc reallocBytesfree"GHC.Internal.Foreign.Marshal.UtilsnewwithfromBooltoBoolmaybeNew maybeWith maybePeekwithMany copyBytes moveBytes fillBytes"GHC.Internal.Foreign.Marshal.Array mallocArray mallocArray0 callocArray callocArray0 allocaArray allocaArray0 reallocArray reallocArray0 peekArray peekArray0 pokeArray pokeArray0newArray newArray0 withArray withArrayLen withArray0 withArrayLen0 copyArray moveArray lengthArray0 advancePtr&GHC.Internal.Foreign.C.String.Encoding CStringLenCString peekCStringpeekCStringLen newCString newCStringLen withCStringwithCStringLennewCStringLen0withCStringLen0withCStringsLencharIsRepresentableGHC.Internal.Foreign.C.String CWStringLenCWStringcastCCharToCharcastCharToCCharcastCUCharToCharcastCharToCUCharcastCSCharToCharcastCharToCSChar peekCAStringpeekCAStringLen newCAStringnewCAStringLen withCAStringwithCAStringLen peekCWStringpeekCWStringLen newCWStringnewCWStringLen withCWStringwithCWStringLenGHC.Internal.Foreign.C.ErrorErrnoeOKe2BIGeACCES eADDRINUSE eADDRNOTAVAILeADV eAFNOSUPPORTeAGAINeALREADYeBADFeBADMSGeBADRPCeBUSYeCHILDeCOMM eCONNABORTED eCONNREFUSED eCONNRESETeDEADLK eDESTADDRREQeDIRTYeDOMeDQUOTeEXISTeFAULTeFBIGeFTYPE eHOSTDOWN eHOSTUNREACHeIDRMeILSEQ eINPROGRESSeINTReINVALeIOeISCONNeISDIReLOOPeMFILEeMLINKeMSGSIZE eMULTIHOP eNAMETOOLONGeNETDOWN eNETRESET eNETUNREACHeNFILEeNOBUFSeNODATAeNODEVeNOENTeNOEXECeNOLCKeNOLINKeNOMEMeNOMSGeNONET eNOPROTOOPTeNOSPCeNOSReNOSTReNOSYSeNOTBLKeNOTCONNeNOTDIR eNOTEMPTYeNOTSOCKeNOTSUPeNOTTYeNXIO eOPNOTSUPPePERM ePFNOSUPPORTePIPEePROCLIM ePROCUNAVAIL ePROGMISMATCH ePROGUNAVAILePROTOePROTONOSUPPORT ePROTOTYPEeRANGEeREMCHGeREMOTEeROFS eRPCMISMATCHeRREMOTE eSHUTDOWNeSOCKTNOSUPPORTeSPIPEeSRCHeSRMNTeSTALEeTIME eTIMEDOUT eTOOMANYREFSeTXTBSYeUSERS eWOULDBLOCKeXDEV isValidErrnogetErrno resetErrno throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfRetrythrowErrnoIfRetryMayBlockthrowErrnoIfRetry_throwErrnoIfRetryMayBlock_throwErrnoIfMinus1throwErrnoIfMinus1_throwErrnoIfMinus1RetrythrowErrnoIfMinus1Retry_throwErrnoIfMinus1RetryMayBlock throwErrnoIfMinus1RetryMayBlock_throwErrnoIfNullthrowErrnoIfNullRetrythrowErrnoIfNullRetryMayBlockthrowErrnoPaththrowErrnoPathIfthrowErrnoPathIf_throwErrnoPathIfNullthrowErrnoPathIfMinus1throwErrnoPathIfMinus1_errnoToIOErrorGHC.Internal.IO.Encoding.IconvlocaleEncodingName iconvEncodingmkIconvEncodingGHC.Internal.IOArrayIOArray newIOArrayunsafeReadIOArrayunsafeWriteIOArray readIOArray writeIOArray boundsIOArrayGHC.Internal.Event.TimeOut TimeoutKeyTK TimeoutEditTimeoutCallback TimeoutQueueGHC.Internal.Encoding.UTF8utf8DecodeCharAddr#utf8DecodeCharPtrutf8DecodeCharByteArray#utf8DecodeForeignPtrutf8DecodeByteArray#utf8CompareByteArray#utf8CountCharsByteArray# utf8EncodePtrutf8EncodeByteArray#utf8EncodedLengthGHC.Internal.Weak.FinalizegetFinalizerExceptionHandlersetFinalizerExceptionHandler&printToHandleFinalizerExceptionHandlerGHC.Internal.WeakWeakmkWeak deRefWeakfinalizeGHC.Internal.Data.IORef mkWeakIORef modifyIORef modifyIORef'atomicModifyIORefatomicWriteIORefsetLocaleEncodingsetFileSystemEncodingsetForeignEncodinginitLocaleEncoding argvEncodingchar8mkTextEncodingGHC.Internal.Stack.CCS CostCentreCostCentreStack getCurrentCCSgetCCSOfclearCCSccsCC ccsParentccLabelccModule ccSrcSpancurrentCallStack ccsToStrings whoCreated renderStackerrorWithStackTrace popCallStack callStackSTMreportHeapOverflow fromThreadIdsetAllocationCountergetAllocationCounterenableAllocationLimitdisableAllocationLimitforkIOWithUnmaskforkOnforkOnWithUnmasknumCapabilitiesgetNumCapabilitiessetNumCapabilitiesgetNumProcessors numSparks childHandler killThreadthrowToyield labelThreadpseqpar runSparks listThreadsthreadCapability threadLabelmkWeakThreadId unsafeIOToSTM atomicallyretryorElsethrowSTMcatchSTMnewTVar newTVarIO readTVarIOreadTVar writeTVarwithMVar modifyMVar_reportStackOverflow reportErrorsetUncaughtExceptionHandlergetUncaughtExceptionHandlerNoMatchingContinuationPromptNestedAtomicallyNonTermination NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFail catchJusthandle handleJust mapExceptiontrytryWithContexttryJustbracket_bracketOnErrornonTerminationnestedAtomicallynoMatchingContinuationPromptGHC.Internal.System.IO.Error tryIOError mkIOErrorisAlreadyExistsErrorisDoesNotExistErrorisAlreadyInUseError isFullError isEOFErrorisIllegalOperationisPermissionError isUserErrorisResourceVanishedErroralreadyExistsErrorTypedoesNotExistErrorTypealreadyInUseErrorType fullErrorType eofErrorTypeillegalOperationErrorTypepermissionErrorType userErrorTyperesourceVanishedErrorTypeisAlreadyExistsErrorTypeisDoesNotExistErrorTypeisAlreadyInUseErrorTypeisFullErrorTypeisEOFErrorTypeisIllegalOperationErrorTypeisPermissionErrorTypeisUserErrorTypeisResourceVanishedErrorTypeioeGetErrorTypeioeGetErrorStringioeGetLocation ioeGetHandleioeGetFileNameioeSetErrorTypeioeSetErrorStringioeSetLocation ioeSetHandleioeSetFileName modifyIOErrorannotateIOError catchIOError$GHC.Internal.Control.Concurrent.MVarswapMVarwithMVarMasked modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVarGHC.Internal.Conc.Signal HandlerFunSignal setHandler runHandlersrunHandlersPtr!GHC.Internal.Control.Monad.ST.ImpfixST GHC.Internal.IO.Handle.InternalsHandleFinalizeraddHandleFinalizer withHandle withHandle' withHandle_ withHandle_'withAllHandles__ withHandle__'augmentIOErrorwantWritableHandlewantReadableHandlewantReadableHandle_wantSeekableHandleioe_closedHandleioe_semiclosedHandleioe_EOFioe_notReadableioe_notWritableioe_finalizedHandle ioe_bufsizhandleFinalizerdEFAULT_CHAR_BUFFER_SIZE flushBufferflushCharBufferflushByteWriteBufferwriteCharBufferflushCharReadBufferflushByteReadBuffermkHandlemkFileHandleNoFinalizer mkFileHandlemkDuplexHandleNoFinalizermkDuplexHandleinitBufferStateopenTextEncodingcloseTextCodecs hClose_impl hClose_help hLookAhead_debugIOreadTextDevicereadTextDeviceNonBlocking decodeByteBufGHC.Internal.Control.ExceptionHandlercatchesallowInterruptmemcpyhGetCharhGetLine hGetContents'hPutCharhPutStr commitBuffer'hPutBufNonBlocking hGetBufSomehGetBufNonBlocking!GHC.Internal.Event.Internal.TypesLifetimeOneShot MultiShotEventevtReadevtWriteGHC.Internal.Event.TimerManager TimerManagerregisterTimeoutunregisterTimeout updateTimeoutGHC.Internal.Event.Manager EventManager IOCallbackFdKeykeyFd registerFd unregisterFd_ unregisterFdcloseFdGHC.Internal.Event.ThreadgetSystemEventManagergetSystemTimerManagerGHC.Internal.Conc.IOensureIOManagerIsRunninginterruptIOManagerioManagerCapabilitiesChangedthreadWaitReadthreadWaitWritethreadWaitReadSTMthreadWaitWriteSTM threadDelay registerDelayGHC.Internal.IO.FDFDfdIsNonBlockingfdFD openFileWithopenFilemkFDstdinstderrreleasesetNonBlockingModereadRawBufferPtrreadRawBufferPtrNoBlockwriteRawBufferPtrwithFileopenFileBlockingwithFileBlockingopenBinaryFilewithBinaryFilemkHandleFromFD fdToHandle' fdToHandle handleToFdGHC.Internal.IO.Handle.LockhLockhTryLockhUnlockHandlePosition HandlePosnhClose hFileSize hSetFileSizehIsEOFisEOF hLookAhead hSetBuffering hSetEncoding hGetEncoding hFlushAllhGetPosnhSetPosnhSeekhTellhIsOpen hIsClosed hIsReadable hIsWritable hGetBuffering hIsSeekablehSetEchohGetEchohIsTerminalDevicehSetBinaryModehSetNewlineMode hDuplicate hDuplicateTohShowputCharputStrputStrLngetChargetLine getContents getContents'interactreadFile readFile' writeFile appendFilereadLnreadIOlocaleEncodinghReadyhPrint openTempFileopenBinaryTempFile"openTempFileWithDefaultPermissions(openBinaryTempFileWithDefaultPermissions fingerprint0fingerprintData getFileHash"GHC.Internal.Data.Functor.IdentityIdentity runIdentitytraverse sequenceAforforM mapAccumL mapAccumR mapAccumM forAccumM fmapDefaultfoldMapDefault $dmtraverse $dmsequenceA$dmmapM $dmsequenceisSubsequenceOf versionTags versionBranch showVersion parseVersionGHC.Internal.Stack.CloneStack StackSnapshot cloneMyStackcloneThreadStackGHC.Internal.InfoProv.Types InfoProvEntInfoProv ipSrcSpan ipSrcFileipModipUnitIdipLabelipTyDescipDescipNameipLocipeProv peekInfoProvConIndex ConstrRep AlgConstr IntConstr FloatConstr CharConstrDataRepAlgRepCharRepNoRepConstrDataTypegfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMo fromConstr fromConstrB fromConstrM dataTypeName dataTypeRep constrType constrRep repConstr mkDataType mkConstrTagmkConstrdataTypeConstrs constrFields constrFixity showConstr readConstr isAlgType indexConstr constrIndexmaxConstrIndex mkIntType mkFloatType mkCharTypemkIntegralConstr mkRealConstr mkCharConstr mkNoRepType isNorepType tyconUQname tyconModule $dmgfoldl $dmdataCast1 $dmdataCast2$dmgmapT $dmgmapQl $dmgmapQr$dmgmapQ $dmgmapQi$dmgmapM $dmgmapMp $dmgmapMoGHC.Internal.Functor.ZipListZipList getZipListItem $dmfromListN putTraceMsg traceWith traceShowWithtraceEventWith flushEventLogSpecConstrAnnotation NoSpecConstrForceSpecConstr maxTupleSizethesortWith groupWithatomicModifyMutVar#resizeSmallMutableArray#GHC.Internal.Stack.Decode StackEntry closureTypesrcLoc functionNamedecode$GHC.Internal.ExecutionStack.InternalLocation objectName sourceColumn sourceLine sourceFile GHC.Internal.Exception.Backtrace BacktracesBacktraceMechanismCostCentreBacktraceHasCallStackBacktraceExecutionBacktrace IPEBacktracegetBacktraceMechanismStatesetBacktraceMechanismStatedisplayBacktracescollectBacktracesGHC.Internal.System.MemperformMinorGCperformBlockingMajorGCperformMajorGC performGCGHC.Internal.ProfilingstopHeapProfTimerstartHeapProfTimerrequestHeapCensusstartProfTimer stopProfTimerIsLabelNoIOGHC.Internal.Data.STRef modifySTRef modifySTRef'#GHC.Internal.Control.Monad.IO.ClassMonadIOGHC.Internal.StableName StableNamemakeStableNamehashStableName eqStableName#GHC.Internal.Foreign.Marshal.UnsafeunsafeLocalStateGHC.Internal.Control.CategoryCategory<<<GHC.Internal.Foreign.ConcurrentGHC.Internal.System.ExitexitWith exitFailure exitSuccessdieGHC.Internal.Data.UniqueUnique newUnique hashUnique"GHC.Internal.Foreign.Marshal.ErrorthrowIfthrowIf_ throwIfNeg throwIfNeg_ throwIfNull!GHC.Internal.Foreign.Marshal.PoolPoolnewPoolfreePoolwithPool pooledMallocpooledMallocBytes pooledReallocpooledReallocBytespooledMallocArraypooledMallocArray0pooledReallocArraypooledReallocArray0 pooledNewpooledNewArraypooledNewArray0 spInfoSrcLocspInfoModuleName spInfoUnitIdIsStatic StaticKeydeRefStaticPtr staticKeyunsafeLookupStaticPtr staticPtrInfo staticPtrKeys#GHC.Internal.Type.Reflection.UnsafemkTrAppGHC.Internal.InfoProv whereFromGHC.Internal.Environment getFullArgs.GHC.Internal.System.Environment.ExecutablePathgetExecutablePathexecutablePath getProgNamegetEnv lookupEnvsetEnvunsetEnvwithArgs withProgNamegetEnvironmentGHC.Internal.GHCi.HelpersdisableBufferingflushAll evalWrapper%GHC.Internal.System.Environment.Blank getEnvDefaultGHC.Internal.ResponseFilegetArgsWithResponseFiles unescapeArgs escapeArgsexpandResponseGHC.Internal.ExecutionStack getStackTraceshowStackTraceGHC.Internal.Data.List.NonEmptyfilterM>=><=<forever mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_unless<$!>mfilterMonadZipmzipWithmunzip$dmmzip $dmmzipWith $dmmunzip&GHC.Internal.Control.Monad.ST.Lazy.ImpstrictToLazySTlazyToStrictST ArrowLoop ArrowMonad ArrowApply ArrowChoiceleftright ArrowPlus<+> ArrowZero zeroArrowKleisli runKleisliArrowsecond***&&&returnA^>>>>^<<^^<<leftApp$dm***$dm&&&$dmleft$dmright$dm+++$dm|||AnnotationWrapperrunIO runIOFastExitrunNonIO topHandlertopHandlerFastExitflushStdHandlesGHC.Internal.Conc.BoundrtsSupportsBoundThreadsforkOSforkOSWithUnmaskisCurrentThreadBoundrunInBoundThreadrunInUnboundThread digitToIntisLetterisMarkisNumber isSeparator enumerate WrappedArrow WrapArrow unwrapArrow WrappedMonad WrapMonad unwrapMonad$fAlternativeWrappedArrow$fApplicativeWrappedArrow$fFunctorWrappedArrow$fAlternativeWrappedMonad$fApplicativeWrappedMonad$fFunctorWrappedMonad$fGenericWrappedArrow$fGeneric1TYPEWrappedArrow$fGenericWrappedMonad$fGeneric1TYPEWrappedMonad$fMonadWrappedMonad$fDataWrappedArrow$fDataWrappedMonadinits1tails1 compareLengthrunFinalizerBatch GCDetails&gcdetails_nonmoving_gc_sync_elapsed_ns"gcdetails_nonmoving_gc_sync_cpu_nsgcdetails_elapsed_nsgcdetails_cpu_nsgcdetails_sync_elapsed_ns#gcdetails_block_fragmentation_bytes#gcdetails_par_balanced_copied_bytesgcdetails_par_max_copied_bytesgcdetails_copied_bytesgcdetails_mem_in_use_bytesgcdetails_slop_bytesgcdetails_compact_bytesgcdetails_large_objects_bytesgcdetails_live_bytesgcdetails_allocated_bytesgcdetails_threads gcdetails_genRTSStatsgcnonmoving_gc_max_elapsed_nsnonmoving_gc_elapsed_nsnonmoving_gc_cpu_ns nonmoving_gc_sync_max_elapsed_nsnonmoving_gc_sync_elapsed_nsnonmoving_gc_sync_cpu_ns elapsed_nscpu_ns gc_elapsed_ns gc_cpu_nsmutator_elapsed_nsmutator_cpu_nsinit_elapsed_ns init_cpu_ns$cumulative_par_balanced_copied_bytescumulative_par_max_copied_bytespar_copied_bytes copied_bytescumulative_live_bytesmax_mem_in_use_bytesmax_slop_bytesmax_compact_bytesmax_large_objects_bytesmax_live_bytesallocated_bytes major_gcsgcsRtsTime getRTSStatsgetRTSStatsEnabled$fReadRTSStats$fShowRTSStats$fGenericRTSStats$fReadGCDetails$fShowGCDetails$fGenericGCDetailsRTSFlagshpcFlagsparFlags tickyFlags traceFlagsprofilingFlagscostCentreFlags debugFlags miscFlagsconcurrentFlagsgcFlagsHpcFlags writeTixFile readTixFileParFlags setAffinity parGcThreadsparGcNoSyncWithIdleparGcLoadBalancingGenparGcLoadBalancingEnabledparGcGen parGcEnabledmaxLocalSparksmigrate nCapabilities TickyFlags tickyFileshowTickyStats TraceFlagsuser sparksFull sparksSampledtraceNonmovingGctraceGctraceScheduler timestamptracingDoTrace TraceNone TraceEventLog TraceStderr ProfFlags eraSelector bioSelectorretainerSelector ccsSelector ccSelector typeSelector descrSelector modSelector ccsLengthmaxRetainerSetSizeautomaticEraIncrementshowCCSOnExceptionstartTimeProfileAtStartupstartHeapProfileAtStartupheapProfileIntervalTicksheapProfileInterval doHeapProfile DoHeapProfileNoHeapProfiling HeapByCCS HeapByMod HeapByDescr HeapByTypeHeapByRetainer HeapByLDVHeapByClosureTypeHeapByInfoTable HeapByEraCCFlags msecsPerTick profilerTicks doCostCentres DoCostCentresCostCentresNoneCostCentresSummaryCostCentresVerboseCostCentresAllCostCentresJSON DebugFlagssparkshpcsqueezestmlinkerprofstablesanity block_alloc nonmoving_gcgccafsweak interpreter scheduler IoManagerFlagIoManagerFlagAutoIoManagerFlagSelectIoManagerFlagMIOIoManagerFlagWinIOIoManagerFlagWin32Legacy MiscFlagsnumIoWorkerThreads ioManager linkerMemBaselinkerAlwaysPicinternalCountersdisableDelayedOsMemoryReturnmachineReadablegenerateStackTracegenerateCrashDumpFileinstallSEHHandlersinstallSignalHandlers tickInterval ConcFlagsctxtSwitchTicksctxtSwitchTimeGCFlagsnumaMasknumaallocLimitGraceheapBasedoIdleGCidleGCDelayTimeringBellsweepcompactThresholdcompactsqueezeUpdFrames generations pcFreeHeapreturnDecayFactor oldGenFactorheapSizeSuggestionAutoheapSizeSuggestion minOldGenSizenurseryChunkSize largeAllocLimminAllocAreaSize maxHeapSizestkChunkBufferSize stkChunkSizeinitialStkSize maxStkSize giveStats statsFile GiveGCStats NoGCStatsCollectGCStatsOneLineGCStatsSummaryGCStatsVerboseGCStats getRTSFlags getGCFlags getParFlags getHpcFlags getConcFlags getMiscFlags getDebugFlags getCCFlags getProfFlags getTraceFlags getTickyFlags$fShowRTSFlags$fGenericRTSFlags$fShowHpcFlags$fGenericHpcFlags$fShowParFlags$fGenericParFlags$fShowTickyFlags$fGenericTickyFlags$fShowTraceFlags$fGenericTraceFlags $fShowDoTrace$fGenericDoTrace$fShowProfFlags$fGenericProfFlags$fShowDoHeapProfile$fGenericDoHeapProfile $fShowCCFlags$fGenericCCFlags$fShowDoCostCentres$fGenericDoCostCentres$fShowDebugFlags$fGenericDebugFlags$fShowMiscFlags$fGenericMiscFlags$fEqIoManagerFlag$fEnumIoManagerFlag$fShowIoManagerFlag$fShowConcFlags$fGenericConcFlags $fShowGCFlags$fGenericGCFlags$fShowGiveGCStats$fGenericGiveGCStatsapproxRationalunfoldnonEmpty<|conssome1 groupAllWithgroup1groupBy1 groupWith1 groupAllWith1 permutations1append appendList prependListPicoE12NanoE9MicroE6MilliE3CentiE2DeciE1UniE0 HasResolution resolutionFixedMkFixeddiv'divMod'mod' showFixed$fHasResolutionTYPEE12$fHasResolutionTYPEE9$fHasResolutionTYPEE6$fHasResolutionTYPEE3$fHasResolutionTYPEE2$fHasResolutionTYPEE1$fHasResolutionTYPEE0 $fReadFixed $fShowFixed$fRealFracFixed$fFractionalFixed $fRealFixed $fNumFixed $fEnumFixed$fHasResolutionNaturaln$fLiftBoxedRepFixed $fDataFixed $fEqFixed $fOrdFixedComplex:+realPartimagPart conjugatemkPolarcispolar magnitudephase$fMonadFixComplex$fMonadZipComplex$fMonadComplex$fApplicativeComplex$fStorableComplex$fFloatingComplex$fFractionalComplex $fNumComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1TYPEComplex$fFunctorComplex$fFoldableComplex$fTraversableComplexShow2liftShowsPrec2 liftShowList2Read2liftReadsPrec2 liftReadList2 liftReadPrec2liftReadListPrec2Ord2 liftCompare2Eq2liftEq2Show1 liftShowsPrec liftShowListRead1 liftReadsPrec liftReadList liftReadPrecliftReadListPrecOrd1 liftCompareEq1liftEqeq1compare1 readsPrec1 readPrec1liftReadListDefaultliftReadListPrecDefault showsPrec1eq2compare2 readsPrec2 readPrec2liftReadList2DefaultliftReadListPrec2Default showsPrec2 readsDatareadDatareadsUnaryWith readUnaryWithreadsBinaryWithreadBinaryWithshowsUnaryWithshowsBinaryWith readsUnary readsUnary1 readsBinary1 showsUnary showsUnary1 showsBinary1 $fShow1URec $fOrd1URec $fEq1URec $fShow1URec0 $fOrd1URec0 $fEq1URec0 $fShow1URec1 $fOrd1URec1 $fEq1URec1 $fShow1URec2 $fOrd1URec2 $fEq1URec2 $fShow1URec3 $fOrd1URec3 $fEq1URec3 $fShow1URec4 $fOrd1URec4 $fEq1URec4 $fRead1:.: $fShow1:.: $fOrd1:.:$fEq1:.: $fRead1:*: $fShow1:*: $fOrd1:*:$fEq1:*: $fRead1:+: $fShow1:+: $fOrd1:+:$fEq1:+: $fRead1M1 $fShow1M1$fOrd1M1$fEq1M1 $fRead1K1 $fShow1K1$fOrd1K1$fEq1K1 $fRead1Rec1 $fShow1Rec1 $fOrd1Rec1 $fEq1Rec1 $fRead1Par1 $fShow1Par1 $fOrd1Par1 $fEq1Par1 $fRead1U1 $fShow1U1$fOrd1U1$fEq1U1 $fRead1V1 $fShow1V1$fOrd1V1$fEq1V1$fShow1Complex$fRead1Complex $fEq1Complex $fShow1Down $fRead1Down $fOrd1Down $fEq1Down $fRead1Proxy $fShow1Proxy $fOrd1Proxy $fEq1Proxy $fShow1Const $fRead1Const $fOrd1Const $fEq1Const $fShow2Const $fRead2Const $fOrd2Const $fEq2Const$fShow1Identity$fRead1Identity$fOrd1Identity $fEq1Identity $fShow1Either $fRead1Either $fOrd1Either $fEq1Either $fShow2Either $fRead2Either $fOrd2Either $fEq2Either$fOrd1Generically1$fEq1Generically1 $fShow1Tuple4 $fRead1Tuple4 $fOrd1Tuple4 $fEq1Tuple4 $fShow2Tuple4 $fRead2Tuple4 $fOrd2Tuple4 $fEq2Tuple4 $fShow1Tuple3 $fRead1Tuple3 $fOrd1Tuple3 $fEq1Tuple3 $fShow2Tuple3 $fRead2Tuple3 $fOrd2Tuple3 $fEq2Tuple3 $fShow1Tuple2 $fShow1Solo $fRead1Tuple2 $fRead1Solo $fOrd1Tuple2 $fOrd1Solo $fEq1Tuple2 $fEq1Solo $fShow2Tuple2 $fRead2Tuple2 $fOrd2Tuple2 $fEq2Tuple2$fShow1NonEmpty$fRead1NonEmpty$fOrd1NonEmpty $fEq1NonEmpty $fShow1List $fRead1List $fOrd1List $fEq1List $fShow1Maybe $fRead1Maybe $fOrd1Maybe $fEq1MaybeInLInR$fTraversableSum $fFoldableSum $fFunctorSum $fShow1Sum $fRead1Sum $fOrd1Sum$fEq1Sum $fDataSum $fGenericSum$fGeneric1kSum $fShowSum $fReadSum$fOrdSum$fEqSumPair$fMonoidProduct$fSemigroupProduct$fMonadZipProduct$fMonadFixProduct$fMonadPlusProduct$fMonadProduct$fAlternativeProduct$fApplicativeProduct$fTraversableProduct$fFoldableProduct$fFunctorProduct$fShow1Product$fRead1Product $fOrd1Product $fEq1Product $fDataProduct$fGenericProduct$fGeneric1kProduct $fShowProduct $fReadProduct $fOrdProduct $fEqProduct getCompose$fTestEqualitykCompose$fAlternativeCompose$fApplicativeCompose$fTraversableCompose$fFoldableCompose$fFunctorCompose$fShow1Compose$fRead1Compose $fOrd1Compose $fEq1Compose $fShowCompose $fReadCompose $fDataCompose$fGenericCompose$fGeneric1kCompose$fSemigroupCompose$fMonoidCompose$fRealFloatCompose$fFloatingCompose$fRealFracCompose$fFractionalCompose$fIntegralCompose $fRealCompose $fNumCompose$fBoundedCompose $fEnumCompose $fOrdCompose $fEqComposeOpgetOp EquivalencegetEquivalence Comparison getComparison Predicate getPredicate Contravariant contramap>$phantom$<>$<>$$<defaultComparisondefaultEquivalencecomparisonEquivalence $fFloatingOp$fFractionalOp$fNumOp$fContravariantOp$fCategoryTYPEOp$fContravariantEquivalence$fContravariantComparison$fContravariantProxy$fContravariantCompose$fContravariantConst$fContravariantProduct$fContravariantSum$fContravariant:+:$fContravariant:.:$fContravariant:*:$fContravariantK1$fContravariantU1$fContravariantV1$fSemigroupPredicate$fMonoidPredicate$fContravariantPredicate $fSemigroupOp $fMonoidOp$fSemigroupEquivalence$fMonoidEquivalence$fSemigroupComparison$fMonoidComparison$fContravariantM1$fContravariantRec1$fContravariantAlt $fBifunctorK1$fBifunctorConst$fBifunctorEither$fBifunctorTuple7$fBifunctorTuple6$fBifunctorTuple5$fBifunctorTuple4$fBifunctorTuple3$fBifunctorTuple2 Bifoldablebifold bifoldMapbifoldrbifoldlbifoldr'bifoldr1bifoldrMbifoldl'bifoldl1bifoldlM bitraverse_bifor_bimapM_biforM_ bisequenceA_ bisequence_biasumbimsumbiListbinullbilengthbielembiconcat bimaximum biminimumbisum biproduct biconcatMapbiandbiorbianybiall bimaximumBy biminimumBy binotElembifind$fBifoldableEither$fBifoldableTuple7$fBifoldableTuple6$fBifoldableTuple5$fBifoldableTuple4$fBifoldableTuple3$fBifoldableK1$fBifoldableConst$fBifoldableTuple2 Bitraversable bisequenceAbimapMfirstAsecondAbiforM bimapAccumL bimapAccumR bimapDefaultbifoldMapDefault$fBitraversableK1$fBitraversableConst$fBitraversableEither$fBitraversableTuple7$fBitraversableTuple6$fBitraversableTuple5$fBitraversableTuple4$fBitraversableTuple3$fBitraversableTuple2 WrappedMonoid WrapMonoid unwrapMonoidArgMaxArgMinArggetMaxgetMincycle1diff mtimesDefault$fEnumWrappedMonoid$fMonoidWrappedMonoid$fSemigroupWrappedMonoid$fMonadFixLast $fMonadLast$fApplicativeLast$fTraversableLast$fFoldableLast $fFunctorLast$fSemigroupLast $fEnumLast$fMonadFixFirst $fMonadFirst$fApplicativeFirst$fTraversableFirst$fFoldableFirst$fFunctorFirst$fSemigroupFirst $fEnumFirst$fBifoldableArg$fBitraversableArg$fBifunctorArg$fOrdArg$fEqArg$fTraversableArg $fFoldableArg $fFunctorArg$fNumMax $fMonadFixMax $fMonadMax$fApplicativeMax$fTraversableMax $fFoldableMax $fFunctorMax $fMonoidMax$fSemigroupMax $fEnumMax$fNumMin $fMonadFixMin $fMonadMin$fApplicativeMin$fTraversableMin $fFoldableMin $fFunctorMin $fMonoidMin$fSemigroupMin $fEnumMin$fBoundedWrappedMonoid$fEqWrappedMonoid$fOrdWrappedMonoid$fShowWrappedMonoid$fReadWrappedMonoid$fDataWrappedMonoid$fGenericWrappedMonoid$fGeneric1TYPEWrappedMonoid $fBoundedLast$fEqLast $fOrdLast $fShowLast $fReadLast $fDataLast $fGenericLast$fGeneric1TYPELast$fBoundedFirst $fEqFirst $fOrdFirst $fShowFirst $fReadFirst $fDataFirst$fGenericFirst$fGeneric1TYPEFirst $fShowArg $fReadArg $fDataArg $fGenericArg$fGeneric1TYPEArg $fBoundedMax$fEqMax$fOrdMax $fShowMax $fReadMax $fDataMax $fGenericMax$fGeneric1TYPEMax $fBoundedMin$fEqMin$fOrdMin $fShowMin $fReadMin $fDataMin $fGenericMin$fGeneric1TYPEMin Foldable1fold1foldMap1 foldMap1' toNonEmpty foldrMap1 foldlMap1' foldlMap1 foldrMap1'foldr1' intercalate1foldrM1 foldrMapM1foldlM1 foldlMapM1$fFoldable1Compose$fFoldable1Sum$fFoldable1Product$fFoldable1Identity$fFoldable1:.:$fFoldable1:*:$fFoldable1:+:$fFoldable1Par1 $fFoldable1V1$fFoldable1Last$fFoldable1First$fFoldable1Max$fFoldable1Min$fFoldable1Product0$fFoldable1Sum0$fFoldable1Dual$fFoldable1Tuple2$fFoldable1Solo$fFoldable1Complex$fFoldable1Down$fFoldable1NonEmpty$fSemigroupJoinWith$fSemigroupFromMaybe$fSemigroupNonEmptyDList $fFoldable1M1$fFoldable1Rec1 $fFoldable1Ap$fFoldable1Alt Bifoldable1bifold1 bifoldMap1$fBifoldable1Const$fBifoldable1Tuple5$fBifoldable1Tuple4$fBifoldable1Tuple3$fBifoldable1Tuple2$fBifoldable1Either$fBifoldable1ArgMutableByteArray ByteArray$fIsListByteArray$fMonoidByteArray$fSemigroupByteArray$fOrdByteArray$fEqMutableByteArray $fEqByteArray$fLiftBoxedRepByteArray$fShowByteArray$fDataMutableByteArray$fDataByteArrayQSemnewQSemwaitQSem signalQSemArgDescrNoArgReqArgOptArgOptDescrOptionArgOrder RequireOrderPermute ReturnInOrder usageInfogetOptgetOpt'$fFunctorArgDescr$fFunctorOptDescr$fFunctorArgOrder unsafeFixIOcpuTimePrecision getCPUTimeQSemNnewQSemN waitQSemN signalQSemNChannewChan writeChanreadChandupChangetChanContentswriteList2Chan$fEqChan forkFinallycompilerVersionfullCompilerVersionosarch compilerName mkWeakPtr addFinalizer mkWeakPairTimeouttimeout$fExceptionTimeout $fShowTimeout $fEqTimeoutModifierParserFieldFormatter FormatParsefpRestfpChar fpModifiers FieldFormatfmtChar fmtModifiers fmtAlternatefmtSign fmtAdjust fmtPrecisionfmtWidth FormatSignSignPlus SignSpaceFormatAdjustment LeftAdjustZeroPadIsChartoCharfromChar PrintfArg formatArg parseFormat HPrintfType PrintfTypeprintfhPrintfvFmt formatChar formatString formatInt formatIntegerperrorerrorBadFormaterrorShortFormaterrorMissingArgumenterrorBadArgument $fIsCharChar$fPrintfArgDouble$fPrintfArgFloat$fPrintfArgNatural$fPrintfArgInteger$fPrintfArgWord64$fPrintfArgWord32$fPrintfArgWord16$fPrintfArgWord8$fPrintfArgWord$fPrintfArgInt64$fPrintfArgInt32$fPrintfArgInt16$fPrintfArgInt8$fPrintfArgInt$fPrintfArgList$fPrintfArgChar$fHPrintfTypeFUN$fPrintfTypeFUN$fHPrintfTypeIO$fPrintfTypeIO$fPrintfTypeList $fShowFUNGHC.Internal.Prim.ExtgetThreadAllocationCounter#Rep_WrappedArrowRep1_WrappedArrowRep_WrappedMonadRep1_WrappedMonad bigNatAdd bigNatAddWordbigNatAddWord# bigNatAnd bigNatAndInt# bigNatAndNotbigNatAndNotWord#bigNatAndWord# bigNatBit bigNatBit# bigNatCheck bigNatCheck#bigNatClearBit# bigNatComparebigNatCompareWordbigNatCompareWord#bigNatComplementBit# bigNatCtz bigNatCtz# bigNatCtzWordbigNatCtzWord#bigNatEncodeDouble#bigNatEq bigNatEq# bigNatEqWord#bigNatFromAbsInt#bigNatFromAddr#bigNatFromAddrBE#bigNatFromAddrLE#bigNatFromByteArray#bigNatFromByteArrayBE#bigNatFromByteArrayLE#bigNatFromWordbigNatFromWord#bigNatFromWord2#bigNatFromWord64#bigNatFromWordArraybigNatFromWordArray#bigNatFromWordListbigNatFromWordList#bigNatFromWordListUnsafe bigNatGcdbigNatGcdWord#bigNatGe bigNatGe#bigNatGt bigNatGt# bigNatGtWord bigNatGtWord# bigNatIndex bigNatIndex# bigNatIsOne bigNatIsOne#bigNatIsPowerOf2# bigNatIsTwo bigNatIsTwo# bigNatIsZero bigNatIsZero# bigNatLcmbigNatLcmWord#bigNatLcmWordWord#bigNatLe bigNatLe# bigNatLeWord bigNatLeWord# bigNatLog2 bigNatLog2# bigNatLogBasebigNatLogBase#bigNatLogBaseWordbigNatLogBaseWord#bigNatLt bigNatLt# bigNatMul bigNatMulWordbigNatMulWord#bigNatNe bigNatNe# bigNatOne bigNatOne#bigNatOr bigNatOrWord#bigNatPopCountbigNatPopCount# bigNatPowModbigNatPowModWord# bigNatQuotbigNatQuotRem#bigNatQuotRemWord#bigNatQuotWordbigNatQuotWord# bigNatRem bigNatRemWordbigNatRemWord# bigNatSetBit# bigNatShiftL bigNatShiftL# bigNatShiftR bigNatShiftR#bigNatShiftRNeg# bigNatSize bigNatSize#bigNatSizeInBasebigNatSizeInBase# bigNatSqr bigNatSubbigNatSubUnsafebigNatSubWord#bigNatSubWordUnsafebigNatSubWordUnsafe# bigNatTestBitbigNatTestBit# bigNatToAddr bigNatToAddr#bigNatToAddrBE#bigNatToAddrLE# bigNatToInt bigNatToInt#bigNatToMutableByteArray#bigNatToMutableByteArrayBE#bigNatToMutableByteArrayLE# bigNatToWord bigNatToWord#bigNatToWord64#bigNatToWordListbigNatToWordMaybe# bigNatXorbigNatXorWord# bigNatZero bigNatZero#gcdIntgcdInt#gcdWordgcdWord# powModWord#raiseDivZero_BigNatBigNat# integerAbs integerAdd integerAnd integerBit integerBit# integerCheck integerCheck#integerCompareintegerComplementintegerDecodeDouble# integerDiv integerDivModintegerDivMod#integerEncodeDoubleintegerEncodeDouble#integerEncodeFloat# integerEq integerEq#integerFromAddrintegerFromAddr#integerFromBigNat#integerFromBigNatNeg#integerFromBigNatSign#integerFromByteArrayintegerFromByteArray#integerFromIntintegerFromInt#integerFromInt64#integerFromNaturalintegerFromWordintegerFromWord#integerFromWord64#integerFromWordListintegerFromWordNeg#integerFromWordSign# integerGcd integerGcde integerGcde# integerGe integerGe# integerGt integerGt#integerIsNegativeintegerIsNegative# integerIsOneintegerIsPowerOf2# integerIsZero integerLcm integerLe integerLe# integerLog2integerLogBaseintegerLogBaseWordintegerLogBaseWord# integerLt integerLt# integerMod integerMul integerNe integerNe# integerNegate integerOne integerOrintegerPopCount#integerPowMod# integerQuotintegerQuotRemintegerQuotRem#integerRecipMod# integerRem integerShiftLintegerShiftL# integerShiftRintegerShiftR# integerSignumintegerSignum#integerSizeInBase# integerSqr integerSubintegerTestBitintegerTestBit# integerToAddrintegerToAddr#integerToBigNatClamp#integerToBigNatSign# integerToInt#integerToInt64#integerToMutableByteArrayintegerToMutableByteArray#integerToNaturalintegerToNaturalClampintegerToNaturalThrowintegerToWord#integerToWord64# integerXor integerZeroINIS naturalAdd naturalAnd naturalAndNot naturalBit naturalBit# naturalCheck naturalCheck#naturalClearBitnaturalClearBit#naturalComparenaturalComplementBitnaturalComplementBit#naturalEncodeDouble#naturalEncodeFloat# naturalEq naturalEq#naturalFromAddrnaturalFromAddr#naturalFromBigNat#naturalFromByteArray#naturalFromWordnaturalFromWord#naturalFromWord2#naturalFromWordList naturalGcd naturalGe naturalGe# naturalGt naturalGt# naturalIsOnenaturalIsPowerOf2# naturalIsZero naturalLcm naturalLe naturalLe# naturalLog2 naturalLog2#naturalLogBasenaturalLogBase#naturalLogBaseWordnaturalLogBaseWord# naturalLt naturalLt# naturalMul naturalNe naturalNe# naturalNegate naturalOne naturalOrnaturalPopCountnaturalPopCount# naturalPowMod naturalQuotnaturalQuotRemnaturalQuotRem# naturalRem naturalSetBitnaturalSetBit# naturalShiftLnaturalShiftL# naturalShiftRnaturalShiftR# naturalSignumnaturalSizeInBase# naturalSqr naturalSubnaturalSubThrownaturalSubUnsafenaturalTestBitnaturalTestBit# naturalToAddrnaturalToAddr#naturalToBigNat#naturalToMutableByteArray#naturalToWord#naturalToWordClampnaturalToWordClamp#naturalToWordMaybe# naturalXor naturalZeroNBNS Rep_RTSStats Rep_GCDetails Rep_RTSFlags Rep_HpcFlags Rep_ParFlagsRep_TickyFlagsRep_TraceFlags Rep_DoTrace Rep_ProfFlagsRep_DoHeapProfile Rep_CCFlagsRep_DoCostCentresRep_DebugFlags Rep_MiscFlags Rep_ConcFlags Rep_GCFlagsRep_GiveGCStats Rep_Complex Rep1_ComplexRep_SumRep1_Sum Rep_Product Rep1_Product Rep_Compose Rep1_ComposeRep_WrappedMonoidRep1_WrappedMonoidRep_Last Rep1_Last Rep_First Rep1_FirstRep_ArgRep1_ArgRep_MaxRep1_MaxRep_MinRep1_MinJoinWithSMaybe FromMaybe NonEmptyDListrunNonEmptyDList newByteArrayunsafeFreezeByteArraysizeofByteArrayindexByteArraywriteByteArraybyteArrayToListbyteArrayFromListNunsafeCopyByteArrayunsafeCopyMutableByteArraycompareByteArraysFromBeginning sameByteArrayappendByteArrayconcatByteArraypasteByteArraysemptyByteArraystimesPolymorphic checkedIntAddcheckedIntMultiplygetCpuTimePrecisioncClockToIntegercTimeToIntegercsuSecondsToInteger withTimespec#GHC.Internal.System.Posix.Internalsc_accessc_chmodc_closec_creatc_dupc_dup2 c_fcntl_lock c_fcntl_read c_fcntl_writec_forkc_fstat c_ftruncatec_getpidc_interruptible_openc_interruptible_open_c_isattyc_lflagc_linkc_lseekc_mkfifoc_openc_pipec_read c_s_isblk c_s_ischr c_s_isdir c_s_isfifo c_s_isreg c_s_issock c_safe_open c_safe_open_ c_safe_read c_safe_write c_sigaddset c_sigemptyset c_sigprocmaskc_stat c_tcgetattr c_tcsetattrc_umaskc_unlinkc_utime c_waitpidc_writecheckForInteriorNuls const_echo const_f_getfl const_f_setfd const_f_setflconst_fd_cloexec const_icanonconst_sig_blockconst_sig_setmask const_sigttou const_tcsanow const_vmin const_vtimedEFAULT_BUFFER_SIZE fdFileSize fdGetModefdStatfdTypefileTypeget_saved_termioshostIsThreadedioe_unknownfiletypelstat newFilePatho_APPENDo_BINARYo_CREATo_EXCLo_NOCTTY o_NONBLOCKo_RDONLYo_RDWRo_TRUNCo_WRONLY peekFilePathpeekFilePathLen poke_c_lflagptr_c_ccputsrtsIsThreaded_sEEK_CURsEEK_ENDsEEK_SETs_isblks_ischrs_isdirs_isfifos_isregs_issocksetCloseOnExec setCookedsetNonBlockingFDset_saved_termiossizeof_sigset_t sizeof_statsizeof_termiosst_devst_inost_modest_mtimest_size statGetTypestatGetType_maybe tcSetAttrthrowInternalNulError withFilePathCFLock CFilePathCGroupCLconvCPasswd CSigactionCSigsetCStatCTermiosCTmCTmsCUtimbufCUtsnameGHC.Internal.System.Posix.Types ByteCountCBlkCntCBlkSizeCCcCClockIdCDev CFsBlkCnt CFsFilCntCGidCIdCInoCKeyCModeCNfdsCNlinkCOffCPidCRLimCSocklenCSpeedCSsizeCTcflagCTimerCUid ClockTickDeviceID EpochTimeFdFileIDFileMode FileOffsetGroupIDLimit LinkCountProcessGroupID ProcessIDUserID