h$       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU 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 2 3 4 5 5 6 7 8;(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comportableSafesdpA 5 is used as an exception that should never be thrown. Example:  newArray# requires a default value to fill the newly created array. If the array is guaranteed to be filled with values (for example, in the  replicate function), then this value will never be needed and, therefore, calculated.  in this case will be a marker of unreachability of this expression.sdp replaces the less informative   and has more neutral names. - occurs when performing the (safe) rebound operation with unacceptable target range (example: an attempt to convert structure with bounds (2, 5) to structure with bounds ('\0', '\255')> is invalid because available size is smaller than required)  - occurs when trying to convert one representation of an index to another, if their dimensions doesn't match (example: trying to convert a list  [1, 2, 3] of type [Int] to an index of type (T4 Int)) - occurs when referring to a non-existent or undefined element; some unsafe structures and operations can lead to the possibility of untracked reading of invalid or undefined values ; - occurs when accessing the contents of an empty structure  - occurs when going beyond the upper boundary of the structure (overflow)  - occurs when going beyond the lower boundary of the structure (underflow)If the error type may depend on the check order, it should be indicated in the documentation. For example: overflow is checked first, and then underflow. But if an overflow is detected, underflow may not be noticed. . constructor order is the recommended order.   (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe"&sdp is just synonym of (e -> e -> Ordering).sdp is just synonym of (e -> e -> Bool).sdp.Spaceship operator - infix version of compare.sdp!Compare tuples by first elements.sdp"Compare tuples by second elements.sdp!Compare tuples by first elements.sdp"Compare tuples by second elements.sdpCommon compare combinator 4(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-(sdp quantified contraint for (Type -> Type -> Type) -kind types.sdp quantified contraint for (Type -> Type) -kind types.sdp(Type -> Type -> Type) kind .sdp(Type -> Type) kind .sdp9 class provides the lazy comparsion structures by length.For some types (e.g., lists), this allows you to speed up the comparison or make it finite. For others (e.g., arrays), it may be convenient abbreviation. sdp+Compare structure length with given number.!sdp%Compare pair of structures by length."sdp+Compare structure length with given number.#sdp+Compare structure length with given number.$sdp+Compare structure length with given number.%sdp+Compare structure length with given number.&sdp+Compare structure length with given number.'sdp+Compare structure length with given number.(sdp%Compare pair of structures by length.)sdp%Compare pair of structures by length.*sdp%Compare pair of structures by length.+sdp%Compare pair of structures by length.,sdp%Compare pair of structures by length.-sdp%Compare pair of structures by length..sdp+Compare given number with structure length./sdp+Compare given number with structure length.0sdp+Compare given number with structure length.1sdp+Compare given number with structure length.2sdp+Compare given number with structure length.3sdp+Compare given number with structure length.4sdp+Compare given number with structure length. !()*+,- &'$%"#./01234!()*+,- &'$%"#.3412/0 4!4"4#4$4%4&4'4(4)4*4+4,4-4.4/40414243444(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy &-9. 6sdp: contraint for (Type -> Type -> Type) -kind types.7sdp: contraint for (Type -> Type) -kind types.8sdp: contraint for (Type -> Type -> Type) -kind types.9sdp: contraint for (Type -> Type) -kind types.:sdp:+ is class of types which have empty values.*Nullable instances must follow some rules:  isNull Z === True x == Z ==> isNull x == True x == y === isNull x == isNull y -- For   instances toList Z === [] fold Z === mempty isNull x === null x isNull x === length x == 0 sum Z === 0 product Z === 1 elem x Z === False foldr f Z === foldl f Z === id foldr1 f Z === foldl1 f Z === undefined ;sdp Empty value.<sdpIs value empty?=sdpOther empty value pattern:  Z === NULL. Defined in  SDP.Nullable since  sdp-0.2.1, earlier - in  SDP.Linear.>sdpOriginally defined in  sdp-ctypes (now  sdp-foreign ), same as Z now.?sdp 6789:;<=> :;<9876>=(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe&/~EsdpCrutch pattern: real (E ) is closed   constructor. EEE7(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comportableSafe2FsdpTernary operator. -(odd 1 ? "is True" $ "is False") == "is True"Gsdp p ?+ f $ a returns   (f a) if (p a) and   otherwise.Hsdp p ?- f $ a returns   if (p a) and   (f a) otherwise.Isdp Prepends   to list.JsdpShort version of 9:.Ksdp(...) = (.) . (.).LsdpLifted (F).MsdpMonadic version of (K).NsdpMonadic vesion of (K) with reversed arguments.Osdp ma >>=<< mb is composition of   and  .PsdpVery useful combinator.QsdpVery very useful combinatorRsdpAn even more useful combinator.SsdpSee R.TsdpT is just   .  . #"%$'& -,+*)!(./01234FGHIJKLMNOPQRSTFGHIJKLMNOPQRSTF1G8H8K0L1 (c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy>; Usdp15-dimensional indexVsdp14-dimensional indexWsdp13-dimensional indexXsdp12-dimensional indexYsdp11-dimensional indexZsdp10-dimensional index[sdp9-dimensional index\sdp8-dimensional index]sdp7-dimensional index^sdp6-dimensional index_sdp5-dimensional index`sdp4-dimensional indexasdp3-dimensional indexbsdp2-dimensional indexcsdp1-dimensional index ((E :& i) without  TypeOperators).dsdpN-dimensional index type. The type (head :& tail) allows working with any finite dimension number.fsdp5Service type, that represents zero-dimensional index.hsdp 2-dimensional index constructor.isdp 3-dimensional index constructor.jsdp 4-dimensional index constructor.ksdp 5-dimensional index constructor.lsdp 6-dimensional index constructor.msdp 7-dimensional index constructor.nsdp 8-dimensional index constructor.osdp 9-dimensional index constructor.psdp!10-dimensional index constructor.qsdp!11-dimensional index constructor.rsdp!12-dimensional index constructor.ssdp!13-dimensional index constructor.tsdp!14-dimensional index constructor.usdp!15-dimensional index constructor.vsdp!UVWXYZ[\]^_`abcdefghijklmnopqrstu!fgdecba`_^]\[ZYXWVUhijklmnopqrstu (c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-?Z sdp quantified contraint for (Type -> Type -> Type) -kind types.sdp quantified contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp) is class of sortable mutable structures.sdpKsdp9The restriction corresponding to rank indices 15 (hecks ).sdp9The restriction corresponding to rank indices 14 (hecks ).sdp9The restriction corresponding to rank indices 13 (hecks ).sdp9The restriction corresponding to rank indices 12 (hecks ).sdp9The restriction corresponding to rank indices 11 (hecks ).sdp9The restriction corresponding to rank indices 10 (hecks ).sdp8The restriction corresponding to rank indices 9 (hecks ).sdp8The restriction corresponding to rank indices 8 (hecks ).sdp8The restriction corresponding to rank indices 7 (hecks ).sdp8The restriction corresponding to rank indices 6 (hecks ).sdp8The restriction corresponding to rank indices 5 (hecks ).sdp8The restriction corresponding to rank indices 4 (hecks ).sdp8The restriction corresponding to rank indices 3 (hecks ).sdp8The restriction corresponding to rank indices 2 (hecks ).sdp8The restriction corresponding to rank indices 1 (hecks ).sdp.A constraint corresponding to rank 0 indices (f).sdp# is service class that constraints  ;.Rules: rank i == rank (j `asTypeOf` i) rank i == length (sizes (i, i)) rank (lastDim E) = 0 rank (lastDim i) = 1 rank (initDim E) = 0 rank (lastDim i) = rank i - 1 5fromGIndex . toGIndex = id toGIndex . fromGIndex = idsdpType of index top dimension.sdpThe type of subspace of  n - 1, where n is the & of the space specified by this  ; type.sdp$Create index from generalized index.sdp$Create generalized index from index.sdpCount of dimensions in represented space (must be finite and constant).sdpAdd new dimension.sdpType operator ) returns generalized equivalent of index.sdp:Convert any index type bounds to generalized index bounds.sdp:Convert generalized index bounds to any index type bounds.sdpsince  base-4.10.0.0 UVWXYZ[\]^_`abcdefghijklmnopqrstu (c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy-9>?XC"sdp Index is service class based on base Ix and repa Shape. Basic rules: 0size bnds >= 0 size bnds == product (sizes bnds) isEmpty bnds == (size bnds == 0) isEmpty bnds == inRange bnds (safeElem bnds i) isEmpty bnds => isOverflow bnds i isEmpty bnds => isUnderflow bnds i inRange bnds i /= isEmpty bnds inRange bnds i /= isOverflow bnds i inRange bnds i /= isUnderflow bnds i inRange bnds i == (safeElem bnds i == i)Note:f6 is (and should remain) the one and only one index of rank 0. is a generalization of   , so all rank 1 indices must satisfy   laws.The cardinality of the set of permissible values for indices mustn't exceed 1 (cardinality of a series of natural numbers), so   types cannot be indices.sdpReturns the size of range.sdp)Returns the sizes of range dimensionwise.sdp/Returns the index belonging to the given range.sdpReturns bounds of nonempty range (swaps bounds in each empty subshape).sdpReturns size of biggest range, that may be represented by this type.sdpReturns default range by size.sdp)Returns index by offset in default range.sdpChecks if the bounds is empty.sdp"Checks the index status in bounds.sdp Checks if the index is overflow.sdp!Checks if the index is underflow.sdpChecks if the index is in .sdpReturns previous index in .sdpReturns next index in range.sdpReturns  (indent) of  in .sdpReturns  by this  (indent) in .sdp2Returns the ordered list of indices in this range.sdpsubshape bnds ij returns subshape of bnds. Checks if ij in bnds subshape, may   .sdp=Drop some dimensions (second argument used as type variable).*dropDim ([1, 2, 3, 4] :: I4 Int) ([] :: E) [1, 2, 3, 4]3dropDim ([1, 2, 3, 4] :: I4 Int) ([1, 2] :: I2 Int)[3, 4]sdpJoin some dimensions.(joinDim ([1, 2] :: I2 Int) [3] :: I3 Int [1, 2, 3]+joinDim ([1, 2] :: I2 Int) [3, 4] :: I4 Int [1, 2, 3, 4]sdpTake some dimensions.*takeDim ([1, 2, 3, 4] :: I4 Int) :: I1 Int[1]%takeDim ([1, 2, 3, 4] :: I4 Int) :: EEsdp is service constraint that corresponds closed (internal) class Sub.  i j  matches if  type i is subspace of  type j.sdp(), is closed type family of shape differences.sdp?InBounds - service type that specifies index and bounds status.sdp Empty rangesdpUnderflow rangesdpIndex in rangesdpOverflow rangesdp/ returns pair of shape difference and subshape.sdpDefault  for   types.sdpDefault  for unsigned types.sdp@since base-4.10.0.0sdp Note that   isn't  4, so it can't be used in multidimensional indices. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu!(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy >?i-sdp  wrapper.sdp is a layer between untyped raw data and parameterized unboxed data structures. Also it prevents direct interaction with primitives.sdp sizeof e n3 returns the length (in bytes) of primitive, where n - count of elements, e - type parameter.sdp is unboxed .sdpUnsafe  $ reader with overloaded result type.sdpUnsafe  $ reader with overloaded result type.sdpUnsafe   writer.sdpProcedure for filling the array with the default value (like calloc).sdp creates new   of given count of elements. First argument used as type variable.sdp is version of , that use first argument as initial value. May fail when trying to write   or  .sdp e bytes# o1# mbytes# o2# n#% unsafely writes elements from bytes# to mbytes#5, where o1# and o2# - offsets (element count), n# - count of elements to copy.sdp e msrc# o1# mbytes# o2# n#% unsafely writes elements from msrc# to mbytes#5, where o1# and o2# - offsets (element count), n# - count of elements to copy.sdp e len off bytes# salt returns bytes# FNV-1 hash, where off# and len#$ is offset and length (in elements).Note: the standard definition of this function is written in Haskell using low-level functions, but this implementation mayn't be as efficient as the foreign procedure in the hashable package.sdp cloneUnboxed e bytes o c creates new c#%-element length immutable slice of bytes# beginning from o# -th element.sdp cloneUnboxedM e mbytes o c creates new c##-element length mutable slice of bytes# beginning from o# -th element.sdp e bytes c creates new sizeof e c bytes length   and copy bytes# to it.sdp e mbytes c creates new sizeof e c bytes length   and copy mbytes# to it.sdpReturns   of suitable type.sdp is proxy version of .sdp is proxy version of .sdpKind (Type -> Type) proxy version of .sdpKind (Type -> Type) proxy version if .sdpKind (Type -> Type) proxy version if .sdpKind (Type -> Type) proxy version of .sdpSame as sdp-0.2 . Use only if you don't need sdp-0.2 compatibility.sdpKind (Type -> Type) proxy version of .sdpKind (Type -> Type) proxy version of .sdpKind (Type -> Type) proxy version of .sdpReturns   of suitable type.sdpKind (Type -> Type -> Type) proxy version of .sdpKind (Type -> Type -> Type) proxy version of .sdpKind (Type -> Type -> Type) proxy version of .sdpKind (Type -> Type -> Type) proxy version of .sdpKind (Type -> Type -> Type) proxy version of .sdpWrapped empty  .sdp  singleton.sdpCreate immutable  array from given list.sdpCreate immutable  array from   stream.sdpCreate immutable  array from known size list.sdpCreate mutable  array from given list.sdpCreate mutable  array from known size list.sdpCreate mutable  array from   stream.sdpConcatenation of two  arrays.sdp4Proxy concatenation of two byte arrays representing  structures.sdp@since base-4.10.0.0..(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthyk>sdpInt value as 8 bytes.sdpInt value as 4 bytes.sdpInt value as 2 bytes.sdpInt value as 1 byte.(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthyl`sdpWord value as 8 bytes.sdpWord value as 4 bytes.sdpWord value as 2 bytes.sdpWord value as 1 byte.(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comportableSafemfsdpZip is generalization of ZipList applicative semantics (but without  ).sdp ZipList-like ( ).(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comportableSafe ->qE sdp quantified contraint for (Type -> Type -> Type) -kind types.sdp quantified contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp& is class of types that can be sorted.sdpsdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdpKind (Type -> Type)  structure.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp,Split - class of splittable data structures.sdp take n es takes first n elements of es.sdp drop n es drops first n elements of es.sdp keep n es takes last n elements of es.sdp sans n es drops last n elements of es.sdp save n es takes first n elements of es if n > 0 and last -n elements otherwise.sdp skip n es drops first n elements of es if n > 0 and last -n elements otherwise.sdp split n es is same to (take n es, drop n es).sdp divide n es is same to (sans n es, keep n es).sdp:Splits line into sequences of given sizes (left to right). splits [5, 3, 12] ['a'..'z'] = ["abcde","fgh","ijklmnopqrst","uvwxyz"]sdp:Splits line into sequences of given sizes (right to left). divides [5,3,12] ['a'..'z'] == ["abcdef","ghijk","lmn","opqrstuvwxyz"]sdp.Splits structures into parts by given offsets. parts [0,5,6,12,26] ['a'..'z'] = ["","abcde","f","ghijkl","mnopqrstuvwxyz",""] -- if previous offset is equal or greater, subline is empty and next begins from previous: parts [0, 5, 4, 12, 26] ['a' .. 'z'] = ["","abcde","","fghijklm","nopqrstuvwxyz",""]sdp&Splits structures into chunks of size n and the rest. :chunks x [] = [] -- forall x chunks 0 es = [] -- forall es 4chunks 3 [1 .. 10] == [[1,2,3],[4,5,6],[7,8,9],[10]]sdpSplit line by first (left) separation element. If there is no such element, splitBy es = (es, Z). splitBy (== '.') "foo" == ("foo","") splitBy (== '.') "foo." == ("foo","") splitBy (== '.') ".foo" == ("","foo") splitBy (== '.') "foo.bar" == ("foo","bar") splitBy (== '.') "foo.bar.baz" == ("foo","bar.baz")sdpSplit line by last (right) separation element. If there is no such element, divide es = (Z, es). divideBy (== '.') "foo" == ("","foo") divideBy (== '.') ".foo" == ("","foo") divideBy (== '.') "foo." == ("foo","") divideBy (== '.') "foo.bar" == ("foo","bar") divideBy (== '.') "foo.bar.baz" == ("foo.bar","baz")sdp#Splits line by separation elements.sdpsplitsOn sub line splits line by sub.  in  context.sdp is just strict <= in  context.sdp is just <? in  context.sdp"Class of bordered data structures.sdpReturns the exact  and  bounds of given structure. If the structure doesn't have explicitly defined boundaries (list, for example), use the  . .sdp Returns lower bound of structuresdp Returns upper bound of structuresdp!Returns actual size of structure.sdp"Returns actual sizes of structure.sdpChecks if an index falls within the boundaries of the structure.sdpReturns index range list.sdp%Returns index by offset in structure.sdp)Returns index offset in structure bounds.sdpPattern ()% is right-size view of line. Same as  and .sdpPattern ()$ is left-size view of line. Same as  and .sdpstripPrefix sub line strips prefix sub of line (if any).sdpstripSuffix sub line strips suffix sub of line (if any).sdpstripPrefix' sub line strips prefix sub of line or returns  .sdpstripSuffix sub line strips suffix sub of line or returns  .sdp,intercalate is generalization of intercalatesdptails es returns sequence of es tails.sdp!tails is generalization of inits.sdpascending es lengths checks if the subsequences of es of lengths lengths is sorted. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu59 8855(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)SafesdpService class for structures with arbitrary bounds. Allows you to extract subsequences corresponding to index subranges.sdp with .sdp(Set new bounds of same type, may shrink.sdpSet new bounds, may shrink.sdpes !! ij returns subshape ij of es.sdpReturns list of es subshapes.sdpUnslice subshapes.(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC Extensions) Trustworthy-9>G2sdp quantified contraint for (Type -> Type -> Type) -kind types.sdp quantified contraint for (Type -> Type -> Type) -kind types.sdp quantified contraint for (Type -> Type) -kind types.sdp quantified contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp= is a class of data structures, that can represent any sets.  is intended for more specific sets than ordered linear structures. In particular, it may not work with an arbitrary comparator, and also (unlike the early implementation) does not impose restrictions on the element type. , as well as -, doesn't provide data protection/validation.sdp The same as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as  compare'.sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdpSame as   .sdp8 is a class of data structures, that can represent sets. doesn't provide data protection/validation before each first action. All functions (except ,) works correctly only with correct sets.  guarantee only that the returned data is correct. So if you need maximum reliability and security, use  containers. But if you want simplicity, openness and a lot of non-set functions without extra conversions, then you are at the right place.Note that function of type  Compare o must follow basic order laws (comparability, transitivity, reflexivity and antisymmetry). With wrong comparator, the result may become implementation-dependent.sdp*Creates ordered set from linear structure.sdpCreates set from linear structure using additional function for choice/merge equal elements.sdpAdding element to set.sdpDeleting element from set.sdpIntersection of two sets.sdp8Difference (relative complement, aka A / B) of two sets.sdp!Symmetric difference of two sets.sdpUnion of two sets.sdpFold by .sdpFold by .sdpFold by .sdpFold by .sdpCompares sets on intersection.sdpCompares sets on disjoint.sdpSame as  (, but can work faster. By default, uses  .sdp1hecks whether a first set is a subset of second.sdpGenerates a list of different subsets (including empty and equivalent).sdp& trying to find lesser element in set.sdp' trying to find greater element in set.sdp0 trying to find greater or equal element in set.sdp/ trying to find lesser or equal element in set.22(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.com,non-portable (requires non-portable modules)Safe>sdpScan is class of scans.(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe -9>$sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp1 is a class of dictionaries (associative arrays). provides a set of operations on associative arrays that aren't specific to + data structures and aren't limited by the ' context (doesn't restrict key type).sdpReturns list of associations (index, element).sdpA less specific version of "SDP.Indexed.Indexed.assoc" that creates a new associative array. For 9 structures without gaps, it may be less effective.  Z // ascs = toMap -- forall ascssdpStrict version of  with default value.Note that the default value is set only for elements included in the range of the created structure and will not be set for values outside its range (when expanding, concatenating, etc.) for most structures since they don't store it.sdp key e map inserts e with key to map. If map( already contains an element with key", the element will be overwritten.If map doesn't allow gaps, then the missing elements should be filled with default values.sdp removes element with given key.If the structure has boundaries, when removed from the beginning (end), they should change accordingly. If the structure doesn't allow gaps, then when removed from the middle, the actual value should be replaced with the default value.sdp key map checks if key in map.sdp4Update elements of immutable structure (by copying).sdp()! is unsafe reader, can be faster () by skipping checks.sdp() is well-safe reader, may   .sdp(). is completely safe, but very boring function.sdpFilter with key.sdp is  for maps but works with real groups of elements, not with consequentive equal elements.7 merges/chooses elements with equal keys from two maps.sdp f mx my applies comb% to values with equal keys. If f x y (where  (k1, x) <- mx,  (k2, y) <- my, k1 == k2 ) is  ', element isn't included to result map. Note that 2 is poorer than a similar functions in containers.sdp f mx my combines elements of  by f : if isJust (f x y) (where &(k1, x) <- mx, (k2, y) <- my, k1 == k2-), then element is added to result map.sdp"Update function, by default uses ().sdplookupLT' k map finds pair  (key, value) with smallest key, where key < k (if any). k may not be a map element.sdplookupGT' k map finds pair  (key, value) with greatest key, where key > k (if any). k may not be a map element.sdplookupLE' k map finds pair  (key, value) with smallest key, where key <= k (if any). If k is a map element, returns (k, e).sdplookupGE' k map finds pair  (key, value) with key, where key >= k (if any).sdpReturns list of map keys.sdp+Searches the key of first matching element.sdp+Searches the keys of all matching elements.sdp is   with key.sdp is   with key.sdp is strict version of .sdp is strict version of .9 9 9 (c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe&'(-9>zsdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdpKind (Type -> Type)  structure.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp is  version for mutable data structures. This class is designed with the possibility of in-place implementation, so many operations from  have no analogues here.sdp takeM n es returns a reference to the es, keeping first n elements. Changes in the source and result must be synchronous.sdp dropM n es returns a reference to the es, discarding first n elements. Changes in the source and result must be synchronous.sdp keepM n es returns a reference to the es, keeping last n elements. Changes in the source and result must be synchronous.sdp sansM n es returns a reference to the es, discarding last n elements. Changes in the source and result must be synchronous.sdp splitM n es# returns pair of references to the es%: keeping and discarding first n elements. Changes in the source and result must be synchronous.sdp divideM n es# returns pair of references to the es$: discarding and keeping last n elements. Changes in the source and results must be synchronous.sdp splitM ns es returns the sequence of es# prefix references of length n <- ns8. Changes in the source and results must be synchronous.sdpdividesM ns es returns the sequence of es# suffix references of length n <- ns8. Changes in the source and results must be synchronous.sdp partsM n es returns the sequence of es1 prefix references, splitted by offsets in es8. Changes in the source and results must be synchronous.sdp chunksM n es returns the sequence of es# prefix references of length n8. Changes in the source and results must be synchronous.sdp eachM n es returns new sequence of es elements with step n-. eachM shouldn't return references to es.sdp prefixM p es returns the longest es prefix size, satisfying p.sdp suffixM p es returns the longest es suffix size, satisfying p.sdp mprefix p es returns the longest es prefix size, satisfying p.sdp msuffix p es returns the longest es suffix size, satisfying p.sdp is  version for mutable data structures. This class is designed with the possibility of in-place implementation, so many operations from  have no analogues here.sdpMonadic .sdpMonadic <.sdpMonadic .sdp is monadic version of . This procedure mustn't modify the source structure or return references to its mutable fields.sdp is monadic version of . This procedure mustn't modify the source structure or return references to its mutable fields.sdp) is unsafe monadic offset-based reader.sdp#Unsafe monadic offset-based writer.sdp Create copy.sdpcopied' es l n returns the slice of es from l of length n.sdpMonadic , returns new structure.sdpMonadic in-place &, reverse elements of given structure.sdpMonadic .sdpMonadic version of .sdp n es removes element with offset n from es.sdp es i j5 cyclically shifts the elements with offsets between i and j (i < j) one position to the left (the j-th element is in the i-th position, the i -th in the (i+1) th, etc.) If i >= j, does nothing.sdp$copyTo source soff target toff count writes count elements of source from soff to target starting with toff.sdp# is right monadic fold with offset.sdp" is left monadic fold with offset.sdp is strict version of .sdp is strict version of .sdp is just  in  context.sdp is just  in  context.sdp is strict version of .sdp is strict version of .sdp is  version with  element as base.sdp is  version with  element as base.sdpJust swap two elements.sdp is % version for mutable data structures.sdp returns  of mutable data structure.sdp returns ! bound of mutable data structure.sdp returns ! bound of mutable data structure.sdp returns  of mutable data structure.sdp returns  of mutable data structure.sdp is  version for mutable structures.sdp is  version for mutable structures.sdp is  version for mutable structures.sdp returns  of mutable data structure.sdp() is fmr'-compatible delete element pattern for  fields, see .sdp() is fmr -compatible  element pattern for  fields.sdp() is fmr -compatible  element pattern for  fields. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu5(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportableSafe -9>}sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp( is class of mutable associative arrays.sdp$Create new mutable map from list of (key, element) associations.sdp$Create new mutable map from list of (key, element) associations.sdp is version of @ for mutable maps.sdp() is unsafe monadic reader.sdp() is well-safe monadic reader.sdp()# is completely safe monadic reader.sdp(Update elements by mapping with indices.sdpThis function designed to overwrite large enough fragments of the structure (unlike  and A)!In addition to write operations,  can move and clean, optimize data presentation, etc. of a particular structure. Since the reference to the original structure may not be the same as reference to the result (which implementation is undesirable, but acceptable), the original reference (argument) shouldn't be used after . All standard sdp" structures support safe in-place .If the structure uses unmanaged memory, then all unused fragments in the resulting structure must be deallocated, regardless of reachability by original reference (argument).Please note that  overwrite require a list of associations with indices in the current structure bounds and ignore any other, therefore: fromAssocs bnds ascs /= (fromAssocs bnds ascs >>= flip overwrite ascs)sdpChecks if key in map.sdpReturns list of map keys.sdp (.?) is monadic version of (.$).sdp (*?) is monadic version of (*$).sdp is right monadic fold with key.sdp is left monadic fold with key.sdp is strict version of .sdp is strict version of .555(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe -9>sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp2Service class of mutable to immutable conversions.sdpfreeze is a safe way to convert a mutable structure to a immutable. freeze should copy the old structure or ensure that it will not be used after calling the procedure.sdp unsafeFreeze is unsafe version of .  unsafeFreeze doesn't guarantee that the structure will be copied or locked. It only guarantees that if the old structure isn't used, no error will occur.sdp; is class of ordered associative arrays with static bounds.sdpassoc bnds ascs create new structure from list of associations, without default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).sdpassoc' bnds def ascs creates new structure from list of associations with default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).sdp0 converts this indexed structure to another one.sdp"Safe index-based immutable writer.sdp!Update element by given function.sdp4Create new structure from old by mapping with index.sdp f es ies create a new structure from es0 elements selectively updated by function f and ies associations list.sdp7 creates new indexed structure from old with reshaping.sdp=binaryContain checks that sorted structure has equal element. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe -9Jsdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp contraint for (Type -> Type -> Type) -kind types.sdp contraint for (Type -> Type) -kind types.sdp2Service class of immutable to mutable conversions.sdpthaw< is safe way to convert a immutable structure to a mutable. thaw should copy the old structure or ensure that it will not be used after the procedure calling.sdp unsafeThaw is unsafe version of .  unsafeThaw doesn't guarantee that the structure will be copied or locked. It only guarantees that if the old structure isn't used, no error will occur.sdp/Class for work with mutable indexed structures.sdpfromAssocs bnds ascs creates new structure from list of associations, without default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).sdpfromAssocs' bnds defvalue ascs creates new structure from list of associations, with default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).sdp map key e writes element e to key position safely (if key is out of map range, do nothing). The  function is intended to overwrite only existing values, so its behavior is identical for structures with both static and dynamic boundaries.sdpJust swap two elements.sdp+fromIndexed' is overloaded version of thaw.sdp4fromIndexed converts one mutable structure to other.sdpreshaped creates new indexed structure from old with reshaping function.sdp f es ies create a new structure from es0 elements selectively updated by function f and ies associations list.sdp!Update element by given function. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comportableSafe sdp is just synonym for   .sdp is a version of  that uses a cast function to   elements.sdp/ is naive service sorting procedure, that have O(n^2) complexity in all cases.sdp unsafeInsertionSort cmp es b s e( is internal sorting procedure, where cmp - compare function, es - data structure, [b .. s] - sorted range, [b .. e] - sortable range.(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.com,non-portable (requires non-portable modules)Safe sdp is just synonym for   .sdp is a version of 7 that uses a conversion function to compare elements.sdp is a sorting procedure for mutable random access data structures using any comparison function and having O(nlogn) complexity in the worst case.sdp returns TimSort chunk size by given length.(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy >+sdp is mutable pseudo-primitive  -indexed strict unboxed array.sdp is mutable pseudo-primitive  -indexed strict unboxed array.sdp is mutable pseudo-primitive  #-indexed strict unboxed array type.sdp is immutable pseudo-primitive  %-indexed strict unboxed array type.$ isn't real Haskell primitive (like GHC.Exts types) but for reliability and stability, I made it inaccessible to direct work.sdp returns   field of .sdp returns  offset in elements.sdp creates new  from sized  .sdp returns new  .sdp is unsafe low-lowel coerce of an array with recounting the number of elements and offset (with possible rounding).sdp returns   field of .sdp returns  offset in bytes.sdp creates new  from sized  .sdp returns new  .sdp is unsafe low-lowel coerce of an mutable array with recounting the number of elements and offset (with possible rounding).sdp es byte-wise stores  content to  . Returns the number of overwritten elements and a pointer to psizeof es (sizeOf es) bytes of allocated memory.sdp n ptr byte-wise stores n elements of   ptr to .sdpCalculate hash  using . 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu(c) Andrey Mulik 2019-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy >)sdp is mutable preudo-primitive  -indexed lazy boxed array.sdp is mutable preudo-primitive  -indexed lazy boxed array.sdp is mutable preudo-primitive  -indexed lazy boxed array type.sdp is immutable pseudo-primitive  -indexed lazy boxed array type.$ isn't real Haskell primitive (like GHC.Exts types) but for reliability and stability, I made it inaccessible to direct work.sdp returns   field of .sdp returns  offset in elements.sdp creates new  from sized  .sdp returns new   (uses  ).sdp is   alias.sdp returns   field of  or fails.sdp returns  offset in elements.sdp creates new  from sized  .sdp returns new  .sdp is   alias. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.com non-portable Trustworthy>!sdp of stm s. (c) Andrey Mulik 2021 BSD-stylework.a.mulik@gmail.comportableSafe$sdp is monadic version of .sdpMonadic .sdpMonadic .sdpMonadic .sdpMonadic .sdpMonadic .sdpPure to monadic lifted .sdpPure to monadic lifted .sdpPure to monadic lifted .sdpPure to monadic lifted .sdpPure to monadic lifted .sdpMonadic .sdpMonadic .sdpMonadic .sdpMonadic .sdpMonadic .&(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe,sdp ident is common parser of  structure with name ident: read "ident (0,1) [(0,0),(1,1)]" == read "(0,1) [(0,0),(1,1)]" == assoc (0,1) [(0,0),(1,1)]sdp ident is common parser of  structure with name ident: read "Z" == read "[]" == [] read "['l','g','p','l']" == fromList "lgpl" read "4 [1,5,-1,45,12,6,0,0,12]" == fromListN 4 [1,5,-1,45,12,6,0,0,12]sdp is common  and  parser (recommended).sdp is just = parser, see .sdp is -based parser, see .sdp is -based parser, see .sdp is sdp recommended format   parser for .sdpCommon   parser.sdp  parser: take 5 (readBy enumFromPrec "[1 ..]") == take 5 [1 ..] = [1,2,3,4,5]sdp  parser: >readBy enumFromToPrec "[9 .. 12]" == [9 .. 12] == [9,10,11,12]sdp  parser: take 4 (readBy enumFromThenPrec "[17, -6 .. ]") == take 4 [17, -6 ..] == [17,-6,-29,-52]sdp  parser: take 4 (readBy enumFromThenToPrec "[17, -6 .. 4]") == [17, -6 .. 4] == [17]sdp Just lifted .sdpallPrec is just   sdpallPrecWith is  -based combinator, which reads a sequence of elements without any separators: readBy allPrecWith readPrec "1 2 3 4 5 6 7" :: [Int] == [1 .. 7]sdp readprec name is   with optional name prefix.sdp  with implicit default value.sdp with implicit default value.sdp is generalized  .sdp is generalized  . sdp  is generalized  .    !(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe. sdp  is   template. sdp 2 is a primitive list-to-string conversion pattern.Note that attempting to parse the resulting string with standard ReadS-based functions will cause an error (ambiguous parse). To properly parse a string, use the readRawSequence function from the  SDP.Text.Read module. sdpJust   version for .  "(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy 38>?3 sdp  is list of data chunks. AnyChunks shouldn't contain empty chunks, so the  " constructor is made private (see   and  ).Efficiency of operations on   rep e+ are very sensitive in the efficiency of ,  and  on rep e.  rep e! is only defined for Int-indexed rep e. ,  ,   and   instances compare   rep e? as streams of equal size chunks. To do this, the comparison rep e( must also be lexicographic, also for rep e must implement  and . and  for   rep e are defined for all rep e that already have  and  instances. sdpConstruct immutable   safely. sdpConstruct mutable   safely. sdpExtract immutable   chunks safely. sdp&Creates new immutable structure using . sdp>Creates one-chunk immutable stream, may be memory inefficient. sdpUVWXYZ[\]^_`abcdefghijklmnopqrstu  #(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe>8{ sdp ) is unrolled linked list of boxed values. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  $(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe<" sdp  is mutable version of #B. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  %(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe@ sdp  is mutable version of #B. sdp  is mutable version of #B. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  &(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe>E sdp + is unrolled linked list of unboxed values. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  '(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeI sdpThis   is mutable version of &C. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  ((c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC Extensions)SafeN sdp  is mutable version of &C. sdp  is mutable version of &C. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  )(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportableSafeS sdp Lazy boxed unrolled linked list.  D(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportable Safe-InferredT; *(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy 38>?U sdp = is template, that appends arbitrary bounds to any structure. ,  ,   and   instances ingores bounds. and  instances for   rep e inherit rep e behavior. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  +(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeZT sdp  is mutable version -E. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  ,(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe_ sdp  is mutable version of -E. sdp  is mutable version of -E. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  -(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafec sdp " is bordered unrolled linked list. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  .(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safegp sdp  is mutable version of 0F. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  /(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafel6 sdp  is mutable version of 0F. sdp  is mutable version of 0F. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  0(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeq sdp  - unboxed array. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  1(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeu sdp  is mutable version of 3G. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  2(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafez< sdp  is mutable version of 3G. sdp  is mutable version of 3G. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  3(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe? sdp 1 is bordered strict unboxed unrolled linked list. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  4(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeF sdp  is mutable version of 6H. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  5(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe  sdp  is mutable version of 6H. sdp  is mutable version of 6H. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  6(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe sdp  - lazy boxed array. 6789:;<=>UVWXYZ[\]^_`abcdefghijklmnopqrstu  7(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportableSafe< sdp Lazy boxed unrolled libked list.  I(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportable Safe-Inferred 8(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportableSafe3 sdpLazy boxed array.  J(c) Andrey Mulik 2020-2021 BSD-stylework.a.mulik@gmail.comportable Safe-Inferred KLMKLNKOPKQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                            ;                                                                                          @A                                                ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " #B# # # # $ % % &C& ' ( ( ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + , , -E. / / 0F1 2 2 3G4 5 5 6H7 8 K  K K K K  K  K K K K K K K K K K K K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  KL K K K K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K  K K K K K K K K K K  K  K  K  K  K K  K  K  K  K K K K  K  K  K  K  K  K  K  K        K K  K  K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K  K K  K K  K K K K K  K K K  K K  K K  K K K K K  K K K< K  K  K K K K K  K  K  K K K K K K K K K K K K K K  K K K  K K K K K K K K K  K K K K K K K K K K K K K K K K K K K  K K K K  K K K K K K K K  K K K K  K K K  K K K K K K K K  K K K  K K  K K K K K K K K K K K K K K K  K K K K K KQ KQ KQ KQ K  K K  K K K K K K< K< K< K< K< K< K<=K< K< K<>K< K< K< K< K< K< K< K  K K K K K  K K  K K K            K  K  K  K  K K K K  K K K K K K K K K K K K K K K K  K  K K  K  K K  K  K K K K K K  K K  K  K  K K< K< K< K< K< K< K< K< K< K< K< K< K< K< K< K< K K K K K K K K K K K K  K K K K K K K K  KQ KQ KQ KQ KQ K K K K K K K K9 K K K K K K K K K K K K K K K K K K K K K K  K K K K K  K K K  K K K KKKKKKKKKKKKKKK  K    KK K K K K K K K K KOKOKOKOKOKOKO KO KKKKKKKKKKKKKKKK sdp-0.2.1-BHdU7aWiWiaBthzCRN8N9uSDP.Prim.TArray Text.Read.SDPControl.Exception.SDP SDP.Comparing SDP.Estimate SDP.Nullable SDP.RatioSDP.SafePrelude SDP.Finite SDP.SortM SDP.Tuple SDP.Shape SDP.Index SDP.UnboxedSDP.Unboxed.IntAsSDP.Unboxed.WordAsSDP.ZipSDP.Sort SDP.Linear SDP.ShapedSDP.SetSDP.ScanSDP.Map SDP.LinearMSDP.MapM SDP.Indexed SDP.IndexedMSDP.SortM.Insertion SDP.SortM.TimSDP.Prim.SBytesSDP.Prim.SArraySDP.ZipM Text.Show.SDPSDP.Templates.AnyChunksSDP.Unrolled.UnlistSDP.Unrolled.STUnlistSDP.Unrolled.IOUnlistSDP.ByteList.UblistSDP.ByteList.STUblistSDP.ByteList.IOUblistControl.Concurrent.SDP.TUnlistSDP.Templates.AnyBorderSDP.Unrolled.STSDP.Unrolled.IO SDP.Unrolled SDP.Bytes.ST SDP.Bytes.IO SDP.BytesSDP.ByteList.STSDP.ByteList.IO SDP.ByteList SDP.Array.ST SDP.Array.IO SDP.Array Control.Concurrent.SDP.TUnrolledControl.Concurrent.SDP.TArray Data.Maybe fromMaybeIndex Data.Foldablefoldr1foldl1foldl1'assocswriteM'UnlistUblistControl.Concurent.SDP.TUnlistUnrolledBytesByteListArrayControl.Concurent.SDP.TUnrolledControl.Concurent.SDP.TArraybase GHC.Conc.SyncSTMTVar Text.Read.LexexpectGHC.ShowappPrecUnreachableExceptionIndexExceptionUnacceptableExpansionUndefinedValueUnexpectedRankIndexUnderflow IndexOverflow EmptyRange$fExceptionIndexException$fShowIndexException$fExceptionUnreachableException$fShowUnreachableException$fEqUnreachableException$fEqIndexExceptionCompareEqual<=>eqfsteqsndcmpfstcmpsnd invertcmp Estimate'' Estimate' Estimate2 Estimate1Estimate<.=><==>.==./=.<=.>=.<.>.<..>..<=..>=..==../=.<=.>==./=.<=.>=.<.>. $fEstimate[] Nullable'' Nullable' Nullable2 Nullable1NullablelzeroisNullZNULL$fNullableFunPtr$fNullableStablePtr$fNullableForeignPtr $fNullablePtr $fNullable[]$fNullableMaybe:%??+?-?:+?...?^<=<<>>=>>>=<<liftA4liftA5liftA6liftM6stToMIOI15I14I13I12I11I10I9I8I7I6I5I4I3I2I1:&Eind2ind3ind4ind5ind6ind7ind8ind9ind10ind11ind12ind13ind14ind15 $fNullableE $fIsListE $fDefaultE $fIsList:& $fIsList:&0$fRead:&$fShow:& $fDefault:&$fEnum:&$fEq:&$fOrd:&$fEqE$fOrdE$fShowE$fReadESortM''SortM'SortM2SortM1SortM sortedMBysortMBysortedM sortedMOnsortMsortMOnT15T14T13T12T11T10T9T8T7T6T5T4T3T2fstssndsbothRANK15RANK14RANK13RANK12RANK11RANK10RANK9RANK8RANK7RANK6RANK5RANK4RANK3RANK2RANK1RANK0ShapeDimLastDimInit fromGIndextoGIndexrankconsDiminitDimlastDim unconsDimGIndex toGBounds fromGBounds$fShape(,,,,,,,,,,,,,,)$fShape(,,,,,,,,,,,,,)$fShape(,,,,,,,,,,,,)$fShape(,,,,,,,,,,,)$fShape(,,,,,,,,,,)$fShape(,,,,,,,,,)$fShape(,,,,,,,,)$fShape(,,,,,,,)$fShape(,,,,,,)$fShape(,,,,,) $fShape(,,,,) $fShape(,,,) $fShape(,,) $fShape(,) $fShape:& $fShape:&0$fShapeCSigAtomic$fShapeCPtrdiff $fShapeCBool $fShapeCSize$fShapeCUIntMax$fShapeCIntMax$fShapeCUIntPtr$fShapeCIntPtr$fShapeCULLong $fShapeCULong $fShapeCLLong $fShapeCLong $fShapeCUInt $fShapeCInt$fShapeCUShort $fShapeCShort $fShapeCWchar $fShapeCSChar $fShapeCUChar $fShapeCChar $fShapeWord64 $fShapeWord32 $fShapeWord16 $fShapeWord8 $fShapeWord $fShapeInt64 $fShapeInt32 $fShapeInt16 $fShapeInt8 $fShapeInt$fShapeInteger $fShapeChar $fShape()$fShapeEsizesizessafeElem ordBoundsdefLimit defaultBounds unsafeIndexisEmptyinBounds isOverflow isUnderflowinRangeprevnextoffsetindexrangesubshapeslicedropDimjoinDimtakeDimSubIndex:|:InBoundsERURINORsplitDimoffsetIntegraldefaultBoundsUnsign$fIndex(,,,,,,,,,,,,,,)$fIndex(,,,,,,,,,,,,,)$fIndex(,,,,,,,,,,,,)$fIndex(,,,,,,,,,,,)$fIndex(,,,,,,,,,,)$fIndex(,,,,,,,,,)$fIndex(,,,,,,,,)$fIndex(,,,,,,,)$fIndex(,,,,,,)$fIndex(,,,,,) $fIndex(,,,,) $fIndex(,,,) $fIndex(,,) $fIndex(,) $fIndex:& $fIndex:&0$fIndexCUIntMax$fIndexCUIntPtr$fIndexCULLong $fIndexCULong $fIndexCUInt$fIndexCUShort $fIndexCUChar $fIndexCSize $fIndexCBool$fIndexCSigAtomic$fIndexCPtrdiff$fIndexCIntMax$fIndexCIntPtr $fIndexCLLong $fIndexCLong $fIndexCInt $fIndexCShort $fIndexCWchar $fIndexCSChar $fIndexCChar $fIndexWord64 $fIndexWord32 $fIndexWord16 $fIndexWord8 $fIndexWord $fIndexInt64 $fIndexInt32 $fIndexInt16 $fIndexInt8 $fIndexInt$fIndexInteger $fIndexChar $fIndex()$fIndexE $fNullable(,) $fEstimate(,)$fSubij$fSubii $fEqInBounds$fShowInBounds$fReadInBounds$fEnumInBoundsWrapunwrapUnboxedsizeofsizeof#!#!>#writeByteArray#fillByteArray# newUnboxed newUnboxed' copyUnboxed# copyUnboxedM#hashUnboxedWith cloneUnboxed#cloneUnboxedM# thawUnboxed#freezeUnboxed# fromProxypsizeof#psizeof pnewUnboxed pcopyUnboxed pcopyUnboxedMcloneUnboxed1# pcloneUnboxedpcloneUnboxedM pthawUnboxedpfreezeUnboxed fromProxy1 pnewUnboxed1 pcopyUnboxed1pcopyUnboxedM1pcloneUnboxed1pcloneUnboxedM1lzero#single# fromList# fromFoldable# fromListN# newLinear# newLinearN#fromFoldableM#concat#pconcat$fUnboxed(,,,,,,,,,,,,,,)$fUnboxed(,,,,,,,,,,,,,)$fUnboxed(,,,,,,,,,,,,)$fUnboxed(,,,,,,,,,,,)$fUnboxed(,,,,,,,,,,)$fUnboxed(,,,,,,,,,)$fUnboxed(,,,,,,,,)$fUnboxed(,,,,,,,)$fUnboxed(,,,,,,)$fUnboxed(,,,,,)$fUnboxed(,,,,)$fUnboxed(,,,) $fUnboxed(,,) $fUnboxed(,) $fUnboxed() $fUnboxed:& $fUnboxed:&0 $fUnboxedE $fUnboxedChar $fUnboxedBool$fUnboxedCSigAtomic$fUnboxedCDouble$fUnboxedCFloat$fUnboxedCBool$fUnboxedCSize$fUnboxedCSUSeconds$fUnboxedCUSeconds$fUnboxedCClock$fUnboxedCTime$fUnboxedCPtrdiff$fUnboxedCUIntMax$fUnboxedCIntMax$fUnboxedCUIntPtr$fUnboxedCIntPtr$fUnboxedCULLong$fUnboxedCLLong$fUnboxedCULong$fUnboxedCLong$fUnboxedCUInt $fUnboxedCInt$fUnboxedCUShort$fUnboxedCShort$fUnboxedCWchar$fUnboxedCSChar$fUnboxedCChar$fUnboxedStablePtr$fUnboxedFunPtr $fUnboxedPtr$fUnboxedComplex$fUnboxedRatio$fUnboxedDouble$fUnboxedFloat$fUnboxedWord64$fUnboxedWord32$fUnboxedWord16$fUnboxedWord8 $fUnboxedWord$fUnboxedInt64$fUnboxedInt32$fUnboxedInt16 $fUnboxedInt8 $fUnboxedIntIntAs64IntAs32IntAs16IntAs8$fStorableIntAs8$fUnboxedIntAs8 $fReadIntAs8 $fShowIntAs8 $fIndexIntAs8 $fShapeIntAs8$fStorableIntAs16$fUnboxedIntAs16 $fReadIntAs16 $fShowIntAs16$fIndexIntAs16$fShapeIntAs16$fStorableIntAs32$fUnboxedIntAs32 $fReadIntAs32 $fShowIntAs32$fIndexIntAs32$fShapeIntAs32$fStorableIntAs64$fUnboxedIntAs64 $fReadIntAs64 $fShowIntAs64$fIndexIntAs64$fShapeIntAs64 $fEqIntAs64 $fOrdIntAs64 $fEnumIntAs64$fBoundedIntAs64 $fNumIntAs64 $fRealIntAs64$fIntegralIntAs64 $fEqIntAs32 $fOrdIntAs32 $fEnumIntAs32$fBoundedIntAs32 $fNumIntAs32 $fRealIntAs32$fIntegralIntAs32 $fEqIntAs16 $fOrdIntAs16 $fEnumIntAs16$fBoundedIntAs16 $fNumIntAs16 $fRealIntAs16$fIntegralIntAs16 $fEqIntAs8 $fOrdIntAs8 $fEnumIntAs8$fBoundedIntAs8 $fNumIntAs8 $fRealIntAs8$fIntegralIntAs8WordAs64WordAs32WordAs16WordAs8$fStorableWordAs8$fUnboxedWordAs8 $fReadWordAs8 $fShowWordAs8$fIndexWordAs8$fShapeWordAs8$fStorableWordAs16$fUnboxedWordAs16$fReadWordAs16$fShowWordAs16$fIndexWordAs16$fShapeWordAs16$fStorableWordAs32$fUnboxedWordAs32$fReadWordAs32$fShowWordAs32$fIndexWordAs32$fShapeWordAs32$fStorableWordAs64$fUnboxedWordAs64$fReadWordAs64$fShowWordAs64$fIndexWordAs64$fShapeWordAs64 $fEqWordAs64 $fOrdWordAs64$fEnumWordAs64$fBoundedWordAs64 $fNumWordAs64$fRealWordAs64$fIntegralWordAs64 $fEqWordAs32 $fOrdWordAs32$fEnumWordAs32$fBoundedWordAs32 $fNumWordAs32$fRealWordAs32$fIntegralWordAs32 $fEqWordAs16 $fOrdWordAs16$fEnumWordAs16$fBoundedWordAs16 $fNumWordAs16$fRealWordAs16$fIntegralWordAs16 $fEqWordAs8 $fOrdWordAs8 $fEnumWordAs8$fBoundedWordAs8 $fNumWordAs8 $fRealWordAs8$fIntegralWordAs8Zipzapall2all3all4all5all6any2any3any4any5any6zipzip3zip4zip5zip6zipWithzipWith3zipWith4zipWith5zipWith6$fZip[]Sort''Sort'Sort2Sort1SortsortedBysortBysortedsortedOnsortsortOn $fSort[]a Bordered'' Bordered'Linear''Linear'Split1 Bordered2 Bordered1Linear2Linear1SplittakedropkeepsanssaveskipsplitdividesplitsdividespartschunkssplitBydivideBysplitsBysplitsOn replaceBy removeAllcombojustifyLjustifyReacheachFrom isPrefixOf isSuffixOf isInfixOfprefixsuffixinfixesdropSide takeWhile dropWhiletakeEnddropEndspanlbreaklspanrbreakr selectWhile selectEnd extractWhile extractEnd selectWhile' selectEnd' extractWhile' extractEnd'Linearunconsuncons'toHeadheadtailunsnocunsnoc'toLastinitlastsingle++ replicatefromList fromListNlistRlistL fromFoldable!^writeconcat concatMap interspersefilterexcept partition partitionsselectselect'extractextract'selectsselects' isSubseqOfreverseforcebeforeafterremove subsequencesiteratenubnubByofoldrofoldlofoldr'ofoldl'o_foldro_foldlo_foldr'o_foldl'o_foldr1o_foldl1 o_foldr1' o_foldl1'BorderedboundsloweruppersizeOfsizesOfindexInindicesindexOfoffsetOf:<:> stripPrefix stripSuffix stripPrefix' stripSuffix' intercalatetailsinits ascending$fBordered[]Int$fBordered(,)i $fSplit[]e $fLinear[]eShapeddefaultReboundreboundreshape!!slicesunslice SetWith''Set''SetWith'Set'SetWith2Set2SetWith1Set1Setsetinsertdelete/\\/\\\^//?\\?/\+/ intersectionsunions differencessymdiffsmemberlookupLTlookupGTlookupLElookupGESetWithsetWith groupSetWith insertWith deleteWithintersectionWithdifferenceWith symdiffWith unionWithintersectionsWithdifferencesWith unionsWith symdiffsWithisIntersectsWithisDisjointWith memberWith isSubsetWithsubsets lookupLTWith lookupGTWith lookupGEWith lookupLEWith $fSetWith[]o$fSet[]oScanscanlscanl'scanrscanr'scanl1scanr1 $fScan[]aMap''Map'Map2Map1MaptoMaptoMap'insert'delete'member'//.!!!?filter'union' difference' intersection'update lookupLT' lookupGT' lookupLE' lookupGE'keys.$*$kfoldrkfoldlkfoldr'kfoldl' $fMap[]Inte LinearM''LinearM' BorderedM'' BorderedM'SplitM1LinearM2LinearM1 BorderedM2 BorderedM1SplitMtakeMdropMkeepMsansMsplitMdivideMsplitsMdividesMpartsMchunksMeachMprefixMsuffixMmprefixmsuffixLinearMnewNullnowNullsingleMgetHeadgetLastprependappend newLinear newLinearN fromFoldableMgetLeftgetRight!#>writeMcopiedcopied'reversed reversed'mergedfilledremovedlshiftMcopyToofoldrMofoldlMofoldrM'ofoldlM'foldrMfoldlMfoldrM'foldlM'foldrM1foldlM1swapM BorderedM getBoundsgetLowergetUpper getSizeOf getSizesOf nowIndexIn getOffsetOf getIndexOf getIndices:~=:=+:+=$fIsPropFieldLinearMMapM''MapM'MapM2MapM1MapMnewMapnewMap' getAssocs>!!>!?>updateM overwritememberM'getKeys.?*?kfoldrMkfoldlMkfoldrM'kfoldlM'Freeze''Freeze' Indexed''Indexed'Freeze2Freeze1Indexed2Indexed1Freezefreeze unsafeFreezeIndexedassocassoc' fromIndexedwrite'update'updates'accumimap binaryContain$fIndexed[]InteThaw''Thaw' IndexedM'' IndexedM'Thaw2Thaw1 IndexedM2 IndexedM1Thawthaw unsafeThawIndexedM fromAssocs fromAssocs'swapM' fromIndexed' fromIndexedMreshaped fromAccumupdateM' insertionSortinsertionSortOninsertionSortByunsafeInsertionSorttimSort timSortOn timSortByminrunTSIOBytes# MIOBytes#STBytes#SBytes# unpackSBytes# offsetSBytes# packSBytes# fromSBytes#unsafeCoerceSBytes#unpackSTBytes#offsetSTBytes# packSTBytes# fromSTBytes#unsafeCoerceSTBytes#unsafeSBytesToPtr#unsafePtrToSBytes#hashSBytesWith#$fThawIOSBytes#(,)$fIndexedSBytes#Inte$fMapSBytes#Inte$fSortSBytes#e$fScanSBytes#e$fSetWithSBytes#e $fSetSBytes#e$fBorderedSBytes#Int$fSplitSBytes#e$fEstimateSBytes#$fDefaultSBytes#$fMonoidSBytes#$fSemigroupSBytes#$fNullableSBytes#$fIsListSBytes#$fIsStringSBytes# $fReadSBytes# $fShowSBytes# $fOrdSBytes# $fEqSBytes#$fSortMSTSTBytes#e$fIndexedMSTSTBytes#Inte$fMapMSTSTBytes#Inte$fSplitMSTSTBytes#e$fLinearMSTSTBytes#e$fBorderedMSTSTBytes#Int$fBorderedSTBytes#Int$fEstimateSTBytes# $fEqSTBytes#$fFreezeSTSTBytes#SBytes#$fThawSTSBytes#STBytes#$fLinearSBytes#e$fFreezeIO(,)SBytes#$fFreezeioMIOBytes#SBytes#$fThawioSBytes#MIOBytes#$fSortMioMIOBytes#e$fIndexedMioMIOBytes#Inte$fMapMioMIOBytes#Inte$fSplitMioMIOBytes#e$fLinearMioMIOBytes#e$fBorderedMioMIOBytes#Int$fBorderedMIOBytes#Int$fEstimateMIOBytes# $fEqMIOBytes#IOArray# MIOArray#STArray#SArray# unpackSArray# offsetSArray# packSArray# fromSArray# coerceSArray#unpackSTArray#offsetSTArray# packSTArray# fromSTArray#coerceSTArray#$fThawIOSArray#(,)$fIndexedSArray#Inte$fMapSArray#Inte$fSortSArray#e$fScanSArray#e$fSetWithSArray#e $fSetSArray#e$fBorderedSArray#Int$fSplitSArray#e$fTraversableSArray#$fFoldableSArray#$fApplicativeSArray# $fZipSArray#$fFunctorSArray#$fEstimateSArray#$fDefaultSArray#$fMonoidSArray#$fSemigroupSArray#$fNullableSArray#$fIsListSArray#$fIsStringSArray# $fReadSArray# $fShowSArray# $fOrd1SArray# $fOrdSArray# $fEq1SArray# $fEqSArray#$fSortMSTSTArray#e$fIndexedMSTSTArray#Inte$fMapMSTSTArray#Inte$fSplitMSTSTArray#e$fLinearMSTSTArray#e$fBorderedMSTSTArray#Int$fBorderedSTArray#Int$fEstimateSTArray# $fEqSTArray#$fFreezeSTSTArray#SArray#$fThawSTSArray#STArray#$fLinearSArray#e$fFreezeIO(,)SArray#$fFreezeioMIOArray#SArray#$fThawioSArray#MIOArray#$fSortMioMIOArray#e$fIndexedMioMIOArray#Inte$fMapMioMIOArray#Inte$fSplitMioMIOArray#e$fLinearMioMIOArray#e$fBorderedMioMIOArray#Int$fBorderedMIOArray#Int$fEstimateMIOArray# $fEqMIOArray#TArray#$fFreezeSTMTArray#SArray#$fThawSTMSArray#TArray#$fIndexedMSTMTArray#Inte$fMapMSTMTArray#Inte$fSplitMSTMTArray#e$fLinearMSTMTArray#e$fBorderedMSTMTArray#Int$fBorderedTArray#Int$fEstimateTArray#$fNullableTArray# $fEqTArray#ZipMzipMzipM3zipM4zipM5zipM6mzipWith mzipWith3 mzipWith4 mzipWith5 mzipWith6zipWithM zipWithM3 zipWithM4 zipWithM5 zipWithM6 indexedPrec linearPrec indexedPrec' readZeroPrec readAsList readAsListNreadAssocsPrec readAsEnum enumFromPrecenumFromToPrecenumFromThenPrecenumFromThenToPrec expectPrecallPrec allPrecWith namedPrecreadDef readDefByreadBy readMaybeBy readEitherBy assocsPrecshowsRawshowsRawLinear AnyChunks fromChunks fromChunksMtoChunks$fFreezemAnyChunksAnyChunks$fFreezemAnyChunksimm$fFreezemmutAnyChunks$fThawmAnyChunksAnyChunks$fThawmimmAnyChunks$fThawmAnyChunksmut$fSortMmAnyChunkse$fIndexedMmAnyChunksInte$fMapMmAnyChunksInte$fIndexedAnyChunksInte$fMapAnyChunksInte$fScanAnyChunkse$fSetWithAnyChunkse$fSetAnyChunkse$fSplitMmAnyChunkse$fLinearMmAnyChunkse$fBorderedMmAnyChunksInt$fSplitAnyChunkse$fLinearAnyChunkse$fBorderedAnyChunksInt$fTraversableAnyChunks$fFoldableAnyChunks$fApplicativeAnyChunks$fFunctorAnyChunks$fIsListAnyChunks$fIsStringAnyChunks$fEstimateAnyChunks$fDefaultAnyChunks$fMonoidAnyChunks$fSemigroupAnyChunks$fNullableAnyChunks$fReadAnyChunks$fShowAnyChunks$fShowAnyChunks0$fOrdAnyChunks $fEqAnyChunks$fDataAnyChunks$fGenericAnyChunks$fSortAnyChunkse$fZipAnyChunks$fOrd1AnyChunks$fEq1AnyChunksSTUnlistIOUnlist MIOUnlistSTUblistIOUblist MIOUblistTUnlist AnyBorder$fFreezemAnyBorderAnyBorder$fFreezemmutAnyBorder$fFreezemAnyBorderimm$fThawmAnyBorderAnyBorder$fThawmimmAnyBorder$fThawmAnyBordermut$fSortMmAnyBordere$fIndexedMmAnyBorderie$fMapMmAnyBorderie$fShapedAnyBordere$fIndexedAnyBorderie$fMapAnyBorderie$fSortAnyBordere$fScanAnyBordere$fSetWithAnyBordere$fSetAnyBordere$fSplitMmAnyBordere$fLinearMmAnyBordere$fBorderedMmAnyBorderi$fSplitAnyBordere$fLinearAnyBordere$fBorderedAnyBorderi$fTraversableAnyBorder$fFoldableAnyBorder$fApplicativeAnyBorder$fZipAnyBorder$fFunctorAnyBorder$fEstimateAnyBorder$fDefaultAnyBorder$fMonoidAnyBorder$fSemigroupAnyBorder$fNullableAnyBorder$fIsListAnyBorder$fIsStringAnyBorder$fReadAnyBorder$fShowAnyBorder$fShowAnyBorder0$fOrd1AnyBorder$fOrdAnyBorder$fEq1AnyBorder $fEqAnyBorder$fDataAnyBorder$fGenericAnyBorder STUnrolled IOUnrolled MIOUnrolledSTBytesIOBytesMIOBytes STByteList IOByteList MIOByteListSTArrayIOArrayMIOArray TUnrolledTArrayGHC.IO.ExceptionArrayExceptionGHC.BaseassertControl.ExceptionallowInterruptcatchesHandlerControl.Exception.BasebracketOnErrorbracket_finallybracket onExceptiontryJusttry mapException handleJusthandle catchJustPatternMatchFail RecSelError RecConError RecUpdError NoMethodError TypeErrorNonTerminationNestedAtomicallythrowToioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededCompactionFailedAssertionFailedSomeAsyncExceptionAsyncException UserInterrupt ThreadKilled StackOverflow HeapOverflowIndexOutOfBoundsUndefinedElementGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingState interruptiblethrowIOcatch MaskingStateMaskedUninterruptibleUnmaskedMaskedInterruptible IOException GHC.Exceptionthrow ErrorCallErrorCallWithLocationGHC.Exception.Type ExceptiondisplayException toException fromExceptionArithExceptionRatioZeroDenominatorDenormal DivideByZeroLossOfPrecision UnderflowOverflow SomeExceptionghc-prim GHC.ClassesEq==/=Ord<<=>maxmincompare>= GHC.TypesOrderingGTLTEQData.Ord comparingDowngetDownData.Functor.Classes showsBinary1 showsUnary1 showsUnary readsBinary1 readsUnary1 readsUnaryshowsBinaryWithshowsUnaryWithreadBinaryWithreadsBinaryWith readUnaryWithreadsUnaryWithreadData readsData showsPrec2liftReadListPrec2DefaultliftReadList2Default readPrec2 readsPrec2compare2eq2 showsPrec1liftReadListPrecDefaultliftReadListDefault readPrec1 readsPrec1compare1eq1Eq1liftEqOrd1 liftCompareRead1liftReadListPrec liftReadPrec liftReadsPrec liftReadListShow1 liftShowsPrec liftShowListEq2liftEq2Ord2 liftCompare2Read2liftReadListPrec2 liftReadPrec2liftReadsPrec2 liftReadList2Show2liftShowsPrec2 liftShowList2FoldableGHC.RealRatioRational Data.RatioapproxRational denominator numerator% GHC.MaybeJustNothingMaybejoinliftM2Control.Monad.IO.ClassliftIOstToIOGHC.Primseq System.IOprint Data.Tuplefstsnd otherwisemap$ fromIntegral realToFrac Control.MonadguardGHC.EnumBoundedminBoundmaxBoundEnumpredsuccenumFromThenTo enumFromTo enumFromThenenumFromfromEnumtoEnum GHC.FloatFloatingatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogpiexp Fractionalrecip fromRational/IntegraldivModquotRemmoddivrem toIntegerquotMonad>>>>=returnFunctor<$fmapGHC.NumNumsignumabs*+negate fromInteger-GHC.ReadRead readsPrecreadListReal toRational RealFloatatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatRadix floatDigitsRealFracfloorceilingroundproperFractiontruncateShowshowListshow showsPrecControl.Monad.Fail MonadFailfail Applicative<*liftA2*><*>purefoldr'foldMap'foldelemminimummaximumproductsumfoldl'nulltoListfoldrfoldllengthfoldMapData.Traversable Traversable sequenceAtraversemapMsequence Semigroup<>MonoidmconcatmemptymappendBoolFalseTrueCharDoubleFloatIntinteger-wired-inGHC.Integer.TypeInteger RealWorldIOWord Data.EitherEitherRightLeftData.Bifunctor BifunctorsecondbimapfirstMonadIOmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_ mapAndUnzipMforever<=<>=>filterMforMControl.Applicativeoptional WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipListreadIOreadLninteractControl.Monad.ST.ImpfixSTFilePath userErrorIOErrorData.Functor.ConstConstgetConstfindnotElem minimumBy maximumByallanyorandmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_ Data.OldListunwordswordsunlineslines Text.ReadreadreadseitherControl.Category.idlex readParenText.ParserCombinators.ReadPReadSlcmgcd^^^oddevenGHC.STrunSTST showParen showStringshowCharshowsShowSGHC.Listunzip3unzipbreakspansplitAtcyclerepeatmaybe Data.Functionon Data.Functorvoid<$>uncurrycurrysubtractasTypeOfuntil$!flipconstapliftM5liftM4liftM3liftMwhen=<<liftA3liftA<**> Alternativemanysomeempty<|> MonadPlusmzeromplusStringGHC.Err undefinederrorWithoutStackTraceerror&&||notGHC.IntInt8Int16Int32Int64GHC.WordWord8Word16Word32Word64 bitReverse64 bitReverse32 bitReverse16 bitReverse8 byteSwap64 byteSwap32 byteSwap16 ByteArray#MutableByteArray#GHC.PtrPtr MutableArray#Array# cloneArray#coerceText.ParserCombinators.ReadPrecReadPrecreadPrecmanyTill readMaybe readEither readListPrecparenslexPreadListPrecDefaultreadListDefaultLexemeEOFIdentPuncNumberSymbol readS_to_Prec readPrec_to_S readP_to_Prec readPrec_to_Pchoicepfail<+++++lookgetprecresetstepliftminPrecPrec