h$x[τ       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                                                  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""#$$%%&''()))))))))))))))))))))))))))))))))))))))))))))*++,-../011234 4 5 6 77(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafesdpA 5 is used as an exception that should never be thrown.  and   means that the function is partially defined or missused (if some arguments shouldn't be passed). means that some expression, by definition, cannot be reached (for example, a default value when initializing an array, if each value is guaranteed to be overwritten before use).sdp replaces the less informative   and has more neutral names.5 - occurs if the desired range exceed the actual size  - occurs when trying to convert a list into a generalized index of inappropriate dimension# - occurs if the value is undefined  - occurs if range is empty " - occurs if index overflows range # - occurs if index underflows range  constructors are specified in the order of definition, this is the recommended check order.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.   (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafesdp 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 BSD-stylework.a.mulik@gmail.comportableSafe#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.sdp2Left-side structure length with number comparison.sdp$Two structures by length comparison.sdp2Left-side structure length with number comparison.sdp2Left-side structure length with number comparison. sdp2Left-side structure length with number comparison.!sdp2Left-side structure length with number comparison."sdp2Left-side structure length with number comparison.#sdp2Left-side structure length with number comparison.$sdp$Two structures comparison by length.%sdp$Two structures comparison by length.&sdp$Two structures comparison by length.'sdp$Two structures comparison by length.(sdp$Two structures comparison by length.)sdp$Two structures comparison by length.*sdp3Right-side number with structure length comparison.+sdp3Right-side number with structure length comparison.,sdp3Right-side number with structure length comparison.-sdp3Right-side number with structure length comparison..sdp3Right-side number with structure length comparison./sdp3Right-side number with structure length comparison.0sdp3Right-side number with structure length comparison. $%&'()"# !*+,-./0$%&'()"# !*/0-.+,4444 4!4"4#4$4%4&4'4(4)4*4+4,4-4.4/404(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy&%2sdp2, is class of types which value may be empty.3sdp Empty value.4sdpIs value empty?5sdpOriginally defined in  sdp-ctypes (now  sdp-foreign ), same as Z now.23452345(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe&&;sdpCrutch pattern: real (; ) is closed   constructor. ;;;7(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe*<sdpTernary operator. -(odd 1 ? "is True" $ "is False") == "is True"=sdp p ?+ f $ a returns   (f a) if (p a) and   otherwise.>sdp p ?- f $ a returns   if (p a) and   (f a) otherwise.?sdp Prepends   to list.@sdpShort version of 89.Asdp(...) = (.) . (.).BsdpLifted (<).CsdpMonadic version of (A).DsdpMonadic vesion of (A) with reversed arguments.Esdp ma >>=<< mb is composition of   and  .FsdpVery useful combinator.GsdpVery very useful combinatorHsdpAn even more useful combinator.IsdpSee H.JsdpJ is just   .  . ! #")('&%$*+,-./0<=>?@ABCDEFGHIJ<=>?@ABCDEFGHIJ<1=8>8A0B1 (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.com&non-portable (a lot of GHC extensions) Trustworthy !>?2Ksdp15-dimensional indexLsdp14-dimensional indexMsdp13-dimensional indexNsdp12-dimensional indexOsdp11-dimensional indexPsdp10-dimensional indexQsdp9-dimensional indexRsdp8-dimensional indexSsdp7-dimensional indexTsdp6-dimensional indexUsdp5-dimensional indexVsdp4-dimensional indexWsdp3-dimensional indexXsdp2-dimensional indexYsdp1-dimensional index ((E :& i) without  TypeOperators).ZsdpN-dimensional index type. The type (head :& tail) allows working with any finite dimension number.\sdp5Service type, that represents zero-dimensional index.^sdp 2-dimensional index constructor._sdp 3-dimensional index constructor.`sdp 4-dimensional index constructor.asdp 5-dimensional index constructor.bsdp 6-dimensional index constructor.csdp 7-dimensional index constructor.dsdp 8-dimensional index constructor.esdp 9-dimensional index constructor.fsdp!10-dimensional index constructor.gsdp!11-dimensional index constructor.hsdp!12-dimensional index constructor.isdp!13-dimensional index constructor.jsdp!14-dimensional index constructor.ksdp!15-dimensional index constructor.!KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk!\]Z[YXWVUTSRQPONMLK^_`abcdefghijk (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-5rzsdpKind (* -> *) version of {.{sdp{) is class of sortable mutable structures.|sdp@sdp9The 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 (\).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. KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy!-9>?M!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:\6 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 Note that   isn't  4, so it can't be used in multidimensional indices. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk!(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportable TrustworthyXdsdp 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 is Proxy .sdp(* -> *) kind proxy version of .sdp(* -> *) kind proxy version if .sdpProxy version if .sdpReturns   of suitable type.sdp (* -> * -> *) kind proxy version of .sdp (* -> * -> *) kind proxy version if .sdp (* -> * -> *) kind proxy version if .sdpReturns   of suitable type.sdpcloneUnboxed# e o# c# creates byte array with c# elements of same type as e beginning from o# elements.sdp(* -> *) kind proxy version if .(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) TrustworthyYsdpInt 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) TrustworthyZsdpWord value as 8 bytes.sdpWord value as 4 bytes.sdpWord value as 2 bytes.sdpWord value as 1 byte.(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe[sdpZip is generalization of ZipList applicative semantics (but without pure).sdp ZipList-like  (c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe>^|sdp& is class of types that can be sorted.sdpsdpKind  (* -> * -> *)  structure.sdpKind (* -> *)  structure.sdpKind (* -> *)  structure.sdpKind (* -> *)  structure.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.  sdp*Prepends element to line, constructor for  pattern.sdp(Returns first element of line, may fail.sdp$Returns line except first, may fail.sdpSeparates line to  and , deconstructor for  pattern.sdpSame as 4 > sdp)Appends element to line, constructor for  pattern.sdpReturns line except  element, may fail.sdpReturns last element, may fail.sdpJust singleton.sdpConcatenation of two lines.sdp replicate n e returns a line of n repetitions of the element e.sdpCreates line from list.sdp1Create finite line from (possibly infinite) list.sdpRight to left view of line.sdp$Left to right view of line, same to  .sdp Generalized .sdpReturns the element of a sequence by offset, may be completely unsafe. This is an optimistic read function and shouldn't perform checks for efficiency reasons.If you need safety, use (!) or (!?). The generalization of this function by index type (.!). es !^ i = listL es !! isdp write es n e writes value e in position n+ (offset), returns new structure. If n+ is out of range, returns equal structure (es or copy).sdpGeneralized concat.sdpGeneralized concatMap.sdpGeneralized intersperse.sdpGeneralized filter.sdpInverted filter.sdpGeneralization of partition.sdpGeneralization of partition, that select sublines by predicates.sdp select f es is selective map of es elements to new list.sdp select' f es is selective map of es elements to new line.sdp extract f es returns a selective map of es elements to new list and the remaining elements of the line.sdp extract' f es returns a selective map of es elements to new line and the remaining elements of the line.sdp selects fs es) sequentially applies the functions from fs to the remainder of es, returns a list of selections and the remainder of the last selection.sdpselects' fs es) sequentially applies the functions from fs to the remainder of es, returns a line of selections and the remainder of the last selection.sdpThe isSubseqOf xs ys# checks if all the elements of the xs occur, in order, in the ys1. The elements don't have to occur consecutively.sdpGeneralized reverse.sdp Create new line, equal to given.sdpGeneralized subsequences.sdp iterate n f x returns sequence of n applications of f to x. Note that iterate" returns finite sequence, instead Prelude prototype.sdpSame as nubBy ( ).sdpGeneralization of nubBy.sdp is right fold with offset.sdp is left 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 just   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 .sdp is overloaded empty (3) value constant. Pattern  corresponds to all empty (4 ) values.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 lens checks if the subsequences of es of lengths lens is sorted. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk59 8855(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe%sdpService 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 BSD-stylework.a.mulik@gmail.comnon-portable (GHC Extensions) Trustworthy -9>W,sdpKind (* -> *) .sdpKind (* -> *) .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 total order laws (antisymmetry, transitivity and connexity). If you use the 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.,,(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 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-9>sdpKind  (* -> * -> *)  structure.sdpKind (* -> *)  structure.sdp is a class of dictionaries, simple associative arrays with an arbitrary (implementation-dependent) key.In the current implementation,  (since sdp-0.2) is a superclass of ;.  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 () and may throw .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 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-9<sdpKind  (* -> * -> *)  structure.sdpKind (* -> *)  structure.sdpKind (* -> *)  structure.sdpKind (* -> *)  structure.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 4.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 .sdpMonadic .sdpMonadic version of .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 .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. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk<5(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comportableSafe-9>sdpRank  (* -> * -> *) .sdpRank (* -> *) .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 =)!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 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-9>rsdpKind (* -> *) .sdpKind  (* -> * -> *)  structure.sdpKind (* -> *)  structure.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 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!Update element by given function.sdp4Create new structure from old by mapping with index.sdp=binaryContain checks that sorted structure has equal element. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe-96sdpKind (* -> *) .sdpKind  (* -> * -> *) .sdpKind (* -> *) .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. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafesdp 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.sdpunsafeInsertionSort 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)Safesdp 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 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 . 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~(c) Andrey Mulik 2019 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. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.com non-portable Trustworthy>Zsdp of stm s.(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafesdp 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.sdp2 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 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy 38>?Isdp 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.sdp sdp) is unrolled linked list of boxed values. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk#(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafesdp is mutable version of ">. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~$(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeKsdp is mutable version of ">.sdp is mutable version of ">. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~%(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe>sdp+ is unrolled linked list of unboxed values. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk&(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe$sdpThis  is mutable version of %?. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~'(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC Extensions)Safe sdp is mutable version of %?.sdp is mutable version of %?. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~((c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comportableSafe% sdp Lazy boxed unrolled linked list.)(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions) Trustworthy 38>?&sdp= is template, that appends arbitrary bounds to any structure. ,  ,   and   instances ingores bounds. and  instances for  rep e inherit rep e behavior. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk*(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe*sdp is mutable version ,@. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~+(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe/sdp is mutable version of ,@.sdp is mutable version of ,@. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~,(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe39sdp" is bordered unrolled linked list. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk-(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comnon-portable (GHC extensions)Safe6sdp is mutable version of /A. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~.(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe;sdp is mutable version of /A.sdp is mutable version of /A. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~/(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafe?Wsdp - unboxed array. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk0(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeBsdp is mutable version of 2B. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~1(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeGnsdp is mutable version of 2B.sdp is mutable version of 2B. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~2(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeKsdp1 is bordered strict unboxed unrolled linked list. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk3(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeOnsdp is mutable version of 5C. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~4(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeSsdp is mutable version of 5C. sdp  is mutable version of 5C. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijkz{|}~  5(c) Andrey Mulik 2019 BSD-stylework.a.mulik@gmail.comportableSafeW sdp  - lazy boxed array. 2345KLMNOPQRSTUVWXYZ[\]^_`abcdefghijk  6(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comportableSafe[@ sdp Lazy boxed unrolled libked list.  7(c) Andrey Mulik 2020 BSD-stylework.a.mulik@gmail.comportableSafe[ sdpLazy boxed array.   DEFDEGDHIDJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                        :                                                                                          <;=   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!">""""#$$%?%&''()))))))))) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * + + ,@- . . /A0 1 1 2B3 4 4 5C6 7 D  D  D  D  D D D D  D  D D D D D D D D D D D D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  DE D D D D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D  D D D D D D D D D D  D  D  D  D  D D  D  D D D D  D  D  D  D  D  D  D  D        D D  D  D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D  D D  D D  D D D D D  D D D  D D  D D  D D D D D  D D D  D  D D D D D  D  D  D D D D D D D D D D D D D D  D D D  D D D D D D D D D  D D D D D D D D D D D D D D D D D D D  D D D D  D D D D D D D D  D D D D  D D D  D D D D D D D D  D D D  D D  D D D D D D D D D D D D D D D  D D D D D DJ DJ DJ DJ D  D D  D D D D D D  D D D D D D D D D D D D D D D D D D  D D D D D  D D  D D D            D  D  D  D  D D D D  D D D D D D D D D D D D D D D D D  D  D D  D  D D  D  D D D D D D  D D  D  D  D D D D D D D D D D D D D D D D D D D D D D D D D D D  D D D D D D D D  DJ DJ DJ DJ DJ D D D D D D D D8 D D D D D D D D D D D D D D D D D D D D D D D D  D D D D D  D D D  D D D D  D  D  D  D  D  D  D  D D D D D D D   D    D  D D D D D D D D D DH DH DH DH DH DH DH DH D D D D D D D D D D D D D D D D  sdp-0.2-AH2T5KX1xmG8Wo3slp7kFTSDP.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.SArray Text.Show.SDPSDP.Templates.AnyChunksSDP.Unrolled.UnlistSDP.Unrolled.STUnlistSDP.Unrolled.IOUnlistSDP.ByteList.UblistSDP.ByteList.STUblistSDP.ByteList.IOUblistControl.Concurent.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.ArrayControl.Concurent.SDP.TUnrolledControl.Concurent.SDP.TArray Data.Maybe fromMaybeIndexIndexedassocswriteM'UnlistUblistUnrolledBytesByteListArraybase GHC.Conc.SyncSTMTVar Text.Read.LexexpectGHC.ShowappPrecUnreachableExceptionIndexExceptionUnacceptableExpansionUndefinedValueUnexpectedRankIndexUnderflow IndexOverflow EmptyRange$fExceptionIndexException$fShowIndexException$fExceptionUnreachableException$fShowUnreachableException$fEqUnreachableException$fEqIndexExceptionCompareEqual<=>eqfsteqsndcmpfstcmpsnd invertcmpEstimate<.=><==>.==./=.<=.>=.<.>.<..>..<=..>=..==../=.<=.>==./=.<=.>=.<.>. $fEstimate[]NullablelzeroisNullNULL$fNullableStablePtr$fNullableForeignPtr $fNullablePtr $fNullable[]$fNullableMaybe:%??+?-?:+?...?^<=<<>>=>>>=<<liftA4liftA5liftA6liftM6stToMIOI15I14I13I12I11I10I9I8I7I6I5I4I3I2I1:&Eind2ind3ind4ind5ind6ind7ind8ind9ind10ind11ind12ind13ind14ind15 $fIsListE $fDefaultE $fIsList:& $fIsList:&0$fRead:&$fShow:& $fDefault:&$fEnum:&$fEq:&$fOrd:&$fEqE$fOrdE$fShowE$fReadESortM1SortM 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 $fIndexCBool $fIndexCSize$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$fEnumInBoundsUnboxedsizeofsizeof#!#!>#writeByteArray#fillByteArray# newUnboxed newUnboxed' copyUnboxed# copyUnboxedM#hashUnboxedWithpsizeof pnewUnboxed pcopyUnboxed pcopyUnboxedM fromProxy pnewUnboxed1 pcopyUnboxed1pcopyUnboxedM1 fromProxy1 cloneUnboxed#cloneUnboxed1#$fUnboxedComplex$fUnboxedRatio$fUnboxedDouble$fUnboxedFloat $fUnboxedChar $fUnboxedBool $fUnboxed()$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$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[]SortsortedBysortBysortedsortedOnsortsortOn $fSort[]a Bordered2 Bordered1Split1Linear1SplittakedropkeepsanssaveskipsplitdividesplitsdividespartschunkssplitBydivideBysplitsBysplitsOn 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' isSubseqOfreverseforce subsequencesiteratenubnubByofoldrofoldlofoldr'ofoldl'o_foldro_foldlo_foldr'o_foldl'BorderedboundsloweruppersizeOfsizesOfindexInindicesindexOfoffsetOf:<:>Z stripPrefix stripSuffix stripPrefix' stripSuffix' intercalatetailsinits ascending$fBordered[]Int$fBordered(,)i $fSplit[]e $fLinear[]eShapeddefaultReboundreboundreshape!!slicesunsliceSetWith1Set1Setsetinsertdelete/\\/\\\^//?\\?/\+/ intersectionsunions differencessymdiffsmemberlookupLTlookupGTlookupLElookupGESetWithsetWith groupSetWith insertWith deleteWithintersectionWithdifferenceWith symdiffWith unionWithintersectionsWithdifferencesWith unionsWith symdiffsWithisIntersectsWithisDisjointWith memberWith isSubsetWithsubsets lookupLTWith lookupGTWith lookupGEWith lookupLEWith $fSetWith[]o$fSet[]oScanscanlscanl'scanrscanr'scanl1scanr1 $fScan[]aMap2Map1MaptoMaptoMap'insert'delete'member'//.!!!?filter'union' difference' intersection'update lookupLT' lookupGT' lookupLE' lookupGE'keys.$*$kfoldrkfoldlkfoldr'kfoldl' $fMap[]Inte BorderedM2 BorderedM1LinearM1SplitM1SplitMtakeMdropMkeepMsansMsplitMdivideMsplitsMdividesMpartsMchunksMeachMprefixMsuffixMmprefixmsuffixLinearMnewNullnowNullsingleMgetHeadgetLastprependappend newLinear newLinearN fromFoldableMgetLeftgetRight!#>writeMcopiedcopied'reversedmergedfilledcopyToofoldrMofoldlMofoldrM'ofoldlM'foldrMfoldlMfoldrM'foldlM'swapM BorderedM getBoundsgetLowergetUpper getSizeOf getSizesOf nowIndexIn getOffsetOf getIndexOf getIndicesMapM2MapM1MapMnewMapnewMap' getAssocs>!!>!?>updateM overwritememberM'getKeys.?*?kfoldrMkfoldlMkfoldrM'kfoldlM'Freeze1Indexed2Indexed1Freezefreeze unsafeFreezeassocassoc' fromIndexedwrite'accumimapupdate'updates' binaryContain$fIndexed[]InteThaw1 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#$fMonoidSBytes#$fSemigroupSBytes#$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$fDefaultSBytes#$fNullableSBytes#$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# 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 TUnrolledTArray GHC.Exception ErrorCallGHC.IO.ExceptionAssertionFailedArrayExceptionGHC.Exception.Type ExceptionGHC.BaseassertControl.ExceptionallowInterruptcatchesHandlerControl.Exception.BasebracketOnErrorbracket_finallybracket onExceptiontryJusttry mapException handleJusthandle catchJustPatternMatchFail RecSelError RecConError RecUpdError NoMethodError TypeErrorNonTerminationNestedAtomicallythrowToioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededCompactionFailedSomeAsyncExceptionAsyncException UserInterrupt ThreadKilled StackOverflow HeapOverflowIndexOutOfBoundsUndefinedElementGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingState interruptiblethrowIOcatch MaskingStateMaskedUninterruptibleUnmaskedMaskedInterruptible IOExceptionthrowErrorCallWithLocationdisplayException 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 liftShowList2GHC.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*><*>pure Data.FoldableFoldablefoldr'foldMap'foldelemminimummaximumfoldr1productsumfoldl1foldl'nulltoListfoldrfoldllengthfoldMapData.Traversable Traversable sequenceAtraversemapMsequence Semigroup<>MonoidmconcatmemptymappendBoolFalseTrueCharDoubleFloatIntinteger-wired-inGHC.Integer.TypeInteger RealWorldIOWord Data.EitherEitherRightLeftData.Bifunctor BifunctorsecondbimapfirstMonadIOmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_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.Readreadreadseitherlex readParenText.ParserCombinators.ReadPReadSlcmgcd^^^oddevenGHC.STrunSTST showParen showStringshowCharshowsShowSGHC.Listunzip3unzipbreakspansplitAtcyclerepeatmaybe Data.Functionon Data.Functorvoid<$>uncurrycurrysubtractasTypeOfuntil$!flip.constidapliftM5liftM4liftM3liftMwhen=<<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