2      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW XYZ[\]^_`abcdefgh i j k lmnopqr stuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""" " " " " """""##########$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%&&          '''''(((()()(((((((((((((((((******))))))))))))))))))))))))))))))))))))+++++++++++++++++++++++++++++,,--,-----,,,,,,,-,,, - , , . ................... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O/P/Q/R/S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m-n-o-p-q-r-s-t-u-v-w-x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,0000000000000000000000000000011111111111111'''22'''''''''''''''''''''''''''' ' ' ' ' ''''''''''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}3~333333333334444444444444444444444444444O5None )0BDR 2 Word32s    BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableSafe)0DR$$Safe)0DR)UT)UT BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDRPinning statusLowlevel BooleanCountOf in bytes type aliasEfor code documentation purpose only, just a simple type alias on Int#)Offset in a bytearray, string, type aliasEfor code documentation purpose only, just a simple type alias on Int#File size in bytes BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone  )0BDR:Flag record whether a specific byte array is pinned or notturn an Int# into a Bool<Since GHC 7.8, boolean primitive don't return Bool but Int#.A version friendly of andI#!A version friendly of quotRemInt#*A version friendly fo copyAddrToByteArray#only available from GHC 7.8*A version friendly fo copyByteArrayToAddr#only available from GHC 7.8*A mkWeak# version that keep working on 8.0,signature change in ghc-prim: * 0.4: mkWeakD :: o -> b -> c -> State RealWorld -> (State RealWorld, Weak b) * 0.5 :mkWeak :: o -> b -> (State RealWorld -> (State RealWorld, c )) -> State RealWorld -> (State RealWorld, Weak b)8K8K  None )0DIRWW BSD-style FoundationNone )09;DRNegation support e.g. -(f x)Fractional Literal support'e.g. 1.2 :: Double 0.03 :: FloatIntegral Literal support&e.g. 123 :: Integer 123 :: Word863 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRVV BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRSRQSRQ Safe )*0DR  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRkihjkjih BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR/Only to use internally for internal error cases!for support of if .. then .. elseV|{}~   fedcba`_^]\[ZY!" #$%&'*+GJ,-./012345HI6NOP789:;<=s>LMXgmlnotuvyzlzmyn#"  |{~}!&  5HI6NOP+GJ/4,01239:;<8-.7V%'>LM fedcba`_^]\[ZYXg$*ovut=s BSD-stylePsychohistorians experimentalportableNone)0DRSimple Reader monadSimple State monad  BSD-styleHaskell Foundation experimentalportableNone )0DIR(Class of types that can be byte-swapped.e.g. Word16, Word32, Word64Big Endian valueLittle Endian value.Convert a value in cpu endianess to big endian5Convert from a big endian value to the cpu endianness 1Convert a value in cpu endianess to little endian 8Convert from a little endian value to the cpu endianness &endianness of the current architecture                None )0:BDR  !  !  !  ! BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0ABDRT" Monad that can represent failureHSimilar to MonadFail but with a parametrized Failure linked to the Monad#bThe associated type with the MonadFailure, representing what failure can be encoded in this monad$ Raise a Failure through a monad.%)Primitive monad that can handle mutation.For example: IO and ST.&3type of state token associated with the PrimMonad m'0type of variable associated with the PrimMonad m(mUnwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value.)&Throw Exception in the primitive monad*(Run a Prim monad from a dedicated state#+&Build a new variable in the Prim Monad,#Read the variable in the Prim Monad-$Write the variable in the Prim Monad. just like unwrapPrimMonad9 but throw away the result and return just the new State#/+Convert a prim monad to another prim monad.The net effect is that it coerce the state repr to another, so the runtime representation should be the same, otherwise hilary ensues.0%Convert any prim monad to an ST monad1%Convert any prim monad to an IO monad2$Convert any IO monad to a prim monad3(Touch primitive lifted to any prim monad"#$%&'()*+,-./01234567"#$%&'()*+,-./0123%&'()*+,-"#$./0123 "#$%&'()*+,-./01234567 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDR8-Create a pointer with an associated finalizer;3Check if 2 final ptr points on the same memory bitsit stand to reason that provided a final ptr that is still being referenced and thus have the memory still valid, if 2 final ptrs have the same address, they should be the same final ptr<$create a new FinalPtr from a Pointer='Create a new FinalPtr from a ForeignPtr>.Cast a finalized pointer from type a to type b@}Looks at the raw pointer inside a FinalPtr, making sure the data pointed by the pointer is not finalized during the call to fBUnsafe version of @89:;<=>?@ABCDE 89:;<=>?@AB 89:;><=A@B?89:;<=>?@ABCDENone)0DRFJNon Negative Number literals, convertible through the generic Natural typeH>Number literals, convertible through the generic Integer type.Fall number are Enum'erable, meaning that you can move to next elementFGHIJKLMNOPQRSTUVWXYZ[\]FGHIHIFGFGHIJKLMNOPQRSTUVWXYZ[\] None)069;<=BDRT^OCast an integral value to another value that have the same representional size`Upsize an integral valueThe destination type b9 size need to be greater or equal than the size type of abDownsize an integral valueI^_`abcdefghijklmnopqrstuvwxyz{|}~^_`abcdbccd`a^__E^__`abccdefghijklmnopqrstuvwxyz{|}~None)0BDR ASCII value between 0x0 and 0x7f Convert a  to a unicode code point ,Try to convert a , to a 9If the code point is non ascii, then Nothing is returned.Try to convert 9 to a 9If the byte got higher bit set, then Nothing is returned. Convert a , to a  ignoring all higher bits Convert a Byte to a  ignoring the higher bitNone )0BDR 128 bits Word Add 2 Word128Subtract 2 Word128MultiplicationDivisionModulo Bitwise and Bitwise or Bitwise xorBitwise complementPopulation countBitwise Shift LeftBitwise Shift RightBitwise rotate LeftBitwise rotate LeftTest bitbit"  !None )0BDR 256 bits Word Add 2 Word256Subtract 2 Word256MultiplicationDivisionModulo Bitwise and Bitwise or Bitwise xorBitwise complementPopulation countBitwise Shift LeftBitwise Shift RightBitwise rotate LeftBitwise rotate LeftTest bitbit"  !None%&)*,0ADQRTGConstraint to check if a natural is within a specific bounds of a type.i.e. given a Nat n", is it possible to convert it to ty without losing information?Check if a Nat is in bounds of another integral / natural typesGGet Maximum bounds of different Integral / Natural types related to Nat(@ABCDEFwx@(wxDABCEF6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDR Identical to , but doesn't allow to represent any failure.Only use in validated place6Number of bytes associated with a specific header byte>If the header byte is invalid then NbBytesInvalid is returned,(Check if the byte is a continuation byteJGet the number of following bytes given the first byte of a UTF8 sequence.(Check if the byte is a continuation byteJGet the number of following bytes given the first byte of a UTF8 sequence.  BSD-styleHaskell FoundationNone ),0DRT A type level bounded natural/A type level bounded natural backed by a Word64'Create an element of !$/n!$ from a Word64\If the value is greater than n, then the value is normalized by using the integer modulus n/Create an element of !$/n!$ from a type level Nat Add 2 Zn64subtract 2 Zn64Multiply 2 Zn64)Create an element of !$/n!$ from a Natural.\If the value is greater than n, then the value is normalized by using the integer modulus n/Create an element of !$/n!$ from a type level NatAdd 2 Zn subtract 2 Zn Multiply 2 Zn None )0BDReRepresent class of things that can be added together, contains a neutral element and is commutative. )x + azero = x azero + x = x x + y = y + x !"#$ !"#$6None )09;DR%'Support for division between same typesCThis is likely to change to represent specific mathematic divisions'3Represent types that supports an euclidian division "(x div  y) * y + (x mod  y) == x+9Represent class of things that can be multiplied together #x * midentity = x midentity * x = x,$Identity element over multiplication-;Multiplication of 2 elements that result in another element.Raise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a/%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ %&'()*+-.,/ +,-.'()*%&/(%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ&7-7.8None)0DRR1Represent class of things that can be subtracted.dNote that the result is not necessary of the same type as the operand depending on the actual type. For example: (-) :: Int -> Int -> Int (-) :: DateTime -> DateTime -> Seconds (-) :: Ptr a -> Ptr a -> PtrDiff (-) :: Natural -> Natural -> Maybe NaturalRSTUVWXYZ[\]^_`abcdefgRSTRSTRSTUVWXYZ[\]^_`abcdefgT6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)*0<=BDIRTjCountOf of a data structure.@More specifically, it represents the number of elements of type ty# that fit into the data structure.6length (fromList ['a', 'b', 'c', '']) :: CountOf Char CountOf 4Same caveats as l apply here.l:Offset in a data structure consisting of elements of type ty.Int is a terrible backing type which is hard to get away from, considering that GHC/Haskell are mostly using this for offset. Trying to bring some sanity by a lightweight wrapping.nIOffset in bytes used for memory addressing (e.g. in a vector, string, ..)oFile size in bytesv+subtract 2 CountOf values of the same type.gm need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure.|+subtract 2 CountOf values of the same type.gm need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure.!alignment need to be a power of 2.hijklmnopqrstuvwxyz{|}~ hijklmnopqrstuvwxyz{|}~ oplmnstuwzvyx{}~|qrjkih+hijklmnopqrstuvwxyz{|}~None)0DRCompute the size of the listSum the element in a list BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR?Exception for using NonEmpty assertion with an empty collection?Exception during an operation accessing the vector out of boundXRepresent the type of operation, the index accessed, and the total length of the vector.<The type of operation that triggers an OutOfBound exception.&OOB_Index: reading an immutable vector"OOB_Read: reading a mutable vector!OOB_Write: write a mutable vector   BSD-style Foundation experimentalportableNone)0DR$NonEmpty property for any Collection!None)0DIR.The in-progress state of a building operation.The previous buffers are in reverse order, and this contains the current buffer and the state of progress packing the elements inside.   "None)0DR/Data that can be fully evaluated in Normal Form6     5     # BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>stableportableNone)0DREither a or b or both.$None)09;BDRT [A constraint class for serializable type that have an unique memory compare representatione.g. Float and Double have -0.0 and 0.0 which are Eq individual, yet have a different memory representation which doesn't allow for memcmp operationNRepresent the accessor for types that can be stored in the UArray and MUArray.=Types need to be a instance of storable and have fixed sized.%get the size in bytes of a ty elementget the shift size -return the element stored at a specific index!.Read an element at an index in a mutable array"7Write an element to a specific cell in a mutable array.#Read from Address, without a state. the value read should be considered a constant for all pratical purpose, otherwise bad thing will happens.$4Read a value from Addr in a specific primitive monad%3Write a value to Addr in a specific primitive monad,UCast a CountOf linked to type A (CountOf A) to a CountOf linked to type B (CountOf B)G !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ~ !"#$%&'()*+,-./012345 !"#$%&'()*+20,~-./1345? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ7 BSD-style foundationNone)0DR5Defines the maximum size in bytes of unpinned arrays.?You can change this value by setting the environment variable !HS_FOUNDATION_UARRAY_UNPINNED_MAX to an unsigned integer number. Note: We use  here. If the environment variable changes during runtime and the runtime system decides to recompute this value, referential transparency is violated (like the First Order violated the Galactic Concordance!).CTODO The default value of 1024 bytes is arbitrarily chosen for now.% BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone%&),0ADQRT)[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&[\]\efgdhbcsrtiuvwjlkmnopqxyz{|}~a^_`'[\]^_`abcdefghijklmnopqrstuvwxyz{|}~8None )0DRGet the terminal windows size'Return the size of the current terminalIf the system is not supported or that querying the system result in an error then a default size of (80, 24) will be given back. &None)0DR None)0BDR =sr =sr9 BSD-style FoundationNone )0:BDRADifferent way to encode a Character in UTF8 represented as an ADTTransform a Unicode code point , intovnote that we expect here a valid unicode code point in the *allowed* range. bits will be lost if going above 0x10ffff               :None)0DR?Possible failure related to validating bytes of UTF8 sequences.$Step when processing ASCII characterEStep when processing digits. the value is between 0 and 9 to be validASimilar to Step but used when processing the string from the end.fThe stepper is thus the previous character, and the offset of the beginning of the previous characterStep when walking a Stringthis is a return value composed of : * the unicode code point read (Char) which need to be between 0 and 0x10ffff (inclusive) * The next offset to start reading the next unicode code point (or end);None  )0BDR   <None )0BDRTPA Mutable block of memory containing unpacked bytes representing values of type tyHA block of memory containing unpacked bytes representing values of type ty!Create an empty block of memoryMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use index if unsure."%make a block from a list of elements.#transform a block to a list.$!Check if two blocks are identical%Compare 2 blocks&7Append 2 blocks together by creating a new bigger block$Freeze a mutable block into a block.|If the mutable block is still use after freeze, then the modification will be reflected in an unexpected way in the Block.Thaw an immutable block.If the immutable block is modified, then the original immutable block will be modified too, but lead to unexpected results when querying7Create a new mutable block of a specific size in bytes.qNote that no checks are made to see if the size in bytes is compatible with the size of the underlaying element ty in the block.use  if unsure3Create a new mutable block of a specific N size of ty elementsECopy a number of elements from an array to another array with offsets]Copy a number of bytes from a MutableBlock to another MutableBlock with specific byte offsetsPCopy a number of bytes from a Block to a MutableBlock with specific byte offsets<read from a cell in a mutable block without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use read if unsure.;write to a cell in a mutable block without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use write if unsure.'Use the = to a block in a safer construct;If the block is not pinned, this is a _dangerous_ operationUse the =( to a mutable block in a safer construct;If the block is not pinned, this is a _dangerous_ operation)()!*"#$+%,&-destination mutable blockoffset at destinationsource mutable blockoffset at sourcenumber of elements to copydestination mutable blockoffset at destination source blockoffset at sourcenumber of elements to copydestination mutable blockoffset at destinationsource mutable blockoffset at sourcenumber of elements to copydestination mutable blockoffset at destination source blockoffset at sourcenumber of elements to copy'./0123456)''()!*"#$+%,&-'./0123456( BSD-styleHaskell FoundationNone )0BDRT$Return the length of a Mutable BlockEnote: we don't allow resizing yet, so this can remain a pure function(Set all mutable block element to a valueread a cell in a mutable array.2If the index is out of bounds, an error is raised.#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.*None )0BDRConvert a byte value in Word to two Word9s containing the hexadecimal representation of the Word#GThe output words# are guaranteed to be included in the 0 to 2^7-1 rangejNote that calling convertByte with a value greater than 256 will cause segfault or other horrible effect. hex word16 hex word32 789:789:=None)0BDR;<=>?@;<=>?@;<=>?@>None )0:BDRAAnextAsciiBa specialized to get a digit between 0 and 9 (included)BCDEAFGHIJKLMNOPQDestination bufferDestination start Source buffer Source start Source end;<>BCEAFGHIJKLMNOPQBCDEAFGHIJKLMNOPQ?None )0:BDRRSTURSTURSTU@None)0BDRVWXYZ[VWXYZ[VWXYZ[ANone )0:BDR\AnextAsciiBa specialized to get a digit between 0 and 9 (included)]^_`\abcdefghijklDestination bufferDestination start Source buffer Source start Source endVWY]^`\abcdefghijkl]^_`\abcdefghijklBNone )0:BDRmnopmnopmnopCNone )0<=DRqrstuqsrtuqrstuDNone )0<=DRv+Function defining the ordering relationshipOffset to first element to sortNumber of elements to sortData to be sortedvvENone )0<=BDR wxyz{|}~ tuwxyz{|}~ wxyz{|}~) BSD-styleHaskell FoundationNone)09;<=BDRTLCopy all the block content to the memory starting at the destination addressCreate a new array of size /n by settings each cells through the function f. Thaw a Block into a MutableBlockqthe Block is not modified, instead a new Mutable Block is created and its content is copied to the mutable block4Copy every cells of an existing Block to a new Block5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.Map all element a from a block to a new block of b$the source block to copy8The destination address where the copy is going to start(the size of the block (in element of ty),the function that set the value at the indexthe array created**$+ BSD-styleHaskell FoundationNone)*,0DIQRTf F BSD-styleHaskell FoundationNone)0DRGNone$)09;<=BDORT/An array of type built on top of GHC primitive.The elements need to have fixed sized and the representation is a packed contiguous array in memory that can easily be passed to foreign interface7A Mutable array of types built on top of GHC primitive./Element in this array can be modified in place.'Return if the array is pinned in memory-note that Foreign array are considered pinned-Return if a mutable array is pinned in memory-Create a new pinned mutable array of size @n.Ball the cells are uninitialized and could contains invalid values.?All mutable arrays are allocated on a 64 bits aligned addresses&Create a new mutable array of size @n.When memory for a new array is allocated, we decide if that memory region should be pinned (will not be copied around by GC) or unpinned (can be moved around by GC) depending on its size.MYou can change the threshold value used by setting the environment variable !HS_FOUNDATION_UARRAY_UNPINNED_MAX.<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use read if unsure.;write to a cell in a mutable array without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use write if unsure.MReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use index if unsure.%Freeze a mutable array into an array./the MUArray must not be changed after freezing.Thaw an immutable array.*The UArray must not be used after thawing.!Thaw an array to a mutable array.the array is not modified, instead a new mutable array is created and every values is copied, before returning the mutable array.4Copy every cells of an existing array to a new array&make an array from a list of elements.7Make an array from a list of elements with a size hint.>The list should be of the same size as the hint, as otherwise:The length of the list is smaller than the hint: the array allocated is of the size of the hint, but is sliced to only represent the valid bitsThe length of the list is bigger than the hint: The allocated array is the size of the hint, and the list is truncated to fit.transform an array to a list."Check if two vectors are identicalCompare 2 vectors ECopy a number of elements from an array to another array with offsets Copy nu sequential elements from the specified offset in a source array to the specified position in a destination array.mThis function does not check bounds. Accessing invalid memory can return unpredictable and invalid values.7Append 2 arrays together by creating a new bigger array Create a Block from a UArray.}Note that because of the slice, the destination block is re-allocated and copied, unless the slice point at the whole arrayB destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy .   ;   . BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)09;<=BDRT Mutable Array of a  Array of a1return the numbers of elements in a mutable array1return the numbers of elements in a mutable array5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.MReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  if unsure.read a cell in a mutable array.2If the index is out of bounds, an error is raised.<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  if unsure.#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.;write to a cell in a mutable array without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use  if unsure.%Freeze a mutable array into an array..the MArray must not be changed after freezing.Thaw an immutable array.)The Array must not be used after thawing.!Thaw an array to a mutable array.the array is not modified, instead a new mutable array is created and every values is copied, before returning the mutable array.'Copy the element to a new element arrayECopy a number of elements from an array to another array with offsetsCopy nu sequential elements from the specified offset in a source array to the specified position in a destination array.mThis function does not check bounds. Accessing invalid memory can return unpredictable and invalid values.aAllocate a new array with a fill function that has access to the elements of the source array.&Create a new mutable array of size @n.Ball the cells are uninitialized and could contains invalid values.|All mutable arrays are allocated on a 64 bits aligned addresses and always contains a number of bytes multiples of 64 bits.Create a new array of size /n by settings each cells through the function f.+just like vFromList but with a length hint.The resulting array is guarantee to have been allocated to the length specified, but the slice might point to the initialized cells only in case the length is bigger than the list.7If the length is too small, then the list is truncated.7Append 2 arrays together by creating a new bigger arrayU  destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copydestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new arraythe size of the array,the function that set the value at the indexthe array created !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN9   !"#$%&'()*+,-./0123456789:;<=>?@ABCD9  /0 !"#$%&'*+,()-.123478956;:<=>?@ABCDS   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN/None)*,0DIQRTf$OPQRSTUVWXYZ[\]^_`abcdefghiOPQRSTUVWXYZ[\]^_`abcdefghPQOQRSTUVWXYZ[\]b^_`acdefgh OPQRSTUVWXYZ[\]^_`abcdefghi-#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRTnread a cell in a mutable array.2If the index is out of bounds, an error is raised.o#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.s1return the numbers of elements in a mutable arraytLCreate a pointer on the beginning of the mutable array and call a function f.)The mutable buffer can be mutated by the f@ function and the change will be reflected in the mutable arraycIf the mutable array is unpinned, a trampoline buffer is created and the data is only copied when f return.uCopy from a pointer, count! elements, into the mutable arrayvLCopy all the block content to the memory starting at the destination address mnopq"the start pointer with a finalizer/the number of elements (in elements, not bytes)rstuv the source mutable array to copy8The destination address where the copy is going to startw mnopqrstuvwmswpq uvront mnopqrstuvw, BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)09;<=BDORTx5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.{Create a UArray from a Block%The block is still used by the uarrayaAllocate a new array with a fill function that has access to the elements of the source array.~Create a new array of size /n by settings each cells through the function f.*Create a pinned array that is filled by a filler- function (typically an IO call like hGetBuf)KFreeze a chunk of memory pointed, of specific size into a new unboxed array9update an array by creating a new array with the updates.Jthe operation copy the previous array, modify it in place, then freeze it.LCopy all the block content to the memory starting at the destination address*Recast an array of type a to an array of bKa and b need to have the same size otherwise this raise an async exceptionTTake a count of elements from the array and create an array with just those elements]Drop a count of elements from the array and return the new array minus those dropped elementsmSplit an array into two, with a count of at most N elements in the first one and the remaining in the other.5Similar to breakElem specialized to split on linefeedit either returns: * Left. no line has been found, and whether the last character is a CR * Right, a line has been found with an optional CR, and it returns the array of bytes on the left of the CR/LF, and the the array of bytes on the right of the LF.-Take the N elements from the end of the array-Drop the N elements from the end of the arraySplit an array at the N element from the end, and return the last N elements in the first part of the tuple, and whatever first elements remaining in the secondDSimilar to break but start the search of the breakpoint from the end breakEnd (> 0) [1,2,3,0,0,0]([1,2,3], [0,0,0]) Replace all the occurrencies of needle with  replacement in the haystack string.Dxy"the start pointer with a finalizer/the number of elements (in elements, not bytes)z{ Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new array|}~the size of the array,the function that set the value at the indexthe array createdthe size of the arrayfilling function thatthe source array to copy8The destination address where the copy is going to start[ !"#$%  txyz{|}~[ !"#$% |~t}{ xyzDxyz{|}~0None)*,0DIQRTf#H BSD-style Foundation experimentalportableNone)0:DRZthe unit element use for the encoding. i.e. Word8 for ASCII7 or UTF8, Word16 for UTF16...Idefine the type of error handling you want to use for the next function. %type Error UTF8 = Either UTF8_Invalidnconsume an `Unit encoding` and return the Unicode point and the position of the next possible `Unit encoding`Yhelper to convert a given Array in a given encoding into an array with another encoding.tThis is a helper to convert from one String encoding to another. This function is (quite) slow and needs some work.z``` let s16 = ... -- string in UTF16 -- create s8, a UTF8 String let s8 = runST $ convertWith UTF16 UTF8 (toBytes s16) print s8 ```Input's encoding typeOutput's encoding typethe input raw arrayI BSD-style Foundation experimentalportableNone)0BDR>validate a given byte is within ASCII characters encoring size+This function check the 8th bit is set to 0fconsume an Ascii7 char and return the Unicode point and the position of the next possible Ascii7 char method to access a given byteindex of the byte_either successfully validated the ASCII char and returned the next index or fail with an error\expecting it to be a valid Ascii character. otherwise this function will throw an exceptionJ BSD-style Foundation experimentalportableNone)0BDR K BSD-style Foundation experimentalportableNone)0BDR L BSD-style Foundation experimentalportableNone)0BDR1 BSD-styleHaskell Foundation experimentalportableNone )0:BDIR7Opaque packed array of characters in the ASCII encodingkConvert a Byte Array representing ASCII data directly to an AsciiString without checking for ASCII validity|If the input contains invalid Char7 value (anything above 0x7f), it will trigger runtime async errors when processing data.In doubt, use :Convert a Byte Array representing ASCII checking validity.8If the byte array is not valid, then Nothing is returned M BSD-style FoundationNone )0:BDIRMutable String Buffer.Use as an *append* buffer, as UTF8 variable encoding doesn't really allow to change previously written character without potentially shifting bytes.6Opaque packed array of characters in the UTF8 encodingsize in bytes.this size is available in o(1)(Convert a String to a list of characters/The list is lazily created as evaluation neededDassuming the given Addr# is a valid modified UTF-8 sequence of bytesJWe only modify the given Unicode Null-character (0xC080) into a null bytesFIXME: need to evaluate the kind of modified UTF8 GHC is actually expecting it is plausible they only handle the Null Bytes, which this function actually does. -Create a new String from a list of characterszThe list is strictly and fully evaluated before creating the new String, as the size need to be computed before filling. 5Allocate a MutableString of a specific size in bytes.     $in number of bytes, not of elements.$in number of bytes, not of elements.          2None)0DRXReturns a list of the program's command line arguments (not including the program name)."Lookup variable in the environmentNNone)+,0ABDRT,stop execution and displays an error messageONone)0DR&Use the Show class to create a String.yNote that this is not efficient, since an intermediate [Char] is going to be created before turning into a real String. BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRHIEEE754 Floating point Binary64, double precision (Also known as Double)GIEEE754 Floating point Binary32, simple precision (Also known as Float)!for support of if .. then .. elseV|{}~   fedcba`_^]\[ZY!" #$%&'?qp)*+GJ,-./012345HI6NOP789:;<=s>LMWXgmlnotuvyzjl lzmyn#"  |{~}!&  5HI6NOP+GJ/4Wlj, 01239:;<8-.7V%'?qp>LM fedcba`_^]\[ZYXg$*o)vut=s' BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0:BDRCDVarious String Encoding that can be use to convert to and from bytes UTF8 Encoder"Validate a bytearray for UTF8'nessUOn success Nothing is returned On Failure the position along with the failure reason Similar to  but works on a MutableByteArrayCheck if a String is nullGCreate a string composed of a number @n of Chars (Unicode code points).Zif the input @s contains less characters than required, then the input string is returned.SCreate a string with the remaining Chars after dropping @n Chars from the beginningiSplit a string at the Offset specified (in Char) returning both the leading part and the remaining part.CReturn the offset (in bytes) of the N'th sequence in an UTF8 String Similar to  but from the end Similar to  but from the end Similar to  but from the end:Split on the input string using the predicate as separatore.g. splitOn (== ',') "," == ["",""] splitOn (== ',') ",abc," == ["","abc",""] splitOn (== ':') "abc" == ["abc"] splitOn (== ':') "abc::def" == ["abc","","def"] splitOn (== ':') "::abc::def" == ["","","abc","","def"]8Internal call to make a substring given offset in bytes.tThis is unsafe considering that one can create a substring starting and/or ending on the middle of a UTF8 sequence.;Internal call to split at a given index in offset of bytes.bThis is unsafe considering that one can split in the middle of a UTF8 sequence, so use with care.MBreak a string into 2 strings at the location where the predicate return TrueEBreak a string into 2 strings at the first occurence of the characterFSame as break but cut on a line feed with an optional carriage return.eThis is the same operation as 'breakElem LF' dropping the last character of the string if it's a CR.\Also for efficiency reason (streaming), it returns if the last character was a CR character.Apply a  predicateY to the string to return the longest prefix that satisfy the predicate and the remainingApply a  predicateY to the string to return the longest suffix that satisfy the predicate and the remaining=Drop character from the beginning while the predicate is true>Return whereas the string contains a specific character or notIntersperse the character sep% between each character in the string "intersperse ' ' "Hello Foundation"!"H e l l o F o u n d a t i o n"Allocate a new StringI with a fill function that has access to the characters of the source String. Length of a String using CountOfthis size is available in o(n)Replicate a character c n$ times to create a string of length nCopy the StringkThe slice of memory is copied to a new slice, making the new string independent from the original string.. Create a single element String "Unsafely create a string of up to sz bytes. The callback f needs to return the number of bytes filled in the underlaying bytes buffer. No check is made on the callback return values, and if it's not contained without the bounds, bad things will happen. LMonomorphically map the character in a string and return the transformed one AAppend a Char to the end of the String and return this new String HPrepend a Char to the beginning of the String and return this new StringUExtract the String stripped of the last character and the last character if not emptyIf empty, Nothing is returnedXExtract the First character of a string, and the String stripped of the first character.If empty, Nothing is returnedLLook for a predicate in the String and return the matched character, if any.=Sort the character in a String using a specific sort function'TODO: optimise not going through a list1Filter characters of a string using the predicateReverse a string Replace all the occurrencies of needle with  replacement in the haystack string.$Return the nth character in a StringlCompared to an array, the string need to be scanned from the beginning since the UTF8 encoding is variable.WReturn the index in unit of Char of the first occurence of the predicate returning True!If not found, Nothing is returned=Convert a ByteArray to a string assuming a specific encoding.It returns a 3-tuple of:@The string that has been succesfully converted without any errorAn optional validation errorThe remaining buffer that hasn't been processed (either as a result of an error, or because the encoded sequence is not fully available)Considering a stream of data that is fetched chunk by chunk, it's valid to assume that some sequence might fall in a chunk boundary. When converting chunks, if the error is Nothing and the remaining buffer is not empty, then this buffer need to be prepended to the next chunk*Convert a UTF8 array of bytes to a String.qIf there's any error in the stream, it will automatically insert replacement bytes to replace invalid sequences.In the case of sequence that fall in the middle of 2 chunks, the remaining buffer is supposed to be preprended to the next chunk, and resume the parsing.SDecode a stream of binary chunks containing UTF8 encoding in a list of valid String`Chunk not necessarily contains a valid string, as a UTF8 sequence could be split over 2 chunks.cConvert a Byte Array representing UTF8 data directly to a string without checking for UTF8 validitycIf the input contains invalid sequences, it will trigger runtime async errors when processing data.In doubt, use 6Convert a String to a bytearray in a specific encodingeif the encoding is UTF8, the underlying buffer is returned without extra allocation or any processingJIn any other encoding, some allocation and processing are done to convert.4Split lines in a string using newline as separation.xNote that carriage return preceding a newline are also strip for maximum compatibility between Windows and Unix system.2Split words in a string using spaces as separation words "Hello Foundation"  Hello,  Foundation &Append a character to a String builder ,Create a new String builder using chunks of  sizeChunksI"Read an Integer from a StringCConsume an optional minus sign and many digits until end of string.$Read a Natural from a String(Consume many digits until end of string.%Try to read a Double&+Try to read a floating number as a Rational Note that for safety reason, only exponent between -10000 and 10000 is allowed as otherwise DoS/OOM is very likely. if you don't want this behavior, switching to a scientific type (not provided yet) that represent the exponent separately is the advised solution.')Read an Floating like number of the form:  T  numbers [ l  numbers ] [ ( e | E ) [ T ]  number ]Call a function with:0A boolean representing if the number is negativeYThe digits part represented as a single natural number (123.456 is represented as 123456)?The number of digits in the fractional part (e.g. 123.456 => 3)The exponent if any6The code is structured as a simple state machine that:Optionally Consume a T sign$Consume number for the integral part OptionallyConsume l5Consume remaining digits if not already end of stringOptionally Consume a e or E follow by an optional T and a number)Take decimal digits and accumulate it in acc?The loop starts at the offset specified and finish either when:It reach the end of the stringIt reach a non-ASCII character8It reach an ASCII character that is not a digit (0 to 9)Otherwise each iterations:(Transform the ASCII digits into a numberscale the accumulator by 103Add the number (between 0 and 9) to the accumulatorIt then returns:The new accumulated value'Whether it stop by end of string or not$The end offset when the loop stoppedQIf end offset == start offset then no digits have been consumed by this function -same as decimalDigitsBA specialized for ptr #( Convert a _ to the upper-case equivalent. Does not properly support multicharacter Unicode conversions.) Convert a _ to the upper-case equivalent. Does not properly support multicharacter Unicode conversions.*@Check whether the first string is a prefix of the second string.+@Check whether the first string is a suffix of the second string.,DCheck whether the first string is contains within the second string.STODO: implemented the naive way and thus terribly inefficient, reimplement properly-1Try to strip a prefix from the start of a String.mIf the prefix is not starting the string, then Nothing is returned, otherwise the striped string is returned./Try to strip a suffix from the end of a String.kIf the suffix is not ending the string, then Nothing is returned, otherwise the striped string is returned1Transform string src! to base64 binary representation.2Transform string srct to URL-safe base64 binary representation. The result will be either padded or unpadded, depending on the boolean padded argument.3Transform string src) to OpenBSD base64 binary representation.Z!"#$%&'( Source string)Length of the destination string in bytes7Function called for each character in the source StringReturns the filled new string     )* !+"#$%&' ()*+,-./01234P      !"#$%&'()*+,-./0123P      !#"$%&'()*+,-./0123T!"#$%&'(     )* !+"#$%&' ()*+,-./012343 BSD-styleHaskell FoundationNone)*09;<=BDRT<XClass of things that can mostly be converted from a to b, but with possible error cases.?2Class of things that can be converted from a to b.{In a valid instance, the source should be always representable by the destination, otherwise the instance should be using <A^Same as from but reverse the type variable so that the destination type can be specified firste.g. converting:from _ Word (10 :: Int)into @Word (10 :: Int)Bsame as tryFrom but reversedO;<=>?@AB,CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;<=>?@AB?@><=;ABM;<=>?@AB,CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4 BSD-style#Vincent Hanquez <vincent@snarc.org>None ),0DR$Color compent on 256colors terminals)Gray color compent on 256colors terminalsBSimple color component on 8 color terminal (maximum compatibility)All attribute off(8 Colors + Bold attribute for foreground(8 Colors + Bold attribute for background! Red componentGreen componentBlue component Red componentGreen componentBlue component-./01!-./012PQRSTUSTVSWXSWYSZ[SZ\SZ]SZ^P_`P_aSWbSWcSWdSWeSWfSghSijSikSilSimSnoSWpSWqSWrSWsSWtSWuSZvSZwP_xSWySz{SW|P_}S~SSgSWSSSnSWPPPPPSSSSSWPPPSSSSSSSPSSSSSSPSWSWPPSSPPPSSSSnSnSiSSzSzSzSzSzSzSzSzSzSzSzSzSzSzSzSzSSSSSSSSoSSSSSSSSSSSSZSZSZSZSZSZS~S~S~SSWSWSWSWSWSSSP_P_P_P_P_P_P_P_P_P_555555 5 5 5 5  !"# $ %&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^^_``abcdefghiijkklmnopqrstuvwxyz{|}~                                                                          !"#$%&'())*+,-./0123456789:;<<*+,-./=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~           !!!!!!! ! !!!"!#!$!%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"[#\#]#^#\#_#`#a#b#c#d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%8&          :::::<<<<<<<<<<<<<<<<<<<(((((******))))))))))))))))))))))))))))))) )) ) ) ) +++++++++++++++++++++++++ + +++GGGGGGGGGGGGGGGGGGGGGGGG. .!.".....................#.$...... ..%.&.'......... . ........(.).*.+.,.-.../.0.1.2.3.4.5.6/7/8/9/:///////////////////// / /;/</=/>-?---@-A--"-B-C-D-E,,F,G,H,,I,,J,K,,,L,M,D,N,O,P,,,Q,,R,,S,T,#,$,,,,U,V,,,, ,,%,,W,,,,,, , ,,X,Y,,,,,,,*,+,,,Z,[,(,)0\0]0^0_000000000000000000000 0 0`0a0b1c1c1d1d1e1f1g1h1i1j1k1l1m1nMoMoMpMp2q2rNOst]'u'v'w'x'y'z'{'''''#'$''''''S'T''%'|'' ''''''}'''''' ' ''X'Y''U'g'~''f'e'''*'+','''''''''(')'''''''''''''''3333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444555           666666666666666 6!6"6#6$6%6&6'()*+,WY-./$0$1$2$3$4$5$6$778S9:%%;8<8=8=8>8?8@8A8B8C8D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X9Y:Z:[:\:]:Z:[:\:]:^:_:`;a;b;c;d;e;f<<g<h<<i<<N<j<k<l<<m<n<o<p<q<r<s<t<u<v<w***x*y=z={=|=}=~=>>>>>>>>>>>>m>>>>>????@z@{@|@}@~@AAAAAAAAAAAAmAAAAABBBBCCCCCDEEEEEEEE EE++++++GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGlGGnGGGGGGGGGG...... .!......n...../7//8//////--,,,,,0\00]000000HHHHHuHIIIvIvIIIIIIJzJzJJJJJJJKxKxKKKKKKKLLLyLyLLLLMMMMMMMMMMMMMMMIMMMMM''''''''''''''''''344444%basement-0.0.4-5G9Gc8Ht9hD9gydJD2I2TQBasement.Compat.BaseBasement.Compat.IsListBasement.Compat.SemigroupBasement.Compat.Typeable Basement.NatBasement.Compat.PrimitiveBasement.ImportsBasement.Compat.IdentityBasement.Compat.NaturalBasement.Compat.BifunctorBasement.Types.PtrBasement.Compat.CallStackBasement.IntegralConvBasement.Compat.PrimTypesBasement.Compat.NumLiteralBasement.Compat.MonadTransBasement.EndiannessBasement.FloatingBasement.MonadBasement.FinalPtrBasement.Numerical.NumberBasement.Types.Char7Basement.Types.Word128Basement.Types.Word256Basement.BoundedBasement.Numerical.Additive!Basement.Numerical.MultiplicativeBasement.Numerical.SubtractiveBasement.Types.OffsetSizeBasement.Compat.ExtListBasement.ExceptionBasement.NonEmptyBasement.MutableBuilderBasement.NormalFormBasement.TheseBasement.PrimTypeBasement.Sized.ListBasement.TerminalBasement.StringBasement.Block.MutableBasement.BlockBasement.Base16Basement.Sized.BlockBasement.UArrayBasement.UArray.MutableBasement.BoxedArrayBasement.Sized.VectBasement.Sized.UVectBasement.Types.AsciiStringBasement.Environment Basement.FromBasement.Terminal.ANSIBasement.Numerical.ConversionBasement.UTF8.TableBasement.RuntimeBasement.Terminal.SizeBasement.UTF8.HelperBasement.UTF8.TypesBasement.Bindings.MemoryBasement.Block.BaseBasement.Alg.Native.PrimBasement.Alg.Native.UTF8Basement.Alg.Native.StringBasement.Alg.Foreign.PrimBasement.Alg.Foreign.UTF8Basement.Alg.Foreign.StringBasement.Alg.ClassBasement.Alg.MutableBasement.Alg.PrimArrayBasement.BlockNBasement.UArray.Base!Basement.String.Encoding.EncodingBasement.String.Encoding.ASCII7#Basement.String.Encoding.ISO_8859_1Basement.String.Encoding.UTF16Basement.String.Encoding.UTF32Basement.UTF8.BaseBasement.Error Basement.Showghc-primGHC.Primseqbase Data.TuplefstsndGHC.Base otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=fail>>=>>fmapreturn Data.String fromStringGHC.ExtsIsListfromList fromListNtoListData.Semigroup<>memptymappendmconcat<*>pure*>BoundedEnumEqMonad Data.DataDataFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString Applicative GHC.GenericsGeneric GHC.TypeLitsKnownNat SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerMaybeOrderingIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherRepNat+*^<=?-CmpNatFalseNothingJustTrueW#LeftRightLTEQGTData.Functor.Identity runIdentityIdentitystimessconcatItem GHC.NaturalNatural mkNoRepTypegmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldlDataTypeData.Bifunctorsecondfirstbimap BifunctorControl.Category.id Data.Foldableand Data.MonoidtofromcastPtrGHC.IOthrowIO GHC.Exceptionthrow ExceptionnatVal<=either Data.Functor<$>maxBoundminBoundfromEnumtoEnumpredsuccshowListshow showsPrec Data.Maybemaybe$!flipconst<$<*GHC.Err undefinederrorGHC.Stack.Types HasCallStack/=compare&&||not<>maxminWord32x2 intToInt64 int64ToInt wordToWord64 word64ToWordword64ToWord32s wordToChar wordToInt charToInt ListNonEmptyPinned#Bool#CountOf#Offset# FileSize# PinnedStatusPinnedUnpinnedcompatIsMutableByteArrayPinned#compatIsByteArrayPinned#toPinnedStatus#bool# compatAndI#compatQuotRemInt#compatCopyAddrToByteArray#compatCopyByteArrayToAddr# compatMkWeak# compatGetSizeofMutableByteArray#compatShrinkMutableByteArray#compatResizeMutableByteArray#$fEqPinnedStatusintegerToNaturalnaturalToInteger HasNegationnegate Fractional fromRationalIntegral fromInteger$fFractionalCDouble$fFractionalCFloat$fFractionalDouble$fFractionalFloat$fFractionalRatio$fHasNegationCDouble$fHasNegationCFloat$fHasNegationDouble$fHasNegationFloat$fHasNegationCInt$fHasNegationWord64$fHasNegationWord32$fHasNegationWord16$fHasNegationWord8$fHasNegationWord$fHasNegationInt64$fHasNegationInt32$fHasNegationInt16$fHasNegationInt8$fHasNegationInt$fHasNegationInteger$fIntegralCDouble$fIntegralCFloat$fIntegralDouble$fIntegralFloat$fIntegralCIntPtr$fIntegralCUIntPtr$fIntegralCOff$fIntegralCULong$fIntegralCLong$fIntegralCUInt$fIntegralCInt$fIntegralCUShort$fIntegralCShort$fIntegralCSize$fIntegralIntPtr$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord $fIntegralInt$fIntegralNatural$fIntegralInteger internalError ifThenElseReader runReaderStaterunState $fMonadReader$fApplicativeReader$fFunctorReader $fMonadState$fApplicativeState$fFunctorStateByteSwapBEunBELEunLE Endianness LittleEndian BigEndiantoBEfromBEtoLEfromLE endianness$fByteSwapWord64$fByteSwapWord32$fByteSwapWord16$fOrdBE$fOrdLE$fEqEndianness$fShowEndianness$fShowLE$fEqLE$fBitsLE$fShowBE$fEqBE$fBitsBEintegerToDoublenaturalToDoubledoubleExponantintegerToFloatnaturalToFloat wordToFloat floatToWord wordToDouble doubleToWord MonadFailureFailuremFail PrimMonad PrimStatePrimVar primitive primThrow unPrimMonad primVarNew primVarRead primVarWrite unPrimMonad_unsafePrimCastunsafePrimToSTunsafePrimToIOunsafePrimFromIO primTouch$fMonadFailureEither$fMonadFailureMaybe $fPrimMonadST $fPrimMonadIOFinalPtr FinalForeignfinalPtrSameMemory toFinalPtrtoFinalPtrForeign castFinalPtrwithFinalPtrNoTouch withFinalPtr touchFinalPtrwithUnsafeFinalPtr $fOrdFinalPtr $fEqFinalPtr$fShowFinalPtr IsNatural toNatural IsIntegral toInteger$fIsNaturalCSize$fIsNaturalWord64$fIsNaturalWord32$fIsNaturalWord16$fIsNaturalWord8$fIsNaturalWord$fIsNaturalNatural$fIsIntegralCSize$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralNatural$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fIsIntegralInteger IntegralCast integralCastIntegralUpsizeintegralUpsizeIntegralDownsizeintegralDownsizeintegralDownsizeCheck$fIntegralCastWord32Int32$fIntegralCastWord16Int16$fIntegralCastWord8Int8$fIntegralCastInt32Word32$fIntegralCastInt16Word16$fIntegralCastInt8Word8$fIntegralCastInt64Word64$fIntegralCastWord64Int64$fIntegralCastIntWord$fIntegralCastWordInt$fIntegralDownsizeNaturalWord64$fIntegralDownsizeNaturalWord32$fIntegralDownsizeNaturalWord16$fIntegralDownsizeNaturalWord8 $fIntegralDownsizeIntegerNatural$fIntegralDownsizeIntegerWord64$fIntegralDownsizeIntegerWord32$fIntegralDownsizeIntegerWord16$fIntegralDownsizeIntegerWord8$fIntegralDownsizeIntegerInt64$fIntegralDownsizeIntegerInt32$fIntegralDownsizeIntegerInt16$fIntegralDownsizeIntegerInt8$fIntegralDownsizeWord16Word8$fIntegralDownsizeWord32Word16$fIntegralDownsizeWord32Word8$fIntegralDownsizeWordWord32$fIntegralDownsizeWordWord16$fIntegralDownsizeWordWord8$fIntegralDownsizeWord64Word32$fIntegralDownsizeWord64Word16$fIntegralDownsizeWord64Word8$fIntegralDownsizeInt64Int$fIntegralDownsizeInt64Int32$fIntegralDownsizeInt64Int16$fIntegralDownsizeInt64Int8$fIntegralDownsizeIntInt32$fIntegralDownsizeIntInt16$fIntegralDownsizeIntInt8$fIntegralUpsizeWordWord64$fIntegralUpsizeWord32Word$fIntegralUpsizeWord32Word64$fIntegralUpsizeWord16Word$fIntegralUpsizeWord16Word64$fIntegralUpsizeWord16Word32$fIntegralUpsizeWord8Int$fIntegralUpsizeWord8Int64$fIntegralUpsizeWord8Int32$fIntegralUpsizeWord8Int16$fIntegralUpsizeWord8Word$fIntegralUpsizeWord8Word64$fIntegralUpsizeWord8Word32$fIntegralUpsizeWord8Word16$fIntegralUpsizeIntInt64$fIntegralUpsizeInt32Int$fIntegralUpsizeInt32Int64$fIntegralUpsizeInt16Int$fIntegralUpsizeInt16Int64$fIntegralUpsizeInt16Int32$fIntegralUpsizeInt8Int$fIntegralUpsizeInt8Int64$fIntegralUpsizeInt8Int32$fIntegralUpsizeInt8Int16$fIntegralUpsizeaNatural$fIntegralUpsizeaIntegerChar7toBytetoCharfromCharfromByte fromCharMask fromByteMaskc7_LFc7_CRc7_minusc7_ac7_Ac7_zc7_Zc7_0c7_1c7_2c7_3c7_4c7_5c7_6c7_7c7_8c7_9 $fShowChar7 $fEqChar7 $fOrdChar7Word128quotrem bitwiseAnd bitwiseOr bitwiseXor fromNatural $fBitsWord128 $fNumWord128$fIsNaturalWord128$fIsIntegralWord128$fHasNegationWord128$fIntegralWord128$fStorableWord128 $fOrdWord128$fBoundedWord128 $fEnumWord128 $fShowWord128 $fEqWord128Word256 $fBitsWord256 $fNumWord256$fIsNaturalWord256$fIsIntegralWord256$fHasNegationWord256$fIntegralWord256$fStorableWord256 $fOrdWord256$fBoundedWord256 $fEnumWord256 $fShowWord256 $fEqWord256NatWithinBound NatInBoundOfNatNumMaxBound natValNatural natValInt natValInt64 natValInt32 natValInt16 natValInt8 natValWord natValWord64 natValWord32 natValWord16 natValWord8ZnunZnZn64unZn64zn64zn64NatznznNat$fNumZn $fNumZn64 $fShowZn64$fEqZn64 $fOrdZn64$fShowZn$fEqZn$fOrdZnAdditiveazeroscale $fAdditiveZn$fAdditiveZn64$fAdditiveCSize$fAdditiveDouble$fAdditiveFloat$fAdditiveWord256$fAdditiveWord128$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveNatural$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8 $fAdditiveInt$fAdditiveInteger Divisible/ IDivisibledivmoddivModMultiplicative midentityrecip$fDivisibleDouble$fDivisibleFloat$fDivisibleRatio$fIDivisibleWord256$fIDivisibleWord128$fIDivisibleWord64$fIDivisibleWord32$fIDivisibleWord16$fIDivisibleWord8$fIDivisibleWord$fIDivisibleNatural$fIDivisibleInt64$fIDivisibleInt32$fIDivisibleInt16$fIDivisibleInt8$fIDivisibleInt$fIDivisibleInteger$fMultiplicativeRatio$fMultiplicativeDouble$fMultiplicativeFloat$fMultiplicativeWord256$fMultiplicativeWord128$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeNatural$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeInt$fMultiplicativeInteger Subtractive Difference$fSubtractiveZn$fSubtractiveZn64$fSubtractiveChar$fSubtractiveDouble$fSubtractiveFloat$fSubtractiveWord256$fSubtractiveWord128$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveNatural$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveInt$fSubtractiveInteger Offsetable CountableCountOfOffsetOffset8FileSize+..==# offsetOfE offsetPlusE offsetMinusE offsetSub offsetRecast offsetShiftR offsetShiftL offsetCastsizeCastsizeSubsizeLastOffset sizeAsOffset offsetAsSizesizeOfEcountOfRoundUp csizeOfSize csizeOfOffset sizeOfCSSize sizeOfCSize natValCountOf natValOffset$fIntegralCastWordCountOf$fIntegralCastIntCountOf$fMonoidCountOf$fSemigroupCountOf$fSubtractiveCountOf$fAdditiveCountOf$fIsNaturalCountOf$fIsIntegralCountOf $fNumCountOf$fIntegralCastWordOffset$fIntegralCastIntOffset$fSubtractiveOffset$fIsNaturalOffset$fIsIntegralOffset$fShowFileSize $fEqFileSize $fOrdFileSize $fShowOffset $fEqOffset $fOrdOffset $fEnumOffset$fAdditiveOffset$fIntegralOffset $fNumOffset $fShowCountOf $fEqCountOf $fOrdCountOf $fEnumCountOf$fIntegralCountOflengthnullsumreverse!!NonEmptyCollectionIsEmpty InvalidRecastRecastDestinationSizeRecastSourceSize OutOfBoundOutOfBoundOperationOOB_Read OOB_Write OOB_MemSet OOB_MemCopy OOB_Index outOfBoundprimOutOfBound isOutOfBound$$fExceptionNonEmptyCollectionIsEmpty$fExceptionInvalidRecast$fExceptionOutOfBound$fShowOutOfBoundOperation$fEqOutOfBoundOperation$fShowOutOfBound$fShowRecastSourceSize$fEqRecastSourceSize$fShowRecastDestinationSize$fEqRecastDestinationSize$fShowInvalidRecast$fShowNonEmptyCollectionIsEmptyNonEmpty getNonEmpty$fIsListNonEmpty$fShowNonEmpty $fEqNonEmpty BuildingState prevChunksprevChunksSizecurChunk chunkSizeBuilder runBuilder$fMonadFailureBuilder$fFunctorBuilder$fApplicativeBuilder$fMonadBuilder NormalForm toNormalFormdeepseqforce$fNormalForm(,,,,,,,)$fNormalForm(,,,,,,)$fNormalForm(,,,,,)$fNormalForm(,,,,)$fNormalForm(,,,)$fNormalForm(,,)$fNormalForm(,)$fNormalForm[]$fNormalFormBE$fNormalFormLE$fNormalFormEither$fNormalFormMaybe$fNormalFormZn64$fNormalFormZn$fNormalFormWord256$fNormalFormWord128$fNormalFormChar7$fNormalFormCountOf$fNormalFormOffset$fNormalFormPtr$fNormalFormCDouble$fNormalFormCFloat$fNormalFormCULLong$fNormalFormCLLong$fNormalFormCULong$fNormalFormCLong$fNormalFormCUInt$fNormalFormCInt$fNormalFormCUShort$fNormalFormCShort$fNormalFormCSChar$fNormalFormCUChar$fNormalFormCChar$fNormalForm()$fNormalFormBool$fNormalFormChar$fNormalFormDouble$fNormalFormFloat$fNormalFormNatural$fNormalFormWord$fNormalFormWord64$fNormalFormWord32$fNormalFormWord16$fNormalFormWord8$fNormalFormInteger$fNormalFormInt$fNormalFormInt64$fNormalFormInt32$fNormalFormInt16$fNormalFormInt8TheseThisThat$fFunctorThese$fBifunctorThese$fNormalFormThese $fEqThese $fOrdThese $fShowThesePrimMemoryComparablePrimTypeprimSizeInBytesprimShiftToBytes primBaUIndex primMbaURead primMbaUWrite primAddrIndex primAddrRead primAddrWrite primBaIndex primMbaRead primMbaWriteprimArrayIndexprimMutableArrayReadprimMutableArrayWrite sizeRecast sizeInBytes offsetInBytesoffsetInElementsprimOffsetRecastoffsetIsAligned primOffsetOfEprimWordGetByteAndShiftprimWord64GetByteAndShiftprimWord64GetHiLo$fPrimMemoryComparableBE$fPrimMemoryComparableLE$fPrimMemoryComparableCUChar$fPrimMemoryComparableCChar$fPrimMemoryComparableChar$fPrimMemoryComparableInt64$fPrimMemoryComparableInt32$fPrimMemoryComparableInt16$fPrimMemoryComparableInt8$fPrimMemoryComparableWord256$fPrimMemoryComparableWord128$fPrimMemoryComparableWord64$fPrimMemoryComparableWord32$fPrimMemoryComparableWord16$fPrimMemoryComparableWord8$fPrimMemoryComparableWord$fPrimMemoryComparableInt $fPrimTypeBE $fPrimTypeLE$fPrimTypeChar7$fPrimTypeCUChar$fPrimTypeCChar$fPrimTypeChar$fPrimTypeDouble$fPrimTypeFloat$fPrimTypeInt64$fPrimTypeInt32$fPrimTypeInt16$fPrimTypeInt8$fPrimTypeWord256$fPrimTypeWord128$fPrimTypeWord64$fPrimTypeWord32$fPrimTypeWord16$fPrimTypeWord8$fPrimTypeWord $fPrimTypeIntListNunListNtoListN replicateMmapMmapM_ replicateunconsconsemptycreate createFrom singletonelemappendmaximumminimumheadtailtakedropsplitAt indexStaticindexmapfoldlfoldl'foldrzipzip3zip4zip5zipWithzipWith3zipWith4zipWith5$fNormalFormListN $fShowListN $fEqListN $fOrdListN getDimensions initializeAddraddrPlus addrPlusSz addrPlusCSzptrPlus ptrPlusSz ptrPlusCSz$fEqAddr $fOrdAddrValidationFailure InvalidHeaderInvalidContinuation MissingByteBuildingFailure MutableBlockBlock mutableEmpty unsafeIndex unsafeFreeze unsafeThaw unsafeNewnew newPinnedunsafeCopyElementsunsafeCopyElementsROunsafeCopyBytesunsafeCopyBytesRO unsafeRead unsafeWritemutableWithPtrmutableLengthSizemutableLengthBytesiterSetreadwrite Base16EscapeunsafeConvertByte escapeByte hexWord16 hexWord32unsafeCopyToPtrisPinnedisMutablePinnedthawfreezecopyfoldl1'foldr1snocsubunsnoc revSplitAtbreakbreakEndspanallanysplitOnfindfiltersortBy intersperse$fIndexableBlockty $fRandomAccessMutableBlockprimty MutableBlockNBlockNtoBlockNtoBlock$fNormalFormBlockN $fEqBlockN $fShowBlockNUArrayMUArray newNative unsafeIndexerunsafeFreezeShrinkonMutableBackend unsafeDewrap vFromListN equalMemcmpcopyAtunsafeCopyAtROMArrayArray mutableLengthrevTakerevDropspanEndmapFromUnboxed mapToUnboxed isPrefixOf isSuffixOf builderAppend builderBuild builderBuild_$fRandomAccessMArrayprimty $fIsListArray $fOrdArray $fEqArray $fShowArray $fMonoidArray$fSemigroupArray$fFunctorArray$fNormalFormArray $fDataArrayMVectVectunVecttoVect $fFunctorVect$fNormalFormVect$fEqVect $fShowVectsizeInMutableBytesOfContent mutableSamemutableForeignMemwithMutablePtr copyFromPtr copyToPtr mutableOffset foreignMemfromForeignPtr fromBlock freezeShrink createFromIO createFromPtrupdate unsafeUpdatewithPtrrecast unsafeRecast unsafeTake unsafeDrop breakElem breakLine findIndex revFindIndexmapIndexindicesreplace toHexadecimaltoBase64InternalMUVectUVectunUVecttoUVect$fNormalFormUVect $fEqUVect $fShowUVectMutableAsciiString AsciiStringtoBytesfromBytesUnsafe fromBytes$fIsListAsciiString$fIsStringAsciiString$fShowAsciiString$fSemigroupAsciiString$fMonoidAsciiString$fEqAsciiString$fOrdAsciiString MutableStringStringgetArgs lookupEnvFP64FP32EncodingASCII7UTF8UTF16UTF32 ISO_8859_1mutableValidate dropWhilecharMapfromBytesLenientfromChunkByteslineswords readIntegral readInteger readNatural readDouble readRationalreadFloatingExactupperlower isInfixOf stripPrefix stripSuffixtoBase64 toBase64URLtoBase64OpenBSD$fEncodingEncoderUTF8$fDataEncoding $fEqEncoding $fOrdEncoding$fShowEncoding$fEnumEncoding$fBoundedEncodingTryIntoTryFromtryFromIntoFromintotryInto $fFromZn64Zn $fFromZnZn64$fFromZnWord256$fFromZnWord128$fFromZnWord64$fFromZnWord32$fFromZnWord16 $fFromZnWord8$fFromZn64Word256$fFromZn64Word128$fFromZn64Word64$fFromZn64Word32$fFromZn64Word16$fFromZn64Word8$fTryFromArrayBlockN$fTryFromUArrayBlockN$fTryFromBlockBlockN$fFromBlockNArray$fFromBlockNUArray$fFromBlockNBlock$fTryFromUArrayString$fFromAsciiStringUArray$fFromAsciiStringString$fFromStringUArray$fFromUArrayArray$fFromArrayBlock$fFromUArrayBlock$fFromArrayUArray$fFromBlockUArray$fFromEitherThese$fFromCountOfWord$fFromCountOfInt$fFromMaybeEither$fFromWordWord64$fFromWord64Word256$fFromWord64Word128$fFromWord32Word$fFromWord32Word256$fFromWord32Word128$fFromWord32Word64$fFromWord16Word$fFromWord16Word256$fFromWord16Word128$fFromWord16Word64$fFromWord16Word32$fFromWord8Int$fFromWord8Int64$fFromWord8Int32$fFromWord8Int16$fFromWord8Word$fFromWord8Word256$fFromWord8Word128$fFromWord8Word64$fFromWord8Word32$fFromWord8Word16$fFromIntInt64$fFromInt32Int$fFromInt32Int64$fFromInt16Int$fFromInt16Int64$fFromInt16Int32 $fFromInt8Int$fFromInt8Int64$fFromInt8Int32$fFromInt8Int16$fFromnInteger$fFromnNatural $fFromWordInt $fFromIntWord$fFromaa RGBComponent GrayComponentColorComponent DisplacementEscapecursorUp cursorDown cursorForward cursorBackcursorNextLinecursorPrevLinecursorHorizontalAbsolutecursorPositioneraseScreenFromCursoreraseScreenToCursoreraseScreenAlleraseLineFromCursoreraseLineToCursor eraseLineAllscrollUp scrollDownsgrReset sgrForeground sgrBackgroundsgrForegroundGray24sgrBackgroundGray24sgrForegroundColor216sgrBackgroundColor216 word64ToInt64 int64ToWord64 word64ToWord#byteSwapequalcompare_integralDownsizeBounded complementpopCountshiftLshiftRrotateLrotateRtestBitbitapplyBiWordOnNaturalinv64comb64literal NbBytesCont_ NbBytesContisContinuation getNbBytesisContinuation# getNbBytes#TableunTable NbBytesCont0_ NbBytesCont1_ NbBytesCont2_ NbBytesCont3_NbBytesInvalid NbBytesCont0 NbBytesCont1 NbBytesCont2 NbBytesCont3isContinuation2isContinuation3 contTable headTableadd64sub64mul64addmulscaleNumpowerevensizeIntsizeWordshiftInt shiftWord offset128_64 offset256_64sizeRecastBytesprimOffsetRecastBytesunsafeUArrayUnpinnedMaxSize GHC.IO.UnsafeunsafePerformIO impossible tiocgwinszWinsizews_rowws_col ws_xpixel ws_ypixelc_ioctl ioctlWinsize$fStorableWinsizeUTF8Char asUTF8CharUTF8_1UTF8_2UTF8_3UTF8_4maskContinuation# maskHeader2# maskHeader3# maskHeader4#or3#or4#toChar#toChar1toChar2toChar3toChar4numBytesskipNextHeaderValue headerIsAscii charToBytes StepASCII StepDigitStepBackStepisValidStepASCIIisValidStepDigit$fExceptionValidationFailuresysHsMemFindByteAddrsysHsMemFindByteBasysHsMemcmpPtrPtrsysHsMemcmpPtrBasysHsMemcmpBaPtrsysHsMemcmpBaBainternalFromListinternalToListinternalCompare blockType lengthBytesempty_ compareMemcmpconcattouch $fIsListBlock $fMonoidBlock$fSemigroupBlock $fOrdBlock $fEqBlock $fShowBlock$fNormalFormBlock $fDataBlocktableLotableHiMutable Immutable primIndex primIndex64primRead primWritenextAsciiDigit primWrite8 primRead8 primIndex8 nextAscii expectAsciinextnextSkipprevprevSkip copyFiltervalidatefindIndexPredicaterevFindIndexPredicate RandomAccess Indexable inplaceSortBy findIndexElemrevFindIndexElemfoldl1unMBlockunBlocktoCounttoOffset vFromListvToListvCompare ValidRange UArrayBackendUArrayBA UArrayAddrMUArrayBackend MUArrayMBA MUArrayAddr arrayTypeoffsetoffsetsValidRange newUnpinned onBackend onBackendPureonBackendPure' onBackendPrim unsafeDewrap2pureST equalBytes vCompareBytesvCompareMemcmpmemcmp$fIsListUArray$fMonoidUArray$fSemigroupUArray $fOrdUArray $fEqUArray $fShowUArray$fNormalFormUArray $fDataUArray$fRandomAccessPtrprimty$fIndexablePtrtyunsafeCopyFrom onNewArraycountFromStartfreezeUntilIndexunMVectwithMutablePtrHint breakElemByteoutputLengthBase64convert3unMUVectUnitError encodingNext convertFromTo encodingWriteisAsciiASCII7_InvalidByteOutOfBound CharNotAscii$fEncodingASCII7$fExceptionASCII7_InvalidISO_8859_1_Invalid NotISO_8859_1aone$fEncodingISO_8859_1$fExceptionISO_8859_1_Invalid UTF16_InvalidInvalidUnicode$fEncodingUTF16$fExceptionUTF16_Invalid UTF32_Invalid$fEncodingUTF32$fExceptionUTF32_InvalidsizesToList fromModified sFromList stringType sToListStream$fNormalFormString $fDataString$fIsListString$fIsStringString $fShowString EncoderUTF8indexN splitIndexdecimalDigitsBAdecimalDigitsPtrReadFloatingCallbacknextWithIndexerwriteWithBuilder writeUTF8CharcountCharMoreThanBytesfromEncoderBytestoEncoderBytes stringDewrapnaturalToWord64csi0csi1csi2csi3pshow