T       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) Christoph Breitkopf 2011 BSD-stylechbreitkopf@gmail.com experimentalportableSafe!Intervals with endpoints of type a. and $ use mathematical notation with square brackets for closed and parens for open intervals. This is better for human readability, but is not a valid Haskell expression. Closed intervals look like a list, open intervals look like a tuple, and half-open intervals look like mismatched parens.&Including lower bound, excluding upperClosed at both ends Open at both ends &Excluding lower bound, including upper Like (, but considering the upper bound first. Get the lower bound. Get the upper bound.Is the interval empty?*Does the interval include its lower bound?*Does the interval include its upper bound?Do the two intervals overlap?6Does the first interval completely contain the second?xInterval strictly before another? True if the upper bound of the first interval is below the lower bound of the second.8Interval strictly after another? Same as 'flip before'.(Does the interval contain a given point?*Is a point strictly less than lower bound?-Is a point strictly greater than upper bound?/If the intervals overlap combine them into one.     (c) Christoph Breitkopf 2014 BSD-stylechbreitkopf@gmail.com experimentalnon-portable (MPTC with FD)Safe3579 !Intervals with endpoints of type eN. A minimal instance declaration for a closed interval needs only to define  and . lower bound upper boundbDoes the interval include its lower bound? Default is True for all values, i.e. closed intervals.hDoes the interval include its upper bound bound? Default is True for all values, i.e. closed intervals.xInterval strictly before another? True if the upper bound of the first interval is below the lower bound of the second.8Interval strictly after another? Same as 'flip before'. 6Does the first interval completely contain the second?!Do the two intervals overlap?"*Is a point strictly less than lower bound?#-Is a point strictly greater than upper bound?$(Does the interval contain a given point?%Is the interval empty? !"#$%&' !"#$%&' !"#$%&'  !"#$%&' (c) Christoph Breitkopf 2014 BSD-stylechbreitkopf@gmail.com experimentalnon-portable (MPTC with FD)Safe345g(A map from intervals of type k to values of type v.)O(log n)$. Lookup value for given key. Calls  if the key is not in the map.Use 4 or 5^ instead of this function, unless you are absolutely sure that the key is present in the map.*Same as ^.+O(1). The empty map.,O(1). A map with one entry.-O(1). Is the map empty?.O(n). Number of keys in the map.Caution: unlike  C, which takes constant time, this is linear in the number of keys!/3The height of the tree. For testing/debugging only.0cThe maximum height of a red-black tree with the given number of nodes. For testing/debugging only.1LTree statistics (size, height, maxHeight size). For testing/debugging only.2O(log n)/. Does the map contain the given key? See also 3.3O(log n)3. Does the map not contain the given key? See also 2.4O(log n)8. Look up the given key in the map, returning the value ( value), or  if the key is not in the map.5O(log n). The expression (5 def k map) returns the value at key k or returns default value def! when the key is not in the map.6kReturn the submap of key intervals containing the given point. This is the second element of the value of : 6m `containing` p == let (_,m',_) = m `splitAt` p in m'O(n)7, since potentially all keys could contain the point. O(log n)S average case. This is also the worst case for maps containing no overlapping keys.7~Return the submap of key intervals overlapping (intersecting) the given interval. This is the second element of the value of : Bm `intersecting` i == let (_,m',_) = m `splitIntersecting` i in m'O(n)<, since potentially all keys could intersect the interval. O(log n)2 average case, if few keys intersect the interval.8HReturn the submap of key intervals completely inside the given interval.O(n)<, since potentially all keys could be inside the interval. O(log n)3 average case, if few keys are inside the interval.9O(log n)k. Insert a new key/value pair. If the map already contains the key, its value is changed to the new value.:O(log n)>. Insert with a function, combining new value and old value. : f key value mp* will insert the pair (key, value) into mp^ if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value).;O(log n)C. Insert with a function, combining key, new value and old value. ; f key value mp* will insert the pair (key, value) into mp^ if key does not exist in the map. If the key does exist, the function will insert the pair  (key, f key new_value old_value);. Note that the key passed to f is the same key passed to ;.<O(log n)+. Combine insert with old values retrieval.=O(log n)<. Returns the smallest key and its associated value. Calls  if the map is empty.>O(log n);. Returns the largest key and its associated value. Calls  if the map is empty.?Returns the key with the largest endpoint and its associated value. If there is more than one key with that endpoint, return the rightmost.O(n)0, since all keys could have the same endpoint. O(log n) average case.@O(log n)Q. Remove the smallest key from the map. Return the empty map if the map is empty.AO(log n)P. Remove the largest key from the map. Return the empty map if the map is empty.BO(log n)%. Delete and return the smallest key.CO(log n)$. Delete and return the largest key.DO(log n)(. Update or delete value at minimum key.EO(log n)(. Update or delete value at maximum key.FO(log n)(. Update or delete value at minimum key.GO(log n)(. Update or delete value at maximum key.HO(log n)_. Retrieves the minimal (key,value) pair of the map, and the map stripped of that element, or  if passed an empty map. minViewWithKey (fromList [([5,6],"a"), ([3,4],"b")]) == Just (([3,4],"b"), singleton [5,6] "a") minViewWithKey empty == NothingIO(log n)_. Retrieves the maximal (key,value) pair of the map, and the map stripped of that element, or  if passed an empty map.JO(log n)h. Retrieves the value associated with minimal key of the map, and the map stripped of that element, or  if passed an empty map.KO(log n)h. Retrieves the value associated with maximal key of the map, and the map stripped of that element, or  if passed an empty map.LO(n)[. Fold the values in the map using the given right-associative binary operator, such that L f z ==   f z . n.O(n). A strict version of L. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.MO(n)Z. Fold the values in the map using the given left-associative binary operator, such that M f z ==   f z . n.O(n). A strict version of M. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.NO(n)e. Fold the keys and values in the map using the given right-associative binary operator, such that N f z ==   ( f) z . d.O(n). A strict version of N. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.OO(n)d. Fold the keys and values in the map using the given left-associative binary operator, such that O f z ==   (\z' (kx, x) -> f z' kx x) z . d.O(n). A strict version of O. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.P O(n log n):. Build a new map by combining successive key/value pairs.QO(n)D. Build a new map by combining successive key/value pairs. Same as PU, but works only when the combining functions returns strictly monotonic key values.RO(log n)\. Delete a key from the map. If the map does not contain the key, it is returned unchanged.SO(log n). Update a value at a specific key with the result of the provided function. When the key is not a member of the map, the original map is returned.TO(log n)k. Adjust a value at a specific key. When the key is not a member of the map, the original map is returned.UO(log n). The expression (U f k map) updates the value x at k (if it is in the map). If (f x) is %, the element is deleted. If it is ( y ), the key k is bound to the new value y.VO(log n). The expression (V f k map) updates the value x at k (if it is in the map). If (f k x) is %, the element is deleted. If it is ( y ), the key k is bound to the new value y.WO(log n). Lookup and update. See also Vu. The function returns changed value, if it is updated. Returns the original key value if the map entry is deleted.XO(log n). The expression (X f k map) alters the value x at k, or absence thereof. X7 can be used to insert, delete, or update a value in a Map. In short : 4 k (X f k m) = f (4 k m).YO(n+m). The expression (Y t1 t2!) takes the left-biased union of t1 and t2. It prefers t1- when duplicate keys are encountered, i.e. (Y == Z ).ZO(n+m)". Union with a combining function.[O(n+m)". Union with a combining function.\!The union of a list of maps: (\ ==   Y +).]=The union of a list of maps, with a combining operation: (] f ==   (Z f) +).^O(n+m)\. Difference of two maps. Return elements of the first map not existing in the second map._O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the values of these keys. If it returns D, the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y. `O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the key and both values. If it returns D, the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y. aO(n+m)`. Intersection of two maps. Return data in the first map for the keys existing in both maps. (a m1 m2 == b  m1 m2).bO(n+m)). Intersection with a combining function.cO(n+m)). Intersection with a combining function.dO(n)S. The list of all key/value pairs contained in the map, in ascending order of keys.eO(n)O. The list of all key/value pairs contained in the map, in no particular order.fO(n)T. The list of all key/value pairs contained in the map, in descending order of keys.g O(n log n)7. Build a map from a list of key/value pairs. See also jf. If the list contains more than one value for the same key, the last value for the key is retained.h O(n log n)Q. Build a map from a list of key/value pairs with a combining function. See also k.i O(n log n)Q. Build a map from a list of key/value pairs with a combining function. See also k.jO(n)6. Build a map from an ascending list in linear time. :The precondition (input list is ascending) is not checked.kO(n)_. Build a map from an ascending list in linear time with a combining function for equal keys. :The precondition (input list is ascending) is not checked.lO(n)_. Build a map from an ascending list in linear time with a combining function for equal keys. :The precondition (input list is ascending) is not checked.mO(n)U. Build a map from an ascending list of elements with distinct keys in linear time.  The precondition is not checked.nO(n)B. List of all values in the map, in ascending order of their keys.oO(n)2. List of all keys in the map, in ascending order.pO(n). Set of the keys.qSame as d.rO(n),. Map a function over all values in the map.sO(n),. Map a function over all values in the map.tO(n). The function tN threads an accumulating argument through the map in ascending order of keys.uO(n). The function uN threads an accumulating argument through the map in ascending order of keys.vO(n). The function vO threads an accumulating argument through the map in descending order of keys.w O(n log n). w f s! is the map obtained by applying f to each key of s.)The size of the result may be smaller if fy maps two or more distinct keys to the same new key. In this case the value at the smallest of these keys is retained.x O(n log n). x c f s! is the map obtained by applying f to each key of s.)The size of the result may be smaller if fr maps two or more distinct keys to the same new key. In this case the associated values will be combined using c.yO(n). y f s == w f s, but works only when f2 is strictly monotonic. That is, for any values x and y, if x < y then f x < f y.  The precondition is not checked.zO(n)'. Filter values satisfying a predicate.{O(n),. Filter keys/values satisfying a predicate.|O(n). Partition the map according to a predicate. The first map contains all elements that satisfy the predicate, the second all elements that fail the predicate. See also .}O(n). Partition the map according to a predicate. The first map contains all elements that satisfy the predicate, the second all elements that fail the predicate. See also .~O(n). Map values and collect the  results.O(n)". Map keys/values and collect the  results.O(n). Map values and separate the  and  results.O(n)#. Map keys/values and separate the  and  results.O(n). The expression ( k map ) is a pair  (map1,map2) where the keys in map1 are smaller than k and the keys in map2 larger than k. Any key equal to k is found in neither map1 nor map2.O(n). The expression ( k map) splits a map just like  but also returns 4 k map.O(n). Split around a point. Splits the map into three submaps: intervals below the point, intervals containing the point, and intervals above the point.O(n). Split around an interval. Splits the set into three subsets: intervals below the given interval, intervals intersecting the given interval, and intervals above the given interval.O(n+m). This function is defined as ( =  (==)).O(n+m). The expression ( f t1 t2 ) returns  if all keys in t1 are in tree t2, and f returns * when applied to their respective values.O(n+m)G. Is this a proper submap? (ie. a submap but not equal). Defined as ( =  (==)).O(n+m)J. Is this a proper submap? (ie. a submap but not equal). The expression ( f m1 m2 ) returns  when m1 and m2 are not equal, all keys in m1 are in m2 , and when f returns * when applied to their respective values.^Check red-black-tree and interval search augmentation invariants. For testing/debugging only.     ()* +,-./0123456789:;<!"=>?#$%@&'()ABCDEFGHIJK*+LMNOPQ,R-.STUVWXYZ[\]^_`abc/01d2efghijkl3m45nopqrstuvwxyz{|}~6789:;<=>?@A~ !"#$%()*+,-./0123456789:;<!"=>?@ABCDEFGHIJK*+LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ()* +,-./0123456789:;<!"=>?#$%@&'()ABCDEFGHIJK*+LMNOPQ,R-.STUVWXYZ[\]^_`abc/01d2efghijkl3m45nopqrstuvwxyz{|}~6789:;<=>?@A) * (c) Christoph Breitkopf 2014 BSD-stylechbreitkopf@gmail.com experimentalnon-portable (MPTC with FD)Safep !"#$%()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~p !"#$%()*-.2345678+,9:;<RSTUVWXYZ[\]^_`abcrstuvwxyLMNOPQnopqeghidfjklmz{|}~=>?@ABCDEFGJKHI/01(c) Christoph Breitkopf 2014 BSD-stylechbreitkopf@gmail.com experimentalnon-portable (MPTC with FD)Safe'O(1). A map with one entry.O(log n). The expression ( def k map) returns the value at key k or returns default value def! when the key is not in the map. ufindWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x' findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'O(log n)k. Insert a new key/value pair. If the map already contains the key, its value is changed to the new value.O(log n)>. Insert with a function, combining new value and old value.  f key value mp* will insert the pair (key, value) into mp^ if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value).O(log n)C. Insert with a function, combining key, new value and old value.  f key value mp* will insert the pair (key, value) into mp^ if key does not exist in the map. If the key does exist, the function will insert the pair  (key, f key new_value old_value);. Note that the key passed to f is the same key passed to .O(log n)+. Combine insert with old values retrieval.O(log n). Update a value at a specific key with the result of the provided function. When the key is not a member of the map, the original map is returned.O(log n)k. Adjust a value at a specific key. When the key is not a member of the map, the original map is returned.O(log n)(. Update or delete value at minimum key.O(log n)(. Update or delete value at maximum key.O(log n)(. Update or delete value at minimum key.O(log n)(. Update or delete value at maximum key. O(n log n)7. Build a map from a list of key/value pairs. See also f. If the list contains more than one value for the same key, the last value for the key is retained. O(n log n)Q. Build a map from a list of key/value pairs with a combining function. See also . O(n log n)Q. Build a map from a list of key/value pairs with a combining function. See also .O(n)6. Build a map from an ascending list in linear time. :The precondition (input list is ascending) is not checked.O(n)_. Build a map from an ascending list in linear time with a combining function for equal keys. :The precondition (input list is ascending) is not checked.O(n)_. Build a map from an ascending list in linear time with a combining function for equal keys. :The precondition (input list is ascending) is not checked.O(n),. Map a function over all values in the map.O(n),. Map a function over all values in the map.O(n). The function N threads an accumulating argument through the map in ascending order of keys. let f a b = (a ++ b, b ++ "X") mapAccum f "Everything: " (fromList [(5,"a"), (3,"b")]) == ("Everything: ba", fromList [(3, "bX"), (5, "aX")])O(n). The function N threads an accumulating argument through the map in ascending order of keys. let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X") mapAccumWithKey f "Everything:" (fromList [(5,"a"), (3,"b")]) == ("Everything: 3-b 5-a", fromList [(3, "bX"), (5, "aX")])O(n). The function O threads an accumulating argument through the map in descending order of keys.O(n). Map values and collect the  results.O(n)". Map keys/values and collect the  results.O(n). Map values and separate the  and  results.O(n)#. Map keys/values and separate the  and  results.O(log n). The expression ( f k map) alters the value x at k, or absence thereof. 7 can be used to insert, delete, or update a value in a Map. In short : 4 k ( f k m) = f (4 k m). O(n log n).  c f s! is the map obtained by applying f to each key of s.)The size of the result may be smaller if fr maps two or more distinct keys to the same new key. In this case the associated values will be combined using c.O(log n). The expression ( f k map) updates the value x at k (if it is in the map). If (f x) is %, the element is deleted. If it is ( y ), the key k is bound to the new value y.O(log n). The expression ( f k map) updates the value x at k (if it is in the map). If (f k x) is %, the element is deleted. If it is ( y ), the key k is bound to the new value y.O(log n). Lookup and update. See also u. The function returns changed value, if it is updated. Returns the original key value if the map entry is deleted.O(n+m)". Union with a combining function.O(n+m)". Union with a combining function.=The union of a list of maps, with a combining operation: ( f ==   ( f) +).O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the values of these keys. If it returns D, the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y. O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the key and both values. If it returns D, the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y. O(n+m)). Intersection with a combining function.O(n+m)). Intersection with a combining function.+BCDEp !"#$%()*+-./01234678=>?@ABCHIJKLMNOPQRY\^adefmnopqwyz{|}p !"#$%()*-.234678+RY\^awyLMNOPQnopqedfmz{|}=>?@ABCJKHI/01+BCDE(c) Christoph Breitkopf 2015 BSD-stylechbreitkopf@gmail.com experimentalnon-portable (MPTC with FD)Safe3455A set of intervals of type k.FThe Color of a tree node.Same as .O(1). The empty set.O(1). A set with one entry.O(1). Is the set empty?O(n). Number of keys in the set.Caution: unlike  , this takes linear time!O(log n)1. Does the set contain the given value? See also .O(log n)5. Does the set not contain the given value? See also .hReturn the set of all intervals containing the given point. This is the second element of the value of : 8set `containing` p == let (_,s,_) = set `splitAt` p in sO(n)<, since potentially all intervals could contain the point. O(log n)X average case. This is also the worst case for sets containing no overlapping intervals.|Return the set of all intervals overlapping (intersecting) the given interval. This is the second element of the result of : Dset `intersecting` i == let (_,s,_) = set `splitIntersecting` i in sO(n)>, since potentially all values could intersect the interval. O(log n)4 average case, if few values intersect the interval.OReturn the set of all intervals which are completely inside the given interval.O(n)>, since potentially all values could be inside the interval. O(log n)3 average case, if few keys are inside the interval.O(log n)r. Insert a new value. If the set already contains an element equal to the value, it is replaced by the new value.O(log n)'. Returns the minimal value in the set.O(log n)'. Returns the maximal value in the set.~Returns the interval with the largest endpoint. If there is more than one interval with that endpoint, return the rightmost.O(n)5, since all intervals could have the same endpoint. O(log n) average case.O(log n)U. Remove the smallest element from the set. Return the empty set if the set is empty.O(log n)T. Remove the largest element from the set. Return the empty set if the set is empty.O(log n)). Delete and return the smallest element.O(log n)(. Delete and return the largest element.O(log n)V. Retrieves the minimal element of the set, and the set stripped of that element, or  if passed an empty set.O(log n)V. Retrieves the maximal element of the set, and the set stripped of that element, or  if passed an empty set.O(n)[. Fold the values in the set using the given right-associative binary operator, such that  f z ==   f z . .O(n). A strict version of . Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.O(n)Z. Fold the values in the set using the given left-associative binary operator, such that  f z ==   f z . .O(n). A strict version of . Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.O(log n)c. Delete an element from the set. If the set does not contain the value, it is returned unchanged.O(n+m). The expression ( t1 t2!) takes the left-biased union of t1 and t2. It prefers t1) when duplicate elements are encountered.!The union of a list of sets: ( ==    ).O(n+m)[. Difference of two sets. Return elements of the first set not existing in the second set.O(n+m)^. Intersection of two sets. Return elements in the first set also existing in the second set.O(n)B. The list of all values contained in the set, in ascending order.O(n)<. The list of all values in the set, in no particular order.O(n)9. The list of all values in the set, in descending order. O(n log n)0. Build a set from a list of elements. See also E. If the list contains duplicate values, the last value is retained.O(n)6. Build a set from an ascending list in linear time. :The precondition (input list is ascending) is not checked.O(n)K. Build a set from an ascending list of distinct elements in linear time.  The precondition is not checked.O(n)4. List of all values in the set, in ascending order. O(n log n),. Map a function over all values in the set.)The size of the result may be smaller if f7 maps two or more distinct elements to the same value.O(n).  f s ==  f s, but works only when f2 is strictly monotonic. That is, for any values x and y, if x < y then f x < f y.  The precondition is not checked.O(n)'. Filter values satisfying a predicate.O(n). Partition the set according to a predicate. The first set contains all elements that satisfy the predicate, the second all elements that fail the predicate. See also .O(n). The expression ( k set ) is a pair  (set1,set2) where the elements in set1 are smaller than k and the elements in set2 larger than k. Any key equal to k is found in neither set1 nor set2.O(n). The expression ( k set) splits a set just like  but also returns  k set.O(n). Split around a point. Splits the set into three subsets: intervals below the point, intervals containing the point, and intervals above the point.O(n). Split around an interval. Splits the set into three subsets: intervals below the given interval, intervals intersecting the given interval, and intervals above the given interval.O(n+m)S. Is the first set a subset of the second set? This is always true for equal sets.O(n+m)U. Is the first set a proper subset of the second set? (i.e. a subset but not equal). O(n log n)1. Build a new set by combining successive values.O(n);. Build a new set by combining successive values. Same as Q, but works only when the combining functions returns strictly monotonic values.G3The height of the tree. For testing/debugging only.HcThe maximum height of a red-black tree with the given number of nodes. For testing/debugging only.^Check red-black-tree and interval search augmentation invariants. For testing/debugging only.iIJKLMNOPQRSTUFVWXYZ[\]^_`abcdefghijklmnopqrsGHtuvwxyzA !"#$%A !"#$%\IJKLMNOPQRSTUFVWXYZ[\]^_`abcdefghijklmnopqrsGHtuvwxyz (c) Christoph Breitkopf 2011 BSD-stylechbreitkopf@gmail.com experimentalportableSafeO(n)". Join overlapping intervals with . ]flattenWith (+) (fromList [([1,3],5), ([4,6],2), ([5,8],9)]) == mkMap [([1,3],5), ([4,8],11)]g )*+./0123678=>?@ABCHIJKNORY\^adefmnopqwy{|}g )*.23678+RY\^awyNOnopqedfm{|}=>?@ABCJKHI/01(c) Christoph Breitkopf 2011 BSD-stylechbreitkopf@gmail.com experimentalportableSafeO(n)". Join overlapping intervals with . ]flattenWith (+) (fromList [([1,3],5), ([4,6],2), ([5,8],9)]) == mkMap [([1,3],5), ([4,8],11)]g )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNORSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g )*-.2345678+,9:;<RSTUVWXYZ[\]^_`abcrstuvwxyLMNOnopqeghidfjklmz{|}~=>?@ABCDEFGJKHI/01(c) Christoph Breitkopf 2011 BSD-stylechbreitkopf@gmail.com experimentalportableSafe Deprecated. As of version 0.3, replaced by .O(log n) . Same as :^, but the combining function is applied strictly. This is often the most desirable behavior.!For example, to update a counter: insertWith' (+) k 1 m Deprecated. As of version 0.3, replaced by .O(log n) . Same as ;2, but the combining function is applied strictly. Deprecated.! As of version 0.3, replaced by .O(log n). A strict version of <. Deprecated. As of version 0.5, replaced by L.O(n)s. Fold the values in the map using the given right-associative binary operator. This function is an equivalent of L( and is present for compatibility only. Deprecated. As of version 0.3, replaced by N.O(n)|. Fold the keys and values in the map using the given right-associative binary operator. This function is an equivalent of N( and is present for compatibility only.l )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNORSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{  !"#$%&'()*!"%&$#()' +, - . / 0 1  2 3 4 5 6  7 8 9 : ; < = > ? @ A B C D E F G H I J K L M  N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q  r s t u v w x  y z { | } ~  17;<=>STFGHIghijklrstu|}~XwUVWZ[]_`bc/01 5689:;?@ABCDELM RY\^adefgjmnzPQ-P-P                     23Inter_65Koh4dltr8FfiVwhKeTUWData.IntervalMap.StrictData.IntervalMap.Interval!Data.IntervalMap.Generic.IntervalData.IntervalMap.Generic.LazyData.IntervalMap.Generic.StrictData.IntervalSetData.IntervalMap.LazyData.IntervalMapData.IntervalMap.Generic.BaseData.MapsizePreludefoldrfoldlData.SetbaseGHC.ListfilterGHC.Basemap Data.FoldablenulllookupInterval IntervalCOClosedInterval OpenInterval IntervalOCcompareByUpper lowerBound upperBoundisEmpty leftClosed rightClosedoverlapssubsumesbeforeafterinsidebelowabovecombine genericEqualsgenericCompare IntervalMap!\\empty singletonheight maxHeight showStatsmember notMemberfindWithDefault containing intersectingwithininsert insertWith insertWithKeyinsertLookupWithKeyfindMinfindMaxfindLast deleteMin deleteMax deleteFindMin deleteFindMax updateMin updateMaxupdateMinWithKeyupdateMaxWithKeyminViewWithKeymaxViewWithKeyminViewmaxView foldrWithKey foldlWithKey flattenWithflattenWithMonotonicdeleteadjust adjustWithKeyupdate updateWithKeyupdateLookupWithKeyalterunion unionWith unionWithKeyunions unionsWith differencedifferenceWithdifferenceWithKey intersectionintersectionWithintersectionWithKey toAscListtoList toDescListfromList fromListWithfromListWithKey fromAscListfromAscListWithfromAscListWithKeyfromDistinctAscListelemskeyskeysSetassocs mapWithKeymapAccummapAccumWithKeymapAccumRWithKeymapKeys mapKeysWithmapKeysMonotonic filterWithKey partitionpartitionWithKeymapMaybemapMaybeWithKey mapEithermapEitherWithKeysplit splitLookupsplitAtsplitIntersecting isSubmapOf isSubmapOfByisProperSubmapOfisProperSubmapOfByvalid IntervalSetNilNodefoldr'foldl' mapMonotonic splitMember isSubsetOfisProperSubsetOf insertWith'insertWithKey'insertLookupWithKey'fold foldWithKeyGHC.ReadReadGHC.ShowShowghc-prim GHC.ClassescomparecompareLcompareUcombineOverlapping$fNFDataInterval$fFunctorInterval $fOrdInterval$fReadInterval$fShowInterval$fIntervalIntervalaGHC.ErrerrorJustNothing Data.Tupleuncurry foldrWithKey' foldlWithKey'const Data.EitherLeftRight GHC.TypesTrueUnionUEmptyUConsUAppendT2 DeleteResult'U'S' DeleteResultUSColorRBisRed turnBlackturnRedmNodemaxUpper maxByUpperbalanceLbalanceRunwrapunwrap'annotate deleteMin' deleteMax' unbalancedR unbalancedL setMinValue setMaxValuecombineSuccessivedelete'blackify ascListUnionascListDifferenceascListIntersection toAscList' combineEq isPerfectlog2mkUnion fromUnion ascListSubset$fShowIntervalMap$fReadIntervalMap$fNFDataIntervalMap$fFoldableIntervalMap$fTraversableIntervalMap$fMonoidIntervalMap$fFunctorIntervalMap$fOrdIntervalMap$fEqIntervalMapuniq$fShowIntervalSet$fReadIntervalSet$fNFDataIntervalSet$fFoldableIntervalSet$fMonoidIntervalSet$fOrdIntervalSet$fEqIntervalSet