h$Y*ٌ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc d e f gh i j k l m n opqrstuvwxyz { | } ~                                                                                                                     !!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%&&&&&'''''(((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))********************************************************++++,,,+ + , + , + + + + + + + + + + + + , + + + - - - - - - - - - - - - - - - - - - - - - + + + + + + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 7 7 7 7 6 6  6      8 8 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ; ; ; ;;;;;<<<<<<<<  BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred,3#=fedcfedc  BSD-style Foundation Safe-Inferred,3#7lknm{z}|~7{z}|~nmlk  Safe-Inferred ,-3$  BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred,3$jihjih BSD-style#Vincent Hanquez  experimentalportableNone,3%mRRNone ,3%55 BSD-style FoundationNone ,3>& basement-cdNegation support e.g. -(f x) basement-cdFractional Literal support'e.g. 1.2 :: Double 0.03 :: Float basement-cdIntegral Literal support&e.g. 123 :: Integer 123 :: Word8 BSD-style#Vincent Hanquez  experimentalportableNone,3( basement-cdPinning status basement-cdLowlevel Boolean basement-cdCountOf in bytes type aliasfor code documentation purpose only, just a simple type alias on Int# basement-cd)Offset in a bytearray, string, type aliasfor code documentation purpose only, just a simple type alias on Int# basement-cdFile size in bytes BSD-style#Vincent Hanquez  experimentalportableNone  ,3+- basement-cd:Flag record whether a specific byte array is pinned or not basement-cdturn an Int# into a Bool basement-cd*A mkWeak# version that keep working on 8.0,signature change in ghc-prim: * 0.4: mkWeak :: 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) 9L 9L Safe-Inferred,3+)) BSD-style*Nicolas Di Prima statbleportable Safe-Inferred,3, $$ BSD-style#Vincent Hanquez  experimentalportableNone,3, basement-cd/Only to use internally for internal error cases basement-cd!for support of if .. then .. elseR    a`_^]\[ZYXWVUT!" #$%&'*+HK,-./012346JI7OPQ89:;<=>?NMSbgopqrwxyxywr#"   !&  g6JI7OPQ+HK/4,0123:;<=9-.8R%'?NM a`_^]\[ZYXWVUTSb$*qpo> BSD-stylePsychohistorians experimentalportableNone,3. basement-cdSimple Reader monad basement-cdSimple State monadNone ,-3/' BSD-styleHaskell Foundation experimentalportableNone ,31{ basement-cd(Class of types that can be byte-swapped.e.g. Word16, Word32, Word64 basement-cdBig Endian value basement-cdLittle Endian value basement-cd.Convert a value in cpu endianess to big endian basement-cd5Convert from a big endian value to the cpu endianness basement-cd1Convert a value in cpu endianess to little endian basement-cd8Convert from a little endian value to the cpu endianness basement-cd&endianness of the current architectureNone ,3?1  =None ,32. BSD-style#Vincent Hanquez  experimentalportableNone ,-38 basement-cd Monad that can represent failureSimilar to MonadFail but with a parametrized Failure linked to the Monad basement-cdThe associated type with the MonadFailure, representing what failure can be encoded in this monad basement-cd Raise a Failure through a monad. basement-cd)Primitive monad that can handle mutation.For example: IO and ST. basement-cd3type of state token associated with the PrimMonad m basement-cd0type of variable associated with the PrimMonad m basement-cdUnwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value. basement-cd&Throw Exception in the primitive monad basement-cd(Run a Prim monad from a dedicated state# basement-cd&Build a new variable in the Prim Monad basement-cd#Read the variable in the Prim Monad basement-cd$Write the variable in the Prim Monad basement-cd just like unwrapPrimMonad9 but throw away the result and return just the new State# basement-cd+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. basement-cd%Convert any prim monad to an ST monad basement-cd%Convert any prim monad to an IO monad basement-cd$Convert any IO monad to a prim monad basement-cd(Touch primitive lifted to any prim monad BSD-style#Vincent Hanquez  experimentalportableNone ,3; basement-cd-Create a pointer with an associated finalizer basement-cd3Check 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 basement-cd$create a new FinalPtr from a Pointer basement-cd'Create a new FinalPtr from a ForeignPtr basement-cd.Cast a finalized pointer from type a to type b basement-cdLooks at the raw pointer inside a FinalPtr, making sure the data pointed by the pointer is not finalized during the call to f basement-cdUnsafe version of   >None ,3Number literals, convertible through the generic Integer type.all number are Enum'erable, meaning that you can move to next elementNone'(,39>> basement-cdUpsize an integral valueThe destination type b9 size need to be greater or equal than the size type of a basement-cdDownsize an integral valueNone,3@ basement-cd ASCII value between 0x0 and 0x7f basement-cd Convert a  to a unicode code point , basement-cdTry to convert a , to a 9If the code point is non ascii, then Nothing is returned. basement-cdTry to convert : to a 9If the byte got higher bit set, then Nothing is returned. basement-cd Convert a , to a  ignoring all higher bits basement-cd Convert a Byte to a  ignoring the higher bitNone ,3B basement-cdConvert a byte value in Word to two Word9s containing the hexadecimal representation of the Word#The output words# are guaranteed to be included in the 0 to 2^7-1 rangeNote that calling convertByte with a value greater than 256 will cause segfault or other horrible effect. basement-cd hex word16 basement-cd hex word32None ,3E, basement-cd 128 bits Word basement-cd Add 2 Word128 basement-cdSubtract 2 Word128 basement-cdMultiplication basement-cdDivision basement-cdModulo basement-cd Bitwise and basement-cd Bitwise or basement-cd Bitwise xor basement-cdBitwise complement basement-cdPopulation count basement-cdBitwise Shift Left basement-cdBitwise Shift Right basement-cdBitwise rotate Left basement-cdBitwise rotate LeftNone ,3G basement-cd 256 bits Word basement-cd Add 2 Word256 basement-cdSubtract 2 Word256 basement-cdMultiplication basement-cdDivision basement-cdModulo basement-cd Bitwise and basement-cd Bitwise or basement-cd Bitwise xor basement-cdBitwise complement basement-cdPopulation count basement-cdBitwise Shift Left basement-cdBitwise Shift Right basement-cdBitwise rotate Left basement-cdBitwise rotate LeftNone'(,-/3In basement-cdConstraint 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 basement-cd?Check if a Nat is in bounds of another integral / natural types basement-cdGet Maximum bounds of different Integral / Natural types related to Nat(ABCDEFGuvA(uvEBCDFG BSD-styleHaskell FoundationNone ,/3L7 basement-cdA type level bounded natural basement-cd/A type level bounded natural backed by a Word64 basement-cd'Create an element of B/nB from a Word64If the value is greater than n, then the value is normalized by using the integer modulus n basement-cd/Create an element of B/nB from a type level Nat basement-cd)Create an element of B/nB from a Natural.If the value is greater than n, then the value is normalized by using the integer modulus n basement-cd/Create an element of B/nB from a type level NatNone ,3M basement-cd1Represent class of things that can be subtracted.Note 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 Natural6None ,39>N basement-cdRepresent class of things that can be added together, contains a neutral element and is commutative. )x + azero = x azero + x = x x + y = y + x6None ,39>Qu basement-cd'Support for division between same typesThis is likely to change to represent specific mathematic divisions basement-cd3Represent types that supports an euclidian division "(x @div@ y) * y + (x @mod@ y) == x basement-cd9Represent class of things that can be multiplied together #x * midentity = x midentity * x = x basement-cd$Identity element over multiplication basement-cd;Multiplication of 2 elements that result in another element basement-cdRaise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a  778  BSD-style#Vincent Hanquez  experimentalportableNone,-3VX basement-cdCountOf 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  apply here. basement-cd: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. basement-cdOffset in bytes used for memory addressing (e.g. in a vector, string, ..) basement-cdFile size in bytes basement-cd+subtract 2 CountOf values of the same type.m need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure. basement-cd+subtract 2 CountOf values of the same type.m need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure. basement-cd!alignment need to be a power of 2!! None,3W > >?None ,3X basement-cd'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,3X@@ BSD-style foundationNone,3Z basement-cd5Defines 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!).TODO The default value of 1024 bytes is arbitrarily chosen for now."None,/3>`n  basement-cdA 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 operation basement-cdRepresent 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. basement-cdtype level size of the given ty basement-cd%get the size in bytes of a ty element basement-cdget the shift size basement-cd-return the element stored at a specific index basement-cd.Read an element at an index in a mutable array basement-cd7Write an element to a specific cell in a mutable array. basement-cdRead from Address, without a state. the value read should be considered a constant for all pratical purpose, otherwise bad thing will happens. basement-cd4Read a value from Addr in a specific primitive monad basement-cd3Write a value to Addr in a specific primitive monad basement-cdCast a CountOf linked to type A (CountOf A) to a CountOf linked to type B (CountOf B) basement-cdmutable array to read from basement-cd index of the element to retrieve basement-cdthe element returned basement-cdmutable array to modify basement-cdindex of the element to modify basement-cdthe new value to store#None,3a basement-cd.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.  $ BSD-style#Vincent Hanquez  experimentalportableNone,3dw basement-cd?Exception for using NonEmpty assertion with an empty collection basement-cd?Exception during an operation accessing the vector out of boundRepresent the type of operation, the index accessed, and the total length of the vector. basement-cdstableportableNone,3j basement-cdEither a or b or both.* BSD-style#Vincent Hanquez  experimentalportableNone'(,/38?y<2 basement-cd*A Typed-level sized List equivalent to [a] basement-cdTry to create a ListN from a List, succeeding if the length is correct basement-cd4Create a ListN from a List, expecting a given lengthIf this list contains more or less than the expected length of the resulting type, then an asynchronous error is raised. use  for a more friendly functions basement-cdperforms a monadic action n times, gathering the results in a List of size n. basement-cdEvaluate each monadic action in the list sequentially, and collect the results. basement-cdEvaluate each monadic action in the list sequentially, and ignore the results. basement-cdMap each element of a List to a monadic action, evaluate these actions sequentially and collect the results basement-cdMap each element of a List to a monadic action, evaluate these actions sequentially and ignore the results basement-cdCreate a list of n elements where each element is the element in argument basement-cd(Decompose a list into its head and tail. basement-cdprepend an element to the list basement-cd6Decompose a list into its first elements and the last. basement-cdappend an element to the list basement-cdCreate an empty list of a basement-cdGet the length of a list basement-cd>Create a new list of size n, repeately calling f from 0 to n-1 basement-cd"Same as create but apply an offset basement-cdcreate a list of 1 element basement-cd&Check if a list contains the element a basement-cd-Append 2 list together returning the new list basement-cd!Get the maximum element of a list basement-cd!Get the minimum element of a list basement-cdGet the head element of a list basement-cdGet the tail of a list basement-cd*Get the list with the last element missing basement-cd/Take m elements from the beggining of the list.The number of elements need to be less or equal to the list in argument basement-cd:Drop elements from a list keeping the m remaining elements basement-cd(Split a list into two, returning 2 lists basement-cdGet the i'th elements%This only works with TypeApplication: 0indexStatic @1 (toListN_ [1,2,3] :: ListN 3 Int) basement-cdGet the i'the element basement-cd1Update the value in a list at a specific location basement-cdMap all elements in a list basement-cd3Map all elements in a list with an additional index basement-cdFold all elements from left basement-cd$Fold all elements from left strictly basement-cdFold all elements from left strictly with a first element as the accumulator basement-cdFold all elements from right basement-cdFold all elements from right assuming at least one element is in the list. basement-cdscanl is similar to , but returns a list of successive reduced values from the left scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] basement-cdscanl1 is a variant of scanl% that has no starting value argument: .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] basement-cdReverse a list basement-cdZip 2 lists of the same size, returning a new list of the tuple of each elements basement-cd( to a mutable block in a safer construct;If the block is not pinned, this is a _dangerous_ operation  basement-cdCreate a pointer on the beginning of the MutableBlock and call a function f.(The mutable block can be mutated by the f function and the change will be reflected in the mutable blockIf the mutable block is unpinned, a trampoline buffer is created and the data is only copied when f return.:it is all-in-all highly inefficient as this cause 2 copies  basement-cdSame as   but allow to specify 2 optimisations which is only useful when the MutableBlock is unpinned and need a pinned trampoline to be called safely.If skipCopy is True, then the first copy which happen before the call to f, is skipped. The Ptr is now effectively pointing to uninitialized data in a new mutable Block.If skipCopyBack is True, then the second copy which happen after the call to f, is skipped. Then effectively in the case of a trampoline being used the memory changed by f6 will not be reflected in the original Mutable Block.If using the wrong parameters, it will lead to difficult to debug issue of corrupted buffer which only present themselves with certain Mutable Block that happened to have been allocated unpinned.If unsure use  (, which default to *not* skip any copy.  basement-cddestination mutable block basement-cdoffset at destination basement-cdsource mutable block basement-cdoffset at source basement-cdnumber of elements to copy  basement-cddestination mutable block basement-cdoffset at destination basement-cd source block basement-cdoffset at source basement-cdnumber of elements to copy  basement-cddestination mutable block basement-cdoffset at destination basement-cdsource mutable block basement-cdoffset at source basement-cdnumber of elements to copy  basement-cddestination mutable block basement-cdoffset at destination basement-cd source block basement-cdoffset at source basement-cdnumber of elements to copy  basement-cddestination mutable block basement-cdoffset at destination basement-cd source block basement-cdnumber of bytes to copy  basement-cdhint that the buffer doesn't need to have the same value as the mutable block when calling f basement-cdhint that the buffer is not supposed to be modified by call of f   - BSD-styleHaskell FoundationNone,-39>  basement-cd  an object of type a to b.Do not add instance of this class if the source type is not of the same size of the destination type. Also keep in mind this is casting a value of a given type into a destination type. The value won't be changed to fit the destination represention.If you wish to convert a value of a given type into another type, look at From and TryFrom. 3cast (-10 :: Int) :: Word === 18446744073709551606   + BSD-styleHaskell FoundationNone ,3l  basement-cd(Set all mutable block element to a value  basement-cdread a cell in a mutable array.2If the index is out of bounds, an error is raised.  basement-cd#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.  basement-cdCopy from a pointer, count7 elements, into the Mutable Block at a starting offset ofsif the source pointer is invalid (size or bad allocation), bad things will happen  basement-cdCopy all the block content to the memory starting at the destination addressIf the destination pointer is invalid (size or bad allocation), bad things will happen  basement-cdSource Ptr of ty to start of memory basement-cdDestination mutable block basement-cd-Start offset in the destination mutable block basement-cd Number of ty elements  basement-cd The source mutable block to copy basement-cd&The source offset in the mutable block basement-cd8The destination address where the copy is going to start basement-cdThe number of bytes   , BSD-styleHaskell FoundationNone,3>  basement-cdCopy all the block content to the memory starting at the destination address  basement-cdCreate a new array of size /n by settings each cells through the function f.  basement-cdFreeze a chunk of memory pointed, of specific size into a new unboxed array  basement-cd Thaw a Block into a MutableBlockthe Block is not modified, instead a new Mutable Block is created and its content is copied to the mutable block  basement-cd8Freeze a MutableBlock into a Block, copying all the dataIf the data is modified in the mutable block after this call, then the immutable Block resulting is not impacted.  basement-cd4Copy every cells of an existing Block to a new Block  basement-cd5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.  basement-cdMap all element a from a block to a new block of b  basement-cd%Unsafely recast an UArray containing a to an UArray containing b0The offset and size are converted from units of a to units of b>, but no check are performed to make sure this is compatible.use   if unsure.  basement-cdCast a Block of a to a Block of b)The requirement is that the size of type a8 need to be a multiple or dividend of the size of type b.If this requirement is not met, the InvalidRecast exception is thrown  basement-cdthe source block to copy basement-cd8The destination address where the copy is going to start  basement-cd(the size of the block (in element of ty) basement-cd,the function that set the value at the index basement-cdthe array created/ /  . BSD-styleHaskell FoundationNone,-/3l  basement-cdSized version of   basement-cd  basement-cd Bool set of n bits.  basement-cdoperation over bits  basement-cd8construct a bit set with the bit at the given index set.  basement-cd&test the bit at the given index is set  basement-cdset the bit at the given index  basement-cd clear the bit at the given index  basement-cdoperation over finite bits  basement-cd*get the number of bits in the given object  basement-cdrotate the given bit set.  basement-cdrotate the given bit set.  basement-cd5count of number of bit set to 1 in the given bit set.  basement-cd reverse all bits in the argument  basement-cd$count of the number of leading zeros  basement-cd%count of the number of trailing zeros  basement-cdconvert the given 5 into a   of size nif bits that are not within the boundaries of the 'Bits n' will be truncated.  basement-cd construct a   with all bits set.this function is equivalet to    7 5 6 8 8 8 8GNone&,3>u  basement-cd/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 interface  basement-cd7A Mutable array of types built on top of GHC primitive./Element in this array can be modified in place. basement-cd'Return if the array is pinned in memory-note that Foreign array are considered pinned basement-cd-Return if a mutable array is pinned in memory  basement-cd-Create a new pinned mutable array of size @n.all the cells are uninitialized and could contains invalid values.?All mutable arrays are allocated on a 64 bits aligned addresses basement-cd8Create a new unpinned mutable array of size @n elements.If the size exceeds a GHC-defined threshold, then the memory will be pinned. To be certain about pinning status with small size, use   basement-cd9Same as newNative but expect no extra return value from f  basement-cd&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.You can change the threshold value used by setting the environment variable !HS_FOUNDATION_UARRAY_UNPINNED_MAX.  basement-cdThe 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. basement-cd"Check if two vectors are identical  basement-cdCopy a number of elements from an array to another array with offsets  basement-cdCopy n sequential elements from the specified offset in a source array to the specified position in a destination array.This function does not check bounds. Accessing invalid memory can return unpredictable and invalid values.  basement-cdCreate 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 array  basement-cddestination array basement-cdoffset at destination basement-cd source array basement-cdoffset at source basement-cdnumber of elements to copy  basement-cddestination array basement-cdoffset at destination basement-cd source array basement-cdoffset at source basement-cdnumber of elements to copy/        2 BSD-style#Vincent Hanquez  experimentalportableNone,3>  basement-cdMutable Array of a  basement-cd Array of a  basement-cd1return the numbers of elements in a mutable array  basement-cd5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.  basement-cdReturn the element at a specific index from an array without bounds checking.Reading from invalid memory can return unpredictable and invalid values. use   if unsure.  basement-cdread a cell in a mutable array.2If the index is out of bounds, an error is raised.  basement-cd experimentalportableNone ,3  basement-cdread a cell in a mutable array.2If the index is out of bounds, an error is raised.  basement-cd#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.  basement-cd1return the numbers of elements in a mutable array  basement-cdCreate 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 arrayIf the mutable array is unpinned, a trampoline buffer is created and the data is only copied when f return.  basement-cdCopy from a pointer, count! elements, into the mutable array  basement-cdCopy all the block content to the memory starting at the destination address  basement-cd"the start pointer with a finalizer basement-cd/the number of elements (in elements, not bytes)  basement-cd the source mutable array to copy basement-cd8The destination address where the copy is going to start  0 BSD-style#Vincent Hanquez  experimentalportableNone,3>۷  basement-cd5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.  basement-cdCreate a foreign UArray from foreign memory and given offset/sizeNo check are performed to make sure this is valid, so this is unsafe.This is particularly useful when dealing with foreign memory and  ByteString  basement-cdCreate a UArray from a Block%The block is still used by the uarray  basement-cdFreeze a MUArray into a UArray by copying all the content is a pristine new bufferThe MUArray in parameter can be still be used after the call without changing the resulting frozen data.  basement-cd Just like   but copy only the first n bytesThe size requested need to be smaller or equal to the length of the MUArray, otherwise a Out of Bounds exception is raised  basement-cdCreate a new array of size /n by settings each cells through the function f.  basement-cd*Create a pinned array that is filled by a filler- function (typically an IO call like hGetBuf)  basement-cdFreeze a chunk of memory pointed, of specific size into a new unboxed array  basement-cd9update an array by creating a new array with the updates.the operation copy the previous array, modify it in place, then freeze it.  basement-cdCopy all the block content to the memory starting at the destination address  basement-cd-Get a Ptr pointing to the data in the UArray.Since a UArray is immutable, this Ptr shouldn't be to use to modify the contentsIf the UArray is pinned, then its address is returned as is, however if it's unpinned, a pinned copy of the UArray is made before getting the address.  basement-cd*Recast an array of type a to an array of ba and b need to have the same size otherwise this raise an async exception  basement-cd%Unsafely recast an UArray containing a to an UArray containing b0The offset and size are converted from units of a to units of b>, but no check are performed to make sure this is compatible.use   if unsure.  basement-cdTake a count of elements from the array and create an array with just those elements  basement-cdDrop a count of elements from the array and return the new array minus those dropped elements  basement-cdSplit an array into two, with a count of at most N elements in the first one and the remaining in the other.  basement-cd5Similar 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.  basement-cd-Take the N elements from the end of the array  basement-cd-Drop the N elements from the end of the array  basement-cdSplit 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 second  basement-cdSimilar 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])  basement-cd Replace all the occurrencies of needle with  replacement in the haystack string.  basement-cd"the start pointer with a finalizer basement-cd/the number of elements (in elements, not bytes)  basement-cdthe size of the array basement-cd,the function that set the value at the index basement-cdthe array created  basement-cdthe size of the array basement-cdfilling function that  basement-cdthe source array to copy basement-cd8The destination address where the copy is going to start  4 BSD-styleHaskell Foundation experimentalportableNone ,3?q  basement-cd7Opaque packed array of characters in the ASCII encoding  basement-cdConvert a Byte Array representing ASCII data directly to an AsciiString without checking for ASCII validityIf the input contains invalid Char7 value (anything above 0x7f), it will trigger runtime async errors when processing data.In doubt, use   basement-cd:Convert a Byte Array representing ASCII checking validity.8If the byte array is not valid, then Nothing is returned  H BSD-style Foundation experimentalportableNone,3?  basement-cdthe unit element use for the encoding. i.e. Word8 for ASCII7 or UTF8, Word16 for UTF16... basement-cddefine the type of error handling you want to use for the next function. %type Error UTF8 = Either UTF8_Invalid basement-cdconsume an `Unit encoding` and return the Unicode point and the position of the next possible `Unit encoding` basement-cdhelper to convert a given Array in a given encoding into an array with another encoding.This is a helper to convert from one String encoding to another. This function is (quite) slow and needs some work.``` let s16 = ... -- string in UTF16 -- create s8, a UTF8 String let s8 = runST $ convertWith UTF16 UTF8 (toBytes s16) print s8 ``` basement-cdonly used for type deduction basement-cd/method to access a given `Unit encoding` (see  unsafeIndexer) basement-cdoffset of the `Unit encoding` where starts the encoding of a given unicode basement-cdeither successfully validated the `Unit encoding` and returned the next offset or fail with an `Error encoding` basement-cdonly used for type deduction basement-cdthe unicode character to encode basement-cdInput's encoding type basement-cdOutput's encoding type basement-cdthe input raw arrayI BSD-style Foundation experimentalportableNone,3mJ BSD-style Foundation experimentalportableNone,3K BSD-style Foundation experimentalportableNone,3%L BSD-style Foundation experimentalportableNone,35None,-/3  MNone,3  basement-cd?Possible failure related to validating bytes of UTF8 sequences.  basement-cdRepresent an already encoded UTF8 Char where the the lowest 8 bits is the start of the sequence. If this contains a multi bytes sequence then each higher 8 bits are filled with the remaining sequence 8 bits per 8 bits.For example: A => U+0041 => 41 => 0x00000041 'A => U+20AC => E2 82 AC => 0x00AC82E2 Ȇ( => U+10348 => F0 90 8D 88 => 0x888D90F0 basement-cd(Specialized tuple used for case mapping. basement-cd$Step when processing ASCII character basement-cdStep when processing digits. the value is between 0 and 9 to be valid basement-cdSimilar to Step but used when processing the string from the end.The stepper is thus the previous character, and the offset of the beginning of the previous character basement-cdStep 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) N BSD-style#Vincent Hanquez  experimentalportableNone,3 basement-cd(Check if the byte is a continuation byte basement-cdGet the number of following bytes given the first byte of a UTF8 sequence. basement-cd(Check if the byte is a continuation byte basement-cdGet the number of following bytes given the first byte of a UTF8 sequence.O BSD-style FoundationNone ,3? basement-cdDifferent way to encode a Character in UTF8 represented as an ADT basement-cdTransform a Unicode code point , intonote that we expect here a valid unicode code point in the *allowed* range. bits will be lost if going above 0x10ffff  basement-cdEncode a Char into a CharUTF8  basement-cddecode a CharUTF8 into a CharIf the value inside a CharUTF8 is not properly encoded, this will result in violation of the Char invariants 7None,3   PNone ,3DQNone ,3? basement-cdnextAsciiBa specialized to get a digit between 0 and 9 (included) basement-cd0special case for only non ascii next'er function basement-cdDestination buffer basement-cdDestination start basement-cd Source buffer basement-cd Source start basement-cd Source endR BSD-style FoundationNone ,3?  basement-cdMutable String Buffer.Use as an *append* buffer, as UTF8 variable encoding doesn't really allow to change previously written character without potentially shifting bytes.  basement-cd6Opaque packed array of characters in the UTF8 encoding basement-cdsize in bytes.this size is available in o(1) basement-cd(Convert a String to a list of characters/The list is lazily created as evaluation needed basement-cdassuming the given Addr# is a valid modified UTF-8 sequence of bytesWe 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. basement-cd-Create a new String from a list of charactersThe list is strictly and fully evaluated before creating the new String, as the size need to be computed before filling. basement-cd5Allocate a MutableString of a specific size in bytes. basement-cd$in number of bytes, not of elements. basement-cd$in number of bytes, not of elements. basement-cd$in number of bytes, not of elements. SNone,3  basement-cd&Use the Show class to create a String.Note that this is not efficient, since an intermediate [Char] is going to be created before turning into a real String. TNone,./3J  basement-cd,stop execution and displays an error message  BSD-style#Vincent Hanquez  experimentalportableNone,3  basement-cdIEEE754 Floating point Binary64, double precision (Also known as Double)  basement-cdIEEE754 Floating point Binary32, simple precision (Also known as Float)  basement-cd!for support of if .. then .. elseR    a`_^]\[ZYXWVUT!" #$%&'@ts)*+HK,-./0123456JI7OPQ89:;<=>?NMSbgopqrwxy xyw r# "   !&  g6JI7OPQ+HK/45, 0123:;<=9-.8 R%'@ts?NM a`_^]\[ZYXWVUTSb$*)qpo> 8None,3  basement-cdReturns a list of the program's command line arguments (not including the program name).  basement-cd"Lookup variable in the environment  UNone ,3?'6 BSD-style#Vincent Hanquez  experimentalportableNone ,3? >  basement-cdVarious String Encoding that can be use to convert to and from bytes  basement-cd Similar to  but works on a MutableByteArray  basement-cdCheck if a String is null  basement-cdCreate a string composed of a number @n of Chars (Unicode code points).if the input @s contains less characters than required, then the input string is returned.  basement-cdCreate a string with the remaining Chars after dropping @n Chars from the beginning  basement-cdSplit a string at the Offset specified (in Char) returning both the leading part and the remaining part.  basement-cd Similar to   but from the end  basement-cd Similar to   but from the end  basement-cd Similar to   but from the end  basement-cd: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"]  basement-cd8Internal call to make a substring given offset in bytes.This is unsafe considering that one can create a substring starting and/or ending on the middle of a UTF8 sequence.  basement-cdBreak a string into 2 strings at the location where the predicate return True  basement-cdBreak a string into 2 strings at the first occurence of the character  basement-cdSame as break but cut on a line feed with an optional carriage return.This 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.  basement-cdApply a  predicate to the string to return the longest prefix that satisfy the predicate and the remaining  basement-cdApply a  predicate to the string to return the longest suffix that satisfy the predicate and the remaining  basement-cd=Drop character from the beginning while the predicate is true  basement-cd>Return whereas the string contains a specific character or not  basement-cdIntersperse 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"  basement-cd Length of a String using CountOfthis size is available in o(n)  basement-cdReplicate a character c n$ times to create a string of length n  basement-cdCopy the StringThe slice of memory is copied to a new slice, making the new string independent from the original string..  basement-cdCreate a single element String  basement-cd"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.  basement-cdMonomorphically map the character in a string and return the transformed one  basement-cdAppend a Char to the end of the String and return this new String  basement-cdPrepend a Char to the beginning of the String and return this new String  basement-cdExtract the String stripped of the last character and the last character if not emptyIf empty, Nothing is returned  basement-cdExtract the First character of a string, and the String stripped of the first character.If empty, Nothing is returned  basement-cdLook for a predicate in the String and return the matched character, if any.  basement-cd=Sort the character in a String using a specific sort function'TODO: optimise not going through a list  basement-cd1Filter characters of a string using the predicate  basement-cdReverse a string  basement-cd:Finds where are the insertion points when we search for a needle within an haystack.  basement-cd Replace all the occurrencies of needle with  replacement in the haystack string.  basement-cd$Return the nth character in a StringCompared to an array, the string need to be scanned from the beginning since the UTF8 encoding is variable.  basement-cdReturn the index in unit of Char of the first occurence of the predicate returning True!If not found, Nothing is returned  basement-cd=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  basement-cd*Convert a UTF8 array of bytes to a String.If 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.  basement-cdDecode a stream of binary chunks containing UTF8 encoding in a list of valid StringChunk not necessarily contains a valid string, as a UTF8 sequence could be split over 2 chunks.  basement-cdConvert a Byte Array representing UTF8 data directly to a string without checking for UTF8 validityIf the input contains invalid sequences, it will trigger runtime async errors when processing data.In doubt, use   basement-cd6Convert a String to a bytearray in a specific encodingif the encoding is UTF8, the underlying buffer is returned without extra allocation or any processingIn any other encoding, some allocation and processing are done to convert.  basement-cd4Split lines in a string using newline as separation.Note that carriage return preceding a newline are also strip for maximum compatibility between Windows and Unix system.  basement-cd2Split words in a string using spaces as separation words "Hello Foundation"  Hello,  Foundation  basement-cd&Append a character to a String builder  basement-cd,Create a new String builder using chunks of  sizeChunksI  basement-cdRead an Integer from a StringConsume an optional minus sign and many digits until end of string.  basement-cdRead a Natural from a String(Consume many digits until end of string.  basement-cdTry to read a Double  basement-cd+Try to read a floating number as a RationalNote 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.  basement-cd)Read an Floating like number of the form:    numbers [ x  numbers ] [ ( e | E ) [  ]  number ]Call a function with:0A boolean representing if the number is negativeThe 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  sign$Consume number for the integral part OptionallyConsume x5Consume remaining digits if not already end of stringOptionally Consume a e or E follow by an optional  and a number  basement-cd Convert a   to the upper-case equivalent.  basement-cd Convert a   to the upper-case equivalent.  basement-cd Convert a  % to the unicode case fold equivalent.?Case folding is mostly used for caseless comparison of strings.  basement-cdCheck whether the first string is a prefix of the second string.  basement-cdCheck whether the first string is a suffix of the second string.  basement-cdCheck whether the first string is contains within the second string.TODO: implemented the naive way and thus terribly inefficient, reimplement properly  basement-cd1Try to strip a prefix from the start of a String.If the prefix is not starting the string, then Nothing is returned, otherwise the striped string is returned  basement-cd/Try to strip a suffix from the end of a String.If the suffix is not ending the string, then Nothing is returned, otherwise the striped string is returned  basement-cdTransform string src! to base64 binary representation.  basement-cdTransform string src to URL-safe base64 binary representation. The result will be either padded or unpadded, depending on the boolean padded argument.  basement-cdTransform string src) to OpenBSD base64 binary representation. 9 BSD-style#Vincent Hanquez None  ,/3$  basement-cd$Color compent on 256colors terminals  basement-cd)Gray color compent on 256colors terminals  basement-cdSimple color component on 8 color terminal (maximum compatibility)  basement-cdAll attribute off  basement-cd(8 Colors + Bold attribute for foreground  basement-cd(8 Colors + Bold attribute for background  basement-cd Red component basement-cdGreen component basement-cdBlue component  basement-cd Red component basement-cdGreen component basement-cdBlue component  : BSD-styleHaskell FoundationNone,-3>'  basement-cdClass of things that can mostly be converted from a to b, but with possible error cases.  basement-cd2Class 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   basement-cdSame 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)  basement-cdsame as tryFrom but reversed  ; BSD-style FoundationNone ,3)  basement-cd4run the given builder and return the generated block  basement-cd-run the given builder and return a UTF8Stringthis action is unsafe as there is no guarantee upon the validity of the content of the built block.  basement-cdadd a Block in the builder basement-cdadd a string in the builder basement-cdemit a UTF8 char in the builderthis function may be replaced by `emit :: Encoding -> Char -> Builder`   < BSD-style FoundationNone,3* basement-cd5run the given builder and return the generated Stringprefer  basement-cdadd a string in the builder basement-cdemit a UTF8 char in the builderVWXVWYZ[\Z[]Z^_Z^`ZabZacZadZaeVfgVfhZ^iZ^jZ^kZ^lZmnZopZoqZorZosZ^tZ^uZ^vZ^wZ^xZ^yZ^zZa{Za|Vf}Z^~ZZ^VfZZZmZ^ZZZ^Z^VVVVVZZZZZZVVVZZZZZZZVZZZZZZVZZVVZZVVVZoZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZaZaZaZaZaZaZZZZZZ^Z^Z^Z^Z^Z^Z^Z^Z^ZZZVfVfVfVfVfVfVfVfVfVf>>>>>>>>>>                                                                    ?!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%&&&&&'''''(((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))******************* * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * E E E E E E EE E EE E E E E E E E E E E E E E E E E E - - - - - - - - - - - - - - - - - - - - - + + + + + + , ,, , ,, , , , , , , , , ,,, ,,, , , , , , , , , , , ,, , , , , , , . . . .. . . . . . . .. . . . . . . ... ... . . . . .. . . . . . . . . . / / / / / / / / / / / / / //// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / G G G G GG G G G G G G G G G G G G G G G G G G G 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 222222 2 2 2 22 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 33 33 3 3 3 3 3 333 333 3 3 3 3 33 3 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 00 0 0 00 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00000 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 55 55 5 5 5 5 5 555 555 5 5 5 5 55 5 5 5 5 M M M M M M M O O R R R R ST  8 8 6 6 6 6 6 6 6 66 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 666 6 66 66666 6 6 66 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : :: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ;; ; ; ; ; ; ; ; << < < < < < < = = = = = = = = = = = = = = = = = = > > > > @ Z A A A A A A B B B B B C C C C C C C C C C D E E E G G G G G G G G G G G G G G G G G G G G GH H H H H H I I I J J J J J K K K K L L L L L M M M M M M M M M M M M M N N N N N N O O O O O O O O O O O O O O O O O O O O O O O O O P P P P Q Q QQ Q QQ Q Q Q Q QsQ Q Q QR R R R R R R R R RR R R R R R U U U U 6 +basement-cd-0.0.12.1-AQ3FBEK81AXE3y2ImXypyiBasement.Compat.BaseBasement.Compat.PrimitiveBasement.Compat.IsListBasement.Compat.SemigroupBasement.Compat.Typeable Basement.NatBasement.Compat.NaturalBasement.ImportsBasement.Compat.BifunctorBasement.Compat.IdentityBasement.Compat.C.TypesBasement.Types.PtrBasement.Compat.CallStackBasement.Compat.NumLiteralBasement.Compat.PrimTypesBasement.Compat.MonadTransBasement.Compat.AMPBasement.EndiannessBasement.FloatingBasement.MonadBasement.FinalPtrBasement.IntegralConvBasement.Numerical.NumberBasement.Types.Char7Basement.Base16Basement.Types.Word128Basement.Types.Word256Basement.BoundedBasement.Numerical.SubtractiveBasement.Numerical.Additive!Basement.Numerical.MultiplicativeBasement.Types.OffsetSizeBasement.TerminalBasement.PrimTypeBasement.MutableBuilderBasement.ExceptionBasement.NonEmptyBasement.Compat.ExtListBasement.Alg.XorShiftBasement.NormalFormBasement.TheseBasement.Sized.ListBasement.Block.MutableBasement.Block Basement.CastBasement.Sized.Block Basement.BitsBasement.UArrayBasement.UArray.MutableBasement.BoxedArrayBasement.Sized.VectBasement.Types.AsciiStringBasement.Sized.UVectBasement.StringBasement.Types.CharUTF8Basement.EnvironmentBasement.Terminal.ANSI Basement.FromBasement.Block.BuilderBasement.String.BuilderBasement.HeadHackageUtilsBasement.Numerical.ConversionBasement.Terminal.SizeBasement.RuntimeBasement.Bindings.MemoryBasement.Alg.ClassBasement.Alg.PrimArrayBasement.Alg.MutableBasement.Block.BaseBasement.BlockNBasement.UArray.Base!Basement.String.Encoding.EncodingBasement.String.Encoding.UTF32Basement.String.Encoding.UTF16#Basement.String.Encoding.ISO_8859_1Basement.String.Encoding.ASCII7Basement.UTF8.TypesBasement.UTF8.TableBasement.UTF8.HelperBasement.String.CaseMappingBasement.Alg.UTF8Basement.UTF8.Base Basement.ShowBasement.ErrorBasement.Alg.Stringghc-primGHC.Primseq unsafeCoerce#base Data.TuplefstsndGHC.Base otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=>>=>>fmapreturn Data.String fromStringGHC.ExtsIsListfromList fromListNtoList<>memptymappendmconcat<*>pure*>BoundedEnumEqMonad Data.DataDataFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString Applicative GHC.GenericsGeneric GHC.TypeNatsKnownNat SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybeOrderingIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherRepNat+*^<=?-CmpNatFalseNothingJustTrueW#LeftRightLTEQGTItem mkNoRepTypegmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldlDataTypeData.Bifunctorsecondfirstbimap Bifunctor Control.MonadunlessData.Functor.Identity runIdentityIdentitySystem.Posix.TypesCModeCOffGHC.IOthrowIO GHC.ExceptionthrowGHC.Exception.Type Exception Data.Foldableandtofrom GHC.TypeLitsnatVal<=eitherControl.Category.idForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCBoolCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCIntPtrCUIntPtrCIntMaxCUIntMaxcastPtrmaxBoundminBoundfromEnumtoEnumpredsuccshowListshow showsPrec Data.Maybemaybe Data.Functor<$>$!flipconstwhenstimessconcat<$<*liftA2GHC.Err undefinederrorGHC.Stack.Types HasCallStackcompare<>maxmin/=&&||notintegerToNaturalnaturalToInteger HasNegationnegate Fractional fromRationalIntegral fromInteger$fIntegralCDouble$fIntegralCFloat$fIntegralCOff$fIntegralCSUSeconds$fIntegralCUSeconds$fIntegralCTime$fIntegralCClock$fIntegralCUIntMax$fIntegralCIntMax$fIntegralCUIntPtr$fIntegralCIntPtr$fIntegralCBool$fIntegralCULLong$fIntegralCLLong$fIntegralCSigAtomic$fIntegralCWchar$fIntegralCSize$fIntegralCPtrdiff$fIntegralCULong$fIntegralCLong$fIntegralCUInt$fIntegralCInt$fIntegralCUShort$fIntegralCShort$fIntegralCUChar$fIntegralCSChar$fIntegralCChar$fIntegralDouble$fIntegralFloat$fIntegralIntPtr$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord $fIntegralInt$fIntegralNatural$fIntegralInteger$fFractionalCDouble$fFractionalCFloat$fFractionalDouble$fFractionalFloat$fFractionalRatio$fHasNegationCDouble$fHasNegationCFloat$fHasNegationCIntMax$fHasNegationCLLong$fHasNegationCWchar$fHasNegationCPtrdiff$fHasNegationCLong$fHasNegationCInt$fHasNegationCShort$fHasNegationCSChar$fHasNegationCChar$fHasNegationDouble$fHasNegationFloat$fHasNegationWord64$fHasNegationWord32$fHasNegationWord16$fHasNegationWord8$fHasNegationWord$fHasNegationInt64$fHasNegationInt32$fHasNegationInt16$fHasNegationInt8$fHasNegationInt$fHasNegationIntegerPinned#Bool#CountOf#Offset# FileSize# PinnedStatusPinnedUnpinnedtoPinnedStatus#bool# compatMkWeak#compatIsByteArrayPinned#compatIsMutableByteArrayPinned#$fEqPinnedStatus ListNonEmpty internalError ifThenElseReader runReaderStaterunState $fMonadState$fApplicativeState$fFunctorState $fMonadReader$fApplicativeReader$fFunctorReaderAMPMonadByteSwapBEunBELEunLE Endianness LittleEndian BigEndiantoBEfromBEtoLEfromLE endianness$fByteSwapWord64$fByteSwapWord32$fByteSwapWord16$fOrdBE$fOrdLE$fShowBE$fEqBE$fBitsBE$fShowLE$fEqLE$fBitsLE$fEqEndianness$fShowEndiannessintegerToDoublenaturalToDoubledoubleExponantintegerToFloatnaturalToFloat wordToFloat floatToWord wordToDouble doubleToWord MonadFailureFailuremFail PrimMonad PrimStatePrimVar primitive primThrow unPrimMonad primVarNew primVarRead primVarWrite unPrimMonad_unsafePrimCastunsafePrimToSTunsafePrimToIOunsafePrimFromIO primTouch $fPrimMonadST $fPrimMonadIO$fMonadFailureEither$fMonadFailureMaybeFinalPtr FinalForeignfinalPtrSameMemory toFinalPtrtoFinalPtrForeign castFinalPtrwithFinalPtrNoTouch withFinalPtr touchFinalPtrwithUnsafeFinalPtr $fOrdFinalPtr $fEqFinalPtr$fShowFinalPtrWord32x2 intToInt64 int64ToInt wordToWord64 word64ToWordword64ToWord32s wordToChar wordToInt charToInt IsNatural toNatural IsIntegral toInteger$fIsIntegralCUIntMax$fIsIntegralCIntMax$fIsIntegralCUIntPtr$fIsIntegralCIntPtr$fIsIntegralCBool$fIsIntegralCULLong$fIsIntegralCLLong$fIsIntegralCSigAtomic$fIsIntegralCWchar$fIsIntegralCSize$fIsIntegralCPtrdiff$fIsIntegralCULong$fIsIntegralCLong$fIsIntegralCUInt$fIsIntegralCInt$fIsIntegralCUShort$fIsIntegralCShort$fIsIntegralCUChar$fIsIntegralCSChar$fIsIntegralCChar$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralNatural$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fIsIntegralInteger$fIsNaturalCUIntMax$fIsNaturalCUIntPtr$fIsNaturalCULLong$fIsNaturalCSize$fIsNaturalCULong$fIsNaturalCUInt$fIsNaturalCUShort$fIsNaturalCUChar$fIsNaturalWord64$fIsNaturalWord32$fIsNaturalWord16$fIsNaturalWord8$fIsNaturalWord$fIsNaturalNaturalIntegralUpsizeintegralUpsizeIntegralDownsizeintegralDownsizeintegralDownsizeCheck$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_9c7Lowerc7Upper $fShowChar7 $fEqChar7 $fOrdChar7 Base16EscapeunsafeConvertByte escapeByte hexWord16 hexWord32Word128quotrem bitwiseAnd bitwiseOr bitwiseXor complementpopCountshiftLshiftRrotateLrotateR 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$fIsNaturalZn64$fIsIntegralZn64$fIntegralZn64 $fNumZn64 $fIsNaturalZn$fIsIntegralZn $fIntegralZn$fNumZn$fShowZn$fEqZn$fOrdZn $fShowZn64$fEqZn64 $fOrdZn64 Subtractive Difference$fSubtractiveCDouble$fSubtractiveCFloat$fSubtractiveCOff$fSubtractiveCSUSeconds$fSubtractiveCUSeconds$fSubtractiveCTime$fSubtractiveCClock$fSubtractiveCUIntMax$fSubtractiveCIntMax$fSubtractiveCUIntPtr$fSubtractiveCIntPtr$fSubtractiveCBool$fSubtractiveCULLong$fSubtractiveCLLong$fSubtractiveCSigAtomic$fSubtractiveCWchar$fSubtractiveCSize$fSubtractiveCPtrdiff$fSubtractiveCULong$fSubtractiveCLong$fSubtractiveCUInt$fSubtractiveCInt$fSubtractiveCUShort$fSubtractiveCShort$fSubtractiveCUChar$fSubtractiveCSChar$fSubtractiveCChar$fSubtractiveZn$fSubtractiveZn64$fSubtractiveChar$fSubtractiveDouble$fSubtractiveFloat$fSubtractiveWord256$fSubtractiveWord128$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveNatural$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveInt$fSubtractiveIntegerAdditiveazeroscale$fAdditiveCDouble$fAdditiveCFloat$fAdditiveCOff$fAdditiveCSUSeconds$fAdditiveCUSeconds$fAdditiveCTime$fAdditiveCClock$fAdditiveCUIntMax$fAdditiveCIntMax$fAdditiveCUIntPtr$fAdditiveCIntPtr$fAdditiveCULLong$fAdditiveCLLong$fAdditiveCSigAtomic$fAdditiveCWchar$fAdditiveCSize$fAdditiveCPtrdiff$fAdditiveCULong$fAdditiveCLong$fAdditiveCUInt$fAdditiveCInt$fAdditiveCUShort$fAdditiveCShort$fAdditiveCUChar$fAdditiveCSChar$fAdditiveCChar $fAdditiveZn$fAdditiveZn64$fAdditiveRatio$fAdditiveDouble$fAdditiveFloat$fAdditiveWord256$fAdditiveWord128$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveNatural$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8 $fAdditiveInt$fAdditiveInteger Divisible/ IDivisibledivmoddivModMultiplicative midentityrecip$fIDivisibleCUIntMax$fIDivisibleCIntMax$fIDivisibleCUIntPtr$fIDivisibleCIntPtr$fIDivisibleCULLong$fIDivisibleCLLong$fIDivisibleCSigAtomic$fIDivisibleCWchar$fIDivisibleCSize$fIDivisibleCPtrdiff$fIDivisibleCULong$fIDivisibleCLong$fIDivisibleCUInt$fIDivisibleCInt$fIDivisibleCUShort$fIDivisibleCShort$fIDivisibleCUChar$fIDivisibleCSChar$fIDivisibleCChar$fIDivisibleWord256$fIDivisibleWord128$fIDivisibleWord64$fIDivisibleWord32$fIDivisibleWord16$fIDivisibleWord8$fIDivisibleWord$fIDivisibleNatural$fIDivisibleInt64$fIDivisibleInt32$fIDivisibleInt16$fIDivisibleInt8$fIDivisibleInt$fIDivisibleInteger$fMultiplicativeCDouble$fMultiplicativeCFloat$fMultiplicativeCOff$fMultiplicativeCSUSeconds$fMultiplicativeCUSeconds$fMultiplicativeCTime$fMultiplicativeCClock$fMultiplicativeCUIntMax$fMultiplicativeCIntMax$fMultiplicativeCUIntPtr$fMultiplicativeCIntPtr$fMultiplicativeCULLong$fMultiplicativeCLLong$fMultiplicativeCSigAtomic$fMultiplicativeCWchar$fMultiplicativeCSize$fMultiplicativeCPtrdiff$fMultiplicativeCULong$fMultiplicativeCLong$fMultiplicativeCUInt$fMultiplicativeCInt$fMultiplicativeCUShort$fMultiplicativeCShort$fMultiplicativeCUChar$fMultiplicativeCSChar$fMultiplicativeCChar$fMultiplicativeRatio$fMultiplicativeDouble$fMultiplicativeFloat$fMultiplicativeWord256$fMultiplicativeWord128$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeNatural$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeInt$fMultiplicativeInteger$fDivisibleCDouble$fDivisibleCFloat$fDivisibleDouble$fDivisibleFloat$fDivisibleRatio Offsetable CountableCountOfOffsetOffset8FileSizesentinel+..==# offsetOfE offsetPlusE offsetMinusE offsetSub offsetRecast offsetShiftR offsetShiftL offsetCastsizeCastsizeSubsizeLastOffset sizeAsOffset offsetAsSizesizeOfEcountOfRoundUp csizeOfSize csizeOfOffset sizeOfCSSize sizeOfCSize natValCountOf natValOffset$fIsNaturalOffset$fIsIntegralOffset$fMonoidCountOf$fSemigroupCountOf$fSubtractiveCountOf$fAdditiveCountOf$fIsNaturalCountOf$fIsIntegralCountOf $fNumCountOf$fSubtractiveOffset $fShowCountOf $fEqCountOf $fOrdCountOf $fEnumCountOf$fIntegralCountOf $fShowOffset $fEqOffset $fOrdOffset $fEnumOffset$fAdditiveOffset$fIntegralOffset $fNumOffset$fShowFileSize $fEqFileSize $fOrdFileSizeAddraddrPlus addrPlusSz addrPlusCSzptrPlus ptrPlusSz ptrPlusCSz$fEqAddr $fOrdAddr getDimensions initializePrimMemoryComparablePrimTypePrimSizeprimSizeInBytesprimShiftToBytes primBaUIndex primMbaURead primMbaUWrite primAddrIndex primAddrRead primAddrWrite primBaIndex primMbaRead primMbaWriteprimArrayIndexprimMutableArrayReadprimMutableArrayWrite sizeRecast sizeInBytes offsetInBytesoffsetInElementsprimOffsetRecastoffsetIsAligned primOffsetOfEprimWordGetByteAndShiftprimWord64GetByteAndShiftprimWord64GetHiLo $fPrimTypeBE $fPrimTypeLE$fPrimTypeChar7$fPrimTypeCUChar$fPrimTypeCChar$fPrimTypeChar$fPrimTypeDouble$fPrimTypeFloat$fPrimTypeInt64$fPrimTypeInt32$fPrimTypeInt16$fPrimTypeInt8$fPrimTypeWord256$fPrimTypeWord128$fPrimTypeWord64$fPrimTypeWord32$fPrimTypeWord16$fPrimTypeWord8$fPrimTypeWord $fPrimTypeInt$fPrimMemoryComparableBE$fPrimMemoryComparableLE$fPrimMemoryComparableCUChar$fPrimMemoryComparableCChar$fPrimMemoryComparableChar$fPrimMemoryComparableInt64$fPrimMemoryComparableInt32$fPrimMemoryComparableInt16$fPrimMemoryComparableInt8$fPrimMemoryComparableWord256$fPrimMemoryComparableWord128$fPrimMemoryComparableWord64$fPrimMemoryComparableWord32$fPrimMemoryComparableWord16$fPrimMemoryComparableWord8$fPrimMemoryComparableWord$fPrimMemoryComparableInt BuildingState prevChunksprevChunksSizecurChunk chunkSizeBuilder runBuilder$fMonadFailureBuilder$fFunctorBuilder$fApplicativeBuilder$fMonadBuilderNonEmptyCollectionIsEmpty InvalidRecastRecastDestinationSizeRecastSourceSize OutOfBoundOutOfBoundOperationOOB_Read OOB_Write OOB_MemSet OOB_MemCopy OOB_Index outOfBoundprimOutOfBound isOutOfBound$fExceptionOutOfBound$fExceptionInvalidRecast$$fExceptionNonEmptyCollectionIsEmpty$fShowNonEmptyCollectionIsEmpty$fShowInvalidRecast$fShowRecastDestinationSize$fEqRecastDestinationSize$fShowRecastSourceSize$fEqRecastSourceSize$fShowOutOfBound$fShowOutOfBoundOperation$fEqOutOfBoundOperationNonEmpty getNonEmpty$fIsListNonEmpty$fShowNonEmpty $fEqNonEmptylengthnullsumreverse!!next nextDoublejump 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 $fShowTheseListNunListNtoListNtoListN_ replicateMsequence sequence_mapMmapM_ replicateunconsconsunsnocsnocemptycreate createFrom singletonelemappendmaximumminimumheadtailinittakedropsplitAt indexStaticindexupdateAtmapmapifoldlfoldl'foldl1'foldrfoldr1scanl'scanl1'zipunzipzip3zip4zip5zipWithzipWith3zipWith4zipWith5$fNormalFormListN $fShowListN $fEqListN $fOrdListN$fGenericListN MutableBlockBlockisPinnedisMutablePinned mutableLengthmutableLengthBytes mutableEmpty unsafeIndex unsafeFreeze unsafeThaw unsafeNewnew newPinnedunsafeCopyElementsunsafeCopyElementsROunsafeCopyBytesunsafeCopyBytesROunsafeCopyBytesPtr unsafeRead unsafeWritewithPtrmutableWithPtrwithMutablePtrwithMutablePtrHintCastcast$fCastBlockBlock$fCastWord64Int$fCastIntWord64$fCastInt64Int$fCastIntInt64$fCastInt64Word$fCastWordInt64$fCastWord64Word$fCastWordWord64 $fCastWordInt$fCastWord64Int64$fCastWord32Int32$fCastWord16Int16$fCastWord8Int8 $fCastIntWord$fCastInt64Word64$fCastInt32Word32$fCastInt16Word16$fCastInt8Word8iterSetmutableLengthSizereadwrite copyFromPtr copyToPtrunsafeCopyToPtr createFromPtrthawfreezecopysub revSplitAtbreakbreakEndspanallanysplitOnfindfiltersortBy intersperse unsafeCast$fIndexableBlockWord64$fIndexableBlockty $fRandomAccessMutableBlockprimty MutableBlockNBlockNtoBlockN lengthBytestoBlock mutableCast$fNormalFormBlockN $fEqBlockN $fShowBlockN $fDataBlockN $fOrdBlockNBitsBitOps.&..|..^..<<..>>.bitisBitSetsetBitclearBit FiniteBitsOps numberOfBitsbitFlipcountLeadingZeroscountTrailingZerostoBitsallOne $fBitOpsInt64$fFiniteBitsOpsInt64 $fBitOpsInt32$fFiniteBitsOpsInt32 $fBitOpsInt16$fFiniteBitsOpsInt16 $fBitOpsInt8$fFiniteBitsOpsInt8$fBitOpsWord256$fFiniteBitsOpsWord256$fBitOpsWord128$fFiniteBitsOpsWord128$fBitOpsWord64$fFiniteBitsOpsWord64 $fBitOpsWord$fFiniteBitsOpsWord$fBitOpsWord32$fFiniteBitsOpsWord32$fBitOpsWord16$fFiniteBitsOpsWord16 $fBitOpsWord8$fFiniteBitsOpsWord8 $fBitOpsBool$fFiniteBitsOpsBool$fFiniteBitsOpsBits $fBitOpsBits$fIDivisibleBits$fMultiplicativeBits$fSubtractiveBits$fAdditiveBits $fBoundedBits $fEnumBits $fShowBits$fEqBits $fOrdBitsUArrayMUArray newNative newNative_ unsafeIndexerunsafeFreezeShrinkonMutableBackend unsafeDewrap vFromListN equalMemcmpcopyAtunsafeCopyAtROMArrayArrayrevTakerevDropspanEndmapFromUnboxed mapToUnboxed isPrefixOf isSuffixOf builderAppend builderBuild builderBuild_ $fIsListArray $fOrdArray $fEqArray $fShowArray $fMonoidArray$fSemigroupArray$fFunctorArray$fNormalFormArray $fDataArray$fRandomAccessMArrayprimtyMVectVectunVecttoVect $fFunctorVect$fNormalFormVect$fEqVect $fShowVectsizeInMutableBytesOfContent mutableSamemutableForeignMem mutableOffset foreignMemfromForeignPtr fromBlock freezeShrink createFromIOupdate unsafeUpdaterecast unsafeRecast unsafeTake unsafeDrop breakElem breakLine findIndex revFindIndexmapIndexindicesreplace toHexadecimaltoBase64InternalMutableAsciiString AsciiStringtoBytesfromBytesUnsafe fromBytes$fIsListAsciiString$fIsStringAsciiString$fShowAsciiString$fSemigroupAsciiString$fMonoidAsciiString$fEqAsciiString$fOrdAsciiStringMUVectUVectunUVecttoUVect$fNormalFormUVect $fEqUVect $fShowUVectValidationFailure InvalidHeaderInvalidContinuation MissingByteBuildingFailureCharUTF8encodeCharUTF8decodeCharUTF8 MutableStringStringFP64FP32getArgs lookupEnvEncodingASCII7UTF8UTF16UTF32 ISO_8859_1mutableValidate dropWhilecharMapfromBytesLenientfromChunkByteslineswords readIntegral readInteger readNatural readDouble readRationalreadFloatingExactupperlowercaseFold isInfixOf stripPrefix stripSuffixtoBase64 toBase64URLtoBase64OpenBSD$fEncodingEncoderUTF8$fDataEncoding $fEqEncoding $fOrdEncoding$fShowEncoding$fEnumEncoding$fBoundedEncoding RGBComponent GrayComponentColorComponent DisplacementEscapecursorUp cursorDown cursorForward cursorBackcursorNextLinecursorPrevLinecursorHorizontalAbsolutecursorPositioneraseScreenFromCursoreraseScreenToCursoreraseScreenAlleraseLineFromCursoreraseLineToCursor eraseLineAllscrollUp scrollDownsgrReset sgrForeground sgrBackgroundsgrForegroundGray24sgrBackgroundGray24sgrForegroundColor216sgrBackgroundColor216TryIntoTryFromtryFromIntoFromintotryInto $fFromZn64Zn $fFromZnZn64$fFromZnWord256$fFromZnWord128$fFromZnWord64$fFromZnWord32$fFromZnWord16 $fFromZnWord8$fFromZn64Word256$fFromZn64Word128$fFromZn64Word64$fFromZn64Word32$fFromZn64Word16$fFromZn64Word8$fFromBlockNArray$fFromBlockNUArray$fFromBlockNBlockN$fFromBlockNBlock$fFromAsciiStringUArray$fFromAsciiStringString$fFromStringUArray$fFromUArrayArray$fFromArrayBlock$fFromUArrayBlock$fFromArrayUArray$fFromBlockUArray$fFromWord128Word256$fFromEitherThese$fFromWordCountOf$fFromWordOffset$fFromCountOfWord$fFromCountOfInt$fFromMaybeEither$fFromWordWord64$fFromWord64Word256$fFromWord64Word128$fFromWord32Int$fFromWord32Int64$fFromWord32Word$fFromWord32Word256$fFromWord32Word128$fFromWord32Word64$fFromWord16Int$fFromWord16Int64$fFromWord16Int32$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$fFromaa$fTryFromArrayBlockN$fTryFromUArrayBlockN$fTryFromBlockBlockN$fTryFromUArrayString$fTryFromIntCountOf$fTryFromIntOffsetrununsafeRunStringemitemitPrim emitString emitUTF8Char$fMonoidBuilder$fSemigroupBuilderunsafeStringBuilder runUnsafeemitCharint8ToIntCompat#int16ToIntCompat#int32ToIntCompat#word8ToWordCompat#word16ToWordCompat#word32ToWordCompat#intToInt8Compat#intToInt16Compat#intToInt32Compat#wordToWord8Compat#wordToWord16Compat#wordToWord32Compat#narrow8IntCompat#narrow16IntCompat#narrow32IntCompat#narrow8WordCompat#narrow16WordCompat#narrow32WordCompat# word64ToInt64 int64ToWord64 word64ToWord# intToWordunsafeUArrayUnpinnedMaxSize GHC.IO.UnsafeunsafePerformIOsysHsMemFindByteAddrsysHsMemFindByteBasysHsMemcmpPtrPtrsysHsMemcmpPtrBasysHsMemcmpBaPtrsysHsMemcmpBaBa RandomAccess Indexable findIndexElemrevFindIndexElemfindIndexPredicaterevFindIndexPredicatefoldl1 inplaceSortBy unsafeShrink newUnpinnedequal ValidRange UArrayBackendUArrayBA UArrayAddrMUArrayBackend MUArrayMBA MUArrayAddroffsetoffsetsValidRange onBackend onBackendPureonBackendPure' onBackendPrim unsafeDewrap2pureSTUnitError encodingNext convertFromTo encodingWrite UTF32_Invalid UTF16_InvalidInvalidUnicodeISO_8859_1_Invalid NotISO_8859_1ASCII7_InvalidByteOutOfBound CharNotAsciiCM StepASCII StepDigitStepBackStepstepAsciiRawValueisValidStepASCIIisValidStepDigitisContinuation getNbBytesisContinuation# getNbBytes#isContinuation2isContinuation3UTF8Char asUTF8CharUTF8_4UTF8_3UTF8_2UTF8_1maskContinuation# maskHeader2# maskHeader3# maskHeader4#or3#or4#toChar#toChar1toChar2toChar3toChar4numBytesskipNextHeaderValue headerIsAscii charToBytesisCharUTF8Case1isCharUTF8Case2isCharUTF8Case3isCharUTF8Case4 upperMapping lowerMapping titleMapping foldMappingnextAsciiDigitnextWith nextAscii expectAsciinextSkipprevprevSkip writeASCII writeUTF8sizesToList fromModified sFromList stringType sToListStream copyFiltervalidate