!  3 &      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg 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&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C&D&E'F'G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~)))))))))))))))))))))))))))))))))))))))))))))))))))*************************************************************************************+++ + + + + +++++++++++++++++++ +!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + !+ "+ #+ $+ %+ &+ '+ (+ )+ *+ ++ ,+ -+ .+ /+ 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 %27Numeric to ASCII digits table.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNoneFdefdefNone.=>?@ACFHUVXomstdio(type class for calculating product size.mnomnoPrimitive bits twiddling(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone F3|stdioSearch a word8 in array.MCurrently this function is ~4 times slow than c version, so we didn't use it.}stdioThe unboxed version of |~stdio&Search a word8 array in reverse order.This function is used in  elemIndexEnd1, since there's no c equivalent (memrchr) on OSX.stdioThe unboxed version of ~xyz{|}~yz{|}~xPrimitive casting+Haskell Foundation, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,8=?@AFxstdio* between primitive types of the same size.Fast boxed and unboxed arrays(c) Dong Han, 2017BSDwinterland1989@gmail.com experimental non-portableNone =>?@ACFHVXԓ"stdioIA typeclass to unify box & unboxed, mutable & immutable array operations.Most of these functions simply wrap their primitive counterpart, if there's no primitive ones, we polyfilled using other operations to get the same semantics.One exception is that " only perform closure resizing on v) because current RTS support only that, % will do nothing on other array type.It's reasonable to trust GHC with specializing & inlining these polymorphric functions. They are used across this package and perform identical to their monomophric counterpart.stdio!Make a new array with given size."For boxed array, all elements are U which shall not be accessed. For primitive array, elements are just random garbage.stdio3Make a new array and fill it with an initial value.stdio)Index mutable array in a primitive monad.stdio)Write mutable array in a primitive monad.stdio&Fill mutable array with a given value.stdio{Index immutable array, which is a pure operation. This operation often result in an indexing thunk for lifted arrays, use  'indexArr\'' or  if that's not desired.stdiopIndex immutable array, pattern match on the unboxed unit tuple to force indexing (without forcing the element).stdioIndex immutable array in a primitive monad, this helps in situations that you want your indexing result is not a thunk referencing whole array.stdioBSafely freeze mutable array by make a immutable copy of its slice.stdio@Safely thaw immutable array by make a mutable copy of its slice.stdioUIn place freeze a mutable array, the original mutable array can not be used anymore.stdioWIn place thaw a immutable array, the original immutable array can not be used anymore.stdioACopy a slice of immutable array to mutable array at given offset.stdioqCopy a slice of mutable array to mutable array at given offset. The two mutable arrays shall no be the same one.stdiolCopy a slice of mutable array to mutable array at given offset. The two mutable arrays may be the same one.stdioCreate immutable copy.stdioCreate mutable copy.stdio#Resize mutable array to given size.stdio{Shrink mutable array to given size. This operation only works on primitive arrays. For boxed array, this is a no-op, e.g. sizeOfMutableArr will not change.stdio)Is two mutable array are reference equal.stdioSize of immutable array.stdioSize of mutable array.stdio4Is two immutable array are referencing the same one. Note that J 's result may change depending on compiler's optimizations, for example let arr = runST ... in arr  arr4 may return false if compiler decides to inline it.See  -https://ghc.haskell.org/trac/ghc/ticket/13908 for more background.stdioBottom value (throw (: "Data.Array.uninitialized")") for initialize new boxed array(, ..).RNOTE: These functions may segfault when used with indices which are out of bounds.stdio Create a pinnedW byte array of the specified size, The garbage collector is guaranteed not to move it.stdio Create a pinned primitive array of the specified size and respect given primitive type's alignment. The garbage collector is guaranteed not to move it.stdio$Yield a pointer to the array's data.This operation is only safe on pinned primitive arrays allocated by  or  , and you have to make sure the v can outlive the  &.stdio$Yield a pointer to the array's data.This operation is only safe on pinned primitive arrays allocated by  or  . and you have to make sure the v can outlive the  &.stdio?Yield a pointer to the array's data and do computation with it.This operation is only safe on pinned primitive arrays allocated by  or .0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdio?Yield a pointer to the array's data and do computation with it.This operation is only safe on pinned primitive arrays allocated by  or .0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdio%Check if a primitive array is pinned.stdio-Check if a mutable primitive array is pinned.stdioCast between arraysL<;:_j`abckghilrstuvwLvwtu_j`abckghilsr<;: (Bounded checked boxed and unboxed arrays(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNoneHV8stdio.New size should be >= 0, and <= original size.stdio Create a pinnedW byte array of the specified size, The garbage collector is guaranteed not to move it.stdio Create a pinned primitive array of the specified size and respect given primitive type's alignment. The garbage collector is guaranteed not to move it.=<;:tuvw=vwtu<;: *Extra stuff for PrimArray related literals(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneFPstdio+Construct data with ASCII encoded literals.Example usage: arrASCII :: QuasiQuoter arrASCII = QuasiQuoter (asciiLiteral $ len addr -> [| word8ArrayFromAddr $(len) $(addr) |]) ... word8ArrayFromAddr :: Int -> Addr# -> PrimArray Word8 {- INLINE word8ArrayFromAddr -} word8ArrayFromAddr l addr# = runST $ do mba <- newPrimArray (I# l) copyPtrToMutablePrimArray mba 0 (Ptr addr#) l unsafeFreezePrimArray mba stdio+Construct data with UTF-8 encoded literals. Smiliar to  asciIILiteral, thestdio5Construction function which receive a byte length  ' and a  (  ) expression.stdio Quoter inputstdio Final Quoter!! %unaligned access for primitive arrays(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone=?Fstdiobig endianess wrapper stdiolittle endianess wrapper stdio/Primitive types which can be unaligned accessed          (c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNoneF\>stdioAA mutable variable in the ST monad which can hold an instance of _.@stdio Build a new >AstdioRead the value of an >BstdioWrite a new value into an >CstdioMutate the contents of an >.8Unboxed reference is always strict on the value it hold.>?@ABC>?@ABC3(c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone>@ABC>@ABC (c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNoneF DstdioBAlias for 'PrimIORef Int' which support several atomic operations.EstdioAA mutable variable in the IO monad which can hold an instance of _.Fstdio Build a new EGstdioRead the value of an EHstdioWrite a new value into an EIstdioMutate the contents of an IORef.8Unboxed reference is always strict on the value it hold.Jstdio Build a new DKstdioAtomically add a D, return the value AFTER added.LstdioAtomically add a D , return the value BEFORE added.MstdioAtomically add a D.NstdioAtomically sub a D , return the value AFTER subbed.OstdioAtomically sub a D!, return the value BEFORE subbed.PstdioAtomically sub a DQstdioAtomically and a D, return the value AFTER anded.RstdioAtomically and a D , return the value BEFORE anded.SstdioAtomically and a DTstdioAtomically nand a D , return the value AFTER nanded.UstdioAtomically nand a D!, return the value BEFORE nanded.VstdioAtomically nand a DWstdioAtomically or a D, return the value AFTER ored.XstdioAtomically or a D, return the value BEFORE ored.YstdioAtomically or a DZstdioAtomically xor a D, return the value AFTER xored.[stdioAtomically xor a D , return the value BEFORE xored.\stdioAtomically xor a DDEFGHIJKLMNOPQRSTUVWXYZ[\EFGHIDJLORUX[KNQTWZMPSVY\UTF-8 codecs and helpers.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneF7X]stdio,Return a codepoint's encoded length in bytesRIf the codepoint is invalid, we return 3(encoded bytes length of replacement char U+FFFD).^stdio Encode a  * into bytes, write t for invalid unicode codepoint.]This function assumed there're enough space for encoded bytes, and return the advanced index._stdioThe unboxed version of ^.This function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.`stdio Encode a  *5 into bytes with non-standard UTF-8 encoding(Used in  Data.CBytes).'\NUL' is encoded as two bytes C0 80 , '\xD800' ~ '\xDFFF' is encoded as a three bytes normal UTF-8 codepoint. This function assumed there're enough space for encoded bytes, and return the advanced index.astdioThe unboxed version of `.bstdio Decode a  * from bytesThis function assumed all bytes are UTF-8 encoded, and the index param point to the beginning of a codepoint, the decoded character and the advancing offset are returned.pIt's annoying to use unboxed tuple here but we really don't want allocation even if GHC can't optimize it away.dstdioThe unboxed version of bThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.estdio$Decode a codepoint's length in bytesnThis function assumed all bytes are UTF-8 encoded, and the index param point to the beginning of a codepoint.fstdioThe unboxed version of eThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.gstdio Decode a  * from bytes in rerverse order.This function assumed all bytes are UTF-8 encoded, and the index param point to the end of a codepoint, the decoded character and the backward advancing offset are returned.istdioThe unboxed version of gThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.jstdio6Decode a codepoint's length in bytes in reverse order.hThis function assumed all bytes are UTF-8 encoded, and the index param point to the end of a codepoint.kstdioThe unboxed version of jThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.rstdioZUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.sstdioZUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.tstdioxFFFD, which will be encoded as 0xEF 0xBF 0xBD 3 bytes.]^_`abcdefghijklmnopqrst]^_`abcdefghijklmnopqrstErrno provided by libuv(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableNone7MCtustdioUnicode categories. See 4-, you can combine categories with bitwise or.{stdio*These are the Unicode Normalization Forms: Form | Description ---------------------------- | --------------------------------------------- Normalization Form D (NFD) | Canonical decomposition Normalization Form C (NFC) | Canonical decomposition, followed by canonical composition Normalization Form KD (NFKD) | Compatibility decomposition Normalization Form KC (NFKC) | Compatibility decomposition, followed by canonical composition stdioLocale for case mapping.stdiosee { in Std.Data.Text.BaseHuvwzyx{~}|H{~}|wzyxuvFast boxed and unboxed vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone %2=>?@AFHSVXgqhFstdioOIndex pair type to help GHC unpack in some loops, useful when write fast folds.stdio! is just primitive word8 vectors.stdioPrimitive vectorstdio Boxed vectorstdioKTypeclass for box and unboxed vectors, which are created by slicing arrays.Instead of providing a generalized vector with polymorphric array field, we use this typeclass so that instances use concrete array type can unpack their array payload.stdioVector's mutable array typestdioVector's immutable array typestdio7Get underline array and slice range(offset and length).stdio<Create a vector by slicing an array(with offset and length).stdioGA pattern synonyms for matching the underline array, offset and length.~This is a bidirectional pattern synonyms, but very unsafe if not use properly. Make sure your slice is within array's bounds!stdioO(1) Index array element.Return  + if index is out of bounds.stdioConversion between  , and  *. Should compile to a no-op.stdioUnsafe conversion between  * and  ,<. This is a no-op and silently truncates to 8 bits Chars > '\255'=. It is provided as convenience for PrimVector construction.stdioCreate a vector with size N.stdioOCreate a vector with a initial size N array (which may not be the final array).stdiolCreate a vector with a initial size N array, return both the vector and the monadic result during creating.sThe result is not demanded strictly while the returned vector will be in normal form. It this is not desired, use  return $!' idiom in your initialization function.stdioCreate a vector with a initial size N array (which may not be the final array), return both the vector and the monadic result during creating.sThe result is not demanded strictly while the returned vector will be in normal form. It this is not desired, use  return $!' idiom in your initialization function.stdio(Create a vector up to a specific length.MIf the initialization function return a length larger than initial size, an  will be raised.stdio*Create two vector up to a specific length.MIf the initialization function return lengths larger than initial sizes, an  will be raised.stdioO(1). The empty vector.stdioO(1). Single element vector.stdioO(n). Copy a vector from slice.stdioO(n) Convert a list into a vector Alias for  $.stdioO(n)7 Convert a list into a vector with an approximate size.kIf the list's length is large than the size given, we simply double the buffer size and continue building.This function is a  good consumer$ in the sense of build/foldr fusion.stdioO(n) Alias for  $.stdioO(n)  in reverse order.This function is a  good consumer$ in the sense of build/foldr fusion.stdioO(n) Convert vector to a list.dUnpacking is done lazily. i.e. we will retain reference to the array until all element are consumed.This function is a  good producer$ in the sense of build/foldr fusion.stdioO(n)+ Convert vector to a list in reverse order.This function is a  good producer$ in the sense of build/foldr fusion.stdioO(1) The length of a vector.stdioO(1) Test whether a vector is empty.stdioO(m+n)lThere's no need to guard empty vector because we guard them for you, so appending empty vectors are no-ops.stdioEMapping between vectors (possiblely with two different vector types).1NOTE, the result vector contain thunks in lifted  case, use  if that's not desired.For ,  and  are same, since s never store thunks.stdioEMapping between vectors (possiblely with two different vector types)..This is the strict version map. Note that the  - instance of lifted  is defined with 6 to statisfy laws, which this strict version breaks (3map' id arrayContainsBottom /= arrayContainsBottom ).stdioStrict mapping with index.stdioStrict left to right fold.stdio%Strict left to right fold with index.stdioCStrict left to right fold using first element as the initial value.Throw  if vector is empty.stdioNStrict left to right fold using first element as the initial value. return  + when vector is empty.stdioStrict right to left foldstdio$Strict right to left fold with index1NOTE: the index is counting from 0, not backwards stdioBStrict right to left fold using last element as the initial value.Throw  if vector is empty. stdioMStrict right to left fold using last element as the initial value, return  + when vector is empty. stdioO(n) Concatenate a list of vector.Note:  c have to force the entire list to filter out empty vector and calculate the length for allocation. stdio8Map a function over a vector and concatenate the results stdioO(n)  ( returns the maximum value from a vectorIt's defined with , an : exception will be thrown in the case of an empty vector.stdioO(n)  4 returns the maximum value from a vector, return  + in the case of an empty vector.stdioO(n) " returns the minimum value from a vectorAn 9 exception will be thrown in the case of an empty vector.stdioO(n) 4 returns the minimum value from a vector, return  + in the case of an empty vector.stdioO(n) ( returns the product value from a vectorstdioO(n) ( returns the product value from a vectoraThis function will shortcut on zero. Note this behavior change the semantics for lifted vector: 3product [1,0,undefined] /= product' [1,0,undefined].stdioO(n)& Applied to a predicate and a vector, A determines if any elements of the vector satisfy the predicate.stdioO(n)& Applied to a predicate and a vector, A determines if all elements of the vector satisfy the predicate.stdioO(n)  returns the sum value from a vectorstdioO(n) $ returns count of an element from a vectorstdioThe ( function behaves like a combination of  and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.rNote, this function will only force the result tuple, not the elements inside, to prevent creating thunks during ,  .4 your accumulator and result with the result tuple.stdioThe ( function behaves like a combination of  and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector."The same strictness property with  applys to  too.stdioO(n)  n x is a vector of length n with x the value of every element.Note: 1 will not force the element in boxed vector case.stdioO(n*m)  a vector n times.stdioO(n), where n# is the length of the result. The 0 function is analogous to the List 'unfoldr'. Q builds a vector from a seed value. The function takes the element and returns  +0 if it is done producing the vector or returns  / (a,b), in which case, a& is the next byte in the string, and b* is the seed value for further production. Examples: [ unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0 == pack [0, 1, 2, 3, 4, 5]stdioO(n) Like , m builds a vector from a seed value. However, the length of the result is limited by the first argument to (. This function is more efficient than 1 when the maximum length of the result is known.The following equation relates  and : ,fst (unfoldrN n f s) == take n (unfoldr f s)stdioO(n) * test if given element is in given vector.stdioO(n) 'not . elem'stdioO(n) The o function returns the index of the first element in the given vector which is equal to the query element, or  + if there is no such element. 0stdioO(n) Special  for  using  memchr(3)On most platforms  memchr(3)W is a highly optimized byte searching function, thus we make a special binding for it.A rewrite rule elemIndex = elemIndexBytes is also included. stdioUnlike  -. instance, this mapping evaluate value inside  strictly.!stdio.The chunk size used for I/O. Currently set to 32k-chunkOverhead"stdio-The recommended chunk size. Currently set to 4k - chunkOverhead.#stdioEThe memory management overhead. Currently this is tuned for GHC only.$stdiodefaultInitSize = 30<, used as initialize size when packing list of unknown size.'stdioCast between vectorsstdiopayloadstdio1offset in elements of type a rather than in bytesstdio1length in elements of type a rather than in bytesstdiopayloadstdiooffsetstdiolengthstdiolength in elements of type astdioinitialization functionstdiolength in elements of type astdio_initialization function return a result size and array the result must start from index 0stdioinitialization functionstdioinitialization functionstdiolength's upper boundstdio6initialization function which return the actual lengthY      !"#$%&'Y      $#!"%&'!vectors literals using QuasiQuote(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneF9 NOPQRSTUVWX NOPQRSTUVWXSearching vectors(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FX"YstdioO(n) The Y function extends [, by returning the indices of all elements equal to the query element, in ascending order.ZstdioThe \} function takes a predicate and a vector and returns the index of the first element in the vector satisfying the predicate.[stdioO(n) Special Y for  using  memchr(3)\stdio findIndex f v = fst (find f v)]stdio  findIndexR f v = fst (findR f v)^stdioO(n) find the first index and element matching the predicate in a vector from left to right, if there isn't one, return (length of the vector, Nothing)._stdioO(n) Special _ for  , using  memchr(3)`stdioO(n) find the first index and element matching the predicate in a vector from right to left, if there isn't one, return '(-1, Nothing)'.astdioO(n) Special ` for  with handle roll bit twiddling.bstdioO(n) bo, applied to a predicate and a vector, returns a vector containing those elements that satisfy the predicate.cstdioO(n) The c function takes a predicate, a vector, returns a pair of vector with elements which do and do not satisfy the predicate, respectively; i.e., 4partition p vs == (filter p vs, filter (not . p) vs)dstdioO(n+m); Find the offsets of all indices (possibly overlapping) of needle within haystack using KMP algorithm.6The KMP algorithm need pre-calculate a shift table in O(m)4 time and space, the worst case time complexity is O(n+m)R. Partial apply this function to reuse pre-calculated table between same needles.Chunked input are support via partial match argument, if set we will return an extra negative index in case of partial match at the end of input chunk, e.g. AindicesOverlapping [ascii|ada|] [ascii|adadad|] True == [0,2,-2]Where -2) is the length of the partial match part ad 's negation.WIf an empty pattern is supplied, we will return every possible index of haystack, e.g. %indicesOverlapping "" "abc" = [0,1,2] References:ZKnuth, Donald; Morris, James H.; Pratt, Vaughan: "Fast pattern matching in strings" (1977) @http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080estdioO(n/m); Find the offsets of all indices (possibly overlapping) of needle within haystackH using KMP algorithm, combined with simplified sunday's rule to obtain O(n/m) complexity in average use case.9The hybrid algorithm need pre-calculate a shift table in O(m)6 time and space, and a bad character bloom filter in O(m) time and O(1)+ space, the worst case time complexity is O(n+m). References:nFrantisek FranekChristopher G. JenningsWilliam F. Smyth A Simple Fast Hybrid Pattern-Matching Algorithm (2005)fD. M. Sunday: A Very Fast Substring Search Algorithm. Communications of the ACM, 33, 8, 132-142 (1990)%F. Lundh: The Fast Search Algorithm.  $http://effbot.org/zone/stringlib.htm (2006)fstdioO(n+m)4 Find the offsets of all non-overlapping indices of needle within haystack using KMP algorithm.WIf an empty pattern is supplied, we will return every possible index of haystack, e.g. %indicesOverlapping "" "abc" = [0,1,2]gstdioO(n/m)4 Find the offsets of all non-overlapping indices of needle within haystackH using KMP algorithm, combined with simplified sunday's rule to obtain O(m/n) complexity in average use case.hstdioO(m)$ Calculate the KMP next shift table./The shifting rules is: when a mismatch between  needle[j] and  haystack[i] is found, check if  next[j] == -1", if so next search continue with  needle[0] and  haystack[i+1], otherwise continue with needle[next[j]] and  haystack[i].istdioO(m)> Calculate a simple bloom filter for simplified sunday's rule./The shifting rules is: when a mismatch between  needle[j] and  haystack[i] is found, check if %elemSundayBloom bloom haystack[i+n-j]Z, where n is the length of needle, if not then next search can be safely continued with haystack[i+n-j+1] and  needle[0]-, otherwise next searh should continue with  haystack[i] and  needle[0]2, or fallback to other shifting rules such as KMP.*The algorithm is very simple: for a given  , w, we set the bloom's bit at unsafeShiftL 0x01 (w .&. 0x3f), so there're three false positives per bit. This's particularly suitable for search UTF-8 bytes since the significant bits of a beginning byte is usually the same.jstdio.O(1) Test if a bloom filter contain a certain  ,.dstdiovector to search for (needle)stdiovector to search in (haystack)stdio+report partial match at the end of haystackestdiobytes to search for (needle)stdiobytes to search in (haystack)stdio+report partial match at the end of haystackgstdiobytes to search for (needle)stdiobytes to search in (haystack)stdio+report partial match at the end of haystackYZ[\]^_`abcdefghijZY^`\]bcdf[_aeghijFast vector slice manipulation(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FX|CkstdioO(n) k[ is analogous to (:) for lists, but of different complexity, as it requires making a copy.lstdioO(n)% Append a byte to the end of a vectormstdioO(1)/ Extract the head and tail of a vector, return  + if it is empty.nstdioO(1)/ Extract the init and last of a vector, return  + if vector is empty.ostdioO(1)' Extract the first element of a vector.pstdioO(1)1 Extract the elements after the head of a vector.NOTE: p4 return empty vector in the case of an empty vector.qstdioO(1)& Extract the last element of a vector.rstdioO(1)- Extract the elements before of the last one.NOTE: r4 return empty vector in the case of an empty vector.sstdioO(n)> Return all initial segments of the given vector, empty first.tstdioO(n)C Return all final segments of the given vector, whole vector first.ustdioO(1) u n, applied to a vector xs, returns the prefix of xs of length n, or xs itself if n >  xs.vstdioO(1) v n, applied to a vector xs, returns the suffix of xs of length n, or xs itself if n >  xs.wstdioO(1) w n xs returns the suffix of xs after the first n elements, or [] if n >  xs.xstdioO(1) x n xs returns the prefix of xs before the last n elements, or [] if n >  xs.ystdioO(1)= Extract a sub-range vector with give start index and length.,This function is a total function just like  'take/drop'3, index/length exceeds range will be ingored, e.g. nslice 1 3 "hello" == "ell" slice -1 -1 "hello" == "" slice -2 2 "hello" == "" slice 2 10 "hello" == "llo" This holds for all x y: &slice x y vs == drop x . take (x+y) vszstdioO(1) z n xs is equivalent to (u n xs, w n xs).{stdioO(n) Applied to a predicate p and a vector vs2, returns the longest prefix (possibly empty) of vs of elements that satisfy p.|stdioO(n) Applied to a predicate p and a vector vs2, returns the longest suffix (possibly empty) of vs of elements that satisfy p.}stdioO(n) Applied to a predicate p and a vector vs7, returns the suffix (possibly empty) remaining after { p vs.~stdioO(n) Applied to a predicate p and a vector vs8, returns the prefix (possibly empty) remaining before | p vs.stdioO(n) )dropAround f = dropWhile f . dropWhileR fstdioO(n)u Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest without copying. break (==x) will be rewritten using a memchr.stdioO(n)n Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. span (/=x) will be rewritten using a memchr.stdio behaves like  but from the end of the vector. breakR p == spanR (not.p)stdio behaves like  but from the end of the vector.stdioBreak a vector on a subvector, returning a pair of the part of the vector prior to the match, and the rest of the vector, e.g. 1break "wor" "hello, world" = ("hello, ", "world")stdioO(n) The ( function takes two vectors and returns  /J the remainder of the second iff the first is its prefix, and otherwise  +.stdioThe isPrefix function returns  11 if the first argument is a prefix of the second.stdioO(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match. e.g.commonPrefix "foobar" "fooquux"("foo","bar","quux")commonPrefix "veeble" "fetzer"("","veeble","fetzer")stdio O(n) The | function takes two vectors and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.stdioO(n) The ( function takes two vectors and returns  1) if the first is a suffix of the second.stdio3Check whether one vector is a subvector of another.needle < haystack === null haystack || indices needle haystake /= [].stdioO(n)] Break a vector into pieces separated by the delimiter element consuming the delimiter. I.e. ~split '\n' "a\nb\nd\ne" == ["a","b","d","e"] split 'a' "aXaXaXa" == ["","X","X","X",""] split 'x' "x" == ["",""]and 9intercalate [c] . split c == id split == splitWith . (==)?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.stdioO(m+n)0 Break haystack into pieces separated by needle.JNote: An empty needle will essentially split haystack element by element. Examples:!splitOn "\r\n" "a\r\nb\r\nd\r\ne"["a","b","d","e"] splitOn "aaa" "aaaXaaaXaaaXaaa"["","X","X","X",""]splitOn "x" "x"["",""]and Xintercalate s . splitOn s == id splitOn (singleton c) == split (==c)stdioO(n) Splits a vector into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg. VsplitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == [""]?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.stdioO(n) Breaks a 3 up into a list of words, delimited by ascii space.stdioO(n) Breaks a - up into a list of lines, delimited by ascii n.stdioO(n) Joins words with ascii space.stdioO(n) Joins lines with ascii n.stdioHAdd padding to the left so that the whole vector's length is at least n.stdioIAdd padding to the right so that the whole vector's length is at least n.stdioO(n)  vs% efficiently returns the elements of xs in reverse order.stdioO(n) The  function takes an element and a vector and `intersperses' that element between the elements of the vector. It is analogous to the intersperse function on Lists.stdioO(n) The  function takes a vector and a list of vectors and concatenates the list after interspersing the first argument between each element of the list.Note: # will force the entire vector list.stdioO(n)1 An efficient way to join vector with an element.stdioThe B function transposes the rows and columns of its vector argument.stdio( zip two vector with a zipping function. For example,  2 (+)l is applied to two vector to produce a vector of corresponding sums, the result will be evaluated strictly.stdio4 disassemble a vector with a disassembling function,4The results inside tuple will be evaluated strictly.stdio is similar to foldlA, but returns a list of successive reduced values from the left. Ascanl' f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that -lastM (scanl' f z xs) == Just (foldl f z xs).stdio 'scanl1\'' is a variant of  3% that has no starting value argument. Bscanl1' f [x1, x2, ...] == [x1, x1 `f` x2, ...] scanl1' f [] == []stdio+scanr' is the right-to-left dual of scanl'.stdio is a variant of  4% that has no starting value argument.stdiox' = rangeCut x min max limit x' 's range to min ~ max.stdioO(1)' Extract the first element of a vector.Throw  if vector is empty.stdioO(1)1 Extract the elements after the head of a vector.Throw  if vector is empty.stdioO(1)- Extract the elements before of the last one.Throw  if vector is empty.stdioO(1)& Extract the last element of a vector.Throw  if vector is empty.stdioO(1) Index array element.Throw  if index outside of the vector.stdioO(1) Index array element.Throw  if index outside of the vector.stdioO(1)' Extract the first element of a vector.BMake sure vector is non-empty, otherwise segmentation fault await!stdioO(1)1 Extract the elements after the head of a vector.BMake sure vector is non-empty, otherwise segmentation fault await!stdioO(1)- Extract the elements before of the last one.BMake sure vector is non-empty, otherwise segmentation fault await!stdioO(1)& Extract the last element of a vector.BMake sure vector is non-empty, otherwise segmentation fault await!stdioO(1) Index array element.@Make sure index is in bound, otherwise segmentation fault await!stdioO(1) Index array element.@Make sure index is in bound, otherwise segmentation fault await!stdioO(1) u n, applied to a vector xs, returns the prefix of xs of length n.PMake sure n is smaller than vector's length, otherwise segmentation fault await!stdioO(1) w n xs returns the suffix of xs after the first n elements.PMake sure n is smaller than vector's length, otherwise segmentation fault await!ystdioslice beginning indexstdio slice lengthstdiothe prefix to be testedstdiothe prefix to be testedEklmnopqrstuvwxyz{|}~Eklmnopqrstuwvxyz{|}~Sorting vectors/(c) 2008-2011 Dan Doel, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone -.>@AFHMXpstdio Similar to [ newtype for  5*, this newtype can inverse the order of a  instance when used in .stdio2Types contain radixs, which can be inspected with  during different .#The default instances share a same ' 256, which seems to be a good default.stdio8The size of an auxiliary array, i.e. the counting bucketstdio]The number of passes necessary to sort an array of es, it equals to the key's byte number.stdioNThe radix function used in the first pass, works on the least significant bit.stdioMThe radix function parameterized by the current pass (0 < pass < passes e-1).stdioLThe radix function used in the last pass, works on the most significant bit.stdio O(n*log(n)) Sort vector based on element's  5 instance with classic  (https://en.wikipedia.org/wiki/Merge_sort mergesort algorithm.This is a stable sort, During sorting two O(n) worker arrays are needed, one of them will be freezed into the result vector. The merge sort only begin at tile size larger than  , each tile will be sorted with L, then iteratively merged into larger array, until all elements are sorted.stdioThe mergesort tile size, mergeTileSize = 8.stdioO(n^2) Sort vector based on element's  5 instance with simple  ,https://en.wikipedia.org/wiki/Insertion_sortinsertion-sort algorithm.^This is a stable sort. O(n) extra space are needed, which will be freezed into result vector.stdioO(n) Sort vector based on element's  instance with  (https://en.wikipedia.org/wiki/Radix_sort radix-sort3, (Least significant digit radix sorts variation).WThis is a stable sort, one or two extra O(n) worker array are need depend on how many  shall be performed, and a r counting bucket are also needed. This sort algorithms performed extremly well on small byte size types such as  6 or  ,, while on larger type, constant passes may render this algorithm not suitable for small vectors (turning point around 2^(2*passes)).stdio7merge duplicated adjacent element, prefer left element.CUse this function on a sorted vector will have the same effects as nub.stdio7Merge duplicated adjacent element, prefer left element.stdio8Merge duplicated adjacent element, prefer right element.stdioTMerge duplicated adjacent element, based on a equality tester and a merger function.stdioequality tester,  left right -> eq left rightstdioequality tester,  left right -> eq left rightstdioequality tester,  left right -> eq left rightstdio the merger,  left right -> merge left right[Z[Z5Fast boxed and unboxed vector(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone %2=>?@AFHSVXg١[Z    'NOPQRSTUVWXYZ^`bcdfklmnopqrstuvwxyz{|}~    klmnopqrstuwvxyz{|}~^`ZYbcdf[ZNOPQRSTUVWX'Errno provided by libuv(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableSafegLKstdiotoo many linksstdiono such device or addressstdio end of filestdio unknown errorstdiocross-device link not permittedstdiotext file is busystdioconnection timed outstdiono such processstdio invalid seekstdio-cannot send after transport endpoint shutdownstdioread-only file systemstdioresult too largestdioprotocol wrong type for socketstdioprotocol not supportedstdioprotocol errorstdio broken pipestdiooperation not permittedstdio!operation not supported on socketstdiosocket operation on non-socketstdiodirectory not emptystdionot a directorystdiosocket is not connectedstdiofunction not implementedstdiono space left on devicestdioprotocol not availablestdiomachine is not on the networkstdionot enough memorystdiono such file or directorystdiono such devicestdiono buffer space availablestdiofile table overflowstdionetwork is unreachablestdionetwork is downstdio name too longstdiomessage too longstdiotoo many open filesstdio#too many symbolic links encounteredstdio illegal operation on a directorystdiosocket is already connectedstdio i/o errorstdioinvalid argumentstdiointerrupted system callstdiohost is unreachablestdiofile too largestdio#bad address in system call argumentstdiofile already existsstdiodestination address requiredstdioconnection reset by peerstdioconnection refusedstdio software caused connection abortstdioinvalid Unicode characterstdiooperation canceledstdioresource busy or lockedstdiobad file descriptorstdioconnection already in progress stdiosocket type not supported stdio%service not available for socket type stdioresolved protocol is unknown stdioargument buffer overflow stdiounknown node or servicestdio no addressstdio out of memorystdioai_family not supportedstdiopermanent failurestdiorequest canceledstdioinvalid value for hintsstdiobad ai_flags valuestdiotemporary failurestdioaddress family not supportedstdio resource temporarily unavailablestdioaddress family not supportedstdioaddress not availablestdioaddress already in usestdiopermission deniedstdioargument list too longO     O     Extensible IO exceptions(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2>EHMVX stdioIO exceptions informations.!stdio8the errno name, e.g. EADDRINUSE, etc. empty if no errno."stdio`description for this io error, can be errno description, or some custom description if no errno.#stdiolightweight partial call-stackHstdio^The root type of all io exceptions, you can catch all io exception by catching this root type.LstdioThrow @ if allocation return a  7.MstdioHThrow appropriate IO exception if return value < 0 (libuv's convention).NstdioPThrow appropriate IO exception if return value < 0, otherwise ignore the result.OstdioThrow 67 with name ECLOSED& and description 'resource is closed'.Lstdiothe allocation actionMstdio the IO actionNstdio the IO action  "!#$%&('*),+.-0/214398765<;:=>?@ABCDEIHGFJMKLRQPOYXWVUTS]^N !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQHIJK !"#FGDEBC@A>?<=:;8967452301./,-*+()&'$%LMNOPQ  "!#$%&('*),+.-0/214398765<;:=>?@ABCDEIHGFJMKLKRQPOYXWVUTS^N]"Low resolution (0.1s) timing wheel(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneXMystdioTimer registered by ~ or . 8stdioA simple timing wheel{stdio=Create new low resolution timer manager on capability change.tSince low resolution timer manager is not hooked into RTS, you're responsible to call this function after you call  9> to match timer manager array size with new capability number.OThis is not a must though, when we fetch timer manager we always take a modulo.|stdioGet a z for current thread.}stdio+Check if a timer manager's wheel is turning#This is mostly for testing purpose.~stdiogRegister a new timer on current capability's timer manager, start the timing wheel if it's not turning.hIf the action could block, you may want to run it in another thread. Example to kill a thread after 10s: 4 registerLowResTimer 100 (forkIO $ killThread tid) stdio : (~ t action)stdioSame as ~%, but allow you choose timer manager.stdio2Query how many seconds remain before timer firing.;A return value <= 0 indictate the timer is firing or fired.stdio+Cancel a timer, return the remaining ticks.6This function have no effect after the timer is fired.stdio void . cancelLowResTimerstdio similar to 89<, this function put a limit on time which an IO can consume.,Note timeoutLowRes is also implemented with RN underhood, which can have some surprising effects on some devices, e.g. use  with reading or writing on UVStreams will close the UVStream: once a reading or writing is not able to be done in time.stdio similar to , but raise a  ; instead of return  + if timeout. <stdioICheck if low resolution timer manager loop is running, start loop if not. =stdiohStart low resolution timer loop, the loop is automatically stopped if there's no more new registrations. >stdioQScan the timeout queue in current tick index, and move tick index forward by one.stdio-Cache result of an IO action for give time t.This combinator is useful when you want to share IO result within a period, the action will be called on demand, and the result will be cached for t milliseconds.One common way to get a shared periodical updated value is to start a seperate thread and do calculation periodically, but doing that will stop system from being idle, which stop idle GC from running, and in turn disable deadlock detection, which is too bad. This function solves that.stdio-Throttle an IO action without caching result.nThe IO action will run at leading edge. i.e. once run, during following (t/10)s throttled action will no-ops./Note the action will run in the calling thread.stdio Similar to  but run action in trailing edgeThe IO action will run at trailing edge. i.e. no matter how many times throttled action are called, original action will run only once after (t/10)s.4Note the action will be run in a new created thread.~stdiotimeout in unit of 0.1sstdio3the action you want to perform, it should not blockstdiotimeout in unit of 0.1sstdio3the action you want to perform, it should not blockstdioa low resolution timer managerstdiotimeout in unit of 0.1sstdio3the action you want to perform, it should not blockstdiotimeout in unit of 0.1sstdiotimeout in unit of 0.1sstdiocache time in unit of 0.1sstdiothe original IO actionstdiothrottled IO actionstdiocache time in unit of 0.1sstdiothe original IO actionstdiothrottled IO actionstdiothe original IO actionstdiothrottled IO actionyz{|}~~yz|}{The Resource monad(c) Dong Han, 2017BSDwinterland1989@gmail.com experimental non-portableNone2SX stdio.A high performance resource pool based on STM.We choose to not divide pool into strips due to the difficults in resource balancing. If there is a high contention on resource (see @), just increase the maximum number of resources can be opened. ?stdioA single resource pool entry.stdioA  is an  @v action which acquires some resource of type a and also returns a finalizer of type IO () that releases the resource.The only safe way to use a  is  / 'withResource\'', You should not use the v field directly, unless you want to implement your own resource management. In the later case, you should always use AM since some resource initializations may assume async exceptions are masked. A+ instance is provided so that you can lift  @ computation inside %, this is convenient for propagating  around since many  @ computations carry finalizers.4A convention in stdio is that functions returning a  should be named in initXXXB format, users are strongly recommended to follow this convention.4There're two additional guarantees we made in stdio:9All resources in stdio can track its own liveness, throw & exception using O or P) when used after resource is closed.6All resources' clean up action in stdio is idempotent.Library authors providing initXXX1 are also encouraged to provide these guarantees.stdioCreate  from create and release action.Note, resourceA doesn't open resource itself, resource is created when you use with / with'.stdioCreate  from create and release action.]This function is useful when you want to add some initialization and clean up action inside  monad.stdioTCreate a new resource and run some computation, resource is guarantee to be closed.Be care don't leak the resource through computation return value, because after the computation finishes, the resource is closed already.stdioTCreate a new resource and run some computation, resource is guarantee to be closed.The difference from with is that the computation will receive an extra close action, which can be used to close the resource early before the whole computation finished, the close action can be called multiple times, only the first call will clean up the resource.stdio&Initialize a resource pool with given ULike other initXXX functions, this function won't open a resource pool until you use [. And this resource pool follow the same resource management pattern like other resources.stdioGet a resource pool's 7This function is useful when debug, under load lots of  may indicate contention on resources, i.e. the limit on maximum number of resources can be opened should be adjusted to a higher number. On the otherhand, lots of 0 may indicate there're too much free resources.stdio8Obtain the pooled resource inside a given resource pool.You shouldn't use 3 with this resource after you closed the pool, an & with  EPOOLCLOSED name will be thrown.stdio)maximum number of resources can be openedstdioKamount of time after which an unused resource can be released (in seconds).Use PrimArray with FFI(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneFX stdioType alias for  B .^Since we can't newtype an unlifted type yet, type alias is the best we can get to describe a  BX which we are going to pass across FFI. At C side you should use a proper pointer type. Don't cast  to  (@ since the heap object offset is hard-coded in code generator: Mhttps://github.com/ghc/ghc/blob/master/compiler/codeGen/StgCmmForeign.hs#L520(USE THIS TYPE WITH UNSAFE FFI CALL ONLY.stdioType alias for  C.^Since we can't newtype an unlifted type yet, type alias is the best we can get to describe a  C^ which we are going to pass across FFI. At C side you should use a proper const pointer type. Don't cast  to  (@ since the heap object offset is hard-coded in code generator: Mhttps://github.com/ghc/ghc/blob/master/compiler/codeGen/StgCmmForeign.hs#L520(USE THIS TYPE WITH UNSAFE FFI CALL ONLY.stdio.Pass primitive array to unsafe FFI as pointer.Enable UnliftedFFITypes= extension in your haskell code, use proper pointer type and  CSize/CSsize to marshall  ByteArray# and Int arguments on C side. The second  '2 arguement is the element size not the bytes size. Don't cast  C to  (@ since the heap object offset is hard-coded in code generator: Mhttps://github.com/ghc/ghc/blob/master/compiler/codeGen/StgCmmForeign.hs#L520In haskell side we use type system to distinguish immutable / mutable arrays, but in C side we can't. So it's users' responsibility to make sure the array content is not mutated (a const pointer type may help).,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.stdio6Pass mutable primitive array to unsafe FFI as pointer.The mutable version of .,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.stdioPass  to unsafe FFI as pointerThe  version of . The second  '2 arguement is the first element offset, the third  '! argument is the element length.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.stdioWCreate an one element primitive array and use it as a pointer to the primitive element..Return the element and the computation result.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.stdio,Pass primitive array to safe FFI as pointer.Use proper pointer type and  CSize/CSsize to marshall Ptr a and IntD arguments on C side. The memory pointed by 'Ptr a' will not moved. The second  '2 arguement is the element size not the bytes size.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdio6Pass mutable primitive array to unsafe FFI as pointer.The mutable version of .0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdioPass  to unsafe FFI as pointerThe  version of . The  &F is already pointed to the first element, thus no offset is provided.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdioWCreate an one element primitive array and use it as a pointer to the primitive element.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.stdioZero a structure. There's no Storable or _ constraint on a1 type, thus the length should be given in bytes.stdio,Cast between raw address and tagged pointer.stdio,Cast between tagged pointer and raw address.stdioIn bytes . D E F G H I J ( K C L M N O P Q R S B 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 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\ 7\Unicode text processing(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2FMXgq0stdio represented as UTF-8 encoded stdioExtract UTF-8 encoded  from stdioO(n) Get the nth codepoint from .stdioO(n)P Find the nth codepoint's byte index (pointing to the nth char's begining byte).The index is only meaningful to the whole byte slice, if there's less than n codepoints, the index will point to next byte after the end.stdioO(n) Get the nth codepoint from  counting from the end.stdioO(n)a Find the nth codepoint's byte index from the end (pointing to the previous char's ending byte).The index is only meaningful to the whole byte slice, if there's less than n codepoints, the index will point to previous byte before the start.stdioO(n)/ Validate a sequence of bytes is UTF-8 encoded.)Throw error in case of invalid codepoint.stdioO(n) Convert a string into a text Alias for  defaultInitSize,, will be rewritten to a memcpy if possible.stdioO(n)O Convert a list into a text with an approximate size(in bytes, not codepoints).sIf the encoded bytes length is larger than the size given, we simply double the buffer size and continue building.This function is a  good consumer$ in the sense of build/foldr fusion.stdioO(n) Alias for  defaultInitSize.stdioO(n)  in reverse order.This function is a  good consumer$ in the sense of build/foldr fusion.stdioO(n) Convert text to a char list.dUnpacking is done lazily. i.e. we will retain reference to the array until all element are consumed.This function is a  good producer$ in the sense of build/foldr fusion.stdioO(n)) Convert text to a list in reverse order.This function is a  good producer$ in the sense of build/foldr fusion.stdioO(1). Single char text.stdioO(1) . Empty text.stdioO(n). Copy a text from slice.stdioO(m+n)iThere's no need to guard empty vector because we guard them for you, so appending empty text are no-ops.stdioO(1) Test whether a text is empty.stdioO(n) The char length of a text.stdioO(n) map f t is the  obtained by applying f to each char of t0. Performs replacement on invalid scalar values.stdioStrict mapping with index.stdioStrict left to right fold.stdio%Strict left to right fold with index.stdioStrict right to left foldstdio$Strict right to left fold with index1NOTE: the index is counting from 0, not backwardsstdioO(n) Concatenate a list of text.Note: a have to force the entire list to filter out empty text and calculate the length for allocation.stdio6Map a function over a text and concatenate the resultsstdioO(n) ) returns count of an element from a text.stdioO(n)$ Applied to a predicate and a text, < determines if any chars of the text satisfy the predicate.stdioO(n)" Applied to a predicate and text, < determines if all chars of the text satisfy the predicate.stdioO(n)  char n time.stdioO(n*m)  a text n times.stdioO(n) convert from a char vector.stdioO(n) convert to a char vector.stdio>Check if a string is stable in the NFC (Normalization Form C).stdioHCheck if a string is stable in the specified Unicode Normalization Form.This function can be used as a preprocessing step, before attempting to normalize a string. Normalization is a very expensive process, it is often cheaper to first determine if the string is unstable in the requested normalization form.The result of the check will be YES if the string is stable and MAYBE or NO if it is unstable. If the result is MAYBE, the string does not necessarily have to be normalized.If the result is unstable, the offset parameter is set to the offset for the first unstable code point. If the string is stable, the offset is equivalent to the length of the string in bytes.$For more information, please review  $http://www.unicode.org/reports/tr15/8Unicode Standard Annex #15 - Unicode Normalization Forms.stdio1Normalize a string to NFC (Normalization Form C).stdio?Normalize a string to the specified Unicode Normalization Form.gThe Unicode standard defines two standards for equivalence between characters: canonical and compatibility equivalence. Canonically equivalent characters and sequence represent the same abstract character and must be rendered with the same appearance and behavior. Compatibility equivalent characters have a weaker equivalence and may be rendered differently.Unicode Normalization Forms are formally defined standards that can be used to test whether any two strings of characters are equivalent to each other. This equivalence may be canonical or compatibility.The algorithm puts all combining marks into a specified order and uses the rules for decomposition and composition to transform the string into one of four Unicode Normalization Forms. A binary comparison can then be used to determine equivalence.stdioDRemove case distinction from UTF-8 encoded text with default locale.stdio0Remove case distinction from UTF-8 encoded text.Case folding is the process of eliminating differences between code points concerning case mapping. It is most commonly used for comparing strings in a case-insensitive manner. Conversion is fully compliant with the Unicode 7.0 standard.$Although similar to lowercasing text, there are significant differences. For one, case folding does _not_ take locale into account when converting. In some cases, case folding can be up to 20% faster than lowercasing the same text, but the result cannot be treated as correct lowercased text.Only two locale-specific exception are made when case folding text. In Turkish, U+0049 LATIN CAPITAL LETTER I maps to U+0131 LATIN SMALL LETTER DOTLESS I and U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE maps to U+0069 LATIN SMALL LETTER I.Although most code points can be case folded without changing length, there are notable exceptions. For example, U+0130 (LATIN CAPITAL LETTER I WITH DOT ABOVE) maps to "U+0069 U+0307" (LATIN SMALL LETTER I and COMBINING DOT ABOVE) when converted to lowercase.Only a handful of scripts make a distinction between upper- and lowercase. In addition to modern scripts, such as Latin, Greek, Armenian and Cyrillic, a few historic or archaic scripts have case. The vast majority of scripts do not have case distinctions.stdio<Convert UTF-8 encoded text to lowercase with default locale.stdio(Convert UTF-8 encoded text to lowercase.This function allows conversion of UTF-8 encoded strings to lowercase without first changing the encoding to UTF-32. Conversion is fully compliant with the Unicode 7.0 standard. Although most code points can be converted to lowercase with changing length, there are notable exceptions. For example, U+0130 (LATIN CAPITAL LETTER I WITH DOT ABOVE) maps to "U+0069 U+0307" (LATIN SMALL LETTER I and COMBINING DOT ABOVE) when converted to lowercase.Only a handful of scripts make a distinction between upper- and lowercase. In addition to modern scripts, such as Latin, Greek, Armenian and Cyrillic, a few historic or archaic scripts have case. The vast majority of scripts do not have case distinctions.)Case mapping is not reversible. That is, *toUpper(toLower(x)) != toLower(toUpper(x)).Certain code points (or combinations of code points) apply rules based on the locale. For more information about these exceptional code points, please refer to the Unicode standard: ftp:/ftp.unicode.orgPublicUNIDATASpecialCasing.txtstdio<Convert UTF-8 encoded text to uppercase with default locale.stdio(Convert UTF-8 encoded text to uppercase.<Conversion is fully compliant with the Unicode 7.0 standard.Although most code points can be converted without changing length, there are notable exceptions. For example, U+00DF (LATIN SMALL LETTER SHARP S) maps to "U+0053 U+0053" (LATIN CAPITAL LETTER S and LATIN CAPITAL LETTER S) when converted to uppercase.Only a handful of scripts make a distinction between upper and lowercase. In addition to modern scripts, such as Latin, Greek, Armenian and Cyrillic, a few historic or archaic scripts have case. The vast majority of scripts do not have case distinctions.)Case mapping is not reversible. That is, *toUpper(toLower(x)) != toLower(toUpper(x)).Certain code points (or combinations of code points) apply rules based on the locale. For more information about these exceptional code points, please refer to the Unicode standard: ftp:/ftp.unicode.orgPublicUNIDATASpecialCasing.txtstdio<Convert UTF-8 encoded text to titlecase with default locale.stdio(Convert UTF-8 encoded text to titlecase.This function allows conversion of UTF-8 encoded strings to titlecase. Conversion is fully compliant with the Unicode 7.0 standard.NTitlecase requires a bit more explanation than uppercase and lowercase, because it is not a common text transformation. Titlecase uses uppercase for the first letter of each word and lowercase for the rest. Words are defined as "collections of code points with general category Lu, Ll, Lt, Lm or Lo according to the Unicode database".Effectively, any type of punctuation can break up a word, even if this is not grammatically valid. This happens because the titlecasing algorithm does not and cannot take grammar rules into account. 5Text | Titlecase -------------------------------------|------------------------------------- The running man | The Running Man NATO Alliance | Nato Alliance You're amazing at building libraries | You'Re Amazing At Building Libraries Although most code points can be converted to titlecase without changing length, there are notable exceptions. For example, U+00DF (LATIN SMALL LETTER SHARP S) maps to "U+0053 U+0073" (LATIN CAPITAL LETTER S and LATIN SMALL LETTER S) when converted to titlecase.Certain code points (or combinations of code points) apply rules based on the locale. For more information about these exceptional code points, please refer to the Unicode standard: ftp:/ftp.unicode.orgPublicUNIDATASpecialCasing.txtstdioJCheck if the input string conforms to the category specified by the flags.This function can be used to check if the code points in a string are part of a category. Valid flags are members of the "list of categories". The category for a code point is defined as part of the entry in UnicodeData.txt, the data file for the Unicode code point database.sBy default, the function will treat grapheme clusters as a single code point. This means that the following string: NCode point | Canonical combining class | General category | Name ---------- | ------------------------- | --------------------- | ---------------------- U+0045 | 0 | Lu (Uppercase letter) | LATIN CAPITAL LETTER E U+0300 | 230 | Mn (Non-spacing mark) | COMBINING GRAVE ACCENT Will match with  in its entirety, because the COMBINING GRAVE ACCENT is treated as part of the grapheme cluster. This is useful when e.g. creating a text parser, because you do not have to normalize the text first.+If this is undesired behavior, specify the %UTF8_CATEGORY_IGNORE_GRAPHEME_CLUSTER flag.GIn order to maintain backwards compatibility with POSIX functions like isdigit and isspace , compatibility flags have been provided. Note, however, that the result is only guaranteed to be correct for code points in the Basic Latin range, between U+0000 and 0+007F. Combining a compatibility flag with a regular category flag will result in undefined behavior.stdiooTry to match as many code points with the matching category flags as possible and return the prefix and suffix.tuwxyz{|}~twxyz{|}~uSearching text(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FXstdioO(n) find the first char matching the predicate in a text from left to right, if there isn't one, return the index point to the end of the byte slice.stdioO(n) find the first char matching the predicate in a text from right to left, if there isn't one, return the index point to the end of the byte slice.stdioO(n)" find the index of the byte slice.stdioO(n)3 find the index of the byte slice in reverse order.stdioO(n) h, applied to a predicate and a text, returns a text containing those chars that satisfy the predicate.stdioO(n) The  function takes a predicate, a text, returns a pair of text with codepoints which do and do not satisfy the predicate, respectively; i.e., 7partition p txt == (filter p txt, filter (not . p) txt)stdioO(n) % test if given char is in given text.stdioO(n)  not . elemstdio'(char index, byte index, matching char)  Fast text slice manipulation(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FXk1stdioO(n) [ is analogous to (:) for lists, but of different complexity, as it requires making a copy.stdioO(n)$ Append a char to the end of a text.stdioO(1)- Extract the head and tail of a text, return  + if it is empty.stdioO(1)- Extract the init and last of a text, return  + if text is empty.stdioO(1)" Extract the first char of a text.stdioO(1), Extract the chars after the head of a text.NOTE: 0 return empty text in the case of an empty text.stdioO(1)! Extract the last char of a text.stdioO(1)* Extract the chars before of the last one.NOTE: 0 return empty text in the case of an empty text.stdioO(n)< Return all initial segments of the given text, empty first.stdioO(n)? Return all final segments of the given text, whole text first.stdioO(1)  n, applied to a text xs, returns the prefix of xs of length n, or xs itself if n >  xs.stdioO(1)  n xs returns the suffix of xs after the first n char, or [] if n >  xs.stdioO(1)  n, applied to a text xs, returns the suffix of xs of length n, or xs itself if n >  xs.stdioO(1)  n xs returns the prefix of xs before the last n char, or [] if n >  xs.stdioO(1); Extract a sub-range text with give start index and length.,This function is a total function just like  'take/drop'3, index/length exceeds range will be ingored, e.g. nslice 1 3 "hello" == "ell" slice -1 -1 "hello" == "" slice -2 2 "hello" == "" slice 2 10 "hello" == "llo" This holds for all x y: &slice x y vs == drop x . take (x+y) vsstdioO(n)  n xs is equivalent to ( n xs,  n xs). stdioO(n) Applied to a predicate p and a text t2, returns the longest prefix (possibly empty) of t of elements that satisfy p. stdioO(n) Applied to a predicate p and a text t2, returns the longest suffix (possibly empty) of t of elements that satisfy p. stdioO(n) Applied to a predicate p and a text vs7, returns the suffix (possibly empty) remaining after   p vs. stdioO(n) Applied to a predicate p and a text vs8, returns the prefix (possibly empty) remaining before   p vs. stdioO(n) )dropAround f = dropWhile f . dropWhileR fstdioO(n)s Split the text into the longest prefix of elements that do not satisfy the predicate and the rest without copying.stdioO(n)l Split the text into the longest prefix of elements that satisfy the predicate and the rest without copying.stdio behaves like  but from the end of the text. breakR p == spanR (not.p)stdio behaves like  but from the end of the text.stdiowBreak a text on a subtext, returning a pair of the part of the text prior to the match, and the rest of the text, e.g. 1break "wor" "hello, world" = ("hello, ", "world")stdiovO(n+m) Find all non-overlapping instances of needle in haystack. Each element of the returned list consists of a pair::The entire string prior to the kth match (i.e. the prefix)6The kth match, followed by the remainder of the string Examples: &breakOnAll "::" "" ==> [] breakOnAll "" "abc" ==> [("a", "bc"), ("ab", "c"), ("ab c", "/")] EThe result list is lazy, search is performed when you force the list.stdioOverlapping version of .stdioThe group function takes a text and returns a list of texts such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, group  Mississippi = [M!,"i","ss","i","ss","i","pp","i"] It is a special case of @, which allows the programmer to supply their own equality test.stdioThe + function is the non-overloaded version of .stdioO(n) The & function takes two texts and returns  /J the remainder of the second iff the first is its prefix, and otherwise  +.stdio O(n) The z function takes two texts and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.stdioO(n)[ Break a text into pieces separated by the delimiter element consuming the delimiter. I.e. ~split '\n' "a\nb\nd\ne" == ["a","b","d","e"] split 'a' "aXaXaXa" == ["","X","X","X",""] split 'x' "x" == ["",""]and 9intercalate [c] . split c == id split == splitWith . (==)?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.stdioO(n) Splits a text into components delimited by separators, where the predicate returns True for a separator char. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg. VsplitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == [""]stdioO(m+n)0 Break haystack into pieces separated by needle.JNote: An empty needle will essentially split haystack element by element. Examples:!splitOn "\r\n" "a\r\nb\r\nd\r\ne"["a","b","d","e"] splitOn "aaa" "aaaXaaaXaaaXaaa"["","X","X","X",""]splitOn "x" "x"["",""]and Xintercalate s . splitOn s == id splitOn (singleton c) == split (==c)stdioThe isPrefix function returns  11 if the first argument is a prefix of the second.stdioO(n) The % function takes two text and returns  1) if the first is a suffix of the second.stdio/Check whether one text is a subtext of another.needle < haystack === null haystack || indices needle haystake /= [].stdioO(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match. e.g.commonPrefix "foobar" "fooquux"("foo","bar","quux")commonPrefix "veeble" "fetzer"("","veeble","fetzer") stdioO(n) Breaks a Bytes5 up into a list of words, delimited by unicode space.!stdioO(n); Breaks a text up into a list of lines, delimited by ascii n."stdioO(n) Joins words with ascii space.#stdioO(n) Joins lines with ascii n.$stdioFAdd padding to the left so that the whole text's length is at least n.%stdioGAdd padding to the right so that the whole text's length is at least n.&stdioO(n) The &G function takes a character and places it between the characters of a 0. Performs replacement on invalid scalar values.'stdioO(n)$ Reverse the characters of a string.(stdioO(n) The ( function takes a  and a list of es and concatenates the list after interspersing the first argument between each element of the list.*stdioThe *@ function transposes the rows and columns of its text argument.stdioneedle to search forstdiohaystack in which to search2      !"#$%&'()*2      !"#$%'&()*:Unicode text processing(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2Fg\uwxyz{|}~      !"#$%&'()*      !"#$%'&()*wxyz{|}~uEfficient serialization/format.;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone=>?FHSVXk="+stdioBuilder is a monad to help compose  BuilderStep . With next  BuilderStepg continuation, we can do interesting things like perform some action, or interleave the build process. Notes on  instance:  Builder ()'s  instance use 5, which is different from H/ in that it DOES NOT PROVIDE UTF8 GUARANTEES! :NUL will be written as xC0 x80.xD800 ~ xDFFF; will be encoded in three bytes as normal UTF-8 codepoints..stdio BuilderStep7 is a function that fill buffer under given conditions./stdioHelper type to help ghc unpack1stdio1 will decide how each ., proceed when previous buffer is not enough.5stdioVEncode string with modified UTF-8 encoding, will be rewritten to a memcpy if possible.6stdioTurn  * into + with Modified UTF8 encoding'\NUL' is encoded as two bytes C0 80 , '\xD800' ~ '\xDFFF'4 is encoded as a three bytes normal UTF-8 codepoint.8stdioWrite a .9stdioEnsure that there are at least n many elements available.=stdio shortcut to > $.>stdiorun Builder with 27 strategy, which is suitable for building short bytes.?stdio shortcut to @ !.@stdiorun Builder with 3= strategy, which is suitable for building lazy bytes chunks.Astdio shortcut to B !.Bstdiorun Builder with 4? strategy, which is suitable for doing effects while building.Estdio)write primitive types in host byte order.Fstdio,write primitive types with little endianess.Gstdio)write primitive types with big endianess.HstdioTurn  into + with UTF8 encoding&Illegal codepoints will be written as ts.ZNote, if you're trying to write string literals builders, and you know it doen't contain '\NUL'+ or surrgate codepoints, then you can open OverloadedStrings and use Builder's 1 instance, it can save an extra UTF-8 validation.oThis function will be rewritten into a memcpy if possible, (running a fast UTF-8 validation at runtime first).IstdioTurn  * into + with UTF8 encoding&Illegal codepoints will be written as ts.JstdioTurn  into + with ASCII7 encodingCodepoints beyond '\x7F' will be chopped.KstdioTurn  * into + with ASCII7 encodingCodepoints beyond '\x7F' will be chopped.LstdioTurn  into + with ASCII8 encodingCodepoints beyond '\xFF' will be chopped. Note, this encoding is NOT compatible with UTF8 encoding, i.e. bytes written by this builder may not be legal UTF8 encoding bytes.MstdioTurn  * into + with ASCII8 encodingCodepoints beyond '\xFF' will be chopped. Note, this encoding is NOT compatible with UTF8 encoding, i.e. bytes written by this builder may not be legal UTF8 encoding bytes.NstdioWrite UTF8 encoded Text using +.GNote, if you're trying to write string literals builders, please open OverloadedStrings and use +s / instance, it will be rewritten into a memcpy.Ostdioadd {...} to original builder.Pstdioadd {...} to original builder.Qstdioadd [...] to original builder.Rstdioadd  ... to original builder.Sstdioadd "..." to original builder.Tstdioadd ... to original builder.Ustdiowrite an ASCII :Vstdiowrite an ASCII ,Wstdio.Use separator to connect a vector of builders.Xstdio*Use separator to connect list of builders.0stdiothe buffer contentstdiowriting offsetCstdio size boundstdio2the writer which pure a new offset for next writeDstdio size boundstdio2the writer which pure a new offset for next writeWstdio the seperatorstdiovalue formatterstdio value vectorXstdio the seperatorstdiovalue formatterstdio value list.+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX.1234/0.+,-7=>?@AB89CD:;<EFG56HIJKLMNOPQRSTUVWXTextual numeric builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone  FHSVXibstdio0Control the rendering of floating point numbers.cstdioScientific notation (e.g. 2.3e123).dstdioStandard decimal notation.estdio(Use decimal notation for values between 0.1 and  9,999,999$, and scientific notation otherwise.kstdioIntegral formatting options.mstdio0total width, only effective with padding optionsnstdiopadding optionsostdioshow + when the number is positivepstdio *defaultIFormat = IFormat 0 NoPadding Falseqstdio int = intWith defaultIFormatrstdio Format a   type like Int or Word16 into decimal ASCII digits.sstdioLInternal formatting backed by C FFI, it must be used with type smaller than .WWe use rewrite rules to rewrite most of the integral types formatting to this function.tstdioNInternal formatting in haskell, it can be used with any bounded integral type.vOther than provide fallback for the c version, this function is also used to check the c version's formatting result.ustdio Format a  into decimal ASCII digits.vstdio-Count how many decimal digits an integer has.wstdioDecimal digit to ASCII digit.stdioDecimal digit to ASCII char.xstdio Hexadecimal digit to ASCII char.ystdio+Hexadecimal digit to UPPERCASED ASCII char.zstdio Format a   type into hex nibbles.{stdioThe UPPERCASED version of z.|stdioDecimal encoding of an IEEE .QUsing standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise.}stdioDecimal encoding of an IEEE .QUsing standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise.~stdioAFormat single-precision float using drisu3 with dragon4 fallback.stdioAFormat double-precision float using drisu3 with dragon4 fallback.stdio!Worker function to do formatting.stdioDecimal encoding of a ;, note grisu only handles strictly positive finite numbers.stdioDecimal encoding of a ?, note grisu3_sp only handles strictly positive finite numbers.stdioA Builder which renders a scientific number to full precision, using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999%, and scientific notation otherwise.stdioLike  but provides rendering options.stdiochar*stdioIntstdioIntstdiochar*stdioIntstdioIntstdio The bufferstdiowriting offsetstdio total digitsstdio the value~stdio#Number of decimal places to render.stdio#Number of decimal places to render.stdio#Number of decimal places to render.stdioList of digits and exponentstdio#Number of decimal places to render."bedcfgjhiklmnopqrstuvwxyz{|}~"klmnopfgjhiqruz{bedc}|~wxyvst;Efficient serialization/format.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone =>?FSXm<+56789=>?@ABCDEFGHIJKLMNOPQRSTUVWXbedcfgjhiklmnopqruz{|}~<+7=>?@AB89CDEFG56HIJKLMNklmnopfgjhiqruz{bedc}|~OPQRSTUVWXUTF8 compatible builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone.12789;=>?HMUVj'stdioA class similar to =, serving the purpose that quickly convert a data type to a  value.stdioNewtype wrapper for [Char] to provide textual instances.To encourage using h as the textual representation, we didn't provide special treatment to differentiate instances between [a] and [Char]O in various places. This newtype is therefore to provide instances similar to T.Text%, in case you really need to wrap a .stdioRBuidlers which guarantee UTF-8 encoding, thus can be used to build text directly. Notes on # instance: It's recommended to use z instance, there's a rewrite rule to turn encoding loop into a memcpy, which is much faster (the same rule also apply to ). Different from  Builder (), TextBuilder ()'s 0 instance will give you desired UTF8 guarantees:NUL will be written directly as x00.xD800 ~ xDFFF& will be replaced by replacement char.stdioBuild a  using ), which provide UTF-8 encoding guarantee.stdioUnsafely turn a + into S, thus it's user's responsibility to ensure only UTF-8 complied bytes are written.stdioTurn  into  with UTF8 encoding&Illegal codepoints will be written as <=qs. This function will be rewritten into a memcpy if possible, (running a fast UTF-8 validation at runtime first).stdioTurn  * into  with UTF8 encoding&Illegal codepoints will be written as <=s.stdioTurn  into  with ASCII7 encodingCodepoints beyond '\x7F' will be chopped.stdioTurn  * into  with ASCII7 encodingCodepoints beyond '\x7F' will be chopped.stdioWrite UTF8 encoded  using Builder.GNote, if you're trying to write string literals builders, please open OverloadedStrings and use Builders / instance, it will be rewritten into a memcpy.stdio int = intWith defaultIFormatstdio Format a   type like Int or Word16 into decimal ascii digits.stdio Format a  into decimal ascii digits.stdio Format a   type into hex nibbles.stdioThe UPPERCASED version of .stdioDecimal encoding of an IEEE .QUsing standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise.stdioAFormat single-precision float using drisu3 with dragon4 fallback.stdioDecimal encoding of an IEEE .QUsing standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise.stdioAFormat double-precision float using drisu3 with dragon4 fallback.stdioA Builder which renders a scientific number to full precision, using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999%, and scientific notation otherwise.stdioLike  but provides rendering options.stdioadd (...) to original builder.stdioHAdd "(..)" around builders when condition is met, otherwise add nothing.This is useful when defining  instances.stdioadd {...} to original builder.stdioadd [...] to original builder.stdioadd  ... to original builder.stdioadd "..." to original builder.stdioadd ... to original builder.stdiowrite an ASCII :stdiowrite an ASCII ,stdio.Use separator to connect a vector of builders.stdio,Use separator to connect a list of builders.stdioDirectly convert data to .stdioDirectly convert data to +.stdioDirectly convert data to .stdioFaster  replacement.stdio.Constructor without payload, convert to StringstdioTo keep sync with P instance's escaping rule, we reuse show here, so it won't be as fast as memcpy.stdioConstructor with payloadsstdio#Number of decimal places to render.stdio#Number of decimal places to render.stdio#Number of decimal places to render.stdio the seperatorstdiovalue formatterstdio value liststdio the seperatorstdiovalue formatterstdio value vector7bedcfgjhiklmnop7klmnopfgjhibedcFast map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone%2>HMPVXgR stdiohMapping values of within a set, the result size may change if there're duplicated values after mapping. stdioO(1) empty flat map. stdio O(N*logN)= Pack list of key values, on key duplication prefer left one. stdio O(N*logN)Q Pack list of key values with suggested size, on key duplication prefer left one. stdio O(N*logN)> Pack list of key values, on key duplication prefer right one.stdio O(N*logN)R Pack list of key values with suggested size, on key duplication prefer right one.stdioO(N)7 Unpack a set of values to a list s in ascending order.This function works with  foldr/build fusion in base.stdioO(N)8 Unpack a set of values to a list s in descending order.This function works with  foldr/build fusion in base.stdio O(N*logN)? Pack vector of key values, on key duplication prefer left one.stdio O(N*logN)@ Pack vector of key values, on key duplication prefer right one.stdioO(logN) Binary search on flat map.stdioO(N)> Insert new key value into map, replace old one if key exists.stdioO(N) Delete a key value pair by key.stdioO(n+m) Merge two *, prefer right value on value duplication.stdio?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.          Fast map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone %2>HPVXg(stdioO(1) empty flat map.)stdio O(N*logN)= Pack list of key values, on key duplication prefer left one.*stdio O(N*logN)Q Pack list of key values with suggested size, on key duplication prefer left one.+stdio O(N*logN)> Pack list of key values, on key duplication prefer right one.,stdio O(N*logN)R Pack list of key values with suggested size, on key duplication prefer right one.-stdioO(N)D Unpack key value pairs to a list sorted by keys in ascending order.This function works with  foldr/build fusion in base..stdioO(N)E Unpack key value pairs to a list sorted by keys in descending order.This function works with  foldr/build fusion in base./stdio O(N*logN)? Pack vector of key values, on key duplication prefer left one.0stdio O(N*logN)@ Pack vector of key values, on key duplication prefer right one.1stdioO(logN) Binary search on flat map.2stdioO(N)> Insert new key value into map, replace old one if key exists.3stdioO(N) Delete a key value pair by key.4stdioO(N) Modify a value by key.7The value is evaluated to WHNF before writing into map.5stdioO(n+m) Merge two "(, prefer right value on key duplication.6stdioO(n+m) Merge two " with a merge function.7stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order.8stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).'During folding k is in ascending order.9stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order.:stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).'During folding k is in ascending order.;stdioO(n). ; f s == )  $  ((k, v) -> (,) k  $ f k v) (- m)* That is, behaves exactly like a regular Y except that the traversing function also has access to the key associated with a value.<stdio?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.=stdioElinear scan search from left to right, return the first one if exist.>stdioElinear scan search from right to left, return the first one if exist."#$%&'()*+,-./0123456789:;<=>"#$%(&')*+,-./0132456798:;<=>Fast map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone %2>HMPVgOstdiohMapping values of within a set, the result size may change if there're duplicated values after mapping.PstdioO(1) empty flat map.Qstdio O(N*logN)= Pack list of key values, on key duplication prefer left one.Rstdio O(N*logN)Q Pack list of key values with suggested size, on key duplication prefer left one.Sstdio O(N*logN)> Pack list of key values, on key duplication prefer right one.Tstdio O(N*logN)R Pack list of key values with suggested size, on key duplication prefer right one.UstdioO(N)7 Unpack a set of values to a list s in ascending order.This function works with  foldr/build fusion in base.VstdioO(N)8 Unpack a set of values to a list s in descending order.This function works with  foldr/build fusion in base.Wstdio O(N*logN)? Pack vector of key values, on key duplication prefer left one.Xstdio O(N*logN)@ Pack vector of key values, on key duplication prefer right one.YstdioO(logN) Binary search on flat map.ZstdioO(N)> Insert new key value into map, replace old one if key exists.[stdioO(N) Delete a key value pair by key.\stdioO(n+m) Merge two K*, prefer right value on value duplication.]stdio?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.KLMNOPQRSTUVWXYZ[\]KLMNPOQRSTUVWXY[Z\] Fast map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone %2>HVXg3jmstdioO(1) empty flat map.nstdio O(N*logN)= Pack list of key values, on key duplication prefer left one.ostdio O(N*logN)Q Pack list of key values with suggested size, on key duplication prefer left one.pstdio O(N*logN)> Pack list of key values, on key duplication prefer right one.qstdio O(N*logN)R Pack list of key values with suggested size, on key duplication prefer right one.rstdioO(N)D Unpack key value pairs to a list sorted by keys in ascending order.This function works with  foldr/build fusion in base.sstdioO(N)E Unpack key value pairs to a list sorted by keys in descending order.This function works with  foldr/build fusion in base.tstdio O(N*logN)? Pack vector of key values, on key duplication prefer left one.ustdio O(N*logN)@ Pack vector of key values, on key duplication prefer right one.vstdioO(logN) Binary search on flat map.wstdioO(N)> Insert new key value into map, replace old one if key exists.xstdioO(N) Delete a key value pair by key.ystdioO(N) Modify a value by key.7The value is evaluated to WHNF before writing into map.zstdioO(n+m) Merge two g(, prefer right value on key duplication.{stdioO(n+m) Merge two g with a merge function.|stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order.}stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).)During folding Int is in ascending order.~stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).*During folding Int is in descending order.stdioO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).)During folding Int is in ascending order.stdioO(n).  f s == n  $  ((k, v) -> (,) k  $ f k v) (r m)* That is, behaves exactly like a regular Y except that the traversing function also has access to the key associated with a value.stdio?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.stdioElinear scan search from left to right, return the first one if exist.stdioElinear scan search from right to left, return the first one if exist.ghijklmnopqrstuvwxyz{|}~ghijmklnopqrstuvxwyz{|~}! Efficient deserialization/parse.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone 2>FSXy#stdioSimple CPSed parserqA parser takes a failure continuation, and a success one, while the success continuation is usually composed by R instance, the failure one is more like a reader part, which can be modified via D. If you build parsers from ground, a pattern like this can be used:  xxParser = do ensureN errMsg ... -- make sure we have some bytes Parser $ kf k inp -> -- fail continuation, success continuation and input ... ... kf errMsg (if input not OK) ... k ... (if we get something useful for next parser) stdioType alias for error messagestdioA parse step consumes  and produce .stdio3Simple parsing result, that represent respectively:9Success: the remaining unparsed data and the parsed value:Failure: the remaining unparsed data and the error messageGPartial: that need for more input data, supply empty bytes to indicate stdio version of .stdio-Parse the complete input, without resupplyingstdioDParse the complete input, without resupplying, return the rest bytesstdioParse an input chunkstdio:Finish parsing and fetch result, feed empty bytes if it's  result.stdiofRun a parser with an initial input string, and a monadic action that can supply more input if needed.dNote, once the monadic action return empty bytes, parsers will stop drawing more bytes (take it as ).stdiovRun a parser and keep track of all the input chunks it consumes. Once it's finished, return the final result (always  or ) and all consumed chunks.stdiolReturn both the result of a parse and the portion of the input that was consumed while it was being parsed.stdioEnsure that there are at least n< bytes available. If not, the computation will escape with .nSince this parser is used in many other parsers, an extra error param is provide to attach custom error info.stdiodTest whether all input has been consumed, i.e. there are no remaining undecoded bytes. Fail if not .stdioWTest whether all input has been consumed, i.e. there are no remaining undecoded bytes.stdioA stateful scanner. The predicate consumes and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each byte of the input until one returns  + or the input ends.UThis parser does not fail. It will return an empty string if the predicate returns  + on the first byte of input.stdio Similar to , but working on # chunks, The predicate consumes a  chunk and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each chunk of the input until one chunk got splited to Right (V.Bytes, V.Bytes) or the input ends.stdio.Match any byte, to perform lookahead. Returns  +? if end of input has been reached. Does not consume any input.stdiosMatch any byte, to perform lookahead. Does not consume any input, but will fail if end of input has been reached.stdio The parser  satisfy p0 succeeds for any byte for which the predicate p returns  1,. Returns the byte that is actually parsed. @digit = satisfy isDigit where isDigit w = w >= 48 && w <= 57stdio The parser satisfyWith f p3 transforms a byte, and succeeds if the predicate p returns  1T on the transformed value. The parser returns the transformed byte that was parsed.stdioMatch a specific byte.stdioMatch a specific 8bit char.stdio#Match either a single newline byte '\n'3, or a carriage return followed by a newline byte "\r\n".stdio N bytes.stdio Skip a byte.stdio5Skip past input for as long as the predicate returns  1.stdioSkip over white space using .stdio .isSpace w = w == 32 || w - 9 <= 4 || w == 0xA0stdio/Consume input as long as the predicate returns ; or reach the end of input, and return the consumed input.stdio/Consume input as long as the predicate returns  1; or reach the end of input, and return the consumed input.stdio Similar to t, but requires the predicate to succeed on at least one byte of input: it will fail if the predicate never returns  1 or reach the end of inputstdiobytes s3 parses a sequence of bytes that identically match s.stdioSame as  but ignoring case.stdiotext s8 parses a sequence of UTF8 bytes that identically match s.,,0"Textual numeric parsers.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNonek_stdio:Parse and decode an unsigned hex number. The hex digits 'a' through 'f' may be upper or lower case.&This parser does not accept a leading "0x"n string, and consider sign bit part of the binary hex nibbles, i.e. 'parse hex "0xFF" == Right (-1 :: Int8)'stdio+decode hex digits sequence within an array.stdioA fast digit predicate.stdio,Parse and decode an unsigned decimal number.stdio'decode digits sequence within an array.stdio'decode digits sequence within an array.A fast version to decode ( using machine word as much as possible.stdioA fast digit predicate.stdio0Parse a decimal number with an optional leading '+' or '-' sign character.stdioParse a rational number.6The syntax accepted by this parser is the same as for .Notey: this parser is not safe for use with inputs from untrusted sources. An input with a suitably large exponent such as "1e1000000000" will cause a huge O to be allocated, resulting in what is effectively a denial-of-service attack.#In most cases, it is better to use  or  instead.stdio%Parse a rational number and round to .This parser accepts an optional leading sign character, followed by at least one decimal digit. The syntax similar to that accepted by the . function, with the exception that a trailing '.' or 'e' not& followed by a number is not consumed.%Examples with behaviour identical to : parse_ double "3" == ("", Right 3.0) parse_ double "3.1" == ("", Right 3.1) parse_ double "3e4" == ("", Right 30000.0) parse_ double "3.1e4" == ("", Right 31000.0) cparse_ double ".3" == (".3", Left ParserError) parse_ double "e3" == ("e3", Left ParserError)Examples of differences from : parse_ double "3.foo" == (".foo", Right 3.0) parse_ double "3e" == ("e", Right 3.0) parse_ double "-3e" == ("e", Right -3.0)MThis function does not accept string representations of "NaN" or "Infinity".stdio%Parse a rational number and round to .Single precision version of .stdioParse a scientific number.6The syntax accepted by this parser is the same as for .stdioMParse a scientific number and convert to result using a user supply function.6The syntax accepted by this parser is the same as for . stdioStrip message version.stdioParse a rational number.6The syntax accepted by this parser is the same as for .Notey: this parser is not safe for use with inputs from untrusted sources. An input with a suitably large exponent such as "1e1000000000" will cause a huge O to be allocated, resulting in what is effectively a denial-of-service attack.#In most cases, it is better to use  or  instead.stdio$More strict number parsing(rfc8259). support parse 2314. and  21321exyz without eating extra dot or e via backtrack, this is not allowed in some strict grammer such as JSON, so we make an non-backtrack strict number parser separately using LL(1) lookahead. This parser also agree with  on extra dot or e handling: Qparse_ double "3.foo" == Left ParseError parse_ double "3e" == Left ParseErrorLeading zeros or + sign is also not allowed: Pparse_ double "+3.14" == Left ParseError parse_ double "0014" == Left ParseErrorQIf you have a similar grammer, you can use this parser to save considerable time.  number = [ minus ] int [ frac ] [ exp ] decimal-point = %x2E ; . digit1-9 = %x31-39 ; 1-9 e = %x65 / %x45 ; e E exp = e [ minus / plus ] 1*DIGIT frac = decimal-point 1*DIGIT ZThis function does not accept string representations of "NaN" or "Infinity". reference: -https://tools.ietf.org/html/rfc8259#section-6stdio%Parse a rational number and round to  using stricter grammer.Single precision version of .stdioParse a scientific number.6The syntax accepted by this parser is the same as for .stdioMParse a scientific number and convert to result using a user supply function.6The syntax accepted by this parser is the same as for . stdio)Strip message version of scientifically'.stdio!accumulator, usually start from 0stdio!accumulator, usually start from 0> Efficient deserialization/parse.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FSX88#Buffered IO interface(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone"#2_stdio+Output device with buffer, NOT THREAD SAFE!stdio*Input device with buffer, NOT THREAD SAFE!stdio Output deviceLaws:  should not return until all data are written (may not necessarily flushed to hardware, that should be done in device specific way).stdio Input deviceLaws:  should return 0 on EOF.Note: ' is considered not thread-safe, e.g. A ( device can only be used with a single , If multiple  s are opened on a same ) device, the behaviour will be undefined.stdioRequest bytes from .$The buffering logic is quite simple:If we have pushed back bytes, directly return it, otherwise we read using buffer size. If we read N bytes, and N is larger than half of the buffer size, then we freeze buffer and return, otherwise we copy buffer into result and reuse buffer afterward.stdioRead exactly N bytes&If EOF reached before N bytes read, a  will be thrownstdioRead all chunks from a .stdioRead all chunks from a , and concat chunks together.stdioPush bytes back into bufferstdioRead buffer and parse with Parser.stdioRead until reach a magic bytesGIf EOF is reached before meet a magic byte, partial bytes are returned.stdioRead until reach a magic bytes.If EOF is reached before meet a magic byte, a  will be thrown.stdioRead to a linefeed ('\n' or '\r\n' ), return Bytes before it.EIf EOF is reached before meet a magic byte, partial line is returned.stdioRead to a linefeed ('\n' or '\r\n' ), return Bytes before it.If EOF reached before meet a '\n', a  will be thrown.stdioWrite  into buffered handle.Copy J to buffer if it can hold, otherwise write both buffer(if not empty) and .stdioWrite  into buffered handle.Copy J to buffer if it can hold, otherwise write both buffer(if not empty) and .stdioFlush the buffer(if not empty).stdioInput buffer sizestdioOutput buffer size!"!"$JSON representation and parsers(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone 279F stdio,A JSON value represented as a Haskell value.The Object's payload is a key-value vector instead of a map, which parsed directly from JSON document. This design choice has following advantages:4Allow different strategies handling duplicated keys.Allow different Map" type to do further parsing, e.g. 5?8Roundtrip without touching the original key-value order.ySave time if constructing map is not neccessary, e.g. using a linear scan to find a key if only that key is needed.stdioParse " without consuming trailing bytes.stdioParse Y, and consume all trailing JSON white spaces, if there're bytes left, parsing will fail.stdioIncreamental parse " without consuming trailing bytes.stdioIncreamental parse X and consume all trailing JSON white spaces, if there're bytes left, parsing will fail.stdioXThe only valid whitespace in a JSON document is space, newline, carriage pure, and tab.stdioJSON  parser.stdio"parse json array with leading 91 . stdio%parse json array without leading 91 .stdio#parse json array with leading 123 . stdio'parse json object without leading 123 .% JSON representation and builders(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone 27FkqstdioUse :Y as separator to connect a label(no need to escape, only add quotes) with field builders.stdioUse :M as separator to connect a label(escaped and add quotes) with field builders. stdio Encode a !, you can use this function with toValue to get  encodeJSON with a small overhead.stdioCEscape text into JSON string and add double quotes, escaping rules:  '\b': "\b" '\f': "\f" '\n': "\n" '\r': "\r" '\t': "\t" '"': "\"" '\': "\\" '/': "\/" other chars <= 0x1F: "\u00XX"           &'Fast JSON serialization/deserialization(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone.12789;=>?@AFHMSUVXkq`96+stdio!Typeclass for converting to JSON .-stdioGeneric encode/decode SettingszThere should be no control charactors in formatted texts since we don't escaping those field names or constructor names ([2 relys on Haskell's lexical property). Otherwise !! will output illegal JSON string./stdioformat field labels0stdioformat constructor names.1stdio1 for convert result from JSON ..This is intended to be named differently from  to clear confusions.5stdioJElements of a (JSON) Value path used to describe the location of an error.6stdio4Path element of a key into an object, "object.key".7stdio8Path element of an index into an array, "array[index]".8stdio path of a embedded (JSON) String:stdio=Decode a JSON doc, only trailing JSON whitespace are allowed.;stdio/Decode a JSON bytes, return any trailing bytes.<stdio.Decode JSON doc chunks, return trailing bytes.=stdiocDecode JSON doc chunks, consuming trailing JSON whitespaces (other trailing bytes are not allowed).>stdio#Directly encode data to JSON bytes.?stdio Text version >.@stdioEJSON Docs are guaranteed to be valid UTF-8 texts, so we provide this.AstdioRun a 1 with input value.BstdioRun a 1 with input value.Cstdio version of .DstdioProduce an error message like 4converting XXX failed, expected XXX, encountered XXX.Estdio$Add JSON Path context to a converterWhen converting a complex structure, it helps to annotate (sub)converters with context, so that if an error occurs, you can find its location. jwithFlatMapR "Person" $ \o -> Person <$> o .: "name" <?> Key "name" <*> o .: "age" <?> Key "age"/(Standard methods like '(.:)' already do this.)\With such annotations, if an error occurs, you will get a JSON Path location of that error.FstdioXAdd context to a failure message, indicating the name of the structure being converted. fprependContext "MyType" (fail "[error message]") -- Error: "converting MyType failed, [error message]"IstdioI name f value applies f to the   number when value is a @A and fails using D otherwise.WarningH: If you are converting from a scientific to an unbounded type such as E you may want to add a restriction on the size of the exponent (see KN) to prevent malicious input from filling up the memory of the target system.Error message example wwithScientific "MyType" f (String "oops") -- Error: "converting MyType failed, expected Number, but encountered String"Jstdio@J5 try to convert floating number with following rules:Use  Infinity# to represent out of range numbers.Convert Null as NaNKstdioK name f value applies f to the   number when value is a * with exponent less than or equal to 1024.LstdioK name f value applies f to the   number when value is a  and value is within minBound ~ maxBound.Ostdio Directly use & as key-values for further converting.PstdioTake a F as an 'FM.FlatMap T.Text Value', on key duplication prefer first one.QstdioTake a E as an 'FM.FlatMap T.Text Value', on key duplication prefer last one.RstdioTake a F as an 'HM.HashMap T.Text Value', on key duplication prefer first one.SstdioTake a E as an 'HM.HashMap T.Text Value', on key duplication prefer last one.Tstdio$Decode a nested JSON-encoded string.Ustdio7Retrieve the value associated with the given key of an . The result is Q if the key is not present or the value cannot be converted to the desired type.2This accessor is appropriate if the key and value mustW be present in an object for it to be valid. If the key and value are optional, use V instead.Vstdio7Retrieve the value associated with the given key of an . The result is  +. if the key is not present or if its value is , or 6 if the value cannot be converted to the desired type.This accessor is most useful if the key and value can be absent from an object without affecting its validity. If the key and value are mandatory, use U instead.Wstdio7Retrieve the value associated with the given key of an . The result is  + if the key is not present or 7 if the value cannot be converted to the desired type.This differs from V by attempting to convert B the same as any other JSON value, instead of interpreting it as  +.Ystdio Variant of V" with explicit converter function.Zstdio Variant of W" with explicit converter function.stdioUse ,* as separator to connect list of builders.stdioUse ,. as separator to connect a vector of builders.stdio"Constructor with multiple payloadsstdio!Constructor with a single payloadstdio.Constructor without payload, convert to Stringstdio"Constructor with multiple payloadsstdio!Constructor with a single payloadstdio.Constructor without payload, convert to StringstdioThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype Fixed and provide your own instance using I$ if you want to allow larger inputs.stdioThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype Ratio and provide your own instance using I$ if you want to allow larger inputs.stdioThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype Scientific and provide your own instance using I$ if you want to allow larger inputs.stdio!default instance prefer later keystdio!default instance prefer later keystdioUse  as Proxy astdio"Constructor with multiple payloadsstdio!Constructor with a single payloadstdio.Constructor without payload, convert to StringDstdio/The name of the type you are trying to convert.stdio*The JSON value type you expecting to meet.stdioThe actual value encountered.Tstdiodata type namestdio/a inner converter which will get the converted .Xstdio4the field converter (value part of a key value pair)X !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[X9;:<=>?@AB123CEF56784DGHIKJLMNOPQRSTUVWXYZ[-./0+,)* !(&'$%"#E9 ''Fast JSON serialization/deserialization(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNoneiIEstdioSnake casing a pascal cased constructor name or camel cased field name, words are always lower cased and separated by an underscore.FstdioTrain casing a pascal cased constructor name or camel cased field name, words are always lower cased and separated by a hyphen.E !*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[EFE9;:<=>?@AB123CEF56784DGHIKJLMNOPQRSTUVWXYZ+, ![-./0EF*(Null-ternimated byte string.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone FSX GstdiotA efficient wrapper for immutable null-terminated string which can be automatically freed by ghc garbage collector.stdioOn heap pinned vk there's an invariance that this array's length is always shrinked to contain content and NUL terminatorstdio#String literals with static addressHstdio Create a G with IO action.LUser only have to do content initialization and return the content length, H% takes the responsibility to add the '\NUL' ternimator.LstdioPack a  into null-terminated G.'\NUL' is encoded as two bytes C0 80 , '\xD800' ~ '\xDFFF'4 is encoded as a three bytes normal UTF-8 codepoint.PstdioO(1), (O(n)! in case of literal), convert to 0, which can be processed by vector combinators. NOTE: the '\NUL' ternimator is not included.QstdioO(n), convert from &, allocate pinned memory and add the '\NUL' ternimatorRstdioO(n), convert from &, allocate pinned memory and add the '\NUL' ternimatorSstdioCopy a  type into a G(, return Nothing if the pointer is NULL.&After copying you're free to free the  's memory.Tstdio Same with S , but throw 0 when meet a null pointer.Ustdio Same with T?, but only take N bytes (and append a null byte as terminator).VstdioPass G to foreign function as a  const char*.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Hstdiocapacity n, including the '\NUL' terminatorstdioGinitialization function, write the pointer, return the length (<= n-1)GHIJKLMNOPQRSTUVGHLMNOJIKPQRSTUV)TCP/UDP socket address API(c) Winterland, 2018BSDdrkoster@qq.com experimental non-portableNone2gSfstdioUse the Num! instance (i.e. use a literal or ) to create a  PortNumber. value with the correct network-byte-ordering.1 :: PortNumber1read "1" :: PortNumber1gstdio'Independent of endianness. For example ::1 is stored as  (0, 0, 0, 1).For direct manipulation prefer  and .hstdio'Independent of endianness. For example  127.0.0.1 is stored as (127, 0, 0, 1).For direct manipulation prefer  and .kstdio&IPv4 or IPv6 socket address, i.e. the  sockaddr_in or  sockaddr_in6 struct.ystdioInternet Protocol version 6zstdiointernetwork: UDP, TCP, etc{stdio unspecified}stdio 0.0.0.0~stdio 255.255.255.255stdio 255.255.255.255stdio  127.0.0.1stdio  224.0.0.0stdio  224.0.0.1stdio  224.0.0.255stdio Converts  HostAddress@ to representation-independent IPv4 quadruple. For example for  127.0.0.1 the function will return (127, 0, 0, 1) regardless of host endianness.stdioConverts IPv4 quadruple to  HostAddress.stdio ::stdio ::1.`abcdefghijklmnopqrstuvwxyz{|}~.klm|h}~gjifpqonde{zybcwxtvu`asr*+Simple binary serialization/deserialization(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone 8=>?HUVX_kstdio$LEON, Little Endian Object Notation.stdioSince: 0.8.4.0stdioSince: 0.8.0.0stdioSince: 0.7.6.0  +libuv operations(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableNone  7FHMVg](stdioFlags control copying.: If present, uv_fs_copyfile() will fail with UV_EEXIST if the destination path already exists. The default behavior is to overwrite the destination if it exists.: If present, uv_fs_copyfile() will attempt to create a copy-on-write reflink. If the underlying platform does not support copy-on-write, then a fallback copy mechanism is used.8stdioTerminal mode.When in  mode, input is always available character-by-character, not including modifiers. Additionally, all special processing of characters by the terminal is disabled, including echoing input characters. Note that CTRL+C will no longer cause a SIGINT when in this mode.Dstdio.UVSlotUnSafe wrap a slot which may not have a MVarC in blocking table, i.e. the blocking table need to be resized.stdiouv_run with safe FFI.stdiouv_run with usafe FFI.stdio$Open the file for write-only access.stdioIf the file exists and is a regular file, and the file is opened successfully for write access, its length shall be truncated to zero.stdioDThe file is temporary and should not be flushed to disk if possible.Note  o_TEMPORARY" is only supported on Windows via FILE_ATTRIBUTE_TEMPORARY.stdioyThe file is opened for synchronous IO. Write operations will complete once all data and all metadata are flushed to disk.Note o_SYNC is supported on Windows via FILE_FLAG_WRITE_THROUGH.stdioDOpen the symbolic link itself rather than the resource it points to.stdioDThe file is temporary and should not be flushed to disk if possible.Note  o_SHORT_LIVED" is only supported on Windows via FILE_ATTRIBUTE_TEMPORARY.stdiovAccess is intended to be sequential from beginning to end. The system can use this as a hint to optimize file caching.Note  o_SEQUENTIAL" is only supported on Windows via FILE_FLAG_SEQUENTIAL_SCAN.stdio$Open the file for read-write access.stdio#Open the file for read-only access.stdio\Access is intended to be random. The system can use this as a hint to optimize file caching.Note o_RANDOM" is only supported on Windows via FILE_FLAG_RANDOM_ACCESS.stdioQOpen the file in nonblocking mode if possible. (Definitely not useful with stdio)Note  o_NONBLOCKA is not supported on Windows. (Not useful on regular file anyway)stdio.If the path is a symbolic link, fail the open.Note  o_NOFOLLOW is not supported on Windows.stdioIf the path identifies a terminal device, opening the path will not cause that terminal to become the controlling terminal for the process (if the process does not already have one). (Not sure if this flag is useful)Note o_NOCTTY is not supported on Windows.stdio9Do not update the file access time when the file is read.Note  o_NOATIME is not supported on Windows.stdio$Atomically obtain an exclusive lock.~Note UV_FS_O_EXLOCK is only supported on macOS and Windows. (libuv: Changed in version 1.17.0: support is added for Windows.)stdioIf the o_CREAT8 flag is set and the file already exists, fail the open.!Note In general, the behavior of o_EXCL$ is undefined if it is used without o_CREAT4. There is one exception: on Linux 2.6 and later, o_EXCL can be used without o_CREAT if pathname refers to a block device. If the block device is in use by the system (e.g., mounted), the open will fail with the error EBUSY.stdioThe file is opened for synchronous IO. Write operations will complete once all data and a minimum of metadata are flushed to disk.Note o_DSYNC is supported on Windows via FILE_FLAG_WRITE_THROUGH.stdioKIf the path is not a directory, fail the open. (Not useful on regular file)Note  o_DIRECTORY is not supported on Windows.stdioFile IO is done directly to and from user-space buffers, which must be aligned. Buffer size and address should be a multiple of the physical sector size of the block device, (DO NOT USE WITH stdio's  BufferedIO)stdio1The file is created if it does not already exist.stdiokThe file is opened in append mode. Before each write, the file offset is positioned at the end of the file.stdio4Default mode for open, 0o666(readable and writable).stdio$00001 others have execute permissionstdio"00002 others have write permissionstdio!00004 others have read permissionstdio400007 others have read, write and execute permissionstdio"00010 group has execute permissionstdio 00020 group has write permissionstdio00040 group has read permissionstdio200070 group has read, write and execute permissionstdio!00100 user has execute permissionstdio00200 user has write permissionstdio00400 user has read permissionstdio>00700 user (file owner) has read, write and execute permission stdio-Peek loop data pointer from uv loop pointer.     #"! $%'&()10/.-,+*23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         GDEFCBA?@ >  <=:;8967~}|{zyxwvutsrq4523)10/.-,+*      ( ponm$%'&#"!  lkjihgfedcba`_^]    \[ZYXWVUTS RQPONMLKJIH,IO manager based on libuv(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneX`*1 pstdioA haskell data type wrap an  uv_stream_t inside p# DO NOT provide thread safety! Use  pC concurrently in multiple threads will lead to undefined behavior. wstdioGet  v runing on the same capability. xstdioGet % from blocking table with given slot. ystdio@Poke a prepared buffer and size into loop data under given slot.NOTE, this action is not protected with 'withUVManager_ for effcient reason, you should merge this action with other uv action and put them together inside a 'withUVManager_ or 'withUVManager\''. for example: k ... withUVManager_ uvm $ do pokeBufferTable uvm slot buf len uvReadStart handle ... {stdioFLock an uv mananger, so that we can safely mutate its uv_loop's state.dlibuv is not thread safe, use this function to perform any action which will mutate uv_loop's state. |stdioFLock an uv mananger, so that we can safely mutate its uv_loop's state.iSome action did not request uv_loop pointer explicitly, but will mutate uv_loop underhood, for example:  uv_read_start<. These actions have to be protected by locking the uv_loop.HIn fact most of the libuv's functions are not thread safe, so watch out!stdioStart the uv loop }stdioRun a libuv FFI to get a D (which may exceed block table size), resize the block table in that case, so that the returned slot always has an accompanying  in block table.$Always use this function to turn an  UVSlotUnsafe into GI, so that the block table size synchronize with libuv side's slot table.stdio>Cancel uv async function (actions which can be cancelled with  uv_cancelV) with best effort, if the action is already performed, run an extra clean up action. ~stdio Exception safe uv request helperrThis helper will run a libuv's async function, which will return a libuv side's slot, then we will accommodate a " in block table and wait on that ], until the async function finished or an exception is received, in later case we will call : to cancel the on-going async function with best efforts, stdio Same with  ~ but disgard the result. stdio Same with  ~) but apply an convert function to result.The convert function have all access to the returned value including negative ones, it's convert funtions's responsiblity to throw an exception if appropriate. stdio Same with  ~, but will also run an extra cleanup function if async exception hit this thread but the async action is already successfully performed, e.g. release result memory. stdio1Fork a new GHC thread with active load-balancing.Using libuv based IO solution has a disadvantage that file handlers are bound to certain uv_loop, thus certain uv mananger/capability. Worker threads that migrate to other capability will lead contention since various APIs here is protected by manager's lock, this makes GHC's work-stealing strategy unsuitable for certain workload, such as a webserver. we solve this problem with simple round-robin load-balancing: forkBa will automatically distribute new threads to all capabilities in round-robin manner. Thus its name forkBa(lance). stdio?Safely lock an uv manager and perform uv_handle initialization.2Initialization an UV stream usually take two step:-allocate an uv_stream struct with proper sizeXlock a particular uv_loop from a uv manager, and perform custom initialization, such as  uv_tcp_init.And this is what   do, all you need to do is to provide the manager you want to hook the handle onto(usually the one on the same capability, i.e. the one obtained by  w]), and provide a custom initialization function (which should throw an exception if failed). stdioconvert function p q r s t u v w x y z { | } ~   v w x z y { | } ~  p q r s t u -UDP servers and clients(c) Dong Han, 2018BSDwinterland1989@gmail.com experimental non-portableNoneFX`gk@ stdio UDP options.Though technically message length field in the UDP header is a max of 65535, but large packets could be more likely dropped by routers, usually a packet(IPV4) with a payload <= 508 bytes is considered safe. stdio"maximum size of a received message stdiohow many messages we want to receive per uv loop, inside each uv_run, we do batch receiving, increase this number can improve receiving performance, at the cost of memory and potential GHC thread starving. stdiomaximum size of sending buffer stdiojdo we want bind a local address before receiving & sending? set to Nothing to let OS pick a random one. stdio UDP socket.~UDP socket is not thread safe, don't use it among multiple thread! UDP is not a sequential protocol, thus not an instance of 'Input/Output's. Message are received or sent individually, we do provide batch receiving to improve performance under high load. stdiodefault  , .defaultUDPConfig = UDPConfig 512 6 512 Nothing stdioInitialize a UDP socket. stdioIRecv messages from UDP socket, return source address if available, and a J to indicate if the message is partial (larger than receive buffer size). stdio%Send a UDP message to target address. WARNING: A 0 with errno + will be thrown if message is larger than  .":< ' : < .TCP servers and clients(c) Dong Han, 2018BSDwinterland1989@gmail.com experimental non-portableNone"#EFMXM} stdioA TCP server configuration stdiolistening address stdiolistening socket's backlog size stdiofworker which get an accepted TCP stream, the socket will be closed upon exception or worker finishes. stdioif we want to use  TCP_NODELAY stdioA TCP client configuration stdio*assign a local address, or let OS pick one stdiotarget address stdioif we want to use  TCP_NODELAYstdio TCP Stream. stdio.A default hello world server on localhost:8888 Test it with &main = startServer defaultServerConfig , now try nc -v 127.0.0.1 8888 stdioStart a server-Fork new worker thread upon a new connection.=`abcdefghijklmnopqrstuvwxyz{|}~  / TTY devices(c) Dong Han, 2018~2019BSDwinterland1989@gmail.com experimental non-portableNoneX`Y stdio!Standard input and output streamsFWe support both regular file and TTY based streams, when initialized HN is called to decide which type of devices are connected to standard streams.Note  v is not thread safe, you shouldn't use them without lock. For the same reason you shouldn't use stderr directly, use BC module instead. stdio Don't use   directly, use BC instead. stdio;Change terminal's mode if stdin is connected to a terminal. stdioprint a  to stdout stdioprint a + and flush to stdout. stdioprint a +- and flush to stdout stdout, with a linefeed. stdioread a line from stdin8  8 0High performance logger(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneEXi. stdioLogger configuration. stdio%Minimal flush interval, see Notes on  stdio/A IO action return a formatted date/time string stdio"Buffer size to build each log/line stdioSet to  to filter debug logs stdioSet to , to disable auto data/time string prepending stdio&flush logger's buffer to output devicestdioA default logger config withdebug ON0.1s minimal flush intervaldefaultTSCacheline buffer size 128 bytesshow debug Trueshow timestamp True buffer size equals to !.stdio&A default timestamp cache with format %Y-%m-%dT%H:%M:%S%Z stdioMake a new logger stdioChange stderr logger.stdioManually flush stderr logger. stdio'Flush stderr logger when program exits. stdio log levelstdioflush immediately?stdio log content stdio log levelstdioflush immediately?stdio log content  1Filesystem IO using threadpool(c) Dong Han, 2017~2019BSDwinterland1989@gmail.com experimental non-portableNone27X stdio  wrap a  uv_file_t and a referencing counter'Note this is a differet data type from Std.IO.FileSystem 's one, the  and , instance use thread pool version functions.tlibuv implements read and write method with both implict and explict offset capability. (negative offset result in  read/write system call otherwise  pread/pwrite-), we provide implict offset interface with  , which is NOT thread safe.An offset bundled  ,  Q is also provided, which can be used concurrently. The offset is protected with  and increasing automatically. stdioCreate a reader from an  .Note this will not increase UVFile's referencing counter. stdioChange reader's offset. stdioCreate a writer from an  .Note this will not increase UVFile's referencing counter. stdioChange writer's offset. stdio init a file , which open a file when used.8Resource closing will wait for the referencing counter goes down to zero (no reading or writing is in process), which can be a problem if you are using multiple readers or writers in multiple threads. In that case you have to stop all reading or writing thread if you don't want to block the resource thread. stdioEquivalent to  http://linux.die.net/man/2/mkdirmkdir(2).2Note mode is currently not implemented on Windows. stdioEquivalent to  !http://linux.die.net/man/2/unlink unlink(2). stdioEquivalent to mkdtemp"http://linux.die.net/man/3/mkdtemp?Creates a temporary directory in the most secure manner possible. There are no race conditions in the directory s creation. The directory is readable, writable, and searchable only by the creating user ID. The user of mkdtemp() is responsible for deleting the temporary directory and its contents when done with it.^Note: the argument is the prefix of the temporary directory, so no need to add XXXXXX ending. stdioEquivalent to  http://linux.die.net/man/2/rmdirrmdir(2). stdioEquivalent to  "http://linux.die.net/man/3/scandir scandir(3).ONote Unlike scandir(3), this function does not return the .  and ..  entries.Note On Linux, getting the type of an entry is only supported by some file systems (btrfs, ext2, ext3 and ext4 at the time of this writing), check the  #http://linux.die.net/man/2/getdents getdents(2) man page. stdioEquivalent to http://linux.die.net/man/2/statstat(2) stdioEquivalent to http://linux.die.net/man/2/lstatlstat(2) stdioEquivalent to http://linux.die.net/man/2/fstatfstat(2) stdioEquivalent to  !http://linux.die.net/man/2/rename rename(2).Note On Windows if this function fails with UV_EBUSY, UV_EPERM or UV_EACCES, it will retry to rename the file up to four times with 250ms wait between attempts before giving up. If both path and new_path are existing directories this function will work only if target directory is empty. stdioEquivalent to  http://linux.die.net/man/2/fsyncfsync(2). stdioEquivalent to  $http://linux.die.net/man/2/fdatasync fdatasync(2). stdioEquivalent to  $http://linux.die.net/man/2/ftruncate ftruncate(2). stdio$Copies a file from path to new_path.Warning: If the destination path is created, but an error occurs while copying the data, then the destination path is removed. There is a brief window of time between closing and removing the file where another process could access the file. stdioEquivalent to  !http://linux.die.net/man/2/access access(2)- on Unix. Windows uses GetFileAttributesW(). stdioEquivalent to  http://linux.die.net/man/2/chmodchmod(2). stdioEquivalent to  !http://linux.die.net/man/2/fchmod fchmod(2). stdioEquivalent to  http://linux.die.net/man/2/utimeutime(2). libuv choose M type due to cross platform concerns, we only provide micro-second precision:second = v,nanosecond = (v * 1000000) % 1000000 * 1000;$second and nanosecond are fields in $ respectively.PNote libuv prior to v1.23.1 have issues which may result in nanosecond not set,   doesn't have stdioEquivalent to  !http://linux.die.net/man/2/futime futime(2).Same precision notes with  . stdioEquivalent to  http://linux.die.net/man/2/linklink(2). stdioEquivalent to  "http://linux.die.net/man/2/symlink symlink(2).b| Note On Windows the flags parameter can be specified to control how the symlink will be created.,: indicates that path points to a directory.<: request that the symlink is created using junction points.+On other platforms these flags are ignored. stdioEquivalent to  #http://linux.die.net/man/2/readlink readlink(2). stdioEquivalent to  #http://linux.die.net/man/3/realpath realpath(3) on Unix. Windows uses  Ohttps://msdn.microsoft.com/en-us/library/windows/desktop/aa364962(v=vs.85).aspxGetFinalPathNameByHandle.cWarning This function has certain platform-specific caveats that were discovered when used in Node.macOS and other BSDs: this function will fail with UV_ELOOP if more than 32 symlinks are found while resolving the given path. This limit is hardcoded and cannot be sidestepped.kWindows: while this function works in the common case, there are a number of corner cases where it doesn t:pPaths in ramdisk volumes created by tools which sidestep the Volume Manager (such as ImDisk) cannot be resolved.-Inconsistent casing when using drive letters.&Resolved path bypasses subst d drives.While this function can still be used, it s not recommended if scenarios such as the above need to be supported. The background story and some more details on these issues can be checked  *https://github.com/nodejs/node/issues/7726here.uNote This function is not implemented on Windows XP and Windows Server 2003. On these systems, UV_ENOSYS is returned. stdiothe file we're readingstdioinitial reading offset stdiothe new offsetstdiothe old offset stdiothe file we're writingstdioinitial writing offset stdiothe new offsetstdiothe old offset stdioOpening flags, e.g.  .|. stdioXSets the file mode (permission and sticky bits), but only if the file was created, see . stdioatime, i.e. access timestdiomtime, i.e. modify timem     !"#$%&')*+,-./0146 64 )*+,-./01  !"#$%&'       2 Filesystem IO(c) Dong Han, 2017~2019BSDwinterland1989@gmail.com experimental non-portableNone27X` / stdioAn   bundled with a  protected writing offset. stdioAn   bundled with a  protected reading offset. stdio  wrap a  uv_file_t and a referencing counter.qlibuv implements read and write method with both implict and explict offset capable. (negative offset result in  read/write system call otherwise  pread/pwrite-), we provide implict offset interface with  , which is NOT thread safe.An offset bundled  ,  Q is also provided, which can be used concurrently. The offset is protected with  and increasing automatically. stdioCreate a reader from an  .Note this will not increase UVFile's referencing counter. stdioChange reader's offset. stdioCreate a writer from an  .Note this will not increase UVFile's referencing counter. stdioChange writer's offset. stdio init a file , which open a file when used.8Resource closing will wait for the referencing counter goes down to zero (no reading or writing is in process), which can be a problem if you are using multiple readers or writers in multiple threads. In that case you have to stop all reading or writing thread if you don't want to block the resource thread.ANote, on some versions of OSX, repeatly open and close same file 0 may result in shared memory object error, use  to avoid that. stdioEquivalent to  http://linux.die.net/man/2/mkdirmkdir(2).2Note mode is currently not implemented on Windows. stdioEquivalent to  !http://linux.die.net/man/2/unlink unlink(2). stdioEquivalent to mkdtemp"http://linux.die.net/man/3/mkdtemp?Creates a temporary directory in the most secure manner possible. There are no race conditions in the directory s creation. The directory is readable, writable, and searchable only by the creating user ID. The user of mkdtemp() is responsible for deleting the temporary directory and its contents when done with it.^Note: the argument is the prefix of the temporary directory, so no need to add XXXXXX ending. stdioEquivalent to  http://linux.die.net/man/2/rmdirrmdir(2). stdioEquivalent to  "http://linux.die.net/man/3/scandir scandir(3).ONote Unlike scandir(3), this function does not return the .  and ..  entries.Note On Linux, getting the type of an entry is only supported by some file systems (btrfs, ext2, ext3 and ext4 at the time of this writing), check the  #http://linux.die.net/man/2/getdents getdents(2) man page. stdioEquivalent to http://linux.die.net/man/2/statstat(2) stdioEquivalent to http://linux.die.net/man/2/lstatlstat(2) stdioEquivalent to http://linux.die.net/man/2/fstatfstat(2) stdioEquivalent to  !http://linux.die.net/man/2/rename rename(2).Note On Windows if this function fails with UV_EBUSY, UV_EPERM or UV_EACCES, it will retry to rename the file up to four times with 250ms wait between attempts before giving up. If both path and new_path are existing directories this function will work only if target directory is empty. stdioEquivalent to  http://linux.die.net/man/2/fsyncfsync(2). stdioEquivalent to  $http://linux.die.net/man/2/fdatasync fdatasync(2). stdioEquivalent to  $http://linux.die.net/man/2/ftruncate ftruncate(2). stdio$Copies a file from path to new_path.Warning: If the destination path is created, but an error occurs while copying the data, then the destination path is removed. There is a brief window of time between closing and removing the file where another process could access the file. stdioEquivalent to  !http://linux.die.net/man/2/access access(2)- on Unix. Windows uses GetFileAttributesW(). stdioEquivalent to  http://linux.die.net/man/2/chmodchmod(2). stdioEquivalent to  !http://linux.die.net/man/2/fchmod fchmod(2). stdioEquivalent to  http://linux.die.net/man/2/utimeutime(2). libuv choose M type due to cross platform concerns, we only provide micro-second precision:second = v,nanosecond = (v * 1000000) % 1000000 * 1000;$second and nanosecond are fields in $ respectively.PNote libuv prior to v1.23.1 have issues which may result in nanosecond not set,   doesn't have that issue. stdioEquivalent to  !http://linux.die.net/man/2/futime futime(2).Same precision notes with  . stdioEquivalent to  http://linux.die.net/man/2/linklink(2). stdioEquivalent to  "http://linux.die.net/man/2/symlink symlink(2).b| Note On Windows the flags parameter can be specified to control how the symlink will be created.,: indicates that path points to a directory.<: request that the symlink is created using junction points.+On other platforms these flags are ignored. stdioEquivalent to  #http://linux.die.net/man/2/readlink readlink(2). stdioEquivalent to  #http://linux.die.net/man/3/realpath realpath(3) on Unix. Windows uses  Ohttps://msdn.microsoft.com/en-us/library/windows/desktop/aa364962(v=vs.85).aspxGetFinalPathNameByHandle.cWarning This function has certain platform-specific caveats that were discovered when used in Node.macOS and other BSDs: this function will fail with UV_ELOOP if more than 32 symlinks are found while resolving the given path. This limit is hardcoded and cannot be sidestepped.kWindows: while this function works in the common case, there are a number of corner cases where it doesn t:pPaths in ramdisk volumes created by tools which sidestep the Volume Manager (such as ImDisk) cannot be resolved.-Inconsistent casing when using drive letters.&Resolved path bypasses subst d drives.While this function can still be used, it s not recommended if scenarios such as the above need to be supported. The background story and some more details on these issues can be checked  *https://github.com/nodejs/node/issues/7726here.uNote This function is not implemented on Windows XP and Windows Server 2003. On these systems, UV_ENOSYS is returned. stdiothe file we're readingstdioinitial reading offset stdiothe new offsetstdiothe old offset stdiothe file we're writingstdioinitial writing offset stdiothe new offsetstdiothe old offset stdioOpening flags, e.g.  .|. stdioXSets the file mode (permission and sticky bits), but only if the file was created, see . stdioatime, i.e. access timestdiomtime, i.e. modify timem     !"#$%&')*+,-./0146                               64 )*+,-./01  !"#$%&'                    DEFGHIDJKDLMDNODNPDNQDNQDRSDRTDRUDRVDRWDRXDRYDRZDR[DR\DR]DR^DR^DR_DR_DR`DR`DRaDRaDRbDRbDRcDRcDRdDRdDReDReDfgDhiDhjDhkDhlDhlDhmDhmDhnDhnDhoDhoDhpDhpDhqDhqDhrDhrDhsDhtDhuDhvDhwDhxDhyDhzD{|D{}D{~D{D{D{D{D{D{D{D{D{D{DDDDDDDDDDDDDDDDDDDDJD                          ! " # $ % & ' ( ) * + , - . / 0 0 1 2 2 3 4 5 6 7 8 9 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 d e f g h i j k l m n o p q r s t u v w x y z { | } ~   =      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<<=>?@@77AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"%&)*412784x|~z{;<      !"#$%&'()*+,-./0123456789:;<=>?@@ABCDE #()*,+-01FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;?;                                         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"(""" " " " "" "+"*"0""""""""############ #!#"###$#%#&#'#(#)#*#+#,#-$.$/$$0$A$1$2$3$4$5$6$$7$8$9$:$;$<$=$>$?$@%A%B%7%8%C%9%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&c&d&e&f&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( ((()(((((I({(|(}(~((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))***o************************************************ * * * * ******************* *!*"*#*$*%*&*'*(*)***++,+,+-+-+.+/+0+1+2+2+3+3+4+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+R+S+S+T+T+U+U+V+V+W+W+X+Y+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+{+|+}+~+++++++++,,,,,,,,,,,,,,,,,,,,,,,,,-------------------------------..................///////////////00000000C0000000000000001111111111111111 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2222222222222222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 D G  GH    G  D  D  DE GH !D  " #G  $D % &D % 'D % (G ) *D + ,D - .Df /D 0 1 2 3 4 5 6G  7D 8 9GH :GH ;GH <GH =GH >GH ?GH @GH AGH BGH CGH DGH EGH FGH GGH HGH IGH JGH KGH LGH MGH NGH OGH PGH QGH RGH SGH TGH UGH VGH WGH XD GH YGH ZGH [GH \GH ]GH ^GH _GH `GH aGH bGH cGH dGH eGH fGH gGH hGH iGH jGH kGH lGH mGH nGH oGH pGH qGH rGH sGH tGH uGH vGH wGH xGH yGH zGH {GH |GH }GH ~GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH !GH "GH #GH $GH %GH &GH 'GH (GH )GH *GH +GH ,GH -GH .GH /GH 0GH 1GH 2GH 3GH 4GH 5GH 6GH 7GH 8GH 9GH :GH ;GH <GH =GH >GH ?GH @GH AGH BGH CGH DGH EGH FGH GGH HGH IGH JGH KGH LGH MGH NGH OGH PGH QGH RGH SGH TGH UGH VGH WGH XGH YGH ZGH [GH \GH ]GH ^GH _GH `GH aGH bGH cGH dGH eGH fGH gGH hGH iGH jGH kGH lGH mGH nGH oGH pGH qGH rGH sGH tGH uGH vGH wGH xGH yGH zGH {GH |GH }GH ~GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GHGH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH !GH "GH #GH $GH %GH &GH 'GH (GH )GH *GH +GH ,GH -GH .GH /GH 0GH 1GH 2GH 3GH 4GH 5GH 6GH 7GH 8GH 9GH :GH ;GH <GH =GH >GH ?GH @GH AGH BGH CGH DGH EGH FGH GGH HGH IGH JGH KGH LGH MGH NGH OGH PGH QGH RGH SGH TGH UGH VGH WGH XGH YGH ZGH [GH \GH ]GH ^GH _GH `GH aGH bGH cGH dGH eGH fGH gGH hGH iGH jGH kGH lGH mGH nGH oGH pGH qGH rGH sGH tGH uGH vGH wGH xGH yGH zGH {GH |GH }GH ~GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH !GH "GH #GH $GH %GH &GH 'GH (GH )GH *GH +GH ,GH -GH .GH /GH 0GH 1GH 2GH 3GH 4GH 5GH 6GH 7GH 8GH 9GH :GH ;GH <GH =GH >GH ?GH @GH AGH BGH CGH DGH EGH FGH GGH HGH IGH JGH KGH LGH MGH NGH OGH PGH QGH RGH SGH TGH UGH VGH WGH XGH YGH ZGH [GH \GH ]GH ^GH _GH `GH aGH bGH cGH dGH eGH fGH gGH hGH iGH jGH kGH lGH mGH nGH oGH pGH qGH rGH sGH tGH uGH vGH wGH xGH yGH zGH {GH |GH }GH ~GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH !GH "GH #GH $GH %GH &GH 'GH (GH )GH *GH +GH ,GH -GH .GH /GH 0GH 1GH 2GH 3GH 4GH 5GH 6GH 7GH 8GH 9GH :GH ;GH <GH =GH >GH ?GH @GH AGH BGH CGH DGH EGH FGH GGH HGH IGH JGH KGH LGH MGH NGH OGH PGH QGH RGH SGH TGH UGH VGH WGH XGH YGH ZGH [GH \GH ]GH ^GH _GH `GH aGH bGH cGH dGH eGH fGH gGH hGH iGH jGH kGH lGH mGH nGH oGH pGH qGH rGH sGH tGH uGH vGH wGH xGH yGH zGH {GH |GH }GH ~GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH GH D  DE0D  D  D    D  G  G      D  D D  D  DDE!wDEG D""$ $    DE&&((DD D,,G 1.000$stdio-0.2.0.0-5YmH16k3vlO7FAtmF9PgfBStd.IO.ExceptionStd.Data.ArrayStd.Data.Vector.SortStd.Foreign.PrimArray#Std.Data.Builder.Numeric.DigitTableStd.Data.Generics.UtilsStd.Data.PrimArray.BitTwiddleStd.Data.PrimArray.CastStd.Data.Array.CheckedStd.Data.PrimArray.QQ"Std.Data.PrimArray.UnalignedAccessStd.Data.PrimSTRef.BaseStd.Data.PrimIORefStd.Data.Text.UTF8CodecStd.Data.Text.UTF8RewindStd.Data.Vector.BaseStd.Data.Vector.QQStd.Data.Vector.SearchStd.Data.Vector.ExtraStd.IO.UV.ErrnoStd.IO.LowResTimerStd.IO.ResourceStd.Data.Text.BaseStd.Data.Text.SearchStd.Data.Text.ExtraStd.Data.Builder.BaseStd.Data.Builder.NumericStd.Data.TextBuilderStd.Data.Vector.FlatSetStd.Data.Vector.FlatMapStd.Data.Vector.FlatIntSetStd.Data.Vector.FlatIntMapStd.Data.Parser.BaseStd.Data.Parser.NumericStd.IO.BufferedStd.Data.JSON.ValueStd.Data.JSON.BuilderStd.Data.JSON.Base Std.Data.JSONStd.Data.CBytesStd.IO.SockAddr Std.Data.LEON Std.IO.UV.FFIStd.IO.UV.Manager Std.IO.UDP Std.IO.TCPStd.IO.StdStream Std.IO.LoggerStd.IO.FileSystemTStd.IO.FileSystemStd.Data.PrimSTRef isCategoryStd.Data.VectorEResourceVanishedSystem.Timeouttimeout Std.Data.TextStd.Data.BuilderTreplacementCharStd.Data.ParserFlatMap Data.AesonNumberStd.IOLoggerbaseGHC.Baseassertghc-primGHC.Prim RealWorldGHC.Stack.Types CallStack GHC.Stack callStackControl.ExceptionallowInterruptcatchesHandlerControl.Exception.BasebracketOnErrorbracket_finallybracket onExceptiontryJusttry mapException handleJusthandle catchJustPatternMatchFail RecSelError RecConError RecUpdError NoMethodError TypeErrorNonTerminationNestedAtomically GHC.Conc.SyncthrowToGHC.IO.ExceptionioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededCompactionFailedAssertionFailedSomeAsyncException UserInterrupt ThreadKilled HeapOverflow StackOverflowAsyncExceptionUndefinedElementIndexOutOfBoundsArrayExceptionGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingState interruptiblethrowIOcatchMaskedUninterruptibleMaskedInterruptibleUnmasked MaskingState GHC.Exceptionthrow ErrorCallErrorCallWithLocationGHC.Exception.Type SomeExceptiondisplayException fromException toException ExceptionRatioZeroDenominatorDenormal DivideByZeroLossOfPrecision UnderflowOverflowArithExceptionData.OrdDownGHC.PtrcastPtr HasCallStack(primitive-0.6.4.0-ILgywxtLpvnAOlEISPpP5bData.Primitive.TypesPrim indexOffAddr# readOffAddr# setOffAddr# writeOffAddr# decDigitTable hexDigitTablehexDigitTableUpper alignment#indexByteArray#readByteArray# setByteArray#sizeOf#writeByteArray# ProductSizePSize productSize$fProductSize:*:$fProductSizeM1Data.Primitive.PrimArraycopyMutablePrimArrayToPtrcopyPrimArrayToPtrMutablePrimArray PrimArrayc_memchrisOffsetAligned#mkMask#nullByteMagic#memchrmemchr# memchrReversememchrReverse#Castcast$fCastFloatInt32$fCastDoubleInt64$fCastInt32Float$fCastInt64Double$fCastFloatWord32$fCastDoubleWord64$fCastWord32Float$fCastWord64Double $fCastWordInt$fCastWord64Int64$fCastWord32Int32$fCastWord16Int16$fCastWord8Int8 $fCastIntWord$fCastInt64Word64$fCastInt32Word32$fCastInt16Word16$fCastInt8Word8$fCastabData.Primitive.ArrayArrayarray# MutableArraymarray#Data.Primitive.PtrcopyPtrToMutablePrimArrayData.Primitive.SmallArray SmallArraySmallMutableArrayData.Primitive.UnliftedArrayMutableUnliftedArray PrimUnliftedfromArrayArray# toArrayArray# UnliftedArrayArrIArrMArrnewArr newArrWithreadArrwriteArrsetArrindexArr indexArr' indexArrM freezeArrthawArrunsafeFreezeArr unsafeThawArrcopyArrcopyMutableArrmoveArrcloneArrcloneMutableArrresizeMutableArrshrinkMutableArrsameMutableArr sizeofArrsizeofMutableArrsameArr uninitializednewPinnedPrimArraynewAlignedPinnedPrimArrayprimArrayContentsmutablePrimArrayContentswithPrimArrayContentswithMutablePrimArrayContentsisPrimArrayPinnedisMutablePrimArrayPinned castArraycastMutableArray'$fArrMutableUnliftedArrayUnliftedArraya$fArrMutablePrimArrayPrimArraya!$fArrSmallMutableArraySmallArraya$fArrMutableArrayArraya asciiLiteralarrASCIIword8ArrayFromAddrint8ArrayFromAddr utf8Literal word8LiteralarrW8 int8LiteralarrI8 word16LiteralarrW16word16ArrayFromAddrint16ArrayFromAddr int16LiteralarrI16 word32LiteralarrW32word32ArrayFromAddrint32ArrayFromAddr int32LiteralarrI32 word64LiteralarrW64word64ArrayFromAddrint64ArrayFromAddr int64LiteralarrI64wordArrayFromAddrintArrayFromAddr wordLiteral intLiteralarrWordarrIntBEgetBELEgetLEUnalignedAccess unalignedSizewriteWord8ArrayAsreadWord8ArrayAsindexWord8ArrayAs UnalignedSizegetUnalignedSize$fUnalignedAccessChar$fUnalignedAccessDouble$fUnalignedAccessFloat$fUnalignedAccessInt$fUnalignedAccessInt64$fUnalignedAccessInt32$fUnalignedAccessInt16$fUnalignedAccessWord$fUnalignedAccessWord64$fUnalignedAccessWord32$fUnalignedAccessWord16$fUnalignedAccessInt8$fUnalignedAccessWord8$fUnalignedAccessLE$fUnalignedAccessLE0$fUnalignedAccessLE1$fUnalignedAccessLE2$fUnalignedAccessLE3$fUnalignedAccessLE4$fUnalignedAccessLE5$fUnalignedAccessLE6$fUnalignedAccessLE7$fUnalignedAccessLE8$fUnalignedAccessLE9$fUnalignedAccessBE$fUnalignedAccessBE0$fUnalignedAccessBE1$fUnalignedAccessBE2$fUnalignedAccessBE3$fUnalignedAccessBE4$fUnalignedAccessBE5$fUnalignedAccessBE6$fUnalignedAccessBE7$fUnalignedAccessBE8$fUnalignedAccessBE9$fShowUnalignedSize$fEqUnalignedSize$fShowLE$fEqLE$fShowBE$fEqBE PrimSTRef newPrimSTRef readPrimSTRefwritePrimSTRefmodifyPrimSTRefCounter PrimIORef newPrimIORef readPrimIORefwritePrimIORefmodifyPrimIORef newCounteratomicAddCounter'atomicAddCounteratomicAddCounter_atomicSubCounter'atomicSubCounteratomicSubCounter_atomicAndCounter'atomicAndCounteratomicAndCounter_atomicNandCounter'atomicNandCounteratomicNandCounter_atomicOrCounter'atomicOrCounteratomicOrCounter_atomicXorCounter'atomicXorCounteratomicXorCounter_encodeCharLength encodeChar encodeChar#encodeCharModifiedUTF8encodeCharModifiedUTF8# decodeChar decodeChar_ decodeChar# decodeCharLendecodeCharLen#decodeCharReversedecodeCharReverse_decodeCharReverse#decodeCharLenReversedecodeCharLenReverse#between#isContinueByte#chr1#chr2#chr3#chr4#copyChar copyChar'CategoryNormalizationResult NormalizedYesNormalizedMaybe NormalizedNo NormalizeModeNFCNFKCNFDNFKDLocale utf8envlocale localeDefaultlocaleLithuanianlocaleTurkishAndAzeriLatinnormalizeComposenormalizeDecomposenormalizeCompatibilitynormalizeModeToFlagtoNormalizationResultcategoryLetterUppercasecategoryLetterLowercasecategoryLetterTitlecasecategoryLetterOthercategoryLettercategoryCaseMappedcategoryMarkNonSpacingcategoryMarkSpacingcategoryMarkEnclosing categoryMarkcategoryNumberDecimalcategoryNumberLettercategoryNumberOthercategoryNumbercategoryPunctuationConnectorcategoryPunctuationDashcategoryPunctuationOpencategoryPunctuationClosecategoryPunctuationInitialcategoryPunctuationFinalcategoryPunctuationOthercategoryPunctuationcategorySymbolMathcategorySymbolCurrencycategorySymbolModifiercategorySymbolOthercategorySymbolcategorySeparatorSpacecategorySeparatorLinecategorySeparatorParagraphcategorySeparatorcategoryControlcategoryFormatcategorySurrogatecategoryPrivateUsecategoryUnassignedcategoryCompatibilitycategoryIgnoreGraphemeClustecategoryIscntrlcategoryIsprintcategoryIsspacecategoryIsblankcategoryIsgraphcategoryIspunctcategoryIsalnumcategoryIsalphacategoryIsuppercategoryIslowercategoryIsdigitcategoryIsxdigit $fShowLocale $fEqLocale $fOrdLocale$fGenericLocale$fShowNormalizeMode$fEqNormalizeMode$fOrdNormalizeMode$fGenericNormalizeMode$fShowNormalizationResult$fEqNormalizationResult$fOrdNormalizationResult$fGenericNormalizationResult$fShowCategory $fEqCategory $fOrdCategory$fBitsCategory$fFiniteBitsCategory$fGenericCategoryVectorExceptionIndexOutOfVectorRange EmptyVectorIPairifstisndBytes PrimVectorVectorVecMArrayIArraytoArrfromArr c_fnv_hash_bac_fnv_hash_addrc_ascii_validate_addrc_strlenc_strcmp indexMaybe traverseVectraverseWithIndex traverseVec_traverseWithIndex_ packASCIIw2cc2wcreatecreate'creating creating'createNcreateN2empty singletoncopypackpackNpackRpackRNunpackunpackRlengthnullappendmapmap'imap'foldl'ifoldl'foldl1' foldl1Maybe'foldr'ifoldr'foldr1' foldr1Maybe'concat concatMapmaximum maximumMaybeminimum minimumMaybeproductproduct'anyallsumcount mapAccumL mapAccumR replicatecycleNunfoldrunfoldrNelemnotElem elemIndex mapIPair'defaultChunkSizesmallChunkSize chunkOverheaddefaultInitSizeerrorEmptyVector errorOutRange castVector$fHashable1Vector$fHashableVector$fCoArbitraryVector$fArbitraryVector$fTraversableVector$fFoldableVector$fFunctorVector $fReadVector $fShowVector$fNFDataVector$fMonoidVector$fSemigroupVector $fOrdVector $fEqVector $fVecVectora$fIsStringPrimVector$fHashablePrimVector$fCoArbitraryPrimVector$fArbitraryPrimVector$fReadPrimVector$fShowPrimVector$fNFDataPrimVector$fMonoidPrimVector$fSemigroupPrimVector$fOrdPrimVector$fEqPrimVector$fVecPrimVectora$fFoldCasePrimVector $fNFDataIPair$fFunctorIPair$fCoArbitraryIPair$fArbitraryIPair$fExceptionVectorException $fDataVector $fShowIPair $fEqIPair $fOrdIPair$fShowVectorExceptionasciivecW8vecW16vecW32vecW64vecWordvecI8vecI16vecI32vecI64vecInt elemIndices findIndiceselemIndicesBytes findIndex findIndexRfindfindBytefindR findByteRfilter partitionindicesOverlappingindicesOverlappingBytesindices indicesBytes kmpNextTable sundayBloomelemSundayBloomconssnocunconsunsnoc headMaybe tailMayEmpty lastMaybe initMayEmptyinitstailstaketakeRdropdropRslicesplitAt takeWhile takeWhileR dropWhile dropWhileR dropAroundbreakspanbreakRspanRbreakOngroupgroupBy stripPrefix isPrefixOf commonPrefix stripSuffix isSuffixOf isInfixOfsplitsplitOn splitWithwordslinesunwordsunlinespadLeftpadRightreverse intersperse intercalateintercalateElem transposezipWith' unzipWith'scanl'scanl1'scanr'scanr1'rangeCutheadtailinitlastindexindexM unsafeHead unsafeTail unsafeInit unsafeLast unsafeIndex unsafeIndexM unsafeTake unsafeDrop RadixDownRadix bucketSizepassesradixLSBradixradixMSB mergeSort mergeSortBy mergeTileSize insertSort insertSortBy radixSortmergeDupAdjacentmergeDupAdjacentLeftmergeDupAdjacentRightmergeDupAdjacentBy $fRadixWord64 $fRadixWord32 $fRadixWord16 $fRadixWord $fRadixWord8 $fRadixInt64 $fRadixInt32 $fRadixInt16 $fRadixInt $fRadixInt8$fRadixRadixDown$fShowRadixDown $fEqRadixDown$fPrimRadixDown uv_err_name uv_strerror UV_EMLINKUV_ENXIOUV_EOF UV_UNKNOWNUV_EXDEV UV_ETXTBSY UV_ETIMEDOUTUV_ESRCH UV_ESPIPE UV_ESHUTDOWNUV_EROFS UV_ERANGE UV_EPROTOTYPEUV_EPROTONOSUPPORT UV_EPROTOUV_EPIPEUV_EPERM UV_ENOTSUP UV_ENOTSOCK UV_ENOTEMPTY UV_ENOTDIR UV_ENOTCONN UV_ENOSYS UV_ENOSPCUV_ENOPROTOOPT UV_ENONET UV_ENOMEM UV_ENOENT UV_ENODEV UV_ENOBUFS UV_ENFILEUV_ENETUNREACH UV_ENETDOWNUV_ENAMETOOLONG UV_EMSGSIZE UV_EMFILEUV_ELOOP UV_EISDIR UV_EISCONNUV_EIO UV_EINVALUV_EINTRUV_EHOSTUNREACHUV_EFBIG UV_EFAULT UV_EEXISTUV_EDESTADDRREQ UV_ECONNRESETUV_ECONNREFUSEDUV_ECONNABORTED UV_ECHARSET UV_ECANCELEDUV_EBUSYUV_EBADF UV_EALREADYUV_EAI_SOCKTYPEUV_EAI_SERVICEUV_EAI_PROTOCOLUV_EAI_OVERFLOW UV_EAI_NONAME UV_EAI_NODATA UV_EAI_MEMORY UV_EAI_FAMILY UV_EAI_FAILUV_EAI_CANCELEDUV_EAI_BADHINTSUV_EAI_BADFLAGS UV_EAI_AGAINUV_EAI_ADDRFAMILY UV_EAGAINUV_EAFNOSUPPORTUV_EADDRNOTAVAIL UV_EADDRINUSE UV_EACCESUV_E2BIG uvStdError uvErrNameIOEInfoioeNameioeDescription ioeCallStack Interrupted TimeExpiredUnsupportedOperation HardwareFaultInappropriateTypeInvalidArgument OtherError ProtocolError SystemErrorUnsatisfiedConstraintsPermissionDeniedIllegalOperationEOFResourceExhausted ResourceBusy NoSuchThing AlreadyExistsSomeIOExceptionioExceptionToExceptionioExceptionFromExceptionthrowOOMIfNullthrowUVIfMinusthrowUVIfMinus_ throwECLOSEDthrowECLOSEDSTM throwUVError$fExceptionSomeIOException$fShowSomeIOException $fShowIOEInfo$fExceptionInterrupted$fExceptionResourceVanished$fExceptionTimeExpired$fExceptionUnsupportedOperation$fExceptionHardwareFault$fExceptionInappropriateType$fExceptionInvalidArgument$fExceptionOtherError$fExceptionProtocolError$fExceptionSystemError!$fExceptionUnsatisfiedConstraints$fExceptionPermissionDenied$fExceptionIllegalOperation$fExceptionEOF$fExceptionResourceExhausted$fExceptionResourceBusy$fExceptionNoSuchThing$fExceptionAlreadyExists$fShowInterrupted$fShowResourceVanished$fShowTimeExpired$fShowUnsupportedOperation$fShowHardwareFault$fShowInappropriateType$fShowInvalidArgument$fShowOtherError$fShowProtocolError$fShowSystemError$fShowUnsatisfiedConstraints$fShowPermissionDenied$fShowIllegalOperation $fShowEOF$fShowResourceExhausted$fShowResourceBusy$fShowNoSuchThing$fShowAlreadyExists LowResTimerLowResTimerManager%lowResTimerManagerCapabilitiesChangedgetLowResTimerManagerisLowResTimerManagerRunningregisterLowResTimerregisterLowResTimer_registerLowResTimerOnqueryLowResTimercancelLowResTimercancelLowResTimer_ timeoutLowRestimeoutLowResExthrottle throttle_throttleTrailing_$fExceptionTimeOutException$fShowTimeOutExceptionPool PoolState PoolClosed PoolScanning PoolEmptyResourceacquire initResource initResource_ withResource withResource'initPoolstatPool initInPool$fMonadIOResource$fMonadResource$fApplicativeResource$fFunctorResource $fEqPoolState$fShowPoolStateMBA#BA#withPrimArrayUnsafewithMutablePrimArrayUnsafewithMutableByteArrayUnsafewithPrimVectorUnsafewithPrimUnsafewithPrimUnsafe'withPrimArraySafewithMutablePrimArraySafewithMutableByteArraySafewithPrimVectorSafe withPrimSafe withPrimSafe'clearPtr addrToPtr ptrToAddrText getUTF8Bytesc_utf8_validate_addrc_utf8_validate_ba charByteIndex indexMaybeRcharByteIndexRvalidate validateMaybe fromVectortoVector isNormalizedisNormalizedTo normalize normalizeTocaseFold caseFoldWithtoLower toLowerWithtoUpper toUpperWithtoTitle toTitleWith spanCategory$fIsStringText$fHashableText$fCoArbitraryText$fArbitraryText $fNFDataText $fReadText $fShowText $fOrdText$fEqText$fSemigroupText $fMonoidText breakOnAllbreakOnAllOverlappingBuilder runBuilder BuildStepBufferAllocateStrategy DoubleBuffer InsertChunk OneShotActionstringModifiedUTF8charModifiedUTF8bytesensureN doubleBuffer insertChunk oneShotAction buildBytesbuildBytesWithbuildBytesListbuildBytesListWith buildAndRunbuildAndRunWithatMostwriteN encodePrim encodePrimLE encodePrimBE stringUTF8charUTF8string7char7string8char8textparencurlysquareanglequotessquotescoloncommaintercalateVecintercalateList$fCoArbitraryBuilder$fArbitraryBuilder$fIsStringBuilder$fMonoidBuilder$fSemigroupBuilder$fMonadBuilder$fApplicativeBuilder$fFunctorBuilder $fShowBuilderFFormatExponentFixedGenericPadding NoPaddingRightSpacePaddingLeftSpacePadding ZeroPaddingIFormatwidthpadding postiveSigndefaultIFormatintintWith c_intWith hs_intWithinteger countDigitsi2wDeci2wHexi2wHeXhexheXfloatdouble floatWith doubleWithgrisu3 grisu3_sp scientificscientificWith$fArbitraryPadding$fArbitraryIFormat $fShowPadding $fEqPadding $fOrdPadding $fEnumPadding $fShowIFormat $fEqIFormat $fOrdIFormat $fEnumFFormat $fReadFFormat $fShowFFormatToText toTextBuilderStrchrs TextBuilder getBuilder buildTextunsafeFromBuilder parenWhentoText toBuildertoBytestoString$fShowTextBuilder$fCoArbitraryTextBuilder$fArbitraryTextBuilder$fIsStringTextBuilder $fReadStr $fShowStr $fGToTextM1 $fGToTextM10 $fGToText:+: $fGToTextV1 $fToTextFixed $fToTextRatio$fToTextEither $fToTextMaybe$fToText(,,,,,,)$fToText(,,,,,)$fToText(,,,,) $fToText(,,,) $fToText(,,) $fToText(,)$fToTextPrimVector$fToTextVector $fToText[]$fToTextScientific $fToTextText$fToTextVersion $fToText()$fToTextOrdering$fToTextNatural$fToTextInteger$fToTextWord64$fToTextWord32$fToTextWord16 $fToTextWord8 $fToTextWord $fToTextInt64 $fToTextInt32 $fToTextInt16 $fToTextInt8 $fToTextInt $fToTextFloat$fToTextDouble $fToTextChar $fToTextBool $fGToTextK1 $fToTextStr$fToTextTextBuilder $fGToTextM11 $fGToTextM12$fGFieldToTextM1$fGFieldToTextM10$fGFieldToText:*:$fFunctorTextBuilder$fApplicativeTextBuilder$fMonadTextBuilder$fEqStr$fOrdStr $fDataStr $fGenericStr $fToTextSum$fToTextProduct$fToTextCompose$fToTextTagged $fToTextProxy $fToTextConst$fToTextIdentity$fToTextNonEmpty $fToTextLast $fToTextFirst $fToTextDual$fToTextWrappedMonoid $fToTextLast0$fToTextFirst0 $fToTextMax $fToTextMin$fMonoidTextBuilder$fSemigroupTextBuilderFlatSet sortedValuessize packVector packVectorRinsertdeletemerge binarySearch$fCoArbitraryFlatSet$fArbitraryFlatSet$fMonoidFlatSet$fSemigroupFlatSet$fToTextFlatSet $fShowFlatSet $fEqFlatSet $fOrdFlatSet$fFoldableFlatSet$fNFDataFlatSetsortedKeyValueskmap'lookupadjust' mergeWithKey' foldrWithKey foldlWithKey foldrWithKey' foldlWithKey'traverseWithKey linearSearch linearSearchR$fTraversableFlatMap$fFoldableFlatMap$fFunctorFlatMap$fNFDataFlatMap$fMonoidFlatMap$fSemigroupFlatMap$fCoArbitraryFlatMap$fArbitraryFlatMap$fToTextFlatMap $fShowFlatMap $fEqFlatMap $fOrdFlatMap FlatIntSet$fCoArbitraryFlatIntSet$fArbitraryFlatIntSet$fMonoidFlatIntSet$fSemigroupFlatIntSet$fToTextFlatIntSet$fShowFlatIntSet$fEqFlatIntSet$fOrdFlatIntSet$fNFDataFlatIntSet FlatIntMap$fTraversableFlatIntMap$fFoldableFlatIntMap$fFunctorFlatIntMap$fNFDataFlatIntMap$fMonoidFlatIntMap$fSemigroupFlatIntMap$fCoArbitraryFlatIntMap$fArbitraryFlatIntMap$fToTextFlatIntMap$fShowFlatIntMap$fEqFlatIntMap$fOrdFlatIntMapParser runParser ParseError ParseStepResultSuccessFailurePartialparse_parse parseChunk finishParsing parseChunksrunAndKeepTrackmatch endOfInputatEnd decodePrim decodePrimLE decodePrimBEscan scanChunks peekMaybepeeksatisfy satisfyWithword8 endOfLineskip skipWord8 skipWhile skipSpacesisSpacetakeTill takeWhile1bytesCI $fShowResult$fFunctorResult$fAlternativeParser$fMonadPlusParser$fMonadFailParser $fMonadParser$fApplicativeParser$fFunctorParserhexLoop isHexDigituintdecLoopdecLoopIntegerFastisDigitrationalscientifically rational'double'float' scientific'scientifically'floatToScientificdoubleToScientificShortReadExceptionBufferedOutput BufferedInputOutput writeOutputInput readInputnewBufferedInputnewBufferedOutput readBuffer readExactlyreadAllreadAll' unReadBuffer readParser readToMagic readToMagic'readLine readLine' writeBuffer writeBuilder flushBuffer$fExceptionShortReadException$fShowShortReadExceptionValueObjectStringBoolNull parseValue parseValue'parseValueChunksparseValueChunks'valuearrayobjectstring$fArbitraryValue $fNFDataValue $fEqValue $fShowValue$fGenericValue $fToTextValuekvkv'array'object'GConstrFromValuegConstrFromValue GBuildLookup gBuildLookup GFromFields gFromFields LookupTable GFromValue gFromValue FromValue fromValueGConstrEncodeJSONgConstrEncodeJSONGAddPunctuationgAddPunctuation GEncodeJSON gEncodeJSON EncodeJSON encodeJSONGConstrToValuegConstrToValue GMergeFields gMergeFields GWriteFields gWriteFieldsFieldGToValuegToValueToValuetoValueSettingsfieldFmt constrFmt Converter runConverter ConvertError PathElementKeyIndexEmbedded DecodeErrordecode'decode decodeChunks decodeChunks' encodeBytes encodeTextencodeTextBuilderconvertconvert'fail' typeMismatchprependContextfromNullwithBoolwithScientific withRealFloatwithBoundedScientificwithBoundedIntegralwithText withArray withKeyValues withFlatMap withFlatMapR withHashMap withHashMapRwithEmbeddedJSON.:.:?.:! convertFieldconvertFieldMaybeconvertFieldMaybe'defaultSettings$fShowConvertError$fMonadFailConverter$fMonadConverter$fMonadPlusConverter$fAlternativeConverter$fApplicativeConverter$fFunctorConverter $fGToValueM1 $fGToValueM10$fToValueFixed$fToValueRatio$fToValueMaybe$fToValueVersion $fToValue()$fToValueOrdering$fToValueNatural$fToValueInteger$fToValueWord64$fToValueWord32$fToValueWord16$fToValueWord8 $fToValueWord$fToValueInt64$fToValueInt32$fToValueInt16 $fToValueInt8 $fToValueInt$fToValueDouble$fToValueFloat $fToValueChar $fToValueBool$fToValueNonEmpty $fToValue[]$fToValueHashSet$fToValuePrimVector$fToValueVector$fToValueFlatIntSet$fToValueFlatIntMap$fToValueHashMap$fToValueFlatSet$fToValueFlatMap$fToValueScientific $fToValueStr $fToValueText$fToValueValue$fToValueProxy $fGToValueK1$fGWriteFieldsM1$fGWriteFieldsM10$fGWriteFields:*:$fGMergeFieldsM1$fGMergeFieldsM10$fGMergeFields:*: $fGToValueM11$fGConstrToValueM1$fGConstrToValueM10$fGConstrToValueM11$fGConstrToValue:+:$fGConstrToValueV1$fGEncodeJSON:*:$fGEncodeJSONM1$fGEncodeJSONM10$fEncodeJSONFixed$fEncodeJSONRatio$fEncodeJSONMaybe$fEncodeJSONVersion$fEncodeJSON()$fEncodeJSONOrdering$fEncodeJSONNatural$fEncodeJSONInteger$fEncodeJSONWord64$fEncodeJSONWord32$fEncodeJSONWord16$fEncodeJSONWord8$fEncodeJSONWord$fEncodeJSONInt64$fEncodeJSONInt32$fEncodeJSONInt16$fEncodeJSONInt8$fEncodeJSONInt$fEncodeJSONDouble$fEncodeJSONFloat$fEncodeJSONChar$fEncodeJSONBool$fEncodeJSONNonEmpty$fEncodeJSON[]$fEncodeJSONHashSet$fEncodeJSONPrimVector$fEncodeJSONVector$fEncodeJSONFlatIntSet$fEncodeJSONFlatIntMap$fEncodeJSONHashMap$fEncodeJSONFlatSet$fEncodeJSONFlatMap$fEncodeJSONScientific$fEncodeJSONStr$fEncodeJSONText$fEncodeJSONValue$fEncodeJSONProxy$fGEncodeJSONK1$fGAddPunctuationM1$fGAddPunctuationM10$fGAddPunctuation:*:$fGEncodeJSONM11$fGConstrEncodeJSONM1$fGConstrEncodeJSONM10$fGConstrEncodeJSONM11$fGConstrEncodeJSON:+:$fGConstrEncodeJSONV1$fGFromValueM1$fGFromValueM10$fFromValueFixed$fFromValueRatio$fFromValueMaybe$fFromValueVersion $fFromValue()$fFromValueOrdering$fFromValueNatural$fFromValueInteger$fFromValueWord64$fFromValueWord32$fFromValueWord16$fFromValueWord8$fFromValueWord$fFromValueInt64$fFromValueInt32$fFromValueInt16$fFromValueInt8$fFromValueInt$fFromValueFloat$fFromValueDouble$fFromValueChar$fFromValueBool$fFromValueNonEmpty $fFromValue[]$fFromValueHashSet$fFromValuePrimVector$fFromValueVector$fFromValueFlatIntSet$fFromValueFlatIntMap$fFromValueHashMap$fFromValueFlatSet$fFromValueFlatMap$fFromValueScientific$fFromValueStr$fFromValueText$fFromValueValue$fFromValueProxy$fGFromValueK1$fGFromFieldsM1$fGFromFieldsM10$fGFromFields:*:$fGBuildLookupM1$fGBuildLookupM10$fGBuildLookup:*:$fGFromValueM11$fGConstrFromValueM1$fGConstrFromValueM10$fGConstrFromValueM11$fGConstrFromValue:+:$fGConstrFromValueV1$fEqPathElement$fShowPathElement$fOrdPathElement$fGenericPathElement$fNFDataPathElement$fEqConvertError$fOrdConvertError$fGenericConvertError$fNFDataConvertError$fEncodeJSON(,,,,,,)$fEncodeJSON(,,,,,)$fEncodeJSON(,,,,)$fEncodeJSON(,,,)$fEncodeJSON(,,)$fEncodeJSON(,)$fEncodeJSONProduct$fEncodeJSONEither$fEncodeJSONSum$fToValue(,,,,,,)$fToValue(,,,,,)$fToValue(,,,,)$fToValue(,,,) $fToValue(,,) $fToValue(,)$fToValueProduct$fToValueEither $fToValueSum$fFromValue(,,,,,,)$fFromValue(,,,,,)$fFromValue(,,,,)$fFromValue(,,,)$fFromValue(,,)$fFromValue(,)$fFromValueProduct$fFromValueEither$fFromValueSum$fEncodeJSONTagged$fEncodeJSONConst$fEncodeJSONIdentity$fEncodeJSONLast$fEncodeJSONFirst$fEncodeJSONDual$fEncodeJSONWrappedMonoid$fEncodeJSONLast0$fEncodeJSONFirst0$fEncodeJSONMax$fEncodeJSONMin$fEncodeJSONCompose$fToValueTagged$fToValueConst$fToValueIdentity $fToValueLast$fToValueFirst $fToValueDual$fToValueWrappedMonoid$fToValueLast0$fToValueFirst0 $fToValueMax $fToValueMin$fToValueCompose$fFromValueTagged$fFromValueConst$fFromValueIdentity$fFromValueLast$fFromValueFirst$fFromValueDual$fFromValueWrappedMonoid$fFromValueLast0$fFromValueFirst0$fFromValueMax$fFromValueMin$fFromValueCompose snakeCase trainCaseCBytes fromBytesfromTextfromCStringMaybe fromCString fromCStringN withCBytes$fIsStringCBytes$fHashableCBytes$fMonoidCBytes$fSemigroupCBytes $fOrdCBytes $fEqCBytes$fNFDataCBytes $fReadCBytes $fShowCBytesSocketProtocol SocketType SocketFamily PortNumber Inet6AddrInetAddrScopeIDFlowInfoSockAddr SockAddrInet SockAddrInet6htonlntohlhtonsntohs IPPROTO_UDP IPPROTO_TCPSOCK_SEQPACKETSOCK_RDMSOCK_RAW SOCK_DGRAM SOCK_STREAMAF_INET6AF_INET AF_UNSPECsockAddrFamilyinetAny inetBroadcastinetNone inetLoopbackinetUnspecificGroupinetAllHostsGroupinetMaxLocalGroupinetAddrToTupletupleToInetAddrinet6Any inet6Loopbackinet6AddrToTupletupleToInet6Addr peekSockAddr withSockAddrwithSockAddrStorageaNY_PORT$fStorableInetAddr$fShowInetAddr$fStorableInet6Addr$fShowInet6Addr$fStorablePortNumber$fIntegralPortNumber$fRealPortNumber$fNumPortNumber$fEnumPortNumber$fReadPortNumber$fShowPortNumber$fStorableSocketFamily$fStorableSocketType$fStorableSocketProtocol $fEqInetAddr $fOrdInetAddr $fEqInet6Addr$fOrdInet6Addr$fEqPortNumber$fOrdPortNumber$fShowSockAddr $fEqSockAddr $fOrdSockAddr$fShowSocketFamily$fReadSocketFamily$fEqSocketFamily$fOrdSocketFamily$fShowSocketType$fReadSocketType$fEqSocketType$fOrdSocketType$fShowSocketProtocol$fReadSocketProtocol$fEqSocketProtocol$fOrdSocketProtocolLEONencode$fGLEONEncodeM1$fGLEONEncode:*:$fGLEONEncodeU1$fGLEONEncodeV1$fGLEONDecodeM1$fGLEONDecode:*:$fGLEONDecodeU1$fGLEONDecodeV1$fGLEONDecodeK1$fGLEONEncodeK1$fLEONNonEmpty $fLEONArg$fLEONWrappedMonoid $fLEONOption $fLEONLast $fLEONFirst $fLEONMax $fLEONMin $fLEONAlt $fLEONAny $fLEONAll $fLEONLast0 $fLEONFirst0 $fLEONProduct $fLEONSum $fLEONDual $fLEONVersion$fLEONFingerprint $fLEONEither $fLEONMaybe$fLEONIdentity$fLEON(,,,,,,,,,)$fLEON(,,,,,,,,)$fLEON(,,,,,,,)$fLEON(,,,,,,) $fLEON(,,,,,) $fLEON(,,,,) $fLEON(,,,) $fLEON(,,) $fLEON(,)$fLEON()$fLEON[] $fLEONCBytes $fLEONText$fLEONPrimVector $fLEONVector$fLEONBE $fLEONBE0 $fLEONBE1 $fLEONBE2 $fLEONBE3 $fLEONBE4 $fLEONBE5 $fLEONBE6 $fLEONBE7 $fLEONChar $fLEONDouble $fLEONFloat $fLEONInt64 $fLEONInt32 $fLEONInt16 $fLEONWord64 $fLEONWord32 $fLEONWord16$fLEONOrdering $fLEONBool $fLEONBE8 $fLEONInt $fLEONInt8 $fLEONBE9 $fLEONWord $fLEONWord8 $fLEONInteger $fLEONNatural$fGSumDecodeM1$fGSumDecode:+:$fGSumEncodeM1$fGSumEncode:+: $fSumSizeM1 $fSumSize:+:$fGLEONDecode:+:$fGLEONEncode:+: UVHandleType UVSymlinkFlag AccessResult NoExistence NoPermissionAccessOK UVAccessModeUVCopyFileFlagUVStatstDevstModestNlinkstUidstGidstRdevstInostSize stBlksizestBlocksstFlagsstGenstAtimstMtimstCtim stBirthtim UVTimeSpec uvtSecond uvtNanoSecondUVDirEnt DirEntType DirEntUnknown DirEntFile DirEntDir DirEntLink DirEntFIFO DirEntSocket DirEntChar DirEntBlock UVDirEntType UVFileFlag UVFileMode UVTTYMode UVUDPFlag UVMembershipUVHandle UVRunMode UVLoopDataUVLoopUVFD UVSlotUnSafe unsafeGetSlotUVSlotuv_guess_handlehs_uv_fs_realpath_threadedhs_uv_fs_readlink_threadedhs_uv_fs_readlink_extra_cleanuphs_uv_fs_realpathhs_uv_fs_readlinkhs_uv_fs_readlink_cleanuphs_uv_fs_symlink_threadedhs_uv_fs_symlinkhs_uv_fs_link_threaded hs_uv_fs_linkhs_uv_fs_futime_threadedhs_uv_fs_futimehs_uv_fs_utime_threadedhs_uv_fs_utimehs_uv_fs_fchmod_threadedhs_uv_fs_fchmodhs_uv_fs_chmod_threadedhs_uv_fs_chmodhs_uv_fs_access_threadedhs_uv_fs_accesshs_uv_fs_copyfile_threadedhs_uv_fs_copyfilehs_uv_fs_ftruncate_threadedhs_uv_fs_fdatasync_threadedhs_uv_fs_fsync_threadedhs_uv_fs_rename_threadedhs_uv_fs_lstat_threadedhs_uv_fs_fstat_threadedhs_uv_fs_stat_threadedhs_uv_fs_ftruncatehs_uv_fs_fdatasynchs_uv_fs_fsynchs_uv_fs_renamehs_uv_fs_lstaths_uv_fs_fstat hs_uv_fs_staths_uv_fs_scandir_threadedhs_uv_fs_scandir_extra_cleanuphs_uv_fs_scandirhs_uv_fs_scandir_cleanuphs_uv_fs_mkdtemp_threadedhs_uv_fs_rmdir_threadedhs_uv_fs_mkdir_threadedhs_uv_fs_unlink_threadedhs_uv_fs_write_threadedhs_uv_fs_read_threadedhs_uv_fs_close_threadedhs_uv_fs_open_threadedhs_uv_fs_mkdtemphs_uv_fs_rmdirhs_uv_fs_mkdirhs_uv_fs_unlinkhs_uv_fs_write hs_uv_fs_readhs_uv_fs_close hs_uv_fs_openuv_tty_set_mode uv_tty_init uv_pipe_inituv_udp_getsocknamehs_uv_udp_senduv_udp_recv_stophs_uv_udp_recv_startuv_udp_set_ttluv_udp_set_broadcastuv_udp_set_multicast_interfaceuv_udp_set_multicast_ttluv_udp_set_multicast_loopuv_udp_set_membership uv_udp_bind uv_udp_openuv_udp_init_ex uv_udp_iniths_set_socket_reusehs_uv_tcp_connect uv_tcp_binduv_tcp_keepaliveuv_tcp_nodelayuv_tcp_init_ex uv_tcp_iniths_uv_tcp_openhs_uv_accept_check_closehs_uv_accept_check_iniths_uv_accept_check_alloc hs_uv_write uv_read_stophs_uv_read_starths_uv_listen_resume hs_uv_listen hs_uv_cancelhs_uv_handle_closehs_uv_handle_freehs_uv_handle_alloc hs_uv_filenohs_uv_wake_up_asynchs_uv_wake_up_timer uv_loop_alive uv_run_safeuv_runhs_uv_loop_closehs_uv_loop_inituv_version_string uv_versionUV_FILE UV_SIGNALUV_UDPUV_TTYUV_TIMERUV_TCP UV_STREAM UV_PROCESS UV_PREPAREUV_POLL UV_NAMED_PIPEUV_IDLE UV_HANDLE UV_FS_POLL UV_FS_EVENTUV_CHECKUV_ASYNCUV_UNKNOWN_HANDLESYMLINK_JUNCTION SYMLINK_DIRSYMLINK_DEFAULTX_OKW_OKR_OKF_OKCOPYFILE_FICLONE COPYFILE_EXCLCOPYFILE_DEFAULTO_WRONLYO_TRUNC O_TEMPORARYO_SYNC O_SYMLINK O_SHORT_LIVED O_SEQUENTIALO_RDWRO_RDONLYO_RANDOM O_NONBLOCK O_NOFOLLOWO_NOCTTY O_NOATIMEO_EXLOCKO_EXCLO_DSYNC O_DIRECTORYO_DIRECTO_CREATO_APPEND DEFAULT_MODES_IXOTHS_IWOTHS_IROTHS_IRWXOS_IXGRPS_IWGRPS_IRGRPS_IRWXGS_IXUSRS_IWUSRS_IRUSRS_IRWXUUV_TTY_MODE_IOUV_TTY_MODE_RAWUV_TTY_MODE_NORMALUV_UDP_PARTIALUV_UDP_REUSEADDRUV_UDP_IPV6ONLYUV_UDP_DEFAULT UV_JOIN_GROUPUV_LEAVE_GROUP UV_RUN_NOWAIT UV_RUN_ONCEUV_RUN_DEFAULTINIT_LOOP_SIZESO_REUSEPORT_LOAD_BALANCEACCEPT_BUFFER_SIZEpeekUVEventQueueclearUVEventCounterpeekUVBufferTablepeekUVLoopDatapeekUVHandleDatauV_TCP_IPV6ONLYfromUVDirEntType uV__DT_FILE uV__DT_DIR uV__DT_LINK uV__DT_FIFO uV__DT_SOCKET uV__DT_CHAR uV__DT_BLOCK peekUVDirEnt uvStatSize peekUVStat$fStorableUVTimeSpec $fEqUVRunMode$fOrdUVRunMode$fReadUVRunMode$fShowUVRunMode$fFiniteBitsUVRunMode$fBitsUVRunMode$fStorableUVRunMode$fNumUVRunMode$fShowUVMembership$fEqUVMembership$fOrdUVMembership$fShowUVUDPFlag $fEqUVUDPFlag$fOrdUVUDPFlag$fStorableUVUDPFlag$fBitsUVUDPFlag$fFiniteBitsUVUDPFlag$fNumUVUDPFlag $fEqUVTTYMode$fOrdUVTTYMode$fReadUVTTYMode$fShowUVTTYMode$fFiniteBitsUVTTYMode$fBitsUVTTYMode$fStorableUVTTYMode$fNumUVTTYMode$fEqUVFileMode$fOrdUVFileMode$fReadUVFileMode$fShowUVFileMode$fFiniteBitsUVFileMode$fBitsUVFileMode$fStorableUVFileMode$fNumUVFileMode$fEqUVFileFlag$fOrdUVFileFlag$fReadUVFileFlag$fShowUVFileFlag$fFiniteBitsUVFileFlag$fBitsUVFileFlag$fStorableUVFileFlag$fNumUVFileFlag$fEqUVDirEntType$fOrdUVDirEntType$fReadUVDirEntType$fShowUVDirEntType$fFiniteBitsUVDirEntType$fBitsUVDirEntType$fStorableUVDirEntType$fNumUVDirEntType$fReadDirEntType$fShowDirEntType$fEqDirEntType$fOrdDirEntType$fGenericDirEntType$fShowUVTimeSpec$fReadUVTimeSpec$fEqUVTimeSpec$fOrdUVTimeSpec$fGenericUVTimeSpec $fShowUVStat $fReadUVStat $fEqUVStat $fOrdUVStat$fGenericUVStat$fEqUVCopyFileFlag$fOrdUVCopyFileFlag$fReadUVCopyFileFlag$fShowUVCopyFileFlag$fFiniteBitsUVCopyFileFlag$fBitsUVCopyFileFlag$fStorableUVCopyFileFlag$fNumUVCopyFileFlag$fEqUVAccessMode$fOrdUVAccessMode$fReadUVAccessMode$fShowUVAccessMode$fFiniteBitsUVAccessMode$fBitsUVAccessMode$fStorableUVAccessMode$fNumUVAccessMode$fShowAccessResult$fEqAccessResult$fOrdAccessResult$fEqUVSymlinkFlag$fOrdUVSymlinkFlag$fReadUVSymlinkFlag$fShowUVSymlinkFlag$fFiniteBitsUVSymlinkFlag$fBitsUVSymlinkFlag$fStorableUVSymlinkFlag$fNumUVSymlinkFlag$fEqUVHandleType$fOrdUVHandleType$fReadUVHandleType$fShowUVHandleType$fStorableUVHandleTypeUVStream uvsHandleuvsSlot uvsManager uvsClosed UVManager getUVManager getBlockMVarpokeBufferTablepeekBufferTable withUVManagerwithUVManager_ getUVSlot withUVRequestwithUVRequest_withUVRequest'withUVRequestExforkBa initUVStream $fEqUVManager$fShowUVManager$fOutputUVStream$fInputUVStream$fShowUVStream UDPConfig recvMsgSize recvBatchSize sendMsgSize localUDPAddrUDP udpHandleudpSlot udpManagerudpRecvLargeBufferudpRecvBufferSizudpRecvBufferArray udpSendBuffer udpCloseddefaultUDPConfiginitUDPrecvUDPsendUDP getSockName setMembershipsetMulticastLoopsetMulticastTTLsetMulticastInterface setBroadcastsetTTL $fShowUDP$fShowUDPConfig $fEqUDPConfig$fOrdUDPConfig ServerConfig serverAddr serverBackLog serverWorkerserverWorkerNoDelay ClientConfigclientLocalAddrclientTargetAddr clientNoDelaydefaultClientConfig initClientdefaultServerConfig startServer $fShowTCP $fInputTCP $fOutputTCP StdStreamisStdStreamTTYstdinstdoutstderrstdinBuf stdoutBuf stderrBufsetStdinTTYModeprintStdputStd putLineStd readLineStd$fOutputStdStream$fInputStdStream LoggerConfigloggerMinFlushInterval loggerTsCacheloggerLineBufSizeloggerShowDebug loggerShowTS loggerFlush newLogger setStdLogger getStdLogger withStdLoggerdebuginfowarnfatal otherLevel debugWithinfoWithwarnWith fatalWithotherLevelWith UVFileWriter UVFileReaderUVFilenewUVFileReaderpeekUVFileReadernewUVFileWriterpeekUVFileWriter initUVFilemkdirunlinkmkdtemprmdirscandirstatlstatfstatrenamefsync fdatasync ftruncatecopyfileaccesschmodfchmodutimefutimelinksymlinkreadlinkrealpath$fOutputUVFile $fInputUVFile $fShowUVFile$fInputUVFileReader$fOutputUVFileWriterPtr GHC.TypesIntAddr#template-haskellLanguage.Haskell.TH.SyntaxLitEChar GHC.MaybeNothingGHC.WordWord8FunctorseqJustelemIndexBytesTrueGHC.ListzipWithscanlscanr GHC.ClassesOrdGHC.IntInt8nullPtr TimerListsetNumCapabilities Data.FunctorvoidTimeOutExceptionensureLowResTimerManagerstartLowResTimerManagerfireLowResTimerQueueEntryIOControl.Monad.IO.ClassMonadIOMutableByteArray# ByteArray# realWorld#void# unsafeCoerce# nullAddr# magicDictcoerceproxy#Array#Char#Double#Float#Int#Int32#Int64#Weak# MutableArray#MVar# StablePtr# ArrayArray#MutableArrayArray#State# StableName#MutVar#Void#Word#Word32#Word64# ThreadId#BCO#TVar#Compact#Proxy# SmallArray#SmallMutableArray#Int8X16#Int16X8#Int32X4#Int64X2#Int8X32# Int16X16#Int32X8#Int64X4#Int8X64# Int16X32# Int32X16#Int64X8# Word8X16# Word16X8# Word32X4# Word64X2# Word8X32# Word16X16# Word32X8# Word64X4# Word8X64# Word16X32# Word32X16# Word64X8#FloatX4# DoubleX2#FloatX8# DoubleX4# FloatX16# DoubleX8#gtChar#geChar#eqChar#neChar#ltChar#leChar#ord#+#-#*#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# addWordC# subWordC# plusWord2# minusWord# timesWord# timesWord2# quotWord#remWord# quotRemWord# quotRemWord2#and#or#xor#not#uncheckedShiftL#uncheckedShiftRL# word2Int#gtWord#geWord#eqWord#neWord#ltWord#leWord#popCnt8# popCnt16# popCnt32# popCnt64#popCnt#pdep8#pdep16#pdep32#pdep64#pdep#pext8#pext16#pext32#pext64#pext#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# narrow8Int# narrow16Int# narrow32Int# narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble# fabsDouble# double2Int# double2Float# expDouble# logDouble# sqrtDouble# sinDouble# cosDouble# tanDouble# asinDouble# acosDouble# atanDouble# sinhDouble# coshDouble# tanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat# minusFloat# timesFloat# divideFloat# negateFloat# fabsFloat# float2Int# expFloat# logFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat# powerFloat# float2Double#decodeFloat_Int# newArray#sameMutableArray# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#sameSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#sameMutableByteArray#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexInt16Array#indexInt32Array#indexInt64Array#indexWord8Array#indexWord16Array#indexWord32Array#indexWord64Array#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsInt32#indexWord8ArrayAsInt64#indexWord8ArrayAsInt#indexWord8ArrayAsWord16#indexWord8ArrayAsWord32#indexWord8ArrayAsWord64#indexWord8ArrayAsWord#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readInt16Array#readInt32Array#readInt64Array#readWord8Array#readWord16Array#readWord32Array#readWord64Array#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsInt32#readWord8ArrayAsInt64#readWord8ArrayAsInt#readWord8ArrayAsWord16#readWord8ArrayAsWord32#readWord8ArrayAsWord64#readWord8ArrayAsWord#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeInt16Array#writeInt32Array#writeInt64Array#writeWord8Array#writeWord16Array#writeWord32Array#writeWord64Array#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsInt32#writeWord8ArrayAsInt64#writeWord8ArrayAsInt#writeWord8ArrayAsWord16#writeWord8ArrayAsWord32#writeWord8ArrayAsWord64#writeWord8ArrayAsWord#compareByteArrays#copyByteArray#copyMutableByteArray#copyByteArrayToAddr#copyMutableByteArrayToAddr#copyAddrToByteArray#atomicReadIntArray#atomicWriteIntArray# casIntArray#fetchAddIntArray#fetchSubIntArray#fetchAndIntArray#fetchNandIntArray#fetchOrIntArray#fetchXorIntArray#newArrayArray#sameMutableArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray# plusAddr# minusAddr#remAddr# addr2Int# int2Addr#gtAddr#geAddr#eqAddr#neAddr#ltAddr#leAddr#indexCharOffAddr#indexWideCharOffAddr#indexIntOffAddr#indexWordOffAddr#indexAddrOffAddr#indexFloatOffAddr#indexDoubleOffAddr#indexStablePtrOffAddr#indexInt8OffAddr#indexInt16OffAddr#indexInt32OffAddr#indexInt64OffAddr#indexWord8OffAddr#indexWord16OffAddr#indexWord32OffAddr#indexWord64OffAddr#readCharOffAddr#readWideCharOffAddr#readIntOffAddr#readWordOffAddr#readAddrOffAddr#readFloatOffAddr#readDoubleOffAddr#readStablePtrOffAddr#readInt8OffAddr#readInt16OffAddr#readInt32OffAddr#readInt64OffAddr#readWord8OffAddr#readWord16OffAddr#readWord32OffAddr#readWord64OffAddr#writeCharOffAddr#writeWideCharOffAddr#writeIntOffAddr#writeWordOffAddr#writeAddrOffAddr#writeFloatOffAddr#writeDoubleOffAddr#writeStablePtrOffAddr#writeInt8OffAddr#writeInt16OffAddr#writeInt32OffAddr#writeInt64OffAddr#writeWord8OffAddr#writeWord16OffAddr#writeWord32OffAddr#writeWord64OffAddr# newMutVar# readMutVar# writeMutVar# sameMutVar#atomicModifyMutVar# casMutVar#catch#raise#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# atomically#retry# catchRetry# catchSTM#newTVar# readTVar# readTVarIO# writeTVar# sameTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# sameMVar# isEmptyMVar#delay# waitRead# waitWrite#fork#forkOn# killThread#yield# myThreadId# labelThread#isCurrentThreadBound# noDuplicate# threadStatus#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName# eqStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark#seq# getSpark# numSparks# dataToTag# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure#getApStackVal# getCCSOf#getCurrentCCS# clearCCS# traceEvent# traceMarker#getThreadAllocationCounter#setThreadAllocationCounter#broadcastInt8X16#broadcastInt16X8#broadcastInt32X4#broadcastInt64X2#broadcastInt8X32#broadcastInt16X16#broadcastInt32X8#broadcastInt64X4#broadcastInt8X64#broadcastInt16X32#broadcastInt32X16#broadcastInt64X8#broadcastWord8X16#broadcastWord16X8#broadcastWord32X4#broadcastWord64X2#broadcastWord8X32#broadcastWord16X16#broadcastWord32X8#broadcastWord64X4#broadcastWord8X64#broadcastWord16X32#broadcastWord32X16#broadcastWord64X8#broadcastFloatX4#broadcastDoubleX2#broadcastFloatX8#broadcastDoubleX4#broadcastFloatX16#broadcastDoubleX8# packInt8X16# packInt16X8# packInt32X4# packInt64X2# packInt8X32# packInt16X16# packInt32X8# packInt64X4# packInt8X64# packInt16X32# packInt32X16# packInt64X8# packWord8X16# packWord16X8# packWord32X4# packWord64X2# packWord8X32#packWord16X16# packWord32X8# packWord64X4# packWord8X64#packWord16X32#packWord32X16# packWord64X8# packFloatX4# packDoubleX2# packFloatX8# packDoubleX4# packFloatX16# packDoubleX8#unpackInt8X16#unpackInt16X8#unpackInt32X4#unpackInt64X2#unpackInt8X32#unpackInt16X16#unpackInt32X8#unpackInt64X4#unpackInt8X64#unpackInt16X32#unpackInt32X16#unpackInt64X8#unpackWord8X16#unpackWord16X8#unpackWord32X4#unpackWord64X2#unpackWord8X32#unpackWord16X16#unpackWord32X8#unpackWord64X4#unpackWord8X64#unpackWord16X32#unpackWord32X16#unpackWord64X8#unpackFloatX4#unpackDoubleX2#unpackFloatX8#unpackDoubleX4#unpackFloatX16#unpackDoubleX8#insertInt8X16#insertInt16X8#insertInt32X4#insertInt64X2#insertInt8X32#insertInt16X16#insertInt32X8#insertInt64X4#insertInt8X64#insertInt16X32#insertInt32X16#insertInt64X8#insertWord8X16#insertWord16X8#insertWord32X4#insertWord64X2#insertWord8X32#insertWord16X16#insertWord32X8#insertWord64X4#insertWord8X64#insertWord16X32#insertWord32X16#insertWord64X8#insertFloatX4#insertDoubleX2#insertFloatX8#insertDoubleX4#insertFloatX16#insertDoubleX8# plusInt8X16# plusInt16X8# plusInt32X4# plusInt64X2# plusInt8X32# plusInt16X16# plusInt32X8# plusInt64X4# plusInt8X64# plusInt16X32# plusInt32X16# plusInt64X8# plusWord8X16# plusWord16X8# plusWord32X4# plusWord64X2# plusWord8X32#plusWord16X16# plusWord32X8# plusWord64X4# plusWord8X64#plusWord16X32#plusWord32X16# plusWord64X8# plusFloatX4# plusDoubleX2# plusFloatX8# plusDoubleX4# plusFloatX16# plusDoubleX8# minusInt8X16# minusInt16X8# minusInt32X4# minusInt64X2# minusInt8X32#minusInt16X16# minusInt32X8# minusInt64X4# minusInt8X64#minusInt16X32#minusInt32X16# minusInt64X8#minusWord8X16#minusWord16X8#minusWord32X4#minusWord64X2#minusWord8X32#minusWord16X16#minusWord32X8#minusWord64X4#minusWord8X64#minusWord16X32#minusWord32X16#minusWord64X8# minusFloatX4#minusDoubleX2# minusFloatX8#minusDoubleX4#minusFloatX16#minusDoubleX8# timesInt8X16# timesInt16X8# timesInt32X4# timesInt64X2# timesInt8X32#timesInt16X16# timesInt32X8# timesInt64X4# timesInt8X64#timesInt16X32#timesInt32X16# timesInt64X8#timesWord8X16#timesWord16X8#timesWord32X4#timesWord64X2#timesWord8X32#timesWord16X16#timesWord32X8#timesWord64X4#timesWord8X64#timesWord16X32#timesWord32X16#timesWord64X8# timesFloatX4#timesDoubleX2# timesFloatX8#timesDoubleX4#timesFloatX16#timesDoubleX8#divideFloatX4#divideDoubleX2#divideFloatX8#divideDoubleX4#divideFloatX16#divideDoubleX8# quotInt8X16# quotInt16X8# quotInt32X4# quotInt64X2# quotInt8X32# quotInt16X16# quotInt32X8# quotInt64X4# quotInt8X64# quotInt16X32# quotInt32X16# quotInt64X8# quotWord8X16# quotWord16X8# quotWord32X4# quotWord64X2# quotWord8X32#quotWord16X16# quotWord32X8# quotWord64X4# quotWord8X64#quotWord16X32#quotWord32X16# quotWord64X8# remInt8X16# remInt16X8# remInt32X4# remInt64X2# remInt8X32# remInt16X16# remInt32X8# remInt64X4# remInt8X64# remInt16X32# remInt32X16# remInt64X8# remWord8X16# remWord16X8# remWord32X4# remWord64X2# remWord8X32# remWord16X16# remWord32X8# remWord64X4# remWord8X64# remWord16X32# remWord32X16# remWord64X8#negateInt8X16#negateInt16X8#negateInt32X4#negateInt64X2#negateInt8X32#negateInt16X16#negateInt32X8#negateInt64X4#negateInt8X64#negateInt16X32#negateInt32X16#negateInt64X8#negateFloatX4#negateDoubleX2#negateFloatX8#negateDoubleX4#negateFloatX16#negateDoubleX8#indexInt8X16Array#indexInt16X8Array#indexInt32X4Array#indexInt64X2Array#indexInt8X32Array#indexInt16X16Array#indexInt32X8Array#indexInt64X4Array#indexInt8X64Array#indexInt16X32Array#indexInt32X16Array#indexInt64X8Array#indexWord8X16Array#indexWord16X8Array#indexWord32X4Array#indexWord64X2Array#indexWord8X32Array#indexWord16X16Array#indexWord32X8Array#indexWord64X4Array#indexWord8X64Array#indexWord16X32Array#indexWord32X16Array#indexWord64X8Array#indexFloatX4Array#indexDoubleX2Array#indexFloatX8Array#indexDoubleX4Array#indexFloatX16Array#indexDoubleX8Array#readInt8X16Array#readInt16X8Array#readInt32X4Array#readInt64X2Array#readInt8X32Array#readInt16X16Array#readInt32X8Array#readInt64X4Array#readInt8X64Array#readInt16X32Array#readInt32X16Array#readInt64X8Array#readWord8X16Array#readWord16X8Array#readWord32X4Array#readWord64X2Array#readWord8X32Array#readWord16X16Array#readWord32X8Array#readWord64X4Array#readWord8X64Array#readWord16X32Array#readWord32X16Array#readWord64X8Array#readFloatX4Array#readDoubleX2Array#readFloatX8Array#readDoubleX4Array#readFloatX16Array#readDoubleX8Array#writeInt8X16Array#writeInt16X8Array#writeInt32X4Array#writeInt64X2Array#writeInt8X32Array#writeInt16X16Array#writeInt32X8Array#writeInt64X4Array#writeInt8X64Array#writeInt16X32Array#writeInt32X16Array#writeInt64X8Array#writeWord8X16Array#writeWord16X8Array#writeWord32X4Array#writeWord64X2Array#writeWord8X32Array#writeWord16X16Array#writeWord32X8Array#writeWord64X4Array#writeWord8X64Array#writeWord16X32Array#writeWord32X16Array#writeWord64X8Array#writeFloatX4Array#writeDoubleX2Array#writeFloatX8Array#writeDoubleX4Array#writeFloatX16Array#writeDoubleX8Array#indexInt8X16OffAddr#indexInt16X8OffAddr#indexInt32X4OffAddr#indexInt64X2OffAddr#indexInt8X32OffAddr#indexInt16X16OffAddr#indexInt32X8OffAddr#indexInt64X4OffAddr#indexInt8X64OffAddr#indexInt16X32OffAddr#indexInt32X16OffAddr#indexInt64X8OffAddr#indexWord8X16OffAddr#indexWord16X8OffAddr#indexWord32X4OffAddr#indexWord64X2OffAddr#indexWord8X32OffAddr#indexWord16X16OffAddr#indexWord32X8OffAddr#indexWord64X4OffAddr#indexWord8X64OffAddr#indexWord16X32OffAddr#indexWord32X16OffAddr#indexWord64X8OffAddr#indexFloatX4OffAddr#indexDoubleX2OffAddr#indexFloatX8OffAddr#indexDoubleX4OffAddr#indexFloatX16OffAddr#indexDoubleX8OffAddr#readInt8X16OffAddr#readInt16X8OffAddr#readInt32X4OffAddr#readInt64X2OffAddr#readInt8X32OffAddr#readInt16X16OffAddr#readInt32X8OffAddr#readInt64X4OffAddr#readInt8X64OffAddr#readInt16X32OffAddr#readInt32X16OffAddr#readInt64X8OffAddr#readWord8X16OffAddr#readWord16X8OffAddr#readWord32X4OffAddr#readWord64X2OffAddr#readWord8X32OffAddr#readWord16X16OffAddr#readWord32X8OffAddr#readWord64X4OffAddr#readWord8X64OffAddr#readWord16X32OffAddr#readWord32X16OffAddr#readWord64X8OffAddr#readFloatX4OffAddr#readDoubleX2OffAddr#readFloatX8OffAddr#readDoubleX4OffAddr#readFloatX16OffAddr#readDoubleX8OffAddr#writeInt8X16OffAddr#writeInt16X8OffAddr#writeInt32X4OffAddr#writeInt64X2OffAddr#writeInt8X32OffAddr#writeInt16X16OffAddr#writeInt32X8OffAddr#writeInt64X4OffAddr#writeInt8X64OffAddr#writeInt16X32OffAddr#writeInt32X16OffAddr#writeInt64X8OffAddr#writeWord8X16OffAddr#writeWord16X8OffAddr#writeWord32X4OffAddr#writeWord64X2OffAddr#writeWord8X32OffAddr#writeWord16X16OffAddr#writeWord32X8OffAddr#writeWord64X4OffAddr#writeWord8X64OffAddr#writeWord16X32OffAddr#writeWord32X16OffAddr#writeWord64X8OffAddr#writeFloatX4OffAddr#writeDoubleX2OffAddr#writeFloatX8OffAddr#writeDoubleX4OffAddr#writeFloatX16OffAddr#writeDoubleX8OffAddr#indexInt8ArrayAsInt8X16#indexInt16ArrayAsInt16X8#indexInt32ArrayAsInt32X4#indexInt64ArrayAsInt64X2#indexInt8ArrayAsInt8X32#indexInt16ArrayAsInt16X16#indexInt32ArrayAsInt32X8#indexInt64ArrayAsInt64X4#indexInt8ArrayAsInt8X64#indexInt16ArrayAsInt16X32#indexInt32ArrayAsInt32X16#indexInt64ArrayAsInt64X8#indexWord8ArrayAsWord8X16#indexWord16ArrayAsWord16X8#indexWord32ArrayAsWord32X4#indexWord64ArrayAsWord64X2#indexWord8ArrayAsWord8X32#indexWord16ArrayAsWord16X16#indexWord32ArrayAsWord32X8#indexWord64ArrayAsWord64X4#indexWord8ArrayAsWord8X64#indexWord16ArrayAsWord16X32#indexWord32ArrayAsWord32X16#indexWord64ArrayAsWord64X8#indexFloatArrayAsFloatX4#indexDoubleArrayAsDoubleX2#indexFloatArrayAsFloatX8#indexDoubleArrayAsDoubleX4#indexFloatArrayAsFloatX16#indexDoubleArrayAsDoubleX8#readInt8ArrayAsInt8X16#readInt16ArrayAsInt16X8#readInt32ArrayAsInt32X4#readInt64ArrayAsInt64X2#readInt8ArrayAsInt8X32#readInt16ArrayAsInt16X16#readInt32ArrayAsInt32X8#readInt64ArrayAsInt64X4#readInt8ArrayAsInt8X64#readInt16ArrayAsInt16X32#readInt32ArrayAsInt32X16#readInt64ArrayAsInt64X8#readWord8ArrayAsWord8X16#readWord16ArrayAsWord16X8#readWord32ArrayAsWord32X4#readWord64ArrayAsWord64X2#readWord8ArrayAsWord8X32#readWord16ArrayAsWord16X16#readWord32ArrayAsWord32X8#readWord64ArrayAsWord64X4#readWord8ArrayAsWord8X64#readWord16ArrayAsWord16X32#readWord32ArrayAsWord32X16#readWord64ArrayAsWord64X8#readFloatArrayAsFloatX4#readDoubleArrayAsDoubleX2#readFloatArrayAsFloatX8#readDoubleArrayAsDoubleX4#readFloatArrayAsFloatX16#readDoubleArrayAsDoubleX8#writeInt8ArrayAsInt8X16#writeInt16ArrayAsInt16X8#writeInt32ArrayAsInt32X4#writeInt64ArrayAsInt64X2#writeInt8ArrayAsInt8X32#writeInt16ArrayAsInt16X16#writeInt32ArrayAsInt32X8#writeInt64ArrayAsInt64X4#writeInt8ArrayAsInt8X64#writeInt16ArrayAsInt16X32#writeInt32ArrayAsInt32X16#writeInt64ArrayAsInt64X8#writeWord8ArrayAsWord8X16#writeWord16ArrayAsWord16X8#writeWord32ArrayAsWord32X4#writeWord64ArrayAsWord64X2#writeWord8ArrayAsWord8X32#writeWord16ArrayAsWord16X16#writeWord32ArrayAsWord32X8#writeWord64ArrayAsWord64X4#writeWord8ArrayAsWord8X64#writeWord16ArrayAsWord16X32#writeWord32ArrayAsWord32X16#writeWord64ArrayAsWord64X8#writeFloatArrayAsFloatX4#writeDoubleArrayAsDoubleX2#writeFloatArrayAsFloatX8#writeDoubleArrayAsDoubleX4#writeFloatArrayAsFloatX16#writeDoubleArrayAsDoubleX8#indexInt8OffAddrAsInt8X16#indexInt16OffAddrAsInt16X8#indexInt32OffAddrAsInt32X4#indexInt64OffAddrAsInt64X2#indexInt8OffAddrAsInt8X32#indexInt16OffAddrAsInt16X16#indexInt32OffAddrAsInt32X8#indexInt64OffAddrAsInt64X4#indexInt8OffAddrAsInt8X64#indexInt16OffAddrAsInt16X32#indexInt32OffAddrAsInt32X16#indexInt64OffAddrAsInt64X8#indexWord8OffAddrAsWord8X16#indexWord16OffAddrAsWord16X8#indexWord32OffAddrAsWord32X4#indexWord64OffAddrAsWord64X2#indexWord8OffAddrAsWord8X32#indexWord16OffAddrAsWord16X16#indexWord32OffAddrAsWord32X8#indexWord64OffAddrAsWord64X4#indexWord8OffAddrAsWord8X64#indexWord16OffAddrAsWord16X32#indexWord32OffAddrAsWord32X16#indexWord64OffAddrAsWord64X8#indexFloatOffAddrAsFloatX4#indexDoubleOffAddrAsDoubleX2#indexFloatOffAddrAsFloatX8#indexDoubleOffAddrAsDoubleX4#indexFloatOffAddrAsFloatX16#indexDoubleOffAddrAsDoubleX8#readInt8OffAddrAsInt8X16#readInt16OffAddrAsInt16X8#readInt32OffAddrAsInt32X4#readInt64OffAddrAsInt64X2#readInt8OffAddrAsInt8X32#readInt16OffAddrAsInt16X16#readInt32OffAddrAsInt32X8#readInt64OffAddrAsInt64X4#readInt8OffAddrAsInt8X64#readInt16OffAddrAsInt16X32#readInt32OffAddrAsInt32X16#readInt64OffAddrAsInt64X8#readWord8OffAddrAsWord8X16#readWord16OffAddrAsWord16X8#readWord32OffAddrAsWord32X4#readWord64OffAddrAsWord64X2#readWord8OffAddrAsWord8X32#readWord16OffAddrAsWord16X16#readWord32OffAddrAsWord32X8#readWord64OffAddrAsWord64X4#readWord8OffAddrAsWord8X64#readWord16OffAddrAsWord16X32#readWord32OffAddrAsWord32X16#readWord64OffAddrAsWord64X8#readFloatOffAddrAsFloatX4#readDoubleOffAddrAsDoubleX2#readFloatOffAddrAsFloatX8#readDoubleOffAddrAsDoubleX4#readFloatOffAddrAsFloatX16#readDoubleOffAddrAsDoubleX8#writeInt8OffAddrAsInt8X16#writeInt16OffAddrAsInt16X8#writeInt32OffAddrAsInt32X4#writeInt64OffAddrAsInt64X2#writeInt8OffAddrAsInt8X32#writeInt16OffAddrAsInt16X16#writeInt32OffAddrAsInt32X8#writeInt64OffAddrAsInt64X4#writeInt8OffAddrAsInt8X64#writeInt16OffAddrAsInt16X32#writeInt32OffAddrAsInt32X16#writeInt64OffAddrAsInt64X8#writeWord8OffAddrAsWord8X16#writeWord16OffAddrAsWord16X8#writeWord32OffAddrAsWord32X4#writeWord64OffAddrAsWord64X2#writeWord8OffAddrAsWord8X32#writeWord16OffAddrAsWord16X16#writeWord32OffAddrAsWord32X8#writeWord64OffAddrAsWord64X4#writeWord8OffAddrAsWord8X64#writeWord16OffAddrAsWord16X32#writeWord32OffAddrAsWord32X16#writeWord64OffAddrAsWord64X8#writeFloatOffAddrAsFloatX4#writeDoubleOffAddrAsDoubleX2#writeFloatOffAddrAsFloatX8#writeDoubleOffAddrAsDoubleX4#writeFloatOffAddrAsFloatX16#writeDoubleOffAddrAsDoubleX8#prefetchByteArray3#prefetchMutableByteArray3#prefetchAddr3#prefetchValue3#prefetchByteArray2#prefetchMutableByteArray2#prefetchAddr2#prefetchValue2#prefetchByteArray1#prefetchMutableByteArray1#prefetchAddr1#prefetchValue1#prefetchByteArray0#prefetchMutableByteArray0#prefetchAddr0#prefetchValue0# advancePtrcopyPtr indexOffPtrmovePtr readOffPtrsetPtr subtractPtr writeOffPtr Data.StringIsStringGHC.EnumBoundedGHC.RealIntegralWord64 integer-gmpGHC.Integer.TypeIntegeri2cDec Data.Bits FiniteBitsFloatDoubledoFmt c_grisu3_spc_grisu3writePositiveDecGHC.ShowShowshow Data.EitherRightLeftData.TraversabletraverseMonadfailFalse Text.ReadreadscientificallyInternalscientificallyInternal'array_object_)scientific-0.3.6.2-8YValhgNmOhHWycRs0S2C7Data.Scientific Scientific commaList' commaVec' CBytesOnHeap CBytesLiteralForeign.C.StringCString fromIntegralGHC.MVarMVarstartUVManager cancelUVReqTCPdefaultLoggerConfigdefaultTSCacheflushDefaultLogger