!$2      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc d e f gh i j k l m n opqrstuvwxyz { | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<= > ? @ 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+{,|,},~+++,++++++++++++,+++---------------------++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,......................................../////////////// / / / / /////////////////// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2030415160718191:1;1<0=0>0?0@0A0B0C1D0E0F0G1H0I0J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~2222222222222223333333333333333333333333333331111111111110000000000000000000000000000000000000000000000000000000000000004444444444444455555 5 5 5 5 5555555555555555555 5!6"6#6$6%6&7'7(7)7*6+6,-6./01238485666768696:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~6666669999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;<<<<<<< experimentalportableSafe+2HV\fdcefdce  BSD-style FoundationSafe+2HV]7lknm{z}|~7{z}|~nmlk Safe +,2HV`  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe+2HVajihjih BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2HVc(RRNone +2HMVc55 BSD-style FoundationNone +2=?HVgbasementNegation support e.g. -(f x)basementFractional Literal support'e.g. 1.2 :: Double 0.03 :: FloatbasementIntegral Literal support&e.g. 123 :: Integer 123 :: Word8 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2FHVn(basementPinning status basementLowlevel Boolean!basementCountOf in bytes type aliasEfor code documentation purpose only, just a simple type alias on Int#"basement)Offset in a bytearray, string, type aliasEfor code documentation purpose only, just a simple type alias on Int##basementFile size in bytes !"##"!  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone  +2FHVv$basement:Flag record whether a specific byte array is pinned or not(basementturn an Int# into a Bool)basement*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) 9L$%&'()*+ ($%&')*+9LSafe+2HVw~)-)- BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableSafe+2HVy($$ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2HV|6.basement/Only to use internally for internal error cases/basement!for support of if .. then .. elseR   a`_^]\[ZYXWVUT!" #$%&'*+HK,-./012346JI7OPQ89:;<=>?NMSbgopqrwyx./xywr#"  !& g6JI7OPQ+HK/4,0123:;<=9-.8R%'?NM a`_^]\[ZYXWVUTSb$*qpo>/. BSD-stylePsychohistorians experimentalportableNone+2HVt0basementSimple Reader monad3basementSimple State monad012345345012None +,2HV"<< BSD-styleHaskell Foundation experimentalportableNone +2HMV=basement(Class of types that can be byte-swapped.e.g. Word16, Word32, Word64>basementBig Endian valueAbasementLittle Endian valueGbasement.Convert a value in cpu endianess to big endianHbasement5Convert from a big endian value to the cpu endiannessIbasement1Convert a value in cpu endianess to little endianJbasement8Convert from a little endian value to the cpu endiannessKbasement&endianness of the current architecture=>?@ABCDFEGHIJK=>?@GHABCIJDFEKNone +2>FHV YZ[\]^_`a YZ[\]^_`a BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone +,2EFHVXCbbasement Monad that can represent failureHSimilar to MonadFail but with a parametrized Failure linked to the MonadcbasementbThe associated type with the MonadFailure, representing what failure can be encoded in this monaddbasement Raise a Failure through a monad.ebasement)Primitive monad that can handle mutation.For example: IO and ST.fbasement3type of state token associated with the PrimMonad mgbasement0type of variable associated with the PrimMonad mhbasementmUnwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value.ibasement&Throw Exception in the primitive monadjbasement(Run a Prim monad from a dedicated state#kbasement&Build a new variable in the Prim Monadlbasement#Read the variable in the Prim Monadmbasement$Write the variable in the Prim Monadnbasement just like unwrapPrimMonad9 but throw away the result and return just the new State#obasement+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.pbasement%Convert any prim monad to an ST monadqbasement%Convert any prim monad to an IO monadrbasement$Convert any IO monad to a prim monadsbasement(Touch primitive lifted to any prim monadbcdefghijklmnopqrsefghijklmbcdnopqrs BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone +2FHV%xbasement-Create a pointer with an associated finalizer{basement3Check 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$create a new FinalPtr from a Pointer}basement'Create a new FinalPtr from a ForeignPtr~basement.Cast a finalized pointer from type a to type bbasement}Looks at the raw pointer inside a FinalPtr, making sure the data pointed by the pointer is not finalized during the call to fbasementUnsafe version of  xyz{|}~ xyz{~|}=None +2FHVIbasement 2 Word32s   None+2HVbasementJNon Negative Number literals, convertible through the generic Natural typebasement>Number literals, convertible through the generic Integer type.Fall number are Enum'erable, meaning that you can move to next elementNone+28=?@AFHVXbasementUpsize an integral valueThe destination type b9 size need to be greater or equal than the size type of abasementDownsize an integral valueNone+2FHVbasement ASCII value between 0x0 and 0x7fbasement Convert a  to a unicode code point ,basementTry to convert a , to a 9If the code point is non ascii, then Nothing is returned.basementTry to convert : to a 9If the byte got higher bit set, then Nothing is returned.basement Convert a , to a  ignoring all higher bitsbasement Convert a Byte to a  ignoring the higher bit          None +2FHV\basementConvert 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. basement hex word16!basement hex word32 ! !None +2FHV\"basement 128 bits Word$basement Add 2 Word128%basementSubtract 2 Word128&basementMultiplication'basementDivision(basementModulo)basement Bitwise and*basement Bitwise or+basement Bitwise xor,basementBitwise complement-basementPopulation count.basementBitwise Shift Left/basementBitwise Shift Right0basementBitwise rotate Left1basementBitwise rotate Left basementTest bit basementbit"#$%&'()*+,-./012"#$%&'()*+,./01-2None +2FHVҴ?basement 256 bits WordAbasement Add 2 Word256BbasementSubtract 2 Word256CbasementMultiplicationDbasementDivisionEbasementModuloFbasement Bitwise andGbasement Bitwise orHbasement Bitwise xorIbasementBitwise complementJbasementPopulation countKbasementBitwise Shift LeftLbasementBitwise Shift RightMbasementBitwise rotate LeftNbasementBitwise rotate LeftbasementTest bitbasementbit?@ABCDEFGHIJKLMNO?@ABCDEFGHIKLMNJONone&'+,.2EHUVX\basementGConstraint 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?Check if a Nat is in bounds of another integral / natural types^basementGGet Maximum bounds of different Integral / Natural types related to Nat(ABCDEFGuv\]^_`abcdefghiA(uvEBCDFG_`dcbaeihgf^]\ BSD-styleHaskell FoundationNone +.2HVX jbasementA type level bounded naturallbasement/A type level bounded natural backed by a Word64nbasement'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 nobasement/Create an element of !$/n!$ from a type level Natbasement Add 2 Zn64basementsubtract 2 Zn64basementMultiply 2 Zn64pbasement)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 nqbasement/Create an element of !$/n!$ from a type level NatbasementAdd 2 Znbasement subtract 2 Znbasement Multiply 2 ZnjklmnopqlmjknpoqNone +2HVNbasement1Represent 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 Natural6None +28FHVmbasementeRepresent 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 +28=?HV"basement'Support for division between same typesCThis is likely to change to represent specific mathematic divisionsbasement3Represent types that supports an euclidian division "(x div  y) * y + (x mod  y) == xbasement9Represent class of things that can be multiplied together #x * midentity = x midentity * x = xbasement$Identity element over multiplicationbasement;Multiplication of 2 elements that result in another elementbasementRaise 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 <vincent@snarc.org> experimentalportableNone+,2@AFHMVXx?basementCountOf 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 A apply here.Abasement: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.CbasementIOffset in bytes used for memory addressing (e.g. in a vector, string, ..)DbasementFile size in bytesLbasement+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.Rbasement+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.Wbasement!alignment need to be a power of 2!=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]!DEABCFIJKMPLONQSTRWUGH?@VYXZ[>=\] None+2FHV >wxyz{|}~ wxyz{>|}~>None +2HV4basementGet the terminal windows sizebasement'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+2HV? BSD-style foundationNone+2HV!basement5Defines 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."None+.2=?FHVX, basement[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 operationbasementNRepresent 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.basementtype level size of the given tybasement%get the size in bytes of a ty elementbasementget the shift sizebasement-return the element stored at a specific indexbasement.Read an element at an index in a mutable arraybasement7Write an element to a specific cell in a mutable array.basementRead from Address, without a state. the value read should be considered a constant for all pratical purpose, otherwise bad thing will happens.basement4Read a value from Addr in a specific primitive monadbasement3Write a value to Addr in a specific primitive monadbasementUCast a CountOf linked to type A (CountOf A) to a CountOf linked to type B (CountOf B)basementmutable array to read frombasement index of the element to retrievebasementthe element returnedbasementmutable array to modifybasementindex of the element to modifybasementthe new value to storeTUUT#None+2HMV0zbasement.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 <vincent@snarc.org> experimentalportableNone+2HV9basement?Exception for using NonEmpty assertion with an empty collectionbasement?Exception during an operation accessing the vector out of boundXRepresent the type of operation, the index accessed, and the total length of the vector.basement<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 vectorOOB_MemCopy: copying a vector)OOB_MemSet: initializing a mutable vector% BSD-style Foundation experimentalportableNone+2HV<,basement$NonEmpty property for any Collection@None  +2FHV<ANone +2@AHV=Y !"#&None+2HV? basementCompute the size of the listbasementSum the element in a list' BSD-styleNone+2HVCbasementState of Xoroshiro128 plusbasement!Given a state, call the function f- with the generated Word64 and the next StatebasementSame as D but give a random value of type Double in the range of [0.0 .. 1.0]basement$Jump the state by 2^64 calls of nextBNone +2@AFHVD "#$%&'()*+,-CNone +2@AHVG.basement+Function defining the ordering relationshipbasementOffset to first element to sortbasementNumber of elements to sortbasementData to be sorted.(None+2HVI*basement/Data that can be fully evaluated in Normal Form) BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>stableportableNone+2HVKB5basementEither a or b or both.58675867* BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone&'+.27>EHUVXA2?basement*A Typed-level sized List equivalent to [a]AbasementFTry to create a ListN from a List, succeeding if the length is correctBbasement4Create a ListN from a List, expecting a given length~If this list contains more or less than the expected length of the resulting type, then an asynchronous error is raised. use A for a more friendly functionsCbasementMperforms a monadic action n times, gathering the results in a List of size n.DbasementOEvaluate each monadic action in the list sequentially, and collect the results.EbasementNEvaluate each monadic action in the list sequentially, and ignore the results.FbasementlMap each element of a List to a monadic action, evaluate these actions sequentially and collect the resultsGbasementkMap each element of a List to a monadic action, evaluate these actions sequentially and ignore the resultsHbasementICreate a list of n elements where each element is the element in argumentIbasement(Decompose a list into its head and tail.Jbasementprepend an element to the listKbasement6Decompose a list into its first elements and the last.Lbasementappend an element to the listMbasementCreate an empty list of aNbasementGet the length of a listObasement>Create a new list of size n, repeately calling f from 0 to n-1Pbasement"Same as create but apply an offsetQbasementcreate a list of 1 elementRbasement&Check if a list contains the element aSbasement-Append 2 list together returning the new listTbasement!Get the maximum element of a listUbasement!Get the minimum element of a listVbasementGet the head element of a listWbasementGet the tail of a listXbasement*Get the list with the last element missingYbasement/Take m elements from the beggining of the list.GThe number of elements need to be less or equal to the list in argumentZbasement:Drop elements from a list keeping the m remaining elements[basement(Split a list into two, returning 2 lists\basementGet the i'th elements%This only works with TypeApplication: 0indexStatic @1 (toListN_ [1,2,3] :: ListN 3 Int)]basementGet the i'the element^basement1Update the value in a list at a specific location_basementMap all elements in a list`basement3Map all elements in a list with an additional indexabasementFold all elements from leftbbasement$Fold all elements from left strictlycbasementMFold all elements from left strictly with a first element as the accumulatordbasementFold all elements from rightebasementJFold all elements from right assuming at least one element is in the list.fbasementscanl is similar to a@, 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, ...]gbasementscanl1 is a variant of scanl% that has no starting value argument: .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]hbasementReverse a listibasementQZip 2 lists of the same size, returning a new list of the tuple of each elementsjbasement<Unzip a list of tuple, to 2 List of the deconstructed tupleskbasementZip 3 lists of the same sizelbasementZip 4 lists of the same sizembasementZip 5 lists of the same sizenbasementZip 2 lists using a functionobasementZip 3 lists using a functionpbasementZip 4 lists using a functionqbasementZip 5 lists using a function3?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq3?AB@NOPMQIJKL]\^_`RabcfgdehSUTVWXYZ[iklmjnopqHCDEFGDNone +2FHVXΉwbasementPA Mutable block of memory containing unpacked bytes representing values of type tyybasementHA block of memory containing unpacked bytes representing values of type ty~basement$Return the length of a Mutable BlockEnote: we don't allow resizing yet, so this can remain a pure function/basementCreate an empty block of memorybasementMReturn 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.0basement%make a block from a list of elements.1basementtransform a block to a list.2basement!Check if two blocks are identical3basementCompare 2 blocks4basement7Append 2 blocks together by creating a new bigger blockbasement$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.basementThaw an immutable block.If the immutable block is modified, then the original immutable block will be modified too, but lead to unexpected results when queryingbasement7Create 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 unsurebasement<Create a new unpinned mutable block of a specific N size of ty elementsIf the size exceeds a GHC-defined threshold, then the memory will be pinned. To be certain about pinning status with small size, use basement:Create a new pinned mutable block of a specific N size of ty elementsbasementECopy a number of elements from an array to another array with offsetsbasement]Copy a number of bytes from a MutableBlock to another MutableBlock with specific byte offsetsbasementPCopy a number of bytes from a Block to a MutableBlock with specific byte offsetsbasementNCopy a number of bytes from a Ptr to a MutableBlock with specific byte offsetsbasement<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.basement;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.basement,Get a Ptr pointing to the data in the Block.PSince a Block is immutable, this Ptr shouldn't be to use to modify the contentsIf the Block is pinned, then its address is returned as is, however if it's unpinned, a pinned copy of the Block is made before getting the address.basementUse the >( to a mutable block in a safer construct;If the block is not pinned, this is a _dangerous_ operationbasementKCreate 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 blockcIf 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 copiesbasementSame 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.JIf 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.NIf 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.basementdestination mutable blockbasementoffset at destinationbasementsource mutable blockbasementoffset at sourcebasementnumber of elements to copybasementdestination mutable blockbasementoffset at destinationbasement source blockbasementoffset at sourcebasementnumber of elements to copybasementdestination mutable blockbasementoffset at destinationbasementsource mutable blockbasementoffset at sourcebasementnumber of elements to copybasementdestination mutable blockbasementoffset at destinationbasement source blockbasementoffset at sourcebasementnumber of elements to copybasementdestination mutable blockbasementoffset at destinationbasement source blockbasementnumber of bytes to copybasement\hint that the buffer doesn't need to have the same value as the mutable block when calling fbasement@hint that the buffer is not supposed to be modified by call of fwxyz{|}5~67- BSD-styleHaskell FoundationNone+,28=?@AFHVbasement 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.KIf 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 +2FHVX basement(Set all mutable block element to a valuebasementread a cell in a mutable array.2If the index is out of bounds, an error is raised.basement#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.basementCopy from a pointer, count7 elements, into the Mutable Block at a starting offset ofsQif the source pointer is invalid (size or bad allocation), bad things will happenbasementLCopy all the block content to the memory starting at the destination addressVIf the destination pointer is invalid (size or bad allocation), bad things will happenbasementSource Ptr of ty to start of memorybasementDestination mutable blockbasement-Start offset in the destination mutable blockbasement Number of ty elementsbasement The source mutable block to copybasement&The source offset in the mutable blockbasement8The destination address where the copy is going to startbasementThe number of byteswxyz~yzwx~, BSD-styleHaskell FoundationNone+2=?@AFHVX basementLCopy all the block content to the memory starting at the destination addressbasementCreate a new array of size /n by settings each cells through the function f.basement 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 blockbasement8Freeze a MutableBlock into a Block, copying all the datarIf the data is modified in the mutable block after this call, then the immutable Block resulting is not impacted.basement4Copy every cells of an existing Block to a new Blockbasement5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.basementMap all element a from a block to a new block of bbasement%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.basementCast 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.EIf this requirement is not met, the InvalidRecast exception is thrownbasementthe source block to copybasement8The destination address where the copy is going to startbasement(the size of the block (in element of ty)basement,the function that set the value at the indexbasementthe array created-wxyz{|}-yzwx}{|. BSD-styleHaskell FoundationNone+,.2HMUVXk!3basementSized version of ybasement<Create a new unpinned mutable block of a specific N size of ty elementsIf the size exceeds a GHC-defined threshold, then the memory will be pinned. To be certain about pinning status with small size, use basement:Create a new pinned mutable block of a specific N size of ty elementsbasement,Get a Ptr pointing to the data in the Block.PSince a Block is immutable, this Ptr shouldn't be to use to modify the contentsIf the Block is pinned, then its address is returned as is, however if it's unpinned, a pinned copy of the Block is made before getting the address.basementKCreate 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 blockcIf 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 copiesbasementSame 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.JIf 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.NIf 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\hint that the buffer doesn't need to have the same value as the mutable block when calling fbasement@hint that the buffer is not supposed to be modified by call of f##E BSD-styleHaskell FoundationNone+2HV#'#/ BSD-styleHaskell Foundation experimentalportableNone+,.28=FHSUVXbk38basement%convenient Type Constraint Alias fot  functionsbasement Bool set of n bits.basementoperation over bitsbasement8construct a bit set with the bit at the given index set.basement&test the bit at the given index is setbasementset the bit at the given indexbasement clear the bit at the given indexbasementoperation over finite bitsbasement*get the number of bits in the given objectbasementrotate the given bit set.basementrotate the given bit set. basement5count of number of bit set to 1 in the given bit set. basement reverse all bits in the argument basement$count of the number of leading zeros basement%count of the number of trailing zeros basementconvert the given 5 into a  of size nMif bits that are not within the boundaries of the 'Bits n' will be truncated.basement construct a  with all bits set.this function is equivalet to           7568888FNone%+2=?@AFHSVXm2basement/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 interface4basement7A Mutable array of types built on top of GHC primitive./Element in this array can be modified in place.9basement'Return if the array is pinned in memory-note that Foreign array are considered pinned:basement-Return if a mutable array is pinned in memory7basement-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;basement8Create 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 79basement&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.:basement<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.;basement;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.<basementMReturn 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.>basement%Freeze a mutable array into an array./the MUArray must not be changed after freezing.@basementThaw an immutable array.*The UArray must not be used after thawing.Abasement!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.Bbasement4Copy every cells of an existing array to a new array<basement&make an array from a list of elements.Ebasement7Make 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.=basementtransform an array to a list.>basement"Check if two vectors are identical?basementCompare 2 vectorsGbasementECopy a number of elements from an array to another array with offsetsHbasementCopy 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.@basement7Append 2 arrays together by creating a new bigger arrayIbasementCreate 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 arrayGbasementdestination arraybasementoffset at destinationbasement source arraybasementoffset at sourcebasementnumber of elements to copyHbasementdestination arraybasementoffset at destinationbasement source arraybasementoffset at sourcebasementnumber of elements to copy.ABCDE23FGH456IJ9:7;89:;<=>?@ABKLMNCDOPE>FGHQI2 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2=?@AFHVXJbasementMutable Array of aKbasement Array of aLbasement1return the numbers of elements in a mutable arrayRbasement1return the numbers of elements in a mutable arrayMbasement5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.NbasementMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use M if unsure.Obasementread a cell in a mutable array.2If the index is out of bounds, an error is raised.Pbasement<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use O if unsure.Qbasement#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.Rbasement;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 Q if unsure.Sbasement%Freeze a mutable array into an array..the MArray must not be changed after freezing.TbasementThaw an immutable array.)The Array must not be used after thawing.Ubasement!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.Wbasement'Copy the element to a new element arraySbasementECopy a number of elements from an array to another array with offsetsXbasementCopy 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.TbasementaAllocate a new array with a fill function that has access to the elements of the source array.Ybasement&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.ZbasementCreate a new array of size /n by settings each cells through the function f.Ubasement+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.Vbasement7Append 2 arrays together by creating a new bigger arraySbasementdestination arraybasementoffset at destinationbasement source arraybasementoffset at sourcebasementnumber of elements to copyXbasementdestination arraybasementoffset at destinationbasement source arraybasementoffset at sourcebasementnumber of elements to copyTbasement Source arraybasementLength of the destination arraybasement4Function called for each element in the source arraybasementReturns the filled new arrayZbasementthe size of the arraybasement,the function that set the value at the indexbasementthe array created9JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9KJ[\LWXUYZSTVRPNQOMmn]^_`abcdehijfgklopqruvwstyxz{|}~3None+,.2HMUVXkc1#Vincent Hanquez <vincent@snarc.org> experimentalportableNone +2FHVX6basementread a cell in a mutable array.2If the index is out of bounds, an error is raised.basement#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.basement1return the numbers of elements in a mutable arraybasementLCreate 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.basementCopy from a pointer, count! elements, into the mutable arraybasementLCopy all the block content to the memory starting at the destination addressbasement"the start pointer with a finalizerbasement/the number of elements (in elements, not bytes)basement the source mutable array to copybasement8The destination address where the copy is going to start45789:;CG45C978G;:0 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2=?@AFHSVXsbasement5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.basementACreate a foreign UArray from foreign memory and given offset/sizeENo check are performed to make sure this is valid, so this is unsafe.BThis is particularly useful when dealing with foreign memory and  ByteStringbasementCreate a UArray from a Block%The block is still used by the uarrayWbasementaAllocate a new array with a fill function that has access to the elements of the source array.basementRFreeze a MUArray into a UArray by copying all the content is a pristine new bufferiThe MUArray in parameter can be still be used after the call without changing the resulting frozen data.basement Just like  but copy only the first n bytes{The size requested need to be smaller or equal to the length of the MUArray, otherwise a Out of Bounds exception is raisedbasementCreate a new array of size /n by settings each cells through the function f.basement*Create a pinned array that is filled by a filler- function (typically an IO call like hGetBuf)basementKFreeze a chunk of memory pointed, of specific size into a new unboxed arraybasement9update an array by creating a new array with the updates.Jthe operation copy the previous array, modify it in place, then freeze it.basementLCopy all the block content to the memory starting at the destination addressbasement-Get a Ptr pointing to the data in the UArray.QSince 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*Recast an array of type a to an array of bKa and b need to have the same size otherwise this raise an async exceptionbasement%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.basementTTake a count of elements from the array and create an array with just those elementsbasement]Drop a count of elements from the array and return the new array minus those dropped elementsbasementmSplit an array into two, with a count of at most N elements in the first one and the remaining in the other.basement5Similar 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-Take the N elements from the end of the arraybasement-Drop the N elements from the end of the arraybasementSplit 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 secondbasementDSimilar 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 Replace all the occurrencies of needle with  replacement in the haystack string.basement"the start pointer with a finalizerbasement/the number of elements (in elements, not bytes)Wbasement Source arraybasementLength of the destination arraybasement4Function called for each element in the source arraybasementReturns the filled new arraybasementthe size of the arraybasement,the function that set the value at the indexbasementthe array createdbasementthe size of the arraybasementfilling function thatbasementthe source array to copybasement8The destination address where the copy is going to start\2369:;<=>?@ABDEFHI\23BH6>A@E9?I<=D:;F4 BSD-styleHaskell Foundation experimentalportableNone +2>FHMVbasement7Opaque packed array of characters in the ASCII encodingbasementkConvert 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 basement:Convert a Byte Array representing ASCII checking validity.8If the byte array is not valid, then Nothing is returnedG BSD-style Foundation experimentalportableNone+2>HVXbasementZthe unit element use for the encoding. i.e. Word8 for ASCII7 or UTF8, Word16 for UTF16...YbasementIdefine the type of error handling you want to use for the next function. %type Error UTF8 = Either UTF8_InvalidZbasementnconsume an `Unit encoding` and return the Unicode point and the position of the next possible `Unit encoding`[basementYhelper 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 ```Zbasementonly used for type deductionbasement/method to access a given `Unit encoding` (see  unsafeIndexer)basementKoffset of the `Unit encoding` where starts the encoding of a given unicodebasementqeither successfully validated the `Unit encoding` and returned the next offset or fail with an `Error encoding`\basementonly used for type deductionbasementthe unicode character to encode[basementInput's encoding typebasementOutput's encoding typebasementthe input raw array]XYZ\[H BSD-style Foundation experimentalportableNone+2FHV^_`I BSD-style Foundation experimentalportableNone+2FHV abcdeJ BSD-style Foundation experimentalportableNone+2FHV8fghiK BSD-style Foundation experimentalportableNone+2FHVYjbasement>validate a given byte is within ASCII characters encoring size+This function check the 8th bit is set to 0kbasementfconsume an Ascii7 char and return the Unicode point and the position of the next possible Ascii7 charkbasementmethod to access a given bytebasementindex of the bytebasement_either successfully validated the ASCII char and returned the next index or fail with an errorlbasement\expecting it to be a valid Ascii character. otherwise this function will throw an exceptionmnopq5None+,.2HMUVXk          LNone+2HV.!basement?Possible failure related to validating bytes of UTF8 sequences.&basementRepresent 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: AW => U+0041 => 41 => 0x00000041 ' => U+20AC => E2 82 AC => 0x00AC82E2 H( => U+10348 => F0 90 8D 88 => 0x888D90F0rbasement(Specialized tuple used for case mapping.sbasement$Step when processing ASCII charactertbasementEStep when processing digits. the value is between 0 and 9 to be validubasementASimilar 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 charactervbasementStep 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)!#"$%&'rwsxytzu{v|}~M BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2FHV8:basement Identical to , but doesn't allow to represent any failure.Only use in validated placebasement6Number of bytes associated with a specific header byte>If the header byte is invalid then NbBytesInvalid is returned,basement(Check if the byte is a continuation bytebasementJGet the number of following bytes given the first byte of a UTF8 sequence.basement(Check if the byte is a continuation bytebasementJGet the number of following bytes given the first byte of a UTF8 sequence.N BSD-style FoundationNone +2>FHV?basementADifferent way to encode a Character in UTF8 represented as an ADTbasementTransform 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(basementEncode a Char into a CharUTF8)basementdecode a CharUTF8 into a CharmIf the value inside a CharUTF8 is not properly encoded, this will result in violation of the Char invariants()7None+2HV@&'()&'()ONone +2HSVXAaPNone +2>FHVFbasementAnextAsciiBa specialized to get a digit between 0 and 9 (included)basement0special case for only non ascii next'er functionbasementDestination bufferbasementDestination startbasement Source bufferbasement Source startbasement Source endQ BSD-style FoundationNone +2>FHMVW*basementMutable String Buffer.Use as an *append* buffer, as UTF8 variable encoding doesn't really allow to change previously written character without potentially shifting bytes.,basement6Opaque packed array of characters in the UTF8 encodingbasementsize in bytes.this size is available in o(1)basement(Convert a String to a list of characters/The list is lazily created as evaluation neededbasementDassuming 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.basement-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.basement5Allocate a MutableString of a specific size in bytes.basement$in number of bytes, not of elements.basement$in number of bytes, not of elements.*+,-RNone+2HV[.basement&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..SNone+-.2EFHVX\/basement,stop execution and displays an error message/ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone+2HVac0basementHIEEE754 Floating point Binary64, double precision (Also known as Double)1basementGIEEE754 Floating point Binary32, simple precision (Also known as Float)2basement!for support of if .. then .. elseR   a`_^]\[ZYXWVUT!" #$%&'@ts)*+HK,-./0123456JI7OPQ89:;<=>?NMSbgopqrwyx?A2K,./012xyw/r#."  !& g6JI7OPQ+HK/45A?,,2K0123:;<=9-.810R%'@ts?NM a`_^]\[ZYXWVUTSb$*)qpo>28None+2HVh3basementXReturns a list of the program's command line arguments (not including the program name).4basement"Lookup variable in the environment3434TNone +2>FHVXiS6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone +2>FHVE5basementDVarious String Encoding that can be use to convert to and from bytesbasement UTF8 Encoderbasement"Validate a bytearray for UTF8'nessUOn success Nothing is returned On Failure the position along with the failure reason;basement Similar to  but works on a MutableByteArray<basementCheck if a String is null=basementGCreate 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.>basementSCreate a string with the remaining Chars after dropping @n Chars from the beginning?basementiSplit a string at the Offset specified (in Char) returning both the leading part and the remaining part.basementCReturn the offset (in bytes) of the N'th sequence in an UTF8 String@basement Similar to = but from the endAbasement Similar to > but from the endBbasement Similar to ? but from the endCbasement: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"]Dbasement8Internal 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.basement;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.EbasementMBreak a string into 2 strings at the location where the predicate return TrueGbasementEBreak a string into 2 strings at the first occurence of the characterHbasementFSame 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.IbasementApply a  predicateY to the string to return the longest prefix that satisfy the predicate and the remainingJbasementApply a  predicateY to the string to return the longest suffix that satisfy the predicate and the remainingKbasement=Drop character from the beginning while the predicate is trueLbasement>Return whereas the string contains a specific character or notMbasementIntersperse 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"basementAllocate a new StringI with a fill function that has access to the characters of the source String.Nbasement Length of a String using CountOfthis size is available in o(n)ObasementReplicate a character c n$ times to create a string of length nPbasementCopy the StringkThe slice of memory is copied to a new slice, making the new string independent from the original string..QbasementCreate a single element StringRbasement"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.SbasementLMonomorphically map the character in a string and return the transformed oneTbasementAAppend a Char to the end of the String and return this new StringUbasementHPrepend a Char to the beginning of the String and return this new StringVbasementUExtract the String stripped of the last character and the last character if not emptyIf empty, Nothing is returnedWbasementXExtract the First character of a string, and the String stripped of the first character.If empty, Nothing is returnedXbasementLLook for a predicate in the String and return the matched character, if any.Ybasement=Sort the character in a String using a specific sort function'TODO: optimise not going through a listZbasement1Filter characters of a string using the predicate[basementReverse a string]basement Replace all the occurrencies of needle with  replacement in the haystack string.^basement$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._basementWReturn the index in unit of Char of the first occurence of the predicate returning True!If not found, Nothing is returned`basement=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 chunkabasement*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.bbasementSDecode 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.cbasementcConvert 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 `dbasement6Convert 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.ebasement4Split 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.fbasement2Split words in a string using spaces as separation words "Hello Foundation"  Hello,  Foundation gbasement&Append a character to a String builderhbasement,Create a new String builder using chunks of  sizeChunksIjbasementRead an Integer from a StringCConsume an optional minus sign and many digits until end of string.lbasementRead a Natural from a String(Consume many digits until end of string.mbasementTry to read a Doublenbasement+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.obasement)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 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  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 numberbasement)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 functionbasement-same as decimalDigitsBA specialized for ptr #basement Convert a , , by , using a case mapping function.pbasement Convert a , to the upper-case equivalent.qbasement Convert a , to the upper-case equivalent.rbasement Convert a ,% to the unicode case fold equivalent.?Case folding is mostly used for caseless comparison of strings.sbasement@Check whether the first string is a prefix of the second string.tbasement@Check whether the first string is a suffix of the second string.ubasementDCheck whether the first string is contains within the second string.STODO: implemented the naive way and thus terribly inefficient, reimplement properlyvbasement1Try 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 returnedwbasement/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 returnedzbasementTransform string src! to base64 binary representation.{basementTransform string srct to URL-safe base64 binary representation. The result will be either padded or unpadded, depending on the boolean padded argument.|basementTransform string src) to OpenBSD base64 binary representation.basement Source stringbasement)Length of the destination string in bytesbasement7Function called for each character in the source StringbasementReturns the filled new stringQ!#"$%*+,-57689:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|Q,-*+RON57689:`bcad;P!#"$%^<>=?A@BCDL\MIJEFGHKQSTUVWX_YZ[]ghikjlmnopqrstuvwxyefz{|9 BSD-style#Vincent Hanquez <vincent@snarc.org>None +.2HV basement$Color compent on 256colors terminalsbasement)Gray color compent on 256colors terminalsbasementBSimple color component on 8 color terminal (maximum compatibility)basementAll attribute offbasement(8 Colors + Bold attribute for foregroundbasement(8 Colors + Bold attribute for backgroundbasement Red componentbasementGreen componentbasementBlue componentbasement Red componentbasementGreen componentbasementBlue component: BSD-styleHaskell FoundationNone+,2=?@AFHUVXNbasementXClass of things that can mostly be converted from a to b, but with possible error cases.basement2Class 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^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)basementsame as tryFrom but reversed; BSD-style FoundationNone +2HSVX basementcreate an empty builderGthis does nothing, build nothing, take no space (in the resulted block)basementconcatenate the 2 given buliderbasementconcatenate the list of builderbasement4run the given builder and return the generated blockbasement-run the given builder and return a UTF8Stringdthis action is unsafe as there is no guarantee upon the validity of the content of the built block.basementadd a Block in the builderbasementadd a string in the builderbasementemit a UTF8 char in the builderFthis function may be replaced by `emit :: Encoding -> Char -> Builder`< BSD-style FoundationNone+2HMV#basement5run the given builder and return the generated Stringprefer basementadd a string in the builderbasementemit a UTF8 char in the builderUVWXYZXY[X\]X\^X_`X_aX_bX_cUdeUdfX\gX\hX\iX\jX\kXlmXnoXnpXnqXnrX\sX\tX\uX\vX\wX\xX\yX_zX_{Ud|X\}X~X\UdXXXlX\XXX\X\UUUUUXXXXXXUUUXXXXXXXUXXXXXXUXXUUXXUUUXnX~X~X~X~X~X~X~X~X~X~X~X~X~X~X~X~XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  X_ X_ X_ X_X_X_XXXXX\X\X\X\X\X\X\X\X\X X!X"#Ud$UdUd%Ud&Ud'Ud(Ud)Ud*Ud+Ud,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~==========      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUUVWXYZ[\]^_`abcdefghijklmnopqrrstuvwwxyz{|}~xyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy 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)d)g)h)i)j)k)l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*&*|*}*~***********************)**************DDDDDDD&DDDDDDDDDDDDDDDDDDDD---------------------++++++,,|,~,v,,,,,,,,,,x,z,,w,y,,,,,,,,,,,,),,,,,,,....&.......~.v........x.z..w.y......)..........////////////////~//////// / / / / /////////////////// /!/"/#/$/%/&/'/(/)F*F*F+F+F&FF,FFFFF-FF.FFFF/F0F1F2F3F4F25262222222222222422|2{2&2'22227282222222292:2;2~2v2x2z2w2y22222)2222222<2=2>2?2@2A2B2C2D2E2F2G2H2I2J3K3L3M3N3{3~3v3333333x3z33w3y333333)333O3P3Q3R1S111T1U1111111V00W0X0Y00Z0|0[0\0~0v0]0^000_0`0'00a00b00c0d07080000e0f000000900g0x0z0w0y0000)0h0i0000000>0?0@0j0k0<0=4l4l4m4m4n4o4p4q4r4s4t4u4v4w5x5y5z5{5{5~5v5555555x5z55w5y555555)555|5}5~LLLLLLLNNQQQQRS!8866666666'6666768666666c6d6696666&6v66~6|66z6x6y6w6666)6h6i66e6p666o6n666>6?6@6666666666<6=6666666666666669999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: : : : : ::::::::::::::::::: :!;;";#;$;%;&;';(;)<<*<"<+<$<,<)<(=-=.=/=01123456>7?8X9:@;@<@=@>@?@@AAAAABABCBDBEBFBBBGBBBCHD{DIDJDKDLDDDMD`/NFFFOFPFQFKFRFFSFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaF{2232b2120bGcGdGeGfGgGHhHHIIIiIIjJJJkJlKmK+KKKKnKoKpLqLrLsLtLuLqLrLvLsLtLuLwLxMyMzM{M|M}M~MMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOPPP)PPP+PPPPPPrPPPP&QQQQQQ,QQQ+QQQQQQZTTTETF66666b666;{;;&basement-0.0.10-2z2JaOuy7fVLQL3Bi1dEbrBasement.Compat.BaseBasement.Compat.IsListBasement.Compat.SemigroupBasement.Compat.Typeable Basement.NatBasement.Compat.NaturalBasement.Compat.PrimitiveBasement.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.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.Primseqbase Data.TuplefstsndGHC.Base otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=fail>>=>>fmapreturn Data.String fromStringGHC.ExtsIsListfromList fromListNtoList<>memptymappendmconcat<*>pure*>BoundedEnumEqMonad Data.DataDataFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString Applicative GHC.GenericsGeneric GHC.TypeNatsKnownNat SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.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 CSUSecondsCIntPtrCUIntPtrCIntMaxCUIntMaxcastPtr Data.Functor<$>maxBoundminBoundfromEnumtoEnumpredsuccshowListshow showsPrec Data.Maybemaybe$!flipconstwhenstimessconcat<$<*liftA2GHC.Err undefinederrorGHC.Stack.Types HasCallStack/=compare&&||not<>maxminintegerToNaturalnaturalToInteger 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$fEqEndianness$fShowEndianness$fShowLE$fEqLE$fBitsLE$fShowBE$fEqBE$fBitsBEintegerToDoublenaturalToDoubledoubleExponantintegerToFloatnaturalToFloat 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 $fShowZn64$fEqZn64 $fOrdZn64$fShowZn$fEqZn$fOrdZn 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$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$fShowFileSize $fEqFileSize $fOrdFileSize $fShowOffset $fEqOffset $fOrdOffset $fEnumOffset$fAdditiveOffset$fIntegralOffset $fNumOffset $fShowCountOf $fEqCountOf $fOrdCountOf $fEnumCountOf$fIntegralCountOfAddraddrPlus 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$fShowOutOfBoundOperation$fEqOutOfBoundOperation$fShowOutOfBound$fShowRecastSourceSize$fEqRecastSourceSize$fShowRecastDestinationSize$fEqRecastDestinationSize$fShowInvalidRecast$fShowNonEmptyCollectionIsEmptyNonEmpty 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 copyToPtrunsafeCopyToPtrthawfreezecopysub 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 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 createFromIO createFromPtrupdate 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 runUnsafeemitChar word64ToInt64 int64ToWord64 word64ToWord# intToWordtestBitadd64sub64mul64addmul tiocgwinszunsafeUArrayUnpinnedMaxSize GHC.IO.UnsafeunsafePerformIOsysHsMemFindByteAddrsysHsMemFindByteBasysHsMemcmpPtrPtrsysHsMemcmpPtrBasysHsMemcmpBaPtrsysHsMemcmpBaBa RandomAccess Indexable findIndexElemrevFindIndexElemfindIndexPredicaterevFindIndexPredicatefoldl1 inplaceSortByinternalFromListinternalToListequalinternalCompare unsafeShrink SizeValid newUnpinned vFromListvToListvCompare ValidRange UArrayBackendUArrayBA UArrayAddrMUArrayBackend MUArrayMBA MUArrayAddroffsetoffsetsValidRange onBackend onBackendPureonBackendPure' onBackendPrim unsafeDewrap2pureSTunsafeCopyFromUnitError encodingNext convertFromTo encodingWrite UTF32_Invalid UTF16_InvalidInvalidUnicodeISO_8859_1_Invalid NotISO_8859_1isAsciiASCII7_InvalidByteOutOfBound CharNotAsciiCM StepASCII StepDigitStepBackStepstepAsciiRawValueisValidStepASCIIisValidStepDigit NbBytesCont_ NbBytesContisContinuation 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 EncoderUTF8indexN splitIndexdecimalDigitsBAdecimalDigitsPtr caseConvertconcat