!t[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l mnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                     ! " # $ % & ' ( ) * + ,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""""###############$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''',Numeric to ASCII digits table.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNoneF\cdecdePrimitive bits twiddling(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone FcNvstdioSearch a word8 in array.MCurrently this function is ~4 times slow than c version, so we didn't use it.wstdioThe unboxed version of vxstdio&Search a word8 array in reverse order.This function is used in  elemIndexEnd , since there's no c equivalent.ystdioThe unboxed version of xrstuvwxystuvwxyrPrimitive casting+Haskell Foundation, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,8=?@AFfzstdioz* between primitive types of the same size.z{z{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 p) 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 (9 "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 p 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 p 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 arraysJ;:9^i_`abjfghklmnopqJpqno^i_`abjfghkml;:9(Bounded checked boxed and unboxed arrays(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNoneHV;stdio.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.=;:9nopq=pqno;:9 *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=?FƂstdiobig endianess wrapperstdiolittle endianess wrapperstdio/Primitive types which can be unaligned accessed         (c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNoneF_6stdioAA mutable variable in the ST monad which can hold an instance of ^.8stdio Build a new 69stdioRead the value of an 6:stdioWrite a new value into an 6;stdioMutate the contents of an 6.8Unboxed reference is always strict on the value it hold.6789:;6789:;((c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone689:;689:; (c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNoneF<stdioBAlias for 'PrimIORef Int' which support several atomic operations.=stdioAA mutable variable in the IO monad which can hold an instance of ^.>stdio Build a new =?stdioRead the value of an =@stdioWrite a new value into an =AstdioMutate the contents of an IORef.8Unboxed reference is always strict on the value it hold.Bstdio Build a new <CstdioAtomically add a <, return the value AFTER added.DstdioAtomically add a < , return the value BEFORE added.EstdioAtomically add a <.FstdioAtomically sub a < , return the value AFTER subbed.GstdioAtomically sub a <!, return the value BEFORE subbed.HstdioAtomically sub a <IstdioAtomically and a <, return the value AFTER anded.JstdioAtomically and a < , return the value BEFORE anded.KstdioAtomically and a <LstdioAtomically nand a < , return the value AFTER nanded.MstdioAtomically nand a <!, return the value BEFORE nanded.NstdioAtomically nand a <OstdioAtomically or a <, return the value AFTER ored.PstdioAtomically or a <, return the value BEFORE ored.QstdioAtomically or a <RstdioAtomically xor a <, return the value AFTER xored.SstdioAtomically xor a < , return the value BEFORE xored.TstdioAtomically xor a <<=>?@ABCDEFGHIJKLMNOPQRST=>?@A<BDGJMPSCFILOREHKNQT UTF-8 codecs and helpers.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneF [Ustdio,Return a codepoint's encoded length in bytesRIf the codepoint is invalid, we return 3(encoded bytes length of replacement char U+FFFD).Vstdio Encode a  into bytes, write l for invalid unicode codepoint.]This function assumed there're enough space for encoded bytes, and return the advanced index.WstdioThe unboxed version of V.This function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.Xstdio 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.YstdioThe unboxed version of X.Zstdio 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.\stdioThe unboxed version of ZThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.]stdio$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.^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 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.astdioThe unboxed version of _This function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.bstdio6Decode 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.cstdioThe unboxed version of bThis function is marked as NOINLINEO to reduce code size, and stop messing up simplifier due to too much branches.jstdioZUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.kstdioZUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.lstdioxFFFD, which will be encoded as 0xEF 0xBF 0xBD 3 bytes.UVWXYZ[\]^_`abcdefghijklUVWXYZ[\]^_`abcdefghijklErrno provided by libuv(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableNone7MwmstdioUnicode categories. See )-, you can combine categories with bitwise or.sstdio*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 xstdioLocale for case mapping.~stdiosee s in Std.Data.Text.BaseHmnorqpswvutxyz{|}~Hxy{|}~swvutorqpmnzFast boxed and unboxed vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone %2=>?@AFHSVXgqEstdioOIndex 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.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 backwardsstdioBStrict 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 resultsstdioO(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 vector stdioThe  ( 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.stdioO(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.stdio.The chunk size used for I/O. Currently set to 32k-chunkOverheadstdio-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 vectorsstdiopayloadstdiooffsetstdiolengthstdiolength 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 lengthR     R     !vectors literals using QuasiQuote(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneF! 6789:;<=>?@ 6789:;<=>?@Searching vectors(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FXAstdioO(n) The A function extends [, by returning the indices of all elements equal to the query element, in ascending order.BstdioThe D} function takes a predicate and a vector and returns the index of the first element in the vector satisfying the predicate.CstdioO(n) Special A for  using  memchr(3)Dstdio findIndex f v = fst (find f v)Estdio  findIndexR f v = fst (findR f v)FstdioO(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).GstdioO(n) Special G for  using  memchr(3)HstdioO(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)'.IstdioO(n) Special H for  with handle roll bit twiddling.JstdioO(n) Jo, applied to a predicate and a vector, returns a vector containing those elements that satisfy the predicate.KstdioO(n) The K 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)LstdioO(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#SECTION0080MstdioO(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)NstdioO(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]OstdioO(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.PstdioO(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].QstdioO(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.Rstdio.O(1) Test if a bloom filter contain a certain .Lstdiovector to search for (needle)stdiovector to search in (haystack)stdio+report partial match at the end of haystackMstdiobytes to search for (needle)stdiobytes to search in (haystack)stdio+report partial match at the end of haystackOstdiobytes to search for (needle)stdiobytes to search in (haystack)stdio+report partial match at the end of haystackABCDEFGHIJKLMNOPQRBAFHDEJKLNCGIMOPQRFast vector slice manipulation(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FXu-ASstdioO(n) S[ is analogous to (:) for lists, but of different complexity, as it requires making a copy.TstdioO(n)% Append a byte to the end of a vectorUstdioO(1)/ Extract the head and tail of a vector, return  if it is empty.VstdioO(1)/ Extract the init and last of a vector, return  if vector is empty.WstdioO(1)' Extract the first element of a vector.XstdioO(1)1 Extract the elements after the head of a vector.NOTE: X4 return empty vector in the case of an empty vector.YstdioO(1)& Extract the last element of a vector.ZstdioO(1)- Extract the elements before of the last one.NOTE: Z4 return empty vector in the case of an empty vector.[stdioO(n)> Return all initial segments of the given vector, empty first.\stdioO(n)C Return all final segments of the given vector, whole vector first.]stdioO(1) ] n, applied to a vector xs, returns the prefix of xs of length n, or xs itself if n >  xs.^stdioO(1) ^ n, applied to a vector xs, returns the suffix of xs of length n, or xs itself if n >  xs._stdioO(1) _ n xs returns the suffix of xs after the first n elements, or [] if n >  xs.`stdioO(1) ` n xs returns the prefix of xs before the last n elements, or [] if n >  xs.astdioO(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) vsbstdioO(1) b n xs is equivalent to (] n xs, _ n xs).cstdioO(n) Applied to a predicate p and a vector vs2, returns the longest prefix (possibly empty) of vs of elements that satisfy p.dstdioO(n) Applied to a predicate p and a vector vs2, returns the longest suffix (possibly empty) of vs of elements that satisfy p.estdioO(n) Applied to a predicate p and a vector vs7, returns the suffix (possibly empty) remaining after c p vs.fstdioO(n) Applied to a predicate p and a vector vs8, returns the prefix (possibly empty) remaining before d p vs.gstdioO(n) )dropAround f = dropWhile f . dropWhileR fhstdioO(n)u Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest without copying.istdioO(n)n Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying.jstdioj behaves like h but from the end of the vector. breakR p == spanR (not.p)kstdiok behaves like i but from the end of the vector.lstdioBreak 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")ostdioO(n) The o( function takes two vectors and returns J the remainder of the second iff the first is its prefix, and otherwise .pstdioThe isPrefix function returns 1 if the first argument is a prefix of the second.qstdioO(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")rstdio O(n) The r| function takes two vectors and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.sstdioO(n) The s( function takes two vectors and returns ) if the first is a suffix of the second.tstdio3Check whether one vector is a subvector of another.needle t< haystack === null haystack || indices needle haystake /= [].ustdioO(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.vstdioO(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)wstdioO(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.xstdioO(n) Breaks a 3 up into a list of words, delimited by ascii space.ystdioO(n) Breaks a - up into a list of lines, delimited by ascii n.zstdioO(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,   (+)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  % 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  % 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)' 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) ] 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) _ 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!astdioslice beginning indexstdio slice lengthostdiothe prefix to be testedpstdiothe prefix to be testedCSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~CSTUVWXYZ[\]_^`abcdefghijklmnoruwvpstqxyz{|}~Sorting vectors/(c) 2008-2011 Dan Doel, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone -.>@AFHMX stdio Similar to Z newtype for  *, 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   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 = 16.stdioO(n^2) Sort vector based on element's   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   or , while on larger type, constant passes may render this algorithm not suitable for small vectors (turning point around 2^(2*passes)).ZYZY*Fast boxed and unboxed vector(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone %2=>?@AFHSVXg0ZY     6789:;<=>?@ABFHJKLNSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     STUVWXYZ[\]_^`abcdefghijklmnoruwvpstqxyz{|}~FHBAJKLNZY6789:;<=>?@"Low resolution (0.1s) timing wheel(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneX3stdioTimer registered by  or .stdioA simple timing wheelstdio=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 > 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  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 +,<, this function put a limit on time which an IO can consume.,Note timeoutLowRes is also implemented with QN 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.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*Debounce 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.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 actionErrno provided by libuv(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableSafegKstdiotoo 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 progressstdiosocket type not supportedstdio%service not available for socket typestdioresolved protocol is unknownstdioargument buffer overflowstdiounknown node or servicestdio no addressstdio out of memorystdioai_family not supportedstdiopermanent failurestdiorequest canceledstdioinvalid value for hintsstdiobad ai_flags valuestdiotemporary failure stdioaddress family not supported stdio resource temporarily unavailable stdioaddress family not supported stdioaddress not available stdioaddress already in usestdiopermission deniedstdioargument list too longO     O     Extensible IO exceptions(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2>EHMVX 1 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-stack;stdio^The root type of all io exceptions, you can catch all io exception by catching this root type.?stdioThrow 3 if allocation return a .@stdioHThrow appropriate IO exception if return value < 0 (libuv's convention).AstdioPThrow appropriate IO exception if return value < 0, otherwise ignore the result.BstdioThrow -. with name ECLOSED& and description 'resource is closed'.?stdiothe allocation action@stdio the IO actionAstdio the IO action ! "#$%'&)(+*-,/.103287654;:9<=>?@ABCDHGFEILJKQPONXWVUTSR\]M !"#$%&'()*+,-./0123456789:;<=>?@ABCD;<=>9:78563412/0-.+,)*'(%&#$!" ?@ABCD ! "#$%'&)(+*-,/.103287654;:9<=>?@ABCDHGFEILJKJQPONXWVUTSR]M\The Resource monad(c) Dong Han, 2017BSDwinterland1989@gmail.com experimental non-portableNone2SX? lstdio.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 y@), just increase the maximum number of resources can be opened.stdioA single resource pool entry.qstdioA q 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 q is v / 'withResource\'', You should not use the sv field directly, unless you want to implement your own resource management. In the later case, you should always use @M since some resource initializations may assume async exceptions are masked.+ instance is provided so that you can lift  computation inside q%, this is convenient for propagating q around since many  computations carry finalizers.4A convention in stdio is that functions returning a q 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 B or C) 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.tstdioCreate q from create and release action.Note, resourceA doesn't open resource itself, resource is created when you use with / with'.ustdioCreate q from create and release action.]This function is useful when you want to add some initialization and clean up action inside q monad.vstdioTCreate 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.wstdioTCreate 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.xstdio&Initialize a resource pool with given qULike other initXXX functions, this function won't open a resource pool until you use v[. And this resource pool follow the same resource management pattern like other resources.ystdioGet a resource pool's m7This function is useful when debug, under load lots of p 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 o0 may indicate there're too much free resources.zstdio8Obtain the pooled resource inside a given resource pool.You shouldn't use v3 with this resource after you closed the pool, an  with  EPOOLCLOSED name will be thrown.xstdio)maximum number of resources can be openedstdioKamount of time after which an unused resource can be released (in seconds).lmnopqrstuvwxyzqrstuvwlmnopxyzUse PrimArray with FFI(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneFXuN stdioType alias for  .^Since we can't newtype an unlifted type yet, type alias is the best we can get to describe a X 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 .^Since we can't newtype an unlifted type yet, type alias is the best we can get to describe a ^ 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  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 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 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 { | } ~  [ [Unicode text processing(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2FXg>P0stdio 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.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.tmopqrstuvwx{|}topqrstuvwx{|}mSearching text(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FXQstdioO(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 1 if the first argument is a prefix of the second.stdioO(n) The % function takes two text and returns ) 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 search22/Unicode text processing(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone 2Fg;mopqrstuvwx{|}opqrstuvwx{|}m Efficient deserialization/parse.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone>FSX,stdioSimple CPSed parser 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-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 ).stdiooRun a parser and keep track of all the input it consumes. Once it's finished, return the final result (always   or ) and all consumed chunks.stdioEnsure that there are at least n< bytes available. If not, the computation will escape with .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 ,. Returns the byte that is actually parsed. @digit = satisfy isDigit where isDigit w = w >= 48 && w <= 57 stdio The parser satisfyWith f p3 transforms a byte, and succeeds if the predicate p returns T on the transformed value. The parser returns the transformed byte that was parsed.!stdioMatch a specific byte."stdioMatch a specific 8bit char.#stdioMatch any byte.$stdio#Match either a single newline byte '\n'3, or a carriage return followed by a newline byte "\r\n".%stdio% N bytes.&stdio5Skip past input for as long as the predicate returns .'stdioSkip over white space using  .)stdio/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 ; 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  or reach the end of input,stdiobytes 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.'      !"#$%&'()*+,-.'      !"#$%&'()*+,-.Textual numeric parsers.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone7stdio: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)'8stdio,Parse and decode an unsigned decimal number.9stdio0Parse 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  : parseOnly double "3" == Right ("",1,3.0) parseOnly double "3.1" == Right ("",3,3.1) parseOnly double "3e4" == Right ("",3,30000.0) parseOnly double "3.1e4" == Right ("",5,31000.0) mparseOnly double ".3" == Left (".3",0,"takeWhile1") parseOnly double "e3" == Left ("e3",0,"takeWhile1")Examples of differences from  : ^parseOnly double "3.foo" == Right (".foo",1,3.0) parseOnly double "3e" == Right ("e",1,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 ;.789:;<=>897:<;=>0 Efficient deserialization/parse.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone>FSX(  !#$%&'()*+,-.789:;<=>(  !#$%&'()*+,-.897:<;=>Efficient serialization/format.;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone=>?FHSVXM?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 I, which is different from \/ 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.Bstdio BuilderStep7 is a function that fill buffer under given conditions.CstdioHelper type to help ghc unpackEstdioE will decide how each B, proceed when previous buffer is not enough.IstdioVEncode string with modified UTF-8 encoding, will be rewritten to a memcpy if possible.JstdioTurn  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.LstdioWrite a .MstdioEnsure that there are at least n many elements available.Qstdio shortcut to R .Rstdiorun Builder with F7 strategy, which is suitable for building short bytes.Sstdio shortcut to T .Tstdiorun Builder with G= strategy, which is suitable for building lazy bytes chunks.Ustdio shortcut to V .Vstdiorun Builder with H? strategy, which is suitable for doing effects while building.Ystdio)write primitive types in host byte order.Zstdio,write primitive types with little endianess.[stdio)write primitive types with big endianess.\stdioTurn   into ? with UTF8 encoding&Illegal codepoints will be written as ls.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).]stdioTurn  into ? with UTF8 encoding&Illegal codepoints will be written as ls.^stdioTurn   into ? with ASCII7 encodingCodepoints beyond '\x7F' will be chopped._stdioTurn  into ? with ASCII7 encodingCodepoints beyond '\x7F' will be chopped.`stdioTurn   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.astdioTurn  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.bstdioWrite 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.Dstdiothe buffer contentstdiowriting offsetWstdio size boundstdio4the writer which return a new offset for next writeXstdio size boundstdio4the writer which return a new offset for next write$?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab$EFGHCDB?@AKQRSTUVLMWXNOPYZ[IJ\]^_`abBuffered IO interface(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone"#2n stdioResult returned by v. stdioread and parse successfully stdio parse failed stdio EOF reachedkstdio+Output device with buffer, NOT THREAD SAFE!lstdio*Input device with buffer, NOT THREAD SAFE!mstdio Output deviceLaws: n should not return until all data are written (may not necessarily flushed to hardware, that should be done in device specific way).ostdio Input deviceLaws: p should return 0 on EOF.Note: p' is considered not thread-safe, e.g. A o( device can only be used with a single l, If multiple l s are opened on a same o) device, the behaviour will be undefined.sstdioRequest bytes from l.$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.tstdioRead exactly N bytes&If EOF reached before N bytes read, a i will be thrownustdioPush bytes back into buffervstdioRead buffer and parse with Parser.wstdioRead until reach a magic bytesGIf EOF is reached before meet a magic byte, partial bytes are returned.xstdioRead until reach a magic bytes.If EOF is reached before meet a magic byte, a i will be thrown.ystdioRead to a linefeed ('\n' or '\r\n' ), return Bytes before it.EIf EOF is reached before meet a magic byte, partial line is returned.zstdioRead to a linefeed ('\n' or '\r\n' ), return Bytes before it.+If EOF reached before meet a magic byte, a i 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).qstdioInput buffer sizerstdioOutput buffer sizeijklmnopqrstuvwxyz{|}opmnlqsuvtwxyzkr{|}ijTextual numeric builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone  FHSVXstdio0Control the rendering of floating point numbers.stdioScientific notation (e.g. 2.3e123).stdioStandard decimal notation.stdio(Use decimal notation for values between 0.1 and  9,999,999$, and scientific notation otherwise.stdioIntegral formatting options.stdio0total width, only effective with padding optionsstdiopadding optionsstdioshow + when the number is positivestdio 2defaultIFormat = IFormat 0 NoPadding False Decimalstdio int = intWith defaultIFormatstdio Format a     type like Int or Word16 into decimal ASCII digits.stdio Format a   into decimal ASCII digits.stdio-Count how many decimal digits an integer has.stdioDecimal digit to ASCII digit. stdioDecimal digit to ASCII char.stdio Hexadecimal digit to ASCII char.stdio+Hexadecimal digit to UPPERCASED ASCII char.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.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  .stdioDecimal encoding of a  .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*stdioIntstdioInt stdiochar*stdioIntstdioInt stdio The bufferstdiowriting offsetstdio total digitsstdio the valuestdio#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.  UTF8 compatible builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone 1=?HMVstdioRBuidlers which guarantee UTF-8 encoding, thus can be used to build text directly. Notes on  # instance: It's recommended to use   instance instead of  or X since there's a rewrite rule to turn encoding loop into a memcpy, which is much faster.0Different from 'Builder ()', 'TextBuilder ()''s  - instance will gives desired UTF8 guarantees:""NUL" will be written directly as x00.xD800 ~ xDFFF& will be replaced by replacement char.stdioTurn   into  with UTF8 encoding&Illegal codepoints will be written as 12qs. 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 12s.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.stdio#Number of decimal places to render.stdio#Number of decimal places to render.stdio#Number of decimal places to render.##3Efficient serialization/format.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone =>?FSX_0?KLMQRSTUVWXYZ[\]^_`ab0?KQRSTUVLMWXYZ[\]^_`abNull-ternimated byte string.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone FSXv stdiotA efficient wrapper for immutable null-terminated string which can be automatically freed by ghc garbage collector. stdioOn heap pinned pk there's an invariance that this array's length is always shrinked to contain content and NUL terminator stdio#String literals with static addressstdio Create a  with IO action.LUser only have to do content initialization and return the content length, % takes the responsibility to add the '\NUL' ternimator.stdioPack a   into null-terminated .'\NUL' is encoded as two bytes C0 80 , '\xD800' ~ '\xDFFF'4 is encoded as a three bytes normal UTF-8 codepoint.stdioO(1), (O(n)! in case of literal), convert to 0, which can be processed by vector combinators. NOTE: the '\NUL' ternimator is not included.stdioO(n), convert from &, allocate pinned memory and add the '\NUL' ternimatorstdioO(n), convert from &, allocate pinned memory and add the '\NUL' ternimatorstdioCopy a   type into a (, return Nothing if the pointer is NULL.&After copying you're free to free the   's memory.stdio Same with  , but throw # when meet a null pointer.stdio Same with ?, but only take N bytes (and append a null byte as terminator).stdioPass  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.stdiocapacity n, including the '\NUL' terminatorstdioGinitialization function, write the pointer, return the length (<= n-1) TCP/UDP socket address API(c) Winterland, 2018BSDdrkoster@qq.com experimental non-portableNone2gstdioUse the Num! instance (i.e. use a literal or  ) to create a  PortNumber. value with the correct network-byte-ordering.1 :: PortNumber1read "1" :: PortNumber1stdio'Independent of endianness. For example ::1 is stored as  (0, 0, 0, 1).For direct manipulation prefer  and .stdio'Independent of endianness. For example  127.0.0.1 is stored as (127, 0, 0, 1).For direct manipulation prefer  and .stdio&IPv4 or IPv6 socket address, i.e. the  sockaddr_in or  sockaddr_in6 struct.stdioInternet Protocol version 6stdiointernetwork: UDP, TCP, etcstdio unspecifiedstdio 0.0.0.0stdio 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--!libuv operations(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableNone  7FHMVg0'6stdioFlags 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.fstdio.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.,-./0321456789IHGFEDCBA@?>=<;:JKMLNOWVUTSRQPXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ifghedc   ab ` ^_\]Z[XYOWVUTSRQPNJKML89IHGFEDCBA@?>=<;:67450321~}|{zyxwvu./tsrqponmlk,-j"IO manager based on libuv(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone`rjstdioA haskell data type wrap an  uv_stream_t insidej# DO NOT provide thread safety! Use jC concurrently in multiple threads will lead to undefined behavior.qstdioGet p runing on the same capability.rstdioGet  % from blocking table with given slot.sstdio@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 ... ustdioFLock 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.vstdioFLock 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 loopwstdioRun a libuv FFI to get a f (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 iI, 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.xstdio 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,ystdio Same with x but disgard the result.zstdio Same with x) 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 x, 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 q1), and provide a custom initialization function.zstdioconvert functionjklmnopqrstuvwxyz{|}pqrtsuvwxyz{}jklmno|#TCP servers and clients(c) Dong Han, 2018BSDwinterland1989@gmail.com experimental non-portableNone"#EFXxstdioA TCP server configurationstdioA TCP client configurationstdio.A default hello world server on localhost:8888 Test it with &main = startServer defaultServerConfig , now try nc -v 127.0.0.1 8888stdioStart a server-Fork new worker thread upon a new connection.<$ TTY devices(c) Dong Han, 2018~2019BSDwinterland1989@gmail.com experimental non-portableNone`stdio!Standard input and output streamsFWe support both regular file and TTY based streams, when initialized jN is called to decide which type of devices are connected to standard streams. is different from other j9 in that exception during reading & writing won't close .stdioprint a   to stdoutstdioprint a ? and flush to stdout.stdioprint a ?- and flush to stdout stdout, with a linefeed.stdioread a line from stdin  %High performance logger(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNoneEX stdioLogger configuration.stdio(Buffer size used when creating logger's kstdio%Minimal flush interval, see Notes on stdio/A IO action return a formatted date/time stringstdio"Buffer size to build each log/linestdioSet to   to filter debug logsstdioSet to  , to disable auto data/time string prependingstdio&flush logger's buffer to output device stdioA default logger config withdebug ON data/time%Y-%m-%dT%H:%M:%S%Z ON0.1s minimal flush intervalline buffer size 128 bytesk buffer size equals to .stdioMake a new loggerstdioChange stderr logger. stdioManually flush stderr logger.stdio'Flush stderr logger when program exits.stdio log levelstdioflush immediately?stdio log contentstdio log levelstdioflush immediately?stdio log content&Filesystem IO using threadpool(c) Dong Han, 2017~2019BSDwinterland1989@gmail.com experimental non-portableNone27Xstdio wrap a  uv_file_t and a referencing counter'Note this is a differet data type from Std.IO.FileSystem 's one, the o and m, 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 q, 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 J respectively.PNote libuv prior to v1.23.1 have issues which may result in nanosecond not set,  doesn't havestdioEquivalent 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 offsetstdiothe new offsetstdiothe old offsetstdiothe file we're writingstdioinitial writing offsetstdiothe new offsetstdiothe old offsetstdioOpening 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.01234689:;<=>?@ABCDEFGHIJKLMOPQRSTUVWZ\Ԕ\ZOPQRSTUVW89:;<=>?@ABCDEFGHIJKLM640123.' Filesystem IO(c) Dong Han, 2017~2019BSDwinterland1989@gmail.com experimental non-portableNone27X`WstdioAn  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 q, 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 q0 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 J 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 offsetstdiothe new offsetstdiothe old offsetstdiothe file we're writingstdioinitial writing offsetstdiothe new offsetstdiothe old offsetstdioOpening 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.01234689:;<=>?@ABCDEFGHIJKLMOPQRSTUVWZ\\ZOPQRSTUVW89:;<=>?@ABCDEFGHIJKLM640123. 4567894:;4<=4<>4<?4<?4@A4@B4@C4@D4@E4@F4@G4@H4@I4@J4@K4@L4@L4@M4@M4@N4@N4@O4@O4@P4@P4@Q4@Q4@R4@R4@S4@S4TU4VW4VX4VY4VZ4VZ4V[4V[4V\4V\4V]4V]4V^4V^4V_4V_4V`4V`4Va4Vb4Vc4Vd4Ve4Vf4Vg4Vh4ij4ik4il4im4in4io4ip4iq4ir4is4it4iu4iv4wx4wy4wz4wy4{|4{}4{~4{4{4{4{4{4{4{4{4{44444{|                                    ! ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L 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 { | } ~   2      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"##..$$%%&&''(())**++,,--..//001122334456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrstuvwxyz{|}~  )PTVRSXYabcdefghijkmlnopqrstuvwxyz{|}~kq      !!"#$%&'()*+,-./0123456789:;;<=&',-.1>?@ABCD EFGHIJKLMNOPQRS T T U U V 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&:&;&<&=&>''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>4?7@A78BCDE7@F4GH4IJ45K78L4GMN7@O4PQ4PR4PS7TU4VWX4TY4Z[\]^4_`7@a4bc78d78e78f78g78h78i78j78k78l78m78n78o78p78q78r78s78t78u78v78w78x78y78z78{78|78}78~787878784?787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878 78 78 78 78 78787878787878787878787878787878787878 78!78"78#78$78%78&78'78(78)78*78+78,78-78.78/78078178278378478578678778878978:78;78<78=78>78?78@78A78B78C78D78E78F78G78H78I78J78K78L78M78N78O78P78Q78R78S78T78U78V78W78X78Y78Z78[78\78]78^78_78`78a78b78c78d78e78f78g78h78i78j78k78l78m78n78o78p78q78r78s78t78u78v78w78x78y78z78{78|78}78~7878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878 78 78 78 78 78787878787878787878787878787878787878 78!78"78#78$78%78&78'78(78)78*78+78,78-78.78/78078178278378478578678778878978:78;78<78=78>78?78@78A78B78C78D78E78F78G78H78I78J78K78L78M78N78O78P78Q78R78S78T78U78V78W78X78Y78Z78[78\78]78^78_78`78a78b78c78d78e78f78g78h78i78j78k78l78m78n78o78p78q78r78s78t78u78v78w78x78y78z78{78|78}78~78787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878787878 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 !78 "78 #78 $78 %78 &78 '78 (78 )78 *78 +78 ,78 -78 .78 /78 078 178 278 378 478 578 678 778 878 978 :78 ;78 <78 =78 >78 ?78 @78 A78 B78 C78 D78 E78 F78 G78 H78 I78 J78 K78 L78 M78 N78 O78 P78 Q78 R78 S78 T78 U78 V78 W78 X78 Y78 Z78 [78 \78 ]78 ^78 _78 `78 a78 b78 c78 d78 e78 f78 g78 h78 i78 j78 k78 l78 m78 n78 o78 p78 q78 r78 s78 t78 u78 v78 w78 x78 y78 z78 {78 |78 }78 ~78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 !78 "78 #78 $78 %78 &78 '78 (78 )78 *78 +78 ,78 -78 .78 /78 078 178 278 378 478 578 678 778 878 978 :78 ;78 <78 =78 >78 ?78 @78 A78 B78 C78 D78 E78 F78 G78 H78 I78 J78 K78 L78 M78 N78 O78 P78 Q78 R78 S78 T78 U78 V78 W78 X78 Y78 Z78 [78 \78 ]78 ^78 _78 `78 a78 b78 c78 d78 e78 f78 g78 h78 i78 j78 k78 l78 m78 n78 o78 p78 q78 r78 s78 t78 u78 v78 w78 x78 y78 z78 {78 |78 }78 ~78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78       7@    7@ 4  7@ 4  45    ! "4 # $4 % & '4 ( ) * + , - . /4 0 14 % 24 3 4" 5" 64 7 8% 9% : ;$stdio-0.1.0.0-F3Q7E5AXdcEHzopR6chOAfStd.IO.ExceptionStd.Data.ArrayStd.Data.Vector.SortStd.Foreign.PrimArray#Std.Data.Builder.Numeric.DigitTableStd.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.LowResTimerStd.IO.UV.ErrnoStd.IO.ResourceStd.Data.Text.BaseStd.Data.Text.SearchStd.Data.Text.ExtraStd.Data.Parser.BaseStd.Data.Parser.NumericStd.Data.Builder.BaseStd.IO.BufferedStd.Data.Builder.NumericStd.Data.TextBuilderStd.Data.CBytesStd.IO.SockAddr Std.IO.UV.FFIStd.IO.UV.Manager Std.IO.TCPStd.IO.StdStream Std.IO.LoggerStd.IO.FileSystemTStd.IO.FileSystemStd.Data.PrimSTRef isCategoryStd.Data.VectorSystem.TimeouttimeoutEResourceVanished Std.Data.TextStd.Data.ParserTreplacementCharStd.Data.BuilderbaseGHC.Baseassertghc-primGHC.Prim RealWorld 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.PtrcastPtrGHC.Stack.Types HasCallStack(primitive-0.6.4.0-B90Bn6x92A242KDbQkZvSiData.Primitive.TypesPrim indexOffAddr# readOffAddr# setOffAddr# writeOffAddr# decDigitTable hexDigitTablehexDigitTableUpper alignment#indexByteArray#readByteArray# setByteArray#sizeOf#writeByteArray#Data.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# UnliftedArrayArrnewArr 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 EmptyVectorIPairBytes PrimVectorVectorVecMArrayIArraytoArrfromArr c_fnv_hash_bac_fnv_hash_addrc_ascii_validate_addrc_strlenc_strcmp indexMaybe packASCIIw2cc2wcreatecreate'creating creating'createNcreateN2empty singletoncopypackpackNpackRpackRNunpackunpackRlengthnullappendmapmap'imap'foldl'ifoldl'foldl1' foldl1Maybe'foldr'ifoldr'foldr1' foldr1Maybe'concat concatMapmaximum maximumMaybeminimum minimumMaybeproductproduct'anyallsumcount mapAccumL mapAccumR replicatecycleNunfoldrunfoldrNelemnotElem elemIndexdefaultChunkSizesmallChunkSize chunkOverheaddefaultInitSizeerrorEmptyVector errorOutRange castVector$fHashable1Vector$fHashableVector$fTraversableVector$fFoldableVector$fFunctorVector $fReadVector $fShowVector$fNFDataVector$fMonoidVector$fSemigroupVector $fOrdVector $fEqVector $fVecVectora$fIsStringPrimVector$fHashablePrimVector$fHashablePrimVector0$fReadPrimVector$fShowPrimVector$fNFDataPrimVector$fMonoidPrimVector$fSemigroupPrimVector$fOrdPrimVector$fOrdPrimVector0$fEqPrimVector$fVecPrimVectora$fFoldCasePrimVector$fExceptionVectorException $fDataVector$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'rangeCutheadtailinitlastindex unsafeHead unsafeTail unsafeInit unsafeLast unsafeIndex unsafeTake unsafeDrop RadixDownRadix bucketSizepassesradixLSBradixradixMSB mergeSort mergeSortBy mergeTileSize insertSort insertSortBy radixSort $fRadixWord64 $fRadixWord32 $fRadixWord16 $fRadixWord $fRadixWord8 $fRadixInt64 $fRadixInt32 $fRadixInt16 $fRadixInt $fRadixInt8$fRadixRadixDown$fShowRadixDown $fEqRadixDown$fPrimRadixDown LowResTimerLowResTimerManager%lowResTimerManagerCapabilitiesChangedgetLowResTimerManagerisLowResTimerManagerRunningregisterLowResTimerregisterLowResTimer_registerLowResTimerOnqueryLowResTimercancelLowResTimercancelLowResTimer_ timeoutLowResthrottle throttle_throttleTrailing_$fExceptionTimeOutException$fShowTimeOutException 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$fShowAlreadyExistsPool 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 $fNFDataText $fReadText $fShowText $fOrdText$fEqText breakOnAllbreakOnAllOverlappingParser runParser ParseStepResultSuccessFailurePartialparseparse' parseChunk finishParsing parseChunksrunAndKeepTrackensureN endOfInput decodePrim decodePrimLE decodePrimBEscan scanChunks peekMaybepeeksatisfy satisfyWithword8char8anyWord8 endOfLineskip skipWhile skipSpacestakeTill takeWhile1bytesbytesCItext $fShowResult$fFunctorResult$fAlternativeParser$fMonadPlusParser$fMonadFailParser $fMonadParser$fApplicativeParser$fFunctorParserhexuintintrationaldoublefloat scientificscientificallyBuilder runBuilder BuildStepBufferAllocateStrategy DoubleBuffer InsertChunk OneShotActionstringModifiedUTF8charModifiedUTF8 doubleBuffer insertChunk oneShotAction buildBytesbuildBytesWithbuildBytesListbuildBytesListWith buildAndRunbuildAndRunWithatMostwriteN encodePrim encodePrimLE encodePrimBE stringUTF8charUTF8string7char7string8$fIsStringBuilder$fMonoidBuilder$fSemigroupBuilder$fMonadBuilder$fApplicativeBuilder$fFunctorBuilderShortReadExceptionBufferedOutput BufferedInputOutput writeOutputInput readInputnewBufferedInputnewBufferedOutput readBuffer readExactly unReadBuffer readParser readToMagic readToMagic'readLine readLine' writeBuffer writeBuilder flushBuffer$fExceptionShortReadException$fShowShortReadException$fShowReadResultFFormatExponentFixedGenericPadding NoPadding ZeroPaddingLeftSpacePaddingRightSpacePaddingIFormatwidthpadding postiveSigndefaultIFormatintWithinteger countDigitsi2wDeci2wHexi2wHeXheX floatWith doubleWithgrisu3 grisu3_spscientificWith $fShowPadding $fEqPadding $fOrdPadding $fShowIFormat $fEqIFormat $fOrdIFormat $fEnumFFormat $fReadFFormat $fShowFFormat TextBuilder toBuilder buildText$fIsStringTextBuilder$fFunctorTextBuilder$fApplicativeTextBuilder$fMonadTextBuilder$fMonoidTextBuilder$fSemigroupTextBuilderCBytestoBytes fromBytesfromTextfromCStringMaybe fromCString fromCStringN withCBytes$fIsStringCBytes$fHashableCBytes$fMonoidCBytes$fSemigroupCBytes $fOrdCBytes $fEqCBytes $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 withSockAddraNY_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$fOrdSocketProtocol UVHandleType UVSymlinkFlag AccessResult NoExistence NoPermissionAccessOK UVAccessModeUVCopyFileFlagUVStatstDevstModestNlinkstUidstGidstRdevstInostSize stBlksizestBlocksstFlagsstGenstAtimstMtimstCtim stBirthtim UVTimeSpec uvtSecond uvtNanoSecondUVDirEnt DirEntType DirEntUnknown DirEntFile DirEntDir DirEntLink DirEntFIFO DirEntSocket DirEntChar DirEntBlock UVDirEntType UVFileFlag UVFileMode UVTTYModeUVHandle 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_open uv_tty_init uv_pipe_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_writehs_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_NORMAL 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 $fEqUVTTYMode$fOrdUVTTYMode$fReadUVTTYMode$fShowUVTTYMode$fFiniteBitsUVTTYMode$fBitsUVTTYMode$fStorableUVTTYMode$fEqUVFileMode$fOrdUVFileMode$fReadUVFileMode$fShowUVFileMode$fFiniteBitsUVFileMode$fBitsUVFileMode$fStorableUVFileMode$fEqUVFileFlag$fOrdUVFileFlag$fReadUVFileFlag$fShowUVFileFlag$fFiniteBitsUVFileFlag$fBitsUVFileFlag$fStorableUVFileFlag$fEqUVDirEntType$fOrdUVDirEntType$fReadUVDirEntType$fShowUVDirEntType$fFiniteBitsUVDirEntType$fBitsUVDirEntType$fStorableUVDirEntType$fReadDirEntType$fShowDirEntType$fEqDirEntType$fOrdDirEntType$fGenericDirEntType$fShowUVTimeSpec$fReadUVTimeSpec$fEqUVTimeSpec$fOrdUVTimeSpec$fGenericUVTimeSpec $fShowUVStat $fReadUVStat $fEqUVStat $fOrdUVStat$fGenericUVStat$fEqUVCopyFileFlag$fOrdUVCopyFileFlag$fReadUVCopyFileFlag$fShowUVCopyFileFlag$fFiniteBitsUVCopyFileFlag$fBitsUVCopyFileFlag$fStorableUVCopyFileFlag$fEqUVAccessMode$fOrdUVAccessMode$fReadUVAccessMode$fShowUVAccessMode$fFiniteBitsUVAccessMode$fBitsUVAccessMode$fStorableUVAccessMode$fShowAccessResult$fEqAccessResult$fOrdAccessResult$fEqUVSymlinkFlag$fOrdUVSymlinkFlag$fReadUVSymlinkFlag$fShowUVSymlinkFlag$fFiniteBitsUVSymlinkFlag$fBitsUVSymlinkFlag$fStorableUVSymlinkFlag$fEqUVHandleType$fOrdUVHandleType$fReadUVHandleType$fShowUVHandleType$fStorableUVHandleTypeUVStream uvsHandleuvsSlot uvsManager uvsClosed UVManager getUVManager getBlockMVarpokeBufferTablepeekBufferTable withUVManagerwithUVManager_ getUVSlot withUVRequestwithUVRequest_withUVRequest'withUVRequestExforkBa initUVStream $fEqUVManager$fShowUVManager$fOutputUVStream$fInputUVStream$fShowUVStream ServerConfig serverAddr serverBackLog serverWorkerserverWorkerNoDelay ClientConfigclientLocalAddrclientTargetAddr clientNoDelaydefaultClientConfig initClientdefaultServerConfig startServer StdStreamisStdStreamTTYstdinstdoutstderrstdinBuf stdoutBufprintStdputStd putLineStd readLineStd$fOutputStdStream$fInputStdStream LoggerConfigloggerBufferSizeloggerMinFlushInterval loggerTsCacheloggerLineBufSizeloggerShowDebug loggerShowTSLogger 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.IntInt8 TimerListsetNumCapabilities Data.FunctorvoidensureLowResTimerManagerstartLowResTimerManagerfireLowResTimerQueuenullPtrEntryIOControl.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 word8-0.1.3-hMLtn1WK4pzg7tjcsLRD Data.Word8isSpaceFalse integer-gmpGHC.Integer.TypeIntegerDouble Text.ReadreadFloat Data.StringIsStringString ReadResult ReadSuccess ReadFailureReadEOFGHC.EnumBoundedGHC.RealIntegrali2cDec Data.Bits FiniteBitsdoFmt c_grisu3_spc_grisu3writePositiveDec CBytesOnHeap CBytesLiteralForeign.C.StringCString fromIntegralGHC.MVarMVarstartUVManager cancelUVReqGHC.ShowShowdefaultLoggerConfigflushDefaultLogger