bs;      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2010 Simon MeierNone +;HMRight-shift of a .Right-shift of a .Right-shift of a .Right-shift of a .6Select an implementation depending on the bit-size of ms. Currently, it produces a runtime failure if the bitsize is different. This is detected by the testsuite. 02010-2011 Simon Meier, 2010 Jasper van der JeugtBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com> experimentalGHCNone +;HMdAn encoding that always results in sequence of bytes that is no longer than a pre-determined bound.XAn encoding that always results in a sequence of bytes of a pre-determined, fixed size.0The type used for sizes and sizeBounds of sizes.6Type-constructors supporting lifting of type-products.!Contravariant functors as in the  contravariant package.!An overloaded infix operator for  and .PWe can use it for example to prepend and/or append fixed values to an encoding. nshowEncoding ((\x -> ('\'', (x, '\''))) >$< fixed3) 'x' = "'x'" where fixed3 = char7 >*< char7 >*< char7jNote that the rather verbose syntax for composition stems from the requirement to be able to compute the s and s at compile time.!An overloaded infix operator for  and . For example, (showF (char7 >*< char7) ('x','y') = "xy"(We can combine multiple encodings using  multiple times. @showEncoding (char7 >*< char7 >*< char7) ('x',('y','z')) = "xyz"5The size of the sequences of bytes generated by this .The 1 that always results in the zero-length sequence.LEncode a pair by encoding its first component and then its second component.UChange an encoding such that it first applies a function to the value to be encoded.Note that encodings are Contrafunctors  0http://hackage.haskell.org/package/contravariant". Hence, the following laws hold. CcontramapF id = id contramapF f . contramapF g = contramapF (g . f) Convert a  to a . Convert a  to a .>The bound on the size of sequences of bytes generated by this . Change a C such that it first applies a function to the value to be encoded. Note that s are Contrafunctors  0http://hackage.haskell.org/package/contravariant". Hence, the following laws hold. CcontramapB id = id contramapB f . contramapB g = contramapB (g . f)The 1 that always results in the zero-length sequence.LEncode a pair by encoding its first component and then its second component. Encode an  value using the first  for  values and the second  for  values.Note that the functions , , and  (written below using ) suffice to construct :s for all non-recursive algebraic datatypes. For example, emaybeB :: BoundedEncoding () -> BoundedEncoding a -> BoundedEncoding (Maybe a) maybeB nothing just =  (Left ()) Right  eitherB nothing just Conditionally select a x. For example, we can implement the ASCII encoding that drops characters with Unicode codepoints above 127 as follows. charASCIIDrop =  (< '\128') ( char7)   (c) 2010 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com> experimentalGHCNone +;HM Encode a  using a  encoding. PRE: The / encoding must have a size of at least 4 bytes. Encode a  using a  encoding. PRE: The / encoding must have a size of at least 8 bytes. (c) 2010-2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HM%Encoding single unsigned bytes as-is. Encoding s in big endian format. Encoding s in little endian format. Encoding s in big endian format. Encoding s in little endian format. Encoding s in big endian format. Encoding s in little endian format.Encode a single native machine . The cs is encoded in host order, host endian form, for the machine you are on. On a 64 bit machine the  is an 8 byte value, on a 32 bit machine, 4 bytes. Values encoded this way are not portable to different endian or word sized machines, without conversion. Encoding +s in native host order and host endianness. Encoding +s in native host order and host endianness. Encoding +s in native host order and host endianness.#Encoding single signed bytes as-is. Encoding s in big endian format. Encoding s in little endian format. Encoding s in big endian format. Encoding s in little endian format. Encoding s in big endian format. Encoding s in little endian format.Encode a single native machine . The cs is encoded in host order, host endian form, for the machine you are on. On a 64 bit machine the  is an 8 byte value, on a 32 bit machine, 4 bytes. Values encoded this way are not portable to different endian or integer sized machines, without conversion. Encoding +s in native host order and host endianness. Encoding +s in native host order and host endianness. Encoding +s in native host order and host endianness. Encode a  in big endian format. Encode a  in little endian format. Encode a  in big endian format. Encode a  in little endian format. Encode a  in native host order and host endianness. Values written this way are not portable to different endian machines, without conversion. Encode a * in native host order and host endianness. D(c) Don Stewart 2006-2008 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgunstable non-portableNone +;HM^A space-efficient representation of a Word8 vector, supporting many efficient operations. A  contains 8-bit characters only.0Instances of Eq, Ord, Read, Show, Data, Typeable5The 0 pointer. Used to indicate the empty Bytestring.O(1)& Build a ByteString from a ForeignPtr.EIf you do not need the offset parameter then you do should be using  or  instead.O(1)+ Deconstruct a ForeignPtr from a ByteString8A way of creating ByteStrings outside the IO monad. The Int; argument gives the final size of the ByteString. Unlike V the ByteString is not reallocated if the final size is less than the estimated size.Create ByteString of size l and use action f to fill it's contents. Create ByteString of up to size l and use action f3 to fill it's contents which returns its true size.lGiven the maximum size needed and a function to make the contents of a ByteString, createAndTrim makes the . The generating function is required to return the actual final size (<= the maximum size), and the resulting byte array is realloced to this size.createAndTrim is the main mechanism for creating custom, efficient ByteString functions, using Haskell or C functions to fill the space. Wrapper of mallocForeignPtrBytes# with faster implementation for GHC still neededConversion between  and . Should compile to a no-op.Unsafe conversion between  and <. This is a no-op and silently truncates to 8 bits Chars > '\255'=. It is provided as convenience for ByteString construction.bSelects words corresponding to white-space characters in the Latin-1 range ordered by frequency. 3Selects white-space characters in the Latin-1 rangevJust like unsafePerformIO, but we inline it. Big performance gains as it exposes lots of things to further inlining.  Very unsafe@. In particular, you should do no memory allocation inside an  block. On Hugs this is just unsafePerformIO.7     OffsetLength(ptr, offset, length) !"#$%&&     6      !"#$%&D(c) Don Stewart 2006-2008 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.org provisional non-portableNone +;HM A variety of ' for non-empty ByteStrings.  omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the ByteString is non-empty. A variety of ( for non-empty ByteStrings. . omits the check for the empty case. As with Q, the programmer must provide a separate proof that the ByteString is non-empty.Unsafe : index (subscript) operator, starting from 0, returning a  This omits the bounds check, which means there is an accompanying obligation on the programmer to ensure the bounds are checked in some other way. A variety of ) which omits the checks on nF so there is an obligation on the programmer to provide a proof that  0 <= n <= * xs. A variety of + which omits the checks on nF so there is an obligation on the programmer to provide a proof that  0 <= n <= * xs.O(n) Pack a null-terminated sequence of bytes, pointed to by an Addr# (an arbitrary machine address assumed to point outside the garbage-collected heap) into a  ByteString. A much faster way to create an Addr# is with an unboxed string literal, than to pack a boxed string. A unboxed string literal is compiled to a static char []C by GHC. Establishing the length of the string requires a call to  strlen(3)l, so the Addr# must point to a null-terminated buffer (as is the case with "string"# literals in GHC). Use 2 if you know the length of the string statically. An example: (literalFS = unsafePackAddress "literal"#This function is unsafes. If you modify the buffer pointed to by the original Addr# this modification will be reflected in the resulting  ByteString$, breaking referential transparency.3Note this also won't work if you Add# has embedded '\0'. characters in the string (strlen will fail).O(1) ) provides constant-time construction of  ByteStringsJ which is ideal for string literals. It packs a sequence of bytes into a , given a raw ,. to the string, and the length of the string.This function is unsafe in two ways:the length argument is assumed to be correct. If the length argument is incorrect, it is possible to overstep the end of the byte array.Vif the underying Addr# is later modified, this change will be reflected in resulting  ByteString%, breaking referential transparency.'If in doubt, don't use these functions.O(1) Construct a ~ given a Ptr Word8 to a buffer, a length, and an IO action representing a finalizer. This function is not available on Hugs.This function is unsafe, it is possible to break referential transparency by modifying the underlying buffer pointed to by the first argument. Any changes to the original buffer will be reflected in the resulting  ByteString. /Explicitly run the finaliser associated with a W. References to this value after finalisation may generate invalid memory references.This function is unsafe, as there may be other  ByteStringsj referring to the same underlying pages. If you use this, you need to have a proof of some kind that all Ds ever generated from the underlying byte array are no longer live. O(n) Build a  ByteString from a CString. This value will have now finalizer associated to it, and will not be garbage collected by Haskell. The ByteString length is calculated using  strlen(3) , and thus the complexity is a O(n).This function is unsafe . If the CStringD is later modified, this change will be reflected in the resulting  ByteString%, breaking referential transparency. O(1) Build a  ByteString from a  CStringLen. This value will have noa finalizer associated with it, and will not be garbage collected by Haskell. This operation has O(1)6 complexity as we already know the final size, so no  strlen(3) is required.This funtion is unsafe. If the original  CStringLenD is later modified, this change will be reflected in the resulting  ByteString%, breaking referential transparency. O(n) Build a  ByteString from a malloced CString. This value will have a free(3) finalizer associated to it.This funtion is unsafe. If the original CStringD is later modified, this change will be reflected in the resulting  ByteString%, breaking referential transparency.VThis function is also unsafe if you call its finalizer twice, which will result in a  double free8 error, or if you pass it a CString not allocated with malloc. O(1) construction Use a  ByteString with a function requiring a CString.6This function does zero copying, and merely unwraps a  ByteString to appear as a CString. It is unsafe in two ways: After calling this function the CString6 shares the underlying byte buffer with the original  ByteString. Thus modifying the CString>, either in C, or using poke, will cause the contents of the  ByteString6 to change, breaking referential transparency. Other  ByteStrings0 created by sharing (such as those produced via ) or +1) will also reflect these changes. Modifying the CString; will break referential transparency. To avoid this, use  useAsCString%, which makes a copy of the original  ByteString.CStringsY are often passed to functions that require them to be null-terminated. If the original  ByteString+ wasn't null terminated, neither will the CStringA be. It is the programmers responsibility to guarantee that the  ByteString. is indeed null terminated. If in doubt, use  useAsCString.O(1) construction Use a  ByteString with a function requiring a  CStringLen.6This function does zero copying, and merely unwraps a  ByteString to appear as a  CStringLen. It is unsafe: After calling this function the  CStringLen6 shares the underlying byte buffer with the original  ByteString. Thus modifying the  CStringLen>, either in C, or using poke, will cause the contents of the  ByteString6 to change, breaking referential transparency. Other  ByteStrings0 created by sharing (such as those produced via ) or +1) will also reflect these changes. Modifying the  CStringLen; will break referential transparency. To avoid this, use useAsCStringLen%, which makes a copy of the original  ByteString.      (c) The University of Glasgow 2001, (c) David Roundy 2003-2005, (c) Simon Marlow 2005, (c) Bjorn Bringert 2006, (c) Don Stewart 2005-2008, (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgstableportable Trustworthy +;HMkO(1) The empty O(1) Convert a  into a O(n) Convert a '[Word8]' into a . For applications with large numbers of string literals, pack can be a bottleneck. In such cases, consider using packAddress (GHC only).O(n) Converts a  to a '[Word8]'.O(1)$ Test whether a ByteString is empty.O(1) * returns the length of a ByteString as an .O(n) V is analogous to (:) for lists, but of different complexity, as it requires a memcpy.O(n) Append a byte to the end of a O(1) Extract the first element of a ByteString, which must be non-empty. An exception will be thrown in the case of an empty ByteString.O(1) Extract the elements after the head of a ByteString, which must be non-empty. An exception will be thrown in the case of an empty ByteString.O(1)N Extract the head and tail of a ByteString, returning Nothing if it is empty.O(1) Extract the last element of a ByteString, which must be finite and non-empty. An exception will be thrown in the case of an empty ByteString.O(1) Return all the elements of a V except the last one. An exception will be thrown in the case of an empty ByteString.O(n) Append two ByteStringsO(n)  f xs( is the ByteString obtained by applying f to each element of xs.O(n)  xs% efficiently returns the elements of xs in reverse order.O(n) The  function takes a  and a ; and `intersperses' that byte between the elements of the 9. It is analogous to the intersperse function on Lists. The  2 function transposes the rows and columns of its  argument.!!, applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right." 'foldl\'' is like !i, but strict in the accumulator. However, for ByteStrings, all left folds are strict in the accumulator.##, applied to a binary operator, a starting value (typically the right-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from right to left.$ 'foldr\'' is like # , but strict in the accumulator.%% is a variant of !M that has no starting value argument, and thus must be applied to non-empty  ByteStringsB. An exception will be thrown in the case of an empty ByteString.& 'foldl1\'' is like %a, but strict in the accumulator. An exception will be thrown in the case of an empty ByteString.'' is a variant of #M that has no starting value argument, and thus must be applied to non-empty Bs An exception will be thrown in the case of an empty ByteString.( 'foldr1\'' is a variant of '$, but is strict in the accumulator.)O(n)# Concatenate a list of ByteStrings.*Map a function over a  and concatenate the results+O(n)* Applied to a predicate and a ByteString, +# determines if any element of the  satisfies the predicate.,O(n) Applied to a predicate and a , ,$ determines if all elements of the  satisfy the predicate.-O(n) -" returns the maximum value from a [ This function will fuse. An exception will be thrown in the case of an empty ByteString..O(n) ." returns the minimum value from a [ This function will fuse. An exception will be thrown in the case of an empty ByteString./The /( function behaves like a combination of  and !; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.0The 0( function behaves like a combination of  and #; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString.11 is similar to !Z, but returns a list of successive reduced values from the left. This function will fuse. @scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs.22 is a variant of 1? that has no starting value argument. This function will fuse. .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]3)scanr is the right-to-left dual of scanl.44 is a variant of 3% that has no starting value argument.5O(n) 5 n x is a ByteString of length n with x2 the value of every element. The following holds: .replicate w c = unfoldr w (\u -> Just (u,u)) cThis implemenation uses  memset(3)6O(n), where n# is the length of the result. The 61 function is analogous to the List 'unfoldr'. 6X builds a ByteString from a seed value. The function takes the element and returns -5 if it is done producing the ByteString 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]7O(n) Like 6, 7q builds a ByteString from a seed value. However, the length of the result is limited by the first argument to 7(. This function is more efficient than 61 when the maximum length of the result is known.The following equation relates 7 and 6: ,fst (unfoldrN n f s) == take n (unfoldr f s)8O(1) 8 n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n >  xs.9O(1) 9 n xs returns the suffix of xs after the first n elements, or [] if n >  xs.:O(1) : n xs is equivalent to (8 n xs, 9 n xs).;;, applied to a predicate p and a ByteString xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p.<< p xs$ returns the suffix remaining after ; p xs.== p is equivalent to @ (/ . p).^Under GHC, a rewrite rule will transform break (==) into a call to the specialised breakByte: 6break ((==) x) = breakByte x break (==x) = breakByte x>>i breaks its ByteString argument at the first occurence of the specified byte. It is more efficient than = as it is implemented with  memchr(3). I.e. ,break (=='c') "abcd" == breakByte 'c' "abcd"?? behaves like = but from the end of the breakEnd p == spanEnd (not.p)@@ p xs? breaks the ByteString into two segments. It is equivalent to (; p xs, < p xs)00 breaks its ByteString argument at the first occurence of a byte other than its argument. It is more efficient than 'span (==)' +span (=='c') "abcd" == spanByte 'c' "abcd"AA behaves like @ but from the end of the  . We have -spanEnd (not.isSpace) "x y z" == ("x y ","z")and hspanEnd (not . isSpace) ps == let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x) BO(n) Splits a  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. TsplitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == []CO(n) Break a K into pieces separated by the byte argument, 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 . (==)tAs for all splitting functions in this library, this function does not copy the substrings, it just constructs new  ByteStrings" that are slices of the original.DThe D function takes a ByteString and returns a list of ByteStrings 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 E`, which allows the programmer to supply their own equality test. It is about 40% faster than  groupBy (==)EThe E+ function is the non-overloaded version of D.FO(n) The F function takes a  and a list of es and concatenates the list after interspersing the first argument between each element of the list.1O(n) intercalateWithByte. An efficient way to join to two ByteStrings with a char. Around 4 times faster than the generalised join.GO(1) - index (subscript) operator, starting from 0.HO(n) The H? function returns the index of the first element in the given * which is equal to the query element, or -C if there is no such element. This implementation uses memchr(3).IO(n) The I> function returns the last index of the element in the given * which is equal to the query element, or -3 if there is no such element. The following holds: IelemIndexEnd c xs == (-) (length xs - 1) `fmap` elemIndex c (reverse xs)JO(n) The J function extends H, by returning the indices of all elements equal to the query element, in ascending order. This implementation uses memchr(3).KHcount returns the number of times its argument appears in the ByteString count = length . elemIndices@But more efficiently than using length on the intermediate list.LThe L" function takes a predicate and a Y and returns the index of the first element in the ByteString satisfying the predicate.MThe M function extends LY, by returning the indices of all elements satisfying the predicate, in ascending order.NO(n) N is the  membership predicate.OO(n) O is the inverse of NPO(n) Py, applied to a predicate and a ByteString, returns a ByteString containing those characters that satisfy the predicate.QO(n) The Qk function takes a predicate and a ByteString, and returns the first element in matching the predicate, or - if there is no such element. Ffind f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> NothingRO(n) The R function takes a predicate a ByteString and returns the pair of ByteStrings with elements which do and do not satisfy the predicate, respectively; i.e., 4partition p bs == (filter p xs, filter (not . p) xs)SO(n) The S, function takes two ByteStrings and returns 2* iff the first is a prefix of the second.TO(n) The T, function takes two ByteStrings and returns 2* iff the first is a suffix of the second.The following holds: 2isSuffixOf x y == reverse x `isPrefixOf` reverse ynHowever, the real implemenation uses memcmp to compare the end of the string only, with no reverse required..U4Check whether one string is a substring of another. isInfixOf p s is equivalent to not (null (findSubstrings p s)).VzBreak a string on a substring, returning a pair of the part of the string prior to the match, and the rest of the string.!The following relationships hold: 0break (== c) l == breakSubstring (singleton c) land: findSubstring s l == if null s then Just 0 else case breakSubstring s l of (x,y) | null y -> Nothing | otherwise -> Just (length x)7For example, to tokenise a string, dropping delimiters: mtokenise x y = h : if null t then [] else tokenise x (drop (length x) t) where (h,t) = breakSubstring x y+To skip to the first occurence of a string: snd (breakSubstring x y) 1To take the parts of a string before a delimiter: fst (breakSubstring x y) W<Get the first index of a substring in another string, or - if the string is not found. findSubstring p s is equivalent to  listToMaybe (findSubstrings p s).XVFind the indexes of all (possibly overlapping) occurances of a substring in a string.YO(n) Y takes two ByteStrings and returns a list of corresponding pairs of bytes. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of  operations.ZZ generalises Yj by zipping with the function given as the first argument, instead of a tupling function. For example, Z (+)K is applied to two ByteStrings to produce the list of corresponding sums. 3A specialised version of zipWith for the common case of a simultaneous map over two bytestrings, to build a 3rd. Rewrite rules are used to automatically covert zipWith into zipWith' when a pack is performed on the result of zipWith.[O(n) [^ transforms a list of pairs of bytes into a pair of ByteStrings. Note that this performs two  operations.\O(n)* Return all initial segments of the given , shortest first.]O(n)( Return all final segments of the given , longest first.^O(n)4 Sort a ByteString efficiently, using counting sort._O(n) construction Use a  ByteString. with a function requiring a null-terminated CString. The CString3 will be freed automatically. This is a memcpy(3).`O(n) construction Use a  ByteString with a function requiring a  CStringLen . As for  useAsCString, this function makes a copy of the original  ByteString.aO(n). Construct a new  ByteString from a CString. The resulting  ByteString' is an immutable copy of the original CString4, and is managed on the Haskell heap. The original CString must be null terminated.bO(n). Construct a new  ByteString from a  CStringLen. The resulting  ByteString& is an immutable copy of the original  CStringLen. The  ByteStringD is a normal Haskell value and will be managed on the Haskell heap.cO(n) Make a copy of the ` with its own storage. This is mainly useful to allow the rest of the data pointed to by the  to be garbage collected, for example if a large string has been read in, and only a small part of it is needed in the rest of the program.dRead a line from stdin.eRead a line from a handlef Outputs a  to the specified 4.g Similar to fj except that it will never block. Instead it returns any tail that did not get written. This tail may be  in the case that the whole string was written, or the whole original string if nothing was written. Partial writes are also possible.Note: on Windows and with Haskell implementation other than GHC, this function does not work correctly; it behaves identically to f.hA synonym for hPut, for compatibility i8Write a ByteString to a handle, appending a newline bytejWrite a ByteString to stdoutk6Write a ByteString to stdout, appending a newline bytelRead a  directly from the specified 4B. This is far more efficient than reading the characters into a 5 and then using . First argument is the Handle to read from, and the second is the number of bytes to read. It returns the bytes read, up to n, or  if EOF has been reached.l is implemented in terms of 6.CIf the handle is a pipe or socket, and the writing end is closed, l# will behave as if EOF was reached.mhGetNonBlocking is similar to l, except that it will never block waiting for data to become available, instead it returns only whatever data is available. If there is no data available to be read, m returns .Note: on Windows and with Haskell implementation other than GHC, this function does not work correctly; it behaves identically to l.nLike l, except that a shorter f may be returned if there are not enough bytes immediately available to satisfy the whole request. nN only blocks if there is no data available, and EOF has not yet been reached.o,Read entire handle contents strictly into a .This function reads chunks at a time, doubling the chunksize on each read. The final buffer is then realloced to the appropriate size. For files > half of available memory, this may lead to memory exhaustion. Consider using r in this case.As with lE, the string representation in the file is assumed to be ISO-8859-1.UThe Handle is closed once the contents have been read, or if an exception is thrown.pHgetContents. Read stdin strictly. Equivalent to hGetContents stdin The 4- is closed after the contents have been read.q/The interact function takes a function of type ByteString -> ByteString as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.r$Read an entire file strictly into a B. This is far more efficient than reading the characters into a 5 and then using M. It also may be more efficient than opening the file and reading it using l.sWrite a  to a file.t Append a  to a file.77o is a variant of findIndex, that returns the length of the string if no element is found, rather than Nothing.80Perform an operation with a temporary ByteStringt9 !"#$%&'()*+,-./0123456789:;<=>?@0ABCDEF1GHIJKLMNOPQRSTUVString to search forString to search in+Head and tail of string broken at substringWString to search for.String to seach in.XString to search for.String to seach in.YZ3[\]^_`abcde:;fghijklmn<opqrst78=>?@Ag !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstgF !"%&#$'()*+,-.1234/056789:;<@A=?DE\]CBSTUVWXNOQPRGHJILMKYZ[^cab_`dpjkqrsteolnmfghi>t9 !"#$%&'()*+,-./0123456789:;<=>?@0ABCDEF1GHIJKLMNOPQRSTUVWXYZ3[\]^_`abcde:;fghijklmn<opqrst78=>?@AD(c) Don Stewart 2006-2008 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgstableportable Trustworthy +;HMFuO(1) Convert a  into a vO(n) Convert a 5 into a RFor applications with large numbers of string literals, pack can be a bottleneck.wO(n) Converts a  to a 5.xO(n) xV is analogous to (:) for lists, but of different complexity, as it requires a memcpy.yO(n) Append a Char to the end of a . Similar to x", this function performs a memcpy.zO(1)N Extract the head and tail of a ByteString, returning Nothing if it is empty.{O(1)D Extract the first element of a ByteString, which must be non-empty.|O(1)F Extract the last element of a packed string, which must be non-empty.}O(n) } f xs( is the ByteString obtained by applying f to each element of xs~O(n) The ~ function takes a Char and a < and `intersperses' that Char between the elements of the 8. It is analogous to the intersperse function on Lists., applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right. 'foldl\''. is like foldl, but strict in the accumulator., applied to a binary operator, a starting value (typically the right-identity of the operator), and a packed string, reduces the packed string using the binary operator, from right to left. 'foldr\'' is a strict variant of foldr is a variant of M that has no starting value argument, and thus must be applied to non-empty  ByteStrings.A strict version of  is a variant of M that has no starting value argument, and thus must be applied to non-empty sA strict variant of foldr1Map a function over a  and concatenate the results)Applied to a predicate and a ByteString, # determines if any element of the  satisfies the predicate.Applied to a predicate and a , $ determines if all elements of the  satisfy the predicate." returns the maximum value from a " returns the minimum value from a The ( function behaves like a combination of } and ; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.The ( function behaves like a combination of } and ; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString. is similar to A, but returns a list of successive reduced values from the left: @scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs. is a variant of % that has no starting value argument: .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...])scanr is the right-to-left dual of scanl. is a variant of % that has no starting value argument.O(n)  n x is a ByteString of length n with x2 the value of every element. The following holds: .replicate w c = unfoldr w (\u -> Just (u,u)) cThis implemenation uses  memset(3)O(n), where n# is the length of the result. The 1 function is analogous to the List 'unfoldr'. X builds a ByteString from a seed value. The function takes the element and returns -5 if it is done producing the ByteString or returns . (a,b), in which case, a, is the next character in the string, and b* is the seed value for further production. Examples: Runfoldr (\x -> if x <= '9' then Just (x, succ x) else Nothing) '0' == "0123456789"O(n) Like , q builds a ByteString 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 : &unfoldrN n f s == take n (unfoldr f s), applied to a predicate p and a ByteString xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p. p xs$ returns the suffix remaining after  p xs. p is equivalent to  (/ . p).BBi breaks its ByteString argument at the first occurence of the specified char. It is more efficient than  as it is implemented with  memchr(3). I.e. ,break (=='c') "abcd" == breakChar 'c' "abcd" p xs? breaks the ByteString into two segments. It is equivalent to ( p xs,  p xs) behaves like  but from the end of the  . We have -spanEnd (not.isSpace) "x y z" == ("x y ","z")and hspanEnd (not . isSpace) ps == let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x)  behaves like  but from the end of the breakEnd p == spanEnd (not.p)O(n) Break a K into pieces separated by the byte argument, 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 . (==)tAs for all splitting functions in this library, this function does not copy the substrings, it just constructs new  ByteStrings" that are slices of the original.O(n) Splits a  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. 2splitWith (=='a') "aabbaca" == ["","","bb","c",""]The + function is the non-overloaded version of D.O(1) - index (subscript) operator, starting from 0.O(n) The ? function returns the index of the first element in the given 6 which is equal (by memchr) to the query element, or - if there is no such element.O(n) The > function returns the last index of the element in the given * which is equal to the query element, or -3 if there is no such element. The following holds: IelemIndexEnd c xs == (-) (length xs - 1) `fmap` elemIndex c (reverse xs)O(n) The  function extends [, by returning the indices of all elements equal to the query element, in ascending order.The " function takes a predicate and a X and returns the index of the first element in the ByteString satisfying the predicate.The  function extends Y, by returning the indices of all elements satisfying the predicate, in ascending order.Hcount returns the number of times its argument appears in the ByteString count = length . elemIndicesAlso count '\n' == length . lines@But more efficiently than using length on the intermediate list.O(n)  is the 1 membership predicate. This implementation uses  memchr(3).O(n)  is the inverse of O(n) y, applied to a predicate and a ByteString, returns a ByteString containing those characters that satisfy the predicate.O(n) The k function takes a predicate and a ByteString, and returns the first element in matching the predicate, or - if there is no such element.O(n)  takes two ByteStrings and returns a list of corresponding pairs of Chars. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of wL operations, and so space usage may be large for multi-megabyte ByteStrings generalises j by zipping with the function given as the first argument, instead of a tupling function. For example,  (+)J is applied to two ByteStrings to produce the list of corresponding sums.^ transforms a list of pairs of Chars into a pair of ByteStrings. Note that this performs two v operations.C A variety of { for non-empty ByteStrings. C omits the check for the empty case, which is good for performance, but there is an obligation on the programmer to provide a proof that the ByteString is non-empty.DD` returns the pair of ByteStrings when the argument is broken at the first whitespace byte. I.e. break isSpace == breakSpaceEE efficiently returns the  argument with white space Chars removed from the front. It is more efficient than calling dropWhile for removing whitespace. I.e. dropWhile isSpace == dropSpacet breaks a ByteString up into a list of ByteStrings at newline Chars. The resulting strings do not contain newlines. is an inverse operation to B. It joins lines, after appending a terminating newline to each.f breaks a ByteString up into a list of words, which were delimited by Chars representing white space.The  function is analogous to the  function, on words.readInt reads an Int from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.readInteger reads an Integer from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.$Read an entire file strictly into a B. This is far more efficient than reading the characters into a 5 and then using vR. It also may be more efficient than opening the file and reading it using hGet.Write a  to a file. Append a  to a file.8Write a ByteString to a handle, appending a newline byte6Write a ByteString to stdout, appending a newline byteHuvwxyz{|}~BCDFEGj )89:DFSTUVWX\]^_`abcdefghjlmopquvwxyz{|}~juvwxy{z|}~F )89:D\]STUVWX^cab_`dpjqeolmfghHuvwxyz{|}~BCDFEGxyD(c) Don Stewart 2006-2008 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgunstable non-portableNone +;HM ^A space-efficient representation of a Word8 vector, supporting many efficient operations. A  contains 8-bit characters only.0Instances of Eq, Ord, Read, Show, Data, TypeableH5The data type invariant: Every ByteString is either I or consists of non-null Ls. All functions must preserve this, and the QC properties must check this.J+In a form that checks the invariant lazily.KSmart constructor for L%. Guarantees the data type invariant.BConsume the chunks of a lazy ByteString with a natural right fold._Consume the chunks of a lazy ByteString with a strict, tail-recursive, accumulating left fold.VThe chunk size used for I/O. Currently set to 32k, less the memory management overheadTThe recommended chunk size. Currently set to 4k, less the memory management overheadMEThe memory management overhead. Currently this is tuned for GHC only.LINOPQHJKMRSTUVWXYZ[\]LINOPQHJKMILNOPQHJKMRSTUVWXYZ[\]?(c) Don Stewart 2006 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgstableportable Trustworthy +;HM[O(1) The empty O(1) Convert a  into a O(n) Convert a '[Word8]' into a . O(n) Converts a  to a '[Word8]'.O(c) Convert a list of strict  into a lazy O(c) Convert a lazy  into a list of strict O(1) Convert a strict  into a lazy .O(n) Convert a lazy  into a strict .Note that this is an  expensive operation that forces the whole lazy ByteString into memory and then copies all the data. If possible, try to avoid converting back and forth between strict and lazy bytestrings.O(1)$ Test whether a ByteString is empty.O(n/c) * returns the length of a ByteString as an O(1) ! is analogous to '(:)' for lists.O(1) Unlike , 'cons\'' is strict in the ByteString that we are consing onto. More precisely, it forces the head and the first chunk. It does this because, for space efficiency, it may coalesce the new byte onto the first 'chunk' rather than starting a new 'chunk'.CSo that means you can't use a lazy recursive contruction like this: let xs = cons\' c xs in xsYou can however use  , as well as  and &, to build infinite lazy ByteStrings.O(n/c) Append a byte to the end of a O(1)D Extract the first element of a ByteString, which must be non-empty.O(1)N Extract the head and tail of a ByteString, returning Nothing if it is empty.O(1)O Extract the elements after the head of a ByteString, which must be non-empty.O(n/c)O Extract the last element of a ByteString, which must be finite and non-empty.O(n/c) Return all the elements of a  except the last one.O(n/c) Append two ByteStringsO(n)  f xs( is the ByteString obtained by applying f to each element of xs.O(n)  xs returns the elements of xs in reverse order.The  function takes a  and a ; and `intersperses' that byte between the elements of the 8. It is analogous to the intersperse function on Lists.The 2 function transposes the rows and columns of its  argument., applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right. 'foldl\'' is like  , but strict in the accumulator., applied to a binary operator, a starting value (typically the right-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from right to left. is a variant of M that has no starting value argument, and thus must be applied to non-empty  ByteStrings. 'foldl1\'' is like  , but strict in the accumulator. is a variant of M that has no starting value argument, and thus must be applied to non-empty sO(n)# Concatenate a list of ByteStrings.Map a function over a  and concatenate the resultsO(n)* Applied to a predicate and a ByteString, # determines if any element of the  satisfies the predicate.O(n) Applied to a predicate and a , $ determines if all elements of the  satisfy the predicate.O(n) " returns the maximum value from a O(n) " returns the minimum value from a The ( function behaves like a combination of  and ; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString.The ( function behaves like a combination of  and ; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString. is similar to Z, but returns a list of successive reduced values from the left. This function will fuse. @scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs. f x= returns an infinite ByteString of repeated applications of f to x: %iterate f x == [x, f x, f (f x), ...] x! is an infinite ByteString, with x the value of every element.O(n)  n x is a ByteString of length n with x the value of every element.t ties a finite ByteString into a circular one, or equivalently, the infinite repetition of the original ByteString.O(n) The / function is analogous to the List 'unfoldr'. U builds a ByteString from a seed value. The function takes the element and returns -4 if it is done producing the ByteString or returns . (a,b), in which case, a( is a prepending to the ByteString and b2 is used as the next element in a recursive call.O(n/c)  n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n >  xs.O(n/c)  n xs returns the suffix of xs after the first n elements, or [] if n >  xs.O(n/c)  n xs is equivalent to ( n xs,  n xs)., applied to a predicate p and a ByteString xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p. p xs$ returns the suffix remaining after  p xs. p is equivalent to  (/ . p). p xs? breaks the ByteString into two segments. It is equivalent to ( p xs,  p xs)O(n) Splits a  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. TsplitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == []O(n) Break a K into pieces separated by the byte argument, 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 . (==)tAs for all splitting functions in this library, this function does not copy the substrings, it just constructs new  ByteStrings" that are slices of the original.The  function takes a ByteString and returns a list of ByteStrings 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 A, which allows the programmer to supply their own equality test.The + function is the non-overloaded version of .O(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.O(c) - index (subscript) operator, starting from 0.O(n) The ? function returns the index of the first element in the given * which is equal to the query element, or -C if there is no such element. This implementation uses memchr(3).O(n) The  function extends , by returning the indices of all elements equal to the query element, in ascending order. This implementation uses memchr(3).Hcount returns the number of times its argument appears in the ByteString count = length . elemIndices@But more efficiently than using length on the intermediate list.The " function takes a predicate and a Y and returns the index of the first element in the ByteString satisfying the predicate.O(n) The k function takes a predicate and a ByteString, and returns the first element in matching the predicate, or - if there is no such element. Ffind f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> NothingThe  function extends Y, by returning the indices of all elements satisfying the predicate, in ascending order.O(n)  is the  membership predicate.O(n)  is the inverse of O(n) y, applied to a predicate and a ByteString, returns a ByteString containing those characters that satisfy the predicate.O(n) The  function takes a predicate a ByteString and returns the pair of ByteStrings with elements which do and do not satisfy the predicate, respectively; i.e., 4partition p bs == (filter p xs, filter (not . p) xs)O(n) The , function takes two ByteStrings and returns 2* iff the first is a prefix of the second.O(n) The , function takes two ByteStrings and returns 2* iff the first is a suffix of the second.The following holds: 2isSuffixOf x y == reverse x `isPrefixOf` reverse yO(n)  takes two ByteStrings and returns a list of corresponding pairs of bytes. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of  operations. generalises j by zipping with the function given as the first argument, instead of a tupling function. For example,  (+)J is applied to two ByteStrings to produce the list of corresponding sums.O(n) ^ transforms a list of pairs of bytes into a pair of ByteStrings. Note that this performs two  operations.O(n)* Return all initial segments of the given , shortest first.O(n)( Return all final segments of the given , longest first.O(n) Make a copy of the c with its own storage. This is mainly useful to allow the rest of the data pointed to by the  to be garbage collected, for example if a large string has been read in, and only a small part of it is needed in the rest of the program.^Read entire handle contents lazily into a ). Chunks are read on demand, in at most k6-sized chunks. It does not block waiting for a whole k-sized chunk, so if less than kP bytes are available then they will be returned immediately as a smaller chunk.The handle is closed on EOF. Note: the 4' should be placed in binary mode with  for ^ to work correctly._Read n bytes into a , directly from the specified 4, in chunks of size k.`hGetNonBlockingN is similar to ^, except that it will never block waiting for data to become available, instead it returns only whatever data is available. Chunks are read on demand, in k-sized chunks.Read entire handle contents lazily into a ;. Chunks are read on demand, using the default chunk size..Once EOF is encountered, the Handle is closed. Note: the 4' should be placed in binary mode with  for  to work correctly.Read n bytes into a , directly from the specified 4.hGetNonBlocking is similar to , except that it will never block waiting for data to become available, instead it returns only whatever data is available. If there is no data available to be read,  returns .Note: on Windows and with Haskell implementation other than GHC, this function does not work correctly; it behaves identically to . Read an entire file lazily into a 9. The Handle will be held open until EOF is encountered. Write a  to a file.  Append a  to a file. 9getContents. Equivalent to hGetContents stdin. Will read lazily  Outputs a  to the specified 4. Similar to  j except that it will never block. Instead it returns any tail that did not get written. This tail may be  in the case that the whole string was written, or the whole original string if nothing was written. Partial writes are also possible.Note: on Windows and with Haskell implementation other than GHC, this function does not work correctly; it behaves identically to  .A synonym for hPut, for compatibilityWrite a ByteString to stdout6Write a ByteString to stdout, appending a newline byte/The interact function takes a function of type ByteString -> ByteString as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.aao is a variant of findIndex, that returns the length of the string if no element is found, rather than Nothing.`^_`b     cdefaZ     Z     `^_`b     cdefaD(c) Don Stewart 2006-2008 (c) Duncan Coutts 2006-2011 BSD-style.dons00@gmail.com, duncan@community.haskell.orgstableportable Trustworthy +;HM;O(1) Convert a  into a O(n) Convert a 5 into a . O(n) Converts a  to a 5.O(1) ! is analogous to '(:)' for lists.O(1) Unlike , 'cons\'' is strict in the ByteString that we are consing onto. More precisely, it forces the head and the first chunk. It does this because, for space efficiency, it may coalesce the new byte onto the first 'chunk' rather than starting a new 'chunk'.CSo that means you can't use a lazy recursive contruction like this: let xs = cons\' c xs in xsYou can however use  , as well as - and &, to build infinite lazy ByteStrings.O(n) Append a Char to the end of a . Similar to ", this function performs a memcpy.O(1)D Extract the first element of a ByteString, which must be non-empty.O(1)N Extract the head and tail of a ByteString, returning Nothing if it is empty.O(1)F Extract the last element of a packed string, which must be non-empty.O(n)  f xs( is the ByteString obtained by applying f to each element of xsO(n) The  function takes a Char and a < and `intersperses' that Char between the elements of the 8. It is analogous to the intersperse function on Lists., applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right. 'foldl\''. is like foldl, but strict in the accumulator.  , applied to a binary operator, a starting value (typically the right-identity of the operator), and a packed string, reduces the packed string using the binary operator, from right to left.!! is a variant of M that has no starting value argument, and thus must be applied to non-empty  ByteStrings." 'foldl1\'' is like ! , but strict in the accumulator.## is a variant of  M that has no starting value argument, and thus must be applied to non-empty s$Map a function over a  and concatenate the results%)Applied to a predicate and a ByteString, %# determines if any element of the  satisfies the predicate.&Applied to a predicate and a , &$ determines if all elements of the  satisfy the predicate.''" returns the maximum value from a ((" returns the minimum value from a )) is similar to Z, but returns a list of successive reduced values from the left. This function will fuse. @scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs.*The *( function behaves like a combination of  and ; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString.+The +( function behaves like a combination of  and  ; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString.,, f x= returns an infinite ByteString of repeated applications of f to x: %iterate f x == [x, f x, f (f x), ...]-- x! is an infinite ByteString, with x the value of every element..O(n) . n x is a ByteString of length n with x the value of every element./O(n) The // function is analogous to the List 'unfoldr'. /U builds a ByteString from a seed value. The function takes the element and returns -4 if it is done producing the ByteString or returns . (a,b), in which case, a( is a prepending to the ByteString and b2 is used as the next element in a recursive call.00, applied to a predicate p and a ByteString xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p.11 p xs$ returns the suffix remaining after 0 p xs.22 p is equivalent to 3 (/ . p).33 p xs? breaks the ByteString into two segments. It is equivalent to (0 p xs, 1 p xs)4O(n) Break a K into pieces separated by the byte argument, 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 . (==)tAs for all splitting functions in this library, this function does not copy the substrings, it just constructs new  ByteStrings" that are slices of the original.5O(n) Splits a  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. 2splitWith (=='a') "aabbaca" == ["","","bb","c",""]6The 6+ function is the non-overloaded version of .7O(1) - index (subscript) operator, starting from 0.8O(n) The 8? function returns the index of the first element in the given 6 which is equal (by memchr) to the query element, or - if there is no such element.9O(n) The 9 function extends 8[, by returning the indices of all elements equal to the query element, in ascending order.:The :" function takes a predicate and a X and returns the index of the first element in the ByteString satisfying the predicate.;The ; function extends :Y, by returning the indices of all elements satisfying the predicate, in ascending order.<Hcount returns the number of times its argument appears in the ByteString ?count == length . elemIndices count '\n' == length . lines@But more efficiently than using length on the intermediate list.=O(n) = is the 1 membership predicate. This implementation uses  memchr(3).>O(n) > is the inverse of =?O(n) ?y, applied to a predicate and a ByteString, returns a ByteString containing those characters that satisfy the predicate.@O(n) The @k function takes a predicate and a ByteString, and returns the first element in matching the predicate, or - if there is no such element.AO(n) A takes two ByteStrings and returns a list of corresponding pairs of Chars. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of L operations, and so space usage may be large for multi-megabyte ByteStringsBB generalises Aj by zipping with the function given as the first argument, instead of a tupling function. For example, B (+)J is applied to two ByteStrings to produce the list of corresponding sums.CCt breaks a ByteString up into a list of ByteStrings at newline Chars. The resulting strings do not contain newlines.KAs of bytestring 0.9.0.3, this function is stricter than its list cousin.DD is an inverse operation to CB. It joins lines, after appending a terminating newline to each.EEj breaks a ByteString up into a list of words, which were delimited by Chars representing white space. And tokens isSpace = wordsFThe F function is analogous to the D function, on words.GreadInt reads an Int from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.HreadInteger reads an Integer from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.IRead an entire file lazily into a .JWrite a  to a file.K Append a  to a file.L8Write a ByteString to a handle, appending a newline byteM6Write a ByteString to stdout, appending a newline byte< !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMg\   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM\!" #$%&'()*+-.,/0132645CEDF=>@?789:;<ABGH MIJK L< !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMg(c) 2010 - 2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com> experimentalGHCNone +;HM&h.A stream of non-empty chunks interleaved with i.N+A buffer allocation strategy for executing Os.jA jZ action denotes a computation of a value that writes a stream of bytes as a side-effect. j|s are strict in their side-effect; i.e., the stream of bytes will always be written before the computed value is returned.js are a generalization of Os. They are used when values need to be returned during the computation of a stream of bytes. For example, when performing a block-based encoding of Ms like Base64 encoding, there might be a left-over partial block. Using the j monad, this partial block can be returned after the complete blocks have been encoded. Then, in a later step when more input is known, this partial block can be completed and also encoded.Put () actions are isomorphic to Os. The functions k and lB convert between these two types. Where possible, you should use O%s, as they are slightly cheaper than j.s because they do not carry a computed value.OO's denote sequences of bytes. They are m s where n$ is the zero-length sequence and o! is concatenation, which runs in O(1).pp&s abstract signals to the caller of a q$. There are exactly three signals: r, s, and t.qqs may assume that they are called at most once. However, they must not execute any function that may rise an async. exception, as this would invalidate the code of u below.vzA range of bytes in a buffer represented by the pointer to the first byte of the range and the pointer to the first byte after the range.rSignal that the current q" is done and has computed a value.s'Signal that the current buffer is full.t7Signal that several chunks should be inserted directly.wFill a v using a q.x Construct a O. In contrast to qs, O!s are referentially transparent.yRun a O.zRun a O.{The Ok denoting a zero-length sequence of bytes. This function is only exported for use in rewriting rules. Use n otherwise.|Concatenate two OCs. This function is only exported for use in rewriting rules. Use o otherwise.P;Flush the current buffer. This introduces a chunk boundary.} Construct a j action. In contrast to qs, jGs are referentially transparent in the sense that sequencing the same jL multiple times yields every time the same value with the same side-effect.~Run a j.kRun a O as a side-effect of a Put () action.l Convert a Put () action to a O.uRun a j- action redirecting the produced output to a 4.!The output is buffered using the 4Ms associated buffer. If this buffer is too small to execute one step of the j9 action, then it is replaced with a large enough buffer.Ensure that there are at least n free bytes for the following O.Copy the bytes from a v into the output stream.Q Construct a O that copies the strict Js, if it is smaller than the treshold, and inserts it directly otherwise. For example, byteStringThreshold 1024 copies strict s whose size is less or equal to 1kb, and inserts them directly otherwise. This implies that the average chunk-size of the generated lazy { may be as low as 513 bytes, as there could always be just a single byte between the directly inserted 1025 byte, strict s.R Construct a O that copies the strict .Use this function to create Os from smallish (<= 4kb) 's or if you need to guarantee that the 1 is not shared with the chunks generated by the O.S Construct a O that always inserts the strict  directly as a chunk.kThis implies flushing the output buffer, even if it contains just a single byte. You should therefore use S only for large (> 8kb) ^s. Otherwise, the generated chunks are too fragmented to be processed efficiently afterwards.T Construct a O( that uses the thresholding strategy of Q for each chunk of the lazy .U Construct a O that copies the lazy .V Construct a O% that inserts all chunks of the lazy  directly.W Create a O2 denoting the same sequence of bytes as a strict . The O inserts large \s directly, but copies small ones to ensure that the generated chunks are large on average.X Create a O0 denoting the same sequence of bytes as a lazy . The O" inserts large chunks of the lazy \ directly, but copies small ones to ensure that the generated chunks are large on average.The maximal size of a  that is copied. 2 * - to guarantee that on average a chunk is of . Insert a  of the given size directly.=Sanitize a buffer size; i.e., make it at least the size of a .Y&Use this strategy for generating lazy s whose chunks are discarded right after they are generated. For example, if you just generate them to write them to a network socket.Z&Use this strategy for generating lazy s whose chunks are likely to survive one garbage collection. This strategy trims buffers that are filled less than half in order to avoid spilling too much memory.[ Execute a O" with custom execution parameters. This function is forced to be inlined to allow fusing with the allocation strategy despite its rather heavy code-size. We therefore recommend that you introduce a top-level function once you have fixed your strategy. This avoids unnecessary code duplication. For example, the default O execution function toLazyByteString is defined as follows. {- NOINLINE toLazyByteString .-} toLazyByteString = toLazyByteStringWith (Z  ) empty where empty is the zero-length lazy .&In most cases, the parameters used by toLazyByteString2 give good performance. A sub-performing case of toLazyByteString" is executing short (<128 bytes) O}s. In this case, the allocation overhead for the first 4kb buffer and the trimming cost dominate the cost of executing the O". You can avoid this problem using <toLazyByteStringWith (safeStrategy 128 smallChunkSize) emptyEThis reduces the allocation and trimming overhead, as all generated bs fit into the first buffer and there is no trimming required, if more than 64 bytes are written.9hNjOpqvrNext free byte in current vComputed valuesMinimal size of next v.Next free byte in current v.q to run on the next v. This q& may assume that it is called with a vB of at least the required minimal size; i.e., the caller of this q must guarantee this.tNext free byte in current vNumber of bytes in  continuation.Chunks to insert.q to run on next vw"Build step to use for filling the v. Handling the r signal Handling the s signal Handling the t signalBuffer range to fill.Value computed by filling this v.xA function that fills a v+, calls the continuation with the updated v= once its done, and signals its caller how to proceed using r, s, or  insertChunk.IThis function must be referentially transparent; i.e., calling it multiple times must result in the same sequence of bytes being written. If you need mutable state, then you must allocate it newly upon each call of this function. Moroever, this function must call the continuation once its done. Otherwise, concatenation of Ozs does not work. Finally, this function must write to all bytes that it claims it has written. Otherwise, the resulting OR is not guaranteed to be referentially transparent and sensitive data might leak.yO to runq& that writes the byte stream of this O and signals r upon completion.zO to run Continuation q{|P}A function that fills a v+, calls the continuation with the updated vT and its computed value once its done, and signals its caller how to proceed using r, s, or  insertChunk.pThis function must be referentially transparent; i.e., calling it multiple times must result in the same sequence of bytes being written and the same value being computed. If you need mutable state, then you must allocate it newly upon each call of this function. Moroever, this function must call the continuation once its done. Otherwise, monadic sequencing of jzs does not work. Finally, this function must write to all bytes that it claims it has written. Otherwise, the resulting jR is not guaranteed to be referentially transparent and sensitive data might leak.~ Put to runq, that first writes the byte stream of this j/ and then yields the computed value using the r signal.kluInput v.QRSTUVWXYSize of the first bufferSize of successive bufferseAn allocation strategy that does not trim any of the filled buffers before converting it to a chunk.ZSize of first bufferSize of successive buffershAn allocation strategy that guarantees that at least half of the allocated memory is used for live data[!Buffer allocation strategy to useLazy + to use as the tail of the generated lazy Builder to executeResulting lazy !Buffer allocation strategy to use Continuation stream constructor.j to execute-hNjOpqvrstwxyz{|P}~kluQRSTUVWXYZ[.hNjOpqvrstwxyz{|P}~kluQRSTUVWXYZ[(c) 2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com> experimentalGHCNone +;HM&An encoding table for Base16 encoding.VThe encoding table for hexadecimal values with lower-case characters; e.g., deadbeef.Encode a nibble as an octet. 4encode4_as_8 lowerTable 10 = fromIntegral (char 'a')Encode an octet as 16bit word comprising both encoded nibbles ordered according to the host endianness. Writing these 16bit to memory will write the nibbles in the correct order (i.e. big-endian). J(c) 2010 Jasper Van der Jeugt (c) 2010 - 2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HMEncode the least 7-bits of a  using the ASCII encoding.Decimal encoding of an .Decimal encoding of an .Decimal encoding of an .Decimal encoding of an .Decimal encoding of an .Decimal encoding of a .Decimal encoding of a .Decimal encoding of a .Decimal encoding of a .Decimal encoding of a .Hexadecimal encoding of a .Hexadecimal encoding of a .Hexadecimal encoding of a .Hexadecimal encoding of a .Hexadecimal encoding of a . Encode a & using 2 nibbles (hexadecimal digits). Encode a  using 4 nibbles. Encode a  using 8 nibbles. Encode a  using 16 nibbles. Encode a & using 2 nibbles (hexadecimal digits). Encode a  using 4 nibbles. Encode a  using 8 nibbles. Encode a  using 16 nibbles.Encode an IEEE  using 8 nibbles.Encode an IEEE  using 16 nibbles.##O(c) 2010-2011 Simon Meier (c) 2010 Jasper van der JeugtBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HMEncode a value with a .2Encode a list of values from left-to-right with a .*Encode a list of values represented as an  with a .Heavy inlining. Encode all bytes of a strict  from left-to-right with a O. This function is quite versatile. For example, we can use it to construct a OD that maps every byte before copying it to the buffer to be filled. wmapToBuilder :: (Word8 -> Word8) -> S.ByteString -> Builder mapToBuilder f = encodeByteStringWithF (contramapF f word8)*We can also use it to hex-encode a strict  as shown by the byteStringHexFixed example above.Heavy inlining. Encode all bytes of a lazy  from left-to-right with a . Create a O$ that encodes values with the given Encoding.We rewrite consecutive uses of  encodeWith4 such that the bound-checks are fused. For example, 9encodeWithB (word32 c1) `mappend` encodeWithB (word32 c2)%is rewritten such that the resulting OO checks only once, if ther are at 8 free bytes, instead of checking twice, if there are 4 free bytes. This optimization is not observationally equivalent in a strict sense, as it influences the boundaries of the generated chunks. However, for a user of this library it is observationally equivalent, as chunk boundaries of a lazy T can only be observed through the internal interface. Morevoer, we expect that all Encodings write much fewer than 4kb (the default short buffer size). Hence, it is safe to ignore the additional memory spilled due to the more agressive buffer wrapping introduced by this optimization. Create a O7 that encodes a list of values consecutively using an Encoding4. This function is more efficient than the canonical Zfilter p = B.toLazyByteString . E.encodeLazyByteStringWithF (E.ifF p E.word8) E.emptyF)  mconcat . map (encodeWithB w)or foldMap (encodeWithB w)9because it moves several variables out of the inner loop. Create a O? that encodes a sequence generated from a seed value using an Encoding. Create a O that encodes each  of a strict  using an Encoding. For example, we can write a O that filters a strict  as follows. Cimport Codec.Bounded.Encoding as E (encodeIf, word8, encodeNothing) 1filterBS p = E.encodeIf p E.word8 E.encodeNothingChunk-wise application of encodeByteStringWith.Char8 encode a .UTF-8 encode a .Encode a Unicode character to another datatype, using UTF-8. This function acts as an abstract way of encoding characters, as it is unaware of what needs to happen with the resulting bytes: you have to specify functions to deal with those.For testing use only. Evaluate a  on a given value.For testing use only. Evaluate a  on a given value.For testing use only. Show the result of a  of a given value as a 5< by interpreting the resulting bytes as Unicode codepoints.For testing use only. Show the result of a  of a given value as a 5< by interpreting the resulting bytes as Unicode codepoints. 1-byte UTF-8 2-byte UTF-8 3-byte UTF-8 4-byte UTF-8Input ResultS(c) 2010 - 2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HM Encode a 5 using .\Decimal encoding of an  using the ASCII digits.e.g. MtoLazyByteString (int8Dec 42) = "42" toLazyByteString (int8Dec (-1)) = "-1"]Decimal encoding of an  using the ASCII digits.^Decimal encoding of an  using the ASCII digits._Decimal encoding of an  using the ASCII digits.`Decimal encoding of an  using the ASCII digits.aCurrently slow. Decimal encoding of an  using the ASCII digits.bDecimal encoding of a  using the ASCII digits.cDecimal encoding of a  using the ASCII digits.dDecimal encoding of a  using the ASCII digits.eDecimal encoding of a  using the ASCII digits.fDecimal encoding of a  using the ASCII digits.gCurrently slow. Decimal encoding of an IEEE .hCurrently slow. Decimal encoding of an IEEE .i#Shortest hexadecimal encoding of a  using lower-case characters.j#Shortest hexadecimal encoding of a  using lower-case characters.k#Shortest hexadecimal encoding of a  using lower-case characters.l#Shortest hexadecimal encoding of a  using lower-case characters.m#Shortest hexadecimal encoding of a  using lower-case characters.n Encode a & using 2 nibbles (hexadecimal digits).o Encode a  using 4 nibbles.p Encode a  using 8 nibbles.q Encode a  using 16 nibbles.r Encode a & using 2 nibbles (hexadecimal digits).s Encode a  using 4 nibbles.t Encode a  using 8 nibbles.u Encode a  using 16 nibbles.vEncode an IEEE  using 8 nibbles.wEncode an IEEE  using 16 nibbles.xEncode each byte of a $ using its fixed-width hex encoding.yEncode each byte of a lazy $ using its fixed-width hex encoding.\]^_`abcdefghijklmnopqrstuvwxy\]^_`abcdefghijklmnopqrstuvwxy\]^_`abcdefghijklmnopqrstuvwxy\]^_`abcdefghijklmnopqrstuvwxyL(c) 2010 Jasper Van der Jeugt (c) 2010 - 2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HMz Execute a O+ and return the generated chunks as a lazy C. The work is performed lazy, i.e., only when a chunk of the lazy  is forced.{ Output a O to a 4. The O+ is executed directly on the buffer of the 4`. If the buffer is too small (or not present), then it is replaced with a large enough buffer.It is recommended that the 4 is set to binary and BlockBuffering mode. See hSetBinaryMode and  hSetBuffering.%This function is more efficient than hPut . zs because in many cases no buffer allocation has to be done. Moreover, the results of several executions of short Os are concatenated in the 49s buffer, therefore avoiding unnecessary buffer flushes.|"Encode a single signed byte as-is.}$Encode a single unsigned byte as-is.~ Encode an  in little endian format. Encode an  in little endian format. Encode an  in little endian format. Encode a  in little endian format. Encode a  in little endian format. Encode a  in little endian format. Encode a  in little endian format. Encode a  in little endian format. Encode an  in big endian format. Encode an  in big endian format. Encode an  in big endian format. Encode a  in big endian format. Encode a  in big endian format. Encode a  in big endian format. Encode a  in big endian format. Encode a  in big endian format.Char7 encode a .Char7 encode a 5.Char8 encode a .Char8 encode a 5.UTF-8 encode a .UTF-8 encode a 5.z{|}~OWXz{|}~Oz{WX|}~z{|}~K(c) 2010 Jasper Van der Jeugt (c) 2010-2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com>GHCNone +;HM Encode a single native machine . The a is encoded in host order, host endian form, for the machine you're on. On a 64 bit machine the  is an 8 byte value, on a 32 bit machine, 4 bytes. Values encoded this way are not portable to different endian or int sized machines, without conversion. Encode a * in native host order and host endianness. Encode a * in native host order and host endianness. Encode a * in native host order and host endianness.Encode a single native machine . The a is encoded in host order, host endian form, for the machine you're on. On a 64 bit machine the  is an 8 byte value, on a 32 bit machine, 4 bytes. Values encoded this way are not portable to different endian or word sized machines, without conversion. Encode a * in native host order and host endianness. Encode a * in native host order and host endianness. Encode a * in native host order and host endianness. Encode a r in native host order. Values encoded this way are not portable to different endian machines, without conversion. Encode a  in native host order. NPQRSTUVYZ[[NZYRSQUVTP (c) 2010-2011 Simon MeierBSD3-style (see LICENSE) Simon Meier <iridcode@gmail.com> experimentalGHCNone +;HM4The size of the sequence of bytes generated by this .BThe bound on the size of the sequence of bytes generated by this .(Base-128, variable length encoding of a .(Base-128, variable length encoding of a .(Base-128, variable length encoding of a .(Base-128, variable length encoding of a .(Base-128, variable length encoding of a .)Base-128, variable length encoding of an . Use  for encoding negative numbers.)Base-128, variable length encoding of an . Use  for encoding negative numbers.)Base-128, variable length encoding of an . Use  for encoding negative numbers.)Base-128, variable length encoding of an . Use  for encoding negative numbers.)Base-128, variable length encoding of an . Use  for encoding negative numbers.1Base-128, variable length, ZigZag encoding of an .1Base-128, variable length, ZigZag encoding of an .1Base-128, variable length, ZigZag encoding of an .1Base-128, variable length, ZigZag encoding of an .1Base-128, variable length, ZigZag encoding of an .Heavy inlining.Heavy inlining.Heavy inlining. Prefix a O9 with the size of the sequence of bytes that it denotes.This function is optimized for streaming use. It tries to prefix the size without copying the output. This is achieved by reserving space for the maximum size to be encoded. This succeeds if the output is smaller than the current free buffer size, which is guaranteed to be at least 8kb.If the output does not fit into the current free buffer size, the method falls back to encoding the data to a separate lazy bytestring, computing the size, and encoding the size before inserting the chunks of the separate lazy bytestring. Prefix a j# with the size of its written data.Run a h) and gather its results and their length.Run a q using the untrimmed strategy.&Note: Works only for positive numbers.#Minimal free-sizeGiven a sizeBound on the maximal encodable size this function must return a fixed-size encoding for encoding all smaller size.6An encoding for terminating a chunk of the given size.Inner Builder to transformj with chunked encoding.Minimal free-sizeGiven a sizeBound on the maximal encodable size this function must return a fixed-size encoding for encoding all smaller size.#Encoding a directly inserted chunk.Inner Put to transformj with chunked encoding.Inner buffer-size.tGiven a bound on the maximal size to encode, this function must return a fixed-size encoding for all smaller sizes.j4 to prefix with the length of its sequence of bytes.Buffer-size for inner driver.(Encoding the size for the fallback case.j4 to prefix with the length of its sequence of bytes.#  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&'(+,/-035789:;<=>@ABCDEFGHIJKLMQRSVWUYX[]^_`bcadefgopq%&'()*+,-/.0123456789;<=?@ABCDEFGKLNOPQRSVXYZ[\]^`abgcdefhijopqrsy|}~&'(+,-/035789;<=@ABCDGEFKLQRSVYX[]^`bcadefgop                                          ! "# $% $& $' ( ) * + , - . / 0 1 234 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R 2 ? S T U V W X Y Z [ \ ] ^_-_._N_*_O`abcdefghijklmnopqrstuvwxyz{|}~EFKL12?WXYZ[\]^puvw|%2$Lbytestring-0.10.0.2Data.ByteStringData.ByteString.UnsafeData.ByteString.Char8Data.ByteString.Lazy#Data.ByteString.Lazy.Builder.ExtrasData.ByteString.Lazy.Char8Data.ByteString.Lazy.Builder"Data.ByteString.Lazy.Builder.ASCIICData.ByteString.Lazy.Builder.BasicEncoding.Internal.UncheckedShifts3Data.ByteString.Lazy.Builder.BasicEncoding.Internal$< contramapF contramapBsize sizeBound>*<pairFpairBemptyFtoBfromFemptyBeitherB Data.EitherEitherLeftRight Data.MaybemaybeifBBEFEpair contramap fixedEncodingrunF storableToFboundedEncodingrunB$fMonoidalBoundedEncoding$fMonoidalFixedEncoding$fContravariantBoundedEncoding$fContravariantFixedEncodingencodeFloatViaWord32FFloatencodeDoubleViaWord64FDoubleGHC.IntInt16Int32Int64IntnullForeignPtrfromForeignPtr toForeignPtr unsafeCreate createAndTrimcreatecreate'mallocByteStringeqw2cWord8Charc2w isSpaceWord8 isSpaceChar8inlinePerformIOPSc_count c_minimum c_maximum c_intersperse c_reversec_memsetc_memcpyc_memcmpc_memchrc_free_finalizerc_strlen packBytes packCharsunsafePackLenBytesunsafePackLenCharspackUptoLenBytespackUptoLenChars unpackBytes unpackCharsunpackAppendBytesLazyunpackAppendCharsLazyunpackAppendBytesStrictunpackAppendCharsStrictcreateAndTrim' compareBytesmemchrmemcmpmemcpymemset$fDataByteString$fIsStringByteString$fReadByteString$fShowByteString$fNFDataByteString$fMonoidByteString$fOrdByteString$fEqByteStringGHC.ListGHC.PrimAddr#NothingJust GHC.ClassesnotspanByteintercalateWithByteTruezipWith'GHC.IO.Handle.TypesHandleGHC.BaseStringGHC.IO.Handle.TexthGetBuffindIndexOrEndwithPtr unpackFoldrmkPSmkBigPSillegalBufferSizeerrorEmptyList moduleError moduleErrorIOmoduleErrorMsgfindFromEndUntil breakChar breakSpace dropSpace firstspace firstnonspace invariantEmptycheckInvariantchunkChunk chunkOverheadcmp hGetContentsNhGetNhGetNonBlockingNrevNonEmptyChunks revChunks ChunkIOStreamIOPut putBuilderfromPut Data.MonoidMonoidmemptymappend BuildSignal BuildStepdone bufferFull insertChunks BufferRangefillWithBuildStepbuilder runBuilderrunBuilderWithputrunPut ensureFree bytesCopyStepmaximalCopySizelazyByteStringCLazyByteStringCsanitizeYieldCYield1FinishedunPut InsertChunks BufferFullDonebyteStringCopyStepciosToLazyByteStringbuildStepToCIOS $fMonadPut$fApplicativePut $fFunctorPut$fMonoidBuilder EncodingTable lowerTable encode4_as_8encode8_as_16h tableFromListbase16EncodingTable lowerAlphabetInt8c_long_long_uint_hex c_uint_hexc_long_long_uint_dec c_uint_decc_long_long_int_dec c_int_decencodeIntDecimalencodeWordDecimal encodeWordHex encodeWithFencodeListWithFencodeUnfoldrWithF Data.ListencodeByteStringWithFencodeLazyByteStringWithF encodeWithBencodeListWithBencodeUnfoldrWithBencodeByteStringWithBencodeLazyByteStringWithBencodeCharUtf8evalFevalBshowFshowB integer-gmpGHC.Integer.TypeIntegerword8Var word16Var word32Var word64VarwordVarint8Var int8VarSignedint16Varint16VarSignedint32Varint32VarSignedint64Varint64VarSignedintVar intVarSigned encodeChunked putChunkedencodeWithSize putWithSizerunCIOSWithLengthbuildStepToCIOSUntrimmedWithgenDecFixedBound encodeBase128zigZag appsUntilZerogenericVarFixedBoundwordVarFixedBoundword64VarFixedBoundgenHexFixedBoundwordHexFixedBoundword64HexFixedBoundwordDecFixedBoundword64DecFixedBound