śĪzĘ\ļ’A      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ ˆ ‰ Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ® Æ ° ± ² ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł śūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@NoneFWorkaround for slice-wise currined filling functions inlining issues.  See comment to  for details. AAANoneBBNone  !"  !"  !"NoneCDEFGHIJCDEFGHIJNone*#$K%&'L()*+M,-./0N123456O789:;<=P>?@ABCDEQ1RS#$TU%&'VW()*+XY,-./0Z[123456\]789:;<=^_>?@ABCDE*#$K%&'L()*+M,-./0N123456O789:;<=P>?@ABCDEQNoneGWell-known missed in Data.List.Split function. F$Number of chunks to split range on (n) Start of range  End of range Split index function GList to split Number of chuncks (n) Exactly n! even chunks of the initial list FGFGFGNoneHGeneralizes right folds. &To be passed to fold combinators from Data.Yarr.Walk module. IGeneralizes left folds. &To be passed to fold combinators from Data.Yarr.Walk module. J9Generalizes both partially applied left and right folds, & as well as walks with mutable state. "To be passed to walk runners from Data.Yarr.Walk module. K<Alias to frequently used get-write-from-to arguments combo. %To be passed as 1st parameter of all  ing functions  from Data.Yarr.Eval module. LCurried version of J. Identical to M , indeed. MAbstracts interval works: Ks, Ls. To be passed to functions from Data.Yarr.Utils.Fork module  or called directly. HGeneralized right reduce Curried result stateful walk IGeneralized left reduce Curried result stateful walk JInitial state Indexing function #Curried result function -- walker,  emits final state KIndexing function Writing function "Curried result function -- worker L7Lower bound (start for left walks, end for right ones) Upper bound (end or start) Result M Lower bound  Upper bound Result HIJKLMHIJKLMNoneO Version of N which discards results. N)Number of threads to parallelize work on !Per-thread work producer, passed  thread number  [0..threads-1] Results O)Number of threads to parallelize work on !Per-thread work producer, passed  thread number  [0..threads-1] NONONONone`aPQRSTUVWXYZ[bcˆdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ ŒŽ  !"RS#$TU%&'VW()*+XY,-./0Z[123456\]789:;<=^_>?@ABCDEPQRSTUVWXYZ[A TUVWXYZ[ !"PQRS$#'&%+*)(0/.-,654321=<;:987EDCBA@?>`aPQRSTUVWXYZ[bcNone \2GHC simplifier tends to float numeric comparsions > as high in execution graph as possible, which in conjunction = with loop unrolling sometimes leads to dramatic code bloat. I' m not sure -M functions work at all, < but strict versions defenitely keep comparsions unfloated. ]Maybe sequential . ^Definetely sequential . _Maybe sequential ‘. `Definetely sequential ‘. aMaybe sequential clamp. bDefinetely sequential clamp. c9Mainly used to fight against GHC simplifier, which gives C no chance to LLVM to perform Global Value Numbering optimization.  Copied from repa, see   [http://hackage.haskell.org/packages/archive/repa/3.2.3.1/doc/html/Data-Array-Repa-Eval.html d4The function intented to be passed as 3rd parameter  to  unrolled- functions in  class  and . 8If your loading operation is strictly local by elements  (in most cases), use e instead of this function. e Alias to (\_ -> return ()). \]^_`a Min bound  Max bound Value to clamp Value in bounds b Min bound  Max bound Value to clamp Value in bounds cde’“”•–—˜™š›œžŸ ”¢£¤ \]^_`abcde cde\]^_`ab\]^_`abcde’“”•–—˜™š›œžŸ ”¢£¤None„¦§Ø©Ŗ„¦§Ø©Ŗ„¦§Ø©ŖNone««NonemFor internal use. TODO: implement for f and merge with p class p9Class for column-major, regular composite array indices. q0, (0, 0),  (0, 0, 0) rh size is ¬, size (3, 5) == 15 t  (1, 2, 3) `plus` (0, 0, 1) == (1, 2, 4)u (1, 2) `minus` (1, 0) == (0, 2)v  offset == ­ uw=Converts linear, memory index of shaped array to shape index  without bound checks. fromLinear (3, 4) 5 == (1, 1)x Opposite to w!, converts composite array index  to linear, "memory" index without bounds checks. ¬ for h shapes. toLinear (5, 5) (3, 0) == 15y4Component-wise minimum, returns maximum legal index  for all given array extents z Component-wise maximum, used in Data.Yarr.Convolution implementation. &Standard left fold wothout unrolling. *This one and 5 following functions shouldn't be called directly, 2 they are intented to be passed as first argument  to   and functions from  Data.Yarr.Work module. 3Standard right folding function without unrolling. ƒ!Standard fill without unrolling. + To avoid premature optimization just type fill  each time you want to   array  to manifest representation. …Mainly for internal use. 5 Abstracts top-left -- bottom-right pair of indices. †,2D-unrolled filling to maximize profit from  "Global value numbering" LLVM optimization.  Example: blurred <-    ( ! (dim2BlockFill   d)) delayedBlurred(fghijklmno Outer block  Inner block  Shavings pqrstuvwExtent of array  Linear index  Shape index xExtent of array  Shape index  Linear index ySeveral array extents Maximum common shape index z{|}~€Unroll factor d or e Result curried function # to be passed to working functions ‚Unroll factor d or e Result curried function # to be passed to working functions ƒ„Unroll factor d or e Result curried function # to by passed to loading functions …†Block size by x. Use  - " values. Block size by y d or e Result curried function & to be passed to loading functions. ®Æ°±²³“*HIJKLMcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†*MLKJIH…pqrstuvwxyz{|}~€‚ƒ„mnoijklhgf†cdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†®Æ°±²³“ None‡&Number of threads to fork the work on  Lower bound  Upper bound Per-slice interval works Producer of per-thread work, . which returns piece of result for each slice ˆ&Number of threads to fork the work on *(lower bound, upper bound) for each slice Per-slice interval works Producer of per-thread work, 9 which returns pieces of results: [(slice number, result)] ‰&Number of threads to fork the work on  Lower bound  Upper bound Interval work Producer of per-thread work ‡ˆ‰‡ˆ‰‡ˆ‰NoneŠ9Type level fixation of preferred work (load, fold, etc.) $ index type of the array load type.  Parameters:  l - load type index  sh - shape of arrays  i - preferred work index, Int or sh itself ‹+Internal implementation class. Generalizes linear- and simple " indexing and writing function in ™ and • classes. %Class for mutable arrays of vectors.  The class doesn'.t need to define functions, it just gathers it's dependencies. Counterpart for "simple" arrays: •. ‘)Class for arrays which could be created. C It combines a pair of representations: freezed and mutable (raw). 6 This segregation is lifted from Boxed representation 9 and, in the final, from GHC system of primitive arrays.  Parameters:  r! - freezed array representation.  mr% - mutable, raw array representation  l4 - load type index, common for both representations  sh - shape of arrays  a - element type ’O(1)7 Creates and returns mutable array of the given shape. “O(1)A Freezes mutable array and returns array which could be indexed. ”O(1)2 Thaws freezed array and returns mutable version. •Class for mutable arrays. Just like for ™, it's function are unsafe  and require calling ” after the last call. Minimum complete defenition: – or —. #Counterpart for arrays of vectors:  – Shape, genuine monadic writing. Default implementation:  #write tarr sh = linearWrite tarr $ x (  tarr) sh —AFast (usually), linear indexing. Intented to be used internally. Default implementation:  "linearWrite tarr i = write tarr $ w (  tarr) i ˜4Class for arrays of vectors which could be indexed.  The class doesn'.t need to define functions, it just gathers it's dependencies. Counterpart for "simple" arrays: ™. ™)Class for arrays which could be indexed. It's functions are unsafe: you must call ” after the last call. ? Fortunately, you will hardly ever need to call them manually. Minimum complete defenition: š or ›. #Counterpart for arrays of vectors: ˜ š!Shape, genuine monadic indexing. In Yarr arrays are always Y(-indexed and multidimensionally square.  Maximum index is  (extent arr). Default implementation:  !index arr sh = linearIndex arr $ x (  arr) sh ›" Surrogate" linear index.  For h arrays index == linearIndex. Default implementation:   linearIndex arr i = index arr $ w (  arr) i œClass for arrays of vectors.  Paramenters:  r - (entire) representation. , Associated array type for this class is Ÿ r sh (v e).  slr - slice representation  l - load type  sh - shape  v - vector type  e - vector (not array) element type. ) Array element type is entire vector: (v e). Counterpart for "simple" arrays: ž. O(1)' Array of vectors -> vector of arrays. & Think about this function as shallow "# from Prelude.  Slices are views of an underlying array.  Example:   let css = slices coords  xs = css | 0  ys = css | 1 žThis class generalizes ™ and •.  Paramenters:  r - representation,  l - load type,  sh - shape,  a - element type. #Counterpart for arrays of vectors: œ.  !Returns the extent an the array. ”(Calling this function on foreign array ($) $ ensures it is still alive (GC haven't picked it). < In other manifest representations, the function defined as  return ().  ”+ is lifted to top level in class hierarchy E because in fact foreign representation is the heart of the library. ¢O(1) Ensures that array "and all it's real manifest sources  are fully evaluated. : This function is not for people, it is for GHC compiler. Default implementation: force arr = arr `deepseq` return () Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢µ¶·" pŠ‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢"žŸ ”¢œp  ™š›˜•–—‘’“”Š‹ŒŽ Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢µ¶· None£General shape load type index. Ÿs with £ load type index  specialize š and – and leave › and —  functions defined by default. Type-level distinction between ¤ inear and £ aped arrays > is aimed to avoid integral division operations while looping  through composite (g, f ) indices. CIntegral division is very expensive operation even on modern CPUs. ¤Linear load type index. Ÿs with ¤ load type index  define › and — and leave š and –  functions defined by default. „This class extends Ø just like « extends ®. 8 It abstracts slice-wise loading from one array type to  another in specified range. ¦O(n)E Loads vectors from source to target in specified range, slice-wise,  in parallel. §O(n): Sequentially loads vector elements from source to target % in specified range, slice by slice. ØClass abstracts separated in time and space loading  of one array type . to another. Result of running functions with -Slices- infix  is always identical2 to result of running corresponding function from  ® class. Ø and „ are just about performance. + If target representation is separate (ex. (% $)),  using © may be faster than ° because of per-thread memory  locality.  Parameters:   r - source representation  slr - source slice representation  l - source load type  tr - target representation  tslr - target slice representation  tl - target load type  sh - shape of arrays  v - source vector type  v2 - target vector type  e< - vector element type, common for source and target arrays ©O(n); Entirely, slice-wise loads vectors from source to target  in parallel.  Example:  ? -- blurred and delayedBlurred are arrays of color components.  loadSlicesP ƒ ³ delayedBlurred blurred ŖO(n)C Sequentially loads vectors from source to target, slice by slice. «8Class abstracts pair of arrays which could be loaded in " just specified range of indices. "Range" is a multidimensional  segment: segment for h arrays, square for g arrays and  cube for f,. Thus, it is specified by pair of indices:  "top-left" (minimum is q) and " bottom-right" (maximum is  (ø arr tarr) ) corners. ¬O(n)9 Loads elements from source to target in specified range  in parallel.  Example:   let ext = extent convolved  res < - new ext  rangeLoadP ƒ ³ convolved res (5, 5) (ext `minus` (5, 5)) ­O(n)G Sequentially loads elements from source to target in specified range. ®*This class abstracts pair of array types, ' which could be loaded one to another.  Parameters:  r& - source representation. Instance of ™ class. 2 Typically one of fused representations:  &, (% &) or  '(.  l - source load type  tr& - target representation. Instance of • class.  tl - target load type  sh - shape of arrays  a - array element type #Counterpart for arrays of vectors: Ø. TODO:1 this class seems to be overengineered, normally # it should have only 3 parameters:  Load l tl sh.  But Convoluted ('() representation is  tightly connected with it' s load type. ÆUsed in fill parameter function. , There are two options for this type to be: sh itself or Int.  Don't confuse this type with load type indexes: r and l. ( There are 2 different meanings of word "index": data type index 1 (haskell term) and array index (linear, shape). °O(n). Entirely loads source to target in parallel. -First parameter is used to parameterize loop $ unrolling to maximize performance.  Default choice is ƒ" -- vanilla not unrolled looping.  Examples:   tarr <- ’ (  arr)  loadP ƒ ³ arr tarr  loadP (†   d) (“ 2) arr tarr ±O(n) Sequential analog of ° function.  Loads source to target øly.  Example: loadS („  e) ³ arr tarr²(There are 2 common ways to parameterize  parallelism: a) to say "split this work between n threads"  or b) to say "+split this work between maximum reasonable  number of threads" , that is  capabilities. Since  ø* function is monadic, we need always pass  IO Int5 as thread number parameter in order not to multiply B number of functions in this module (there are already too many). ³ Alias to ø. “ Alias to ¹. µO(n)9 This function simplifies the most common way of loading  arrays.  Instead of    mTarget <- ’ (extent source)  ° ƒ ³ source mTarget  target <- “ mTarget You can write just target < - compute (° ƒ ³) source¶!Most common parallel use case of µ.  dComputeP = µ (° ƒ ³)·#Most common sequential use case of µ.  dComputeS = µ (± ƒ)ø.Determines maximum common range of 2 arrays -  y ion of their  s. (£¤„¦Fill function to work  on slices ,Number of threads to parallelize loading on Source array of vectors Target array of vectors  Top-left *and bottom-right corners of range to load §Fill function to work  on slices Source array of vectors Target array of vectors  Top-left *and bottom-right corners of range to load Ø©Fill function to work  on slices ,Number of threads to parallelize loading on Source array of vectors Target array of vectors ŖFill function to work  on slices Source array of vectors Target array of vectors «¬Filling (real worker) function ,Number of threads to parallelize loading on  Source array  Target array  Top-left *and bottom-right corners of range to load ­Filling (real worker) function  Source array  Target array  Top-left *and bottom-right corners of range to load ®Æ°Filling (real worker) function ,Number of threads to parallelize loading on  Source array  Target array ±Filling (real worker) function  Source array  Target array ²³“µLoading function  Source array !Entirely loaded from the source,  “d manifest target array ¶·øŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖK£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø²³“K®Æ°±«¬­Ø©Ŗ„¦§µ¶·¤£ø£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·øŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖ None¹Like Ė-, this class abstracts the pair array types, & which should be fused one to another 0 on maps and zips which accept index of element 0 (several elements for zips) in array (arrays).  Parameters:  rB - source array representation. Determines result representation.  l - source load type  frB (fused repr) - result (fused) array representation. Result array  isn'3t indeed presented in memory, finally it should be    d or  ed to ‘  representation.  fl - result, "shaped" load type  sh - shape of arrays #All functions are already defined, # using non-injective versions from Ā class. The class doesn't have vector counterpart. ŗO(1)( Pure element mapping with array index. »O(1)% Monadic element mapping with index. ¼O(1)& Pure zipping of 2 arrays with index. ½O(1)) Monadic zipping of 2 arrays with index. ¾O(1)& Pure zipping of 3 arrays with index. æO(1)) Monadic zipping of 3 arrays with index. ĄO(1)8 Generalized pure element zipping with index in arrays.  Zipper function is wrapped in   for injectivity. ĮO(1) Monadic version of Ą function. ĀLike Ō, for mappings/*zippings with array index. Used to define  functions in ¹. Minimum complete defenition: Ä, Ę, Č and Ź. The class doesn't have vector counterpart. ĖPThis class abstracts pair of array types, which could be (preferably should be)  mapped (fused)& one to another. Injective version of Ō class.  Parameters:  rE - source array representation. It determines result representation.  frB (fused repr) - result (fused) array representation. Result array  isn'3t indeed presented in memory, finally it should be    d or  ed to ‘  representation.  l1 - load type, common for source and fused arrays  sh - shape of arrays EAll functions are already defined, using non-injective versions from Ō class. The class doesn't have vector counterpart, it' s role play top-level functions  from Data.Yarr.Repr.Separate module. ĢO(1) Pure element mapping.  Main basic "map" in Yarr. ĶO(1) Monadic element mapping. ĪO(1)7 Zipping 2 arrays of the same type indexes and shapes.  Example:  & let productArr = dzip2 (*) arr1 arr2 ĻO(1) Monadic version of Ī function. ŠO(1)7 Zipping 3 arrays of the same type indexes and shapes. ŃO(1) Monadic version of Š function. ŅO(1)1 Generalized element zipping with pure function.  Zipper function is wrapped in   for injectivity. ÓO(1) Monadic version of Ņ function. Ō&Generalized, non-injective version of Ė. Used internally. Minimum complete defenition: Ö, Ų, Ś and Ü. The class doesn't have vector counterpart, it' s role play top-level functions  from Data.Yarr.Repr.Separate module. %¹ŗIndexed mapping function  Source array Fused result array »!Indexed monadic mapping function  Source array Result fused array ¼Indexed zipping function 1st source array 2nd source array Fused result array ½!Indexed monadic zipping function 1st source array 2nd source array Fused result array ¾Indexed zipping function 1st source array 2nd source array 3rd source array Fused result array æ!Indexed monadic zipping function 1st source array 2nd source array 3rd source array Fused result array Ą#Accepts index in array and returns $ wrapped zipper, which positionally % accepts elements from source arrays ( and emits element for the result array Bunch of source arrays Result fused array ĮMonadic indexed zipper Source arrays Result fused array ĀĆ. ÄÅ. Ę. Ē. Č. É. Ź. ĖĢElement mapper function  Source array  Result array Ķ Monadic element mapper function  Source array  Result array ĪPure element zipper function 1st source array 2nd source array Fused result array Ļ Monadic element zipper function 1st source array 2nd source array  Result array ŠPure element zipper function 1st source array 2nd source array 3rd source array  Result array Ń Monadic element zipper function 1st source array 2nd source array 3rd source array Fused result array ŅWrapped function positionally % accepts elements from source arrays # and emits element for fused array Source arrays  Result array ÓWrapped monadic zipper Source arrays  Result array ŌÕ. Ö×. Ų. Ł. Ś. Ū. Ü. Ģ$¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜ$ŌÕÖ×ŲŁŚŪÜĖĢĶĪĻŠŃŅÓĀĆÄÅĘĒČÉŹ¹ŗ»¼½¾æĄĮ¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜĢ NoneŻIn opposite to Ž.elayed (source) Delayed Target holds abstract writing  function: (sh -> a -> IO ())/. It may be used to perform arbitrarily tricky 4 things, because no one obliges you to indeed write % an element inside wrapped function. ŽEDelayed representation is a wrapper for arbitrary indexing function. Ÿ D ¤ sh a instance holds linear getter ( (Int -> IO a)),  and Ÿ D £ sh a - shaped, "true"  (sh -> IO a) index, respectively. D@elayed arrays are most common recipients for fusion operations. ß3Load type preserving wrapping arbirtary array into Želayed representation. ą4Wrap indexing function into delayed representation.  Use this function carefully, don'!t implement through it something M that has specialized implementation in the library (mapping, zipping, etc). /Suitable to obtain arrays of constant element,  of indices (fromFunction sh ¹), and so on. äWraps (š arr)2 into Delayed representation. Normally you shouldn't need D to use this function. It may be dangerous for performance, because  preferred ®%ing type of source array is ignored. ŻŽßąExtent of array Indexing function  Result array įExtent of array Linear ndexing function  Result array āćäåĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßŸ£¤ŻŽąįāßąįāćäå ŽŻ¤£ąįßäåā毎߹įāćäåĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽß None ę?SEparate meta array representation. Internally SEparate arrays  hold vector of it's slices (so,  is just getter for them). Mostly useful for:  Separate in memory manifest $oreign arrays ("Unboxed" arrays  in vector/repa libraries terms). 0 Element-wise vector array fusion (see group of ļ functions). ē Group of  f-...-Elems-( functions is used internally to define   d-...-Elems- functions. ļO(1)* Injective element-wise fusion (mapping).  Example:    let domainHSVImage =  dmapElems (R (* 360) (* 100) (* 100)) " normedHSVImage  Also, used internally to define ) function. šO(1) Monadic vesion of ļ function. õO(1)@ Generalized element-wise zipping of several arrays of vectors. öO(1)G Generalized monadic element-wise zipping of several arrays of vectors ÷O(1)' Glues several arrays of the same type % into one separate array of vectors. / All source arrays must be of the same extent.  Example: !let separateCoords = fromSlices (R xs ys zs)ųO(depends on mapper function)  Maps slices of separate array "entirely". :This function is useful when operation over slices is not + element-wise (in that case you should use )):  -let blurredImage = unsafeMapSlices blur image'The function is unsafe because it doesn't check that slice mapper 3 translates extents uniformly (though it is pure). łO(0)B Converts separate vector between vector types of the same arity.  Example:   -- floatPairs :: Ÿ (ę $) h (   Float)  let cs :: Ÿ (ę $) h (*+ Float)  cs = convert floatPairs ęē. č. é. ź. ė. ģ. ķ. ī. ļVector of mapper functions Source array of vectors  Fused array š&Elemen-wise vector of monadic mappers Source array of vectors  Result array ń. ņ. ó. ō. õVector of wrapped m-ary element-wise zippers #Vector of source arrays of vectors Fused result array öVector of wrapped m-ary  element-wise monadic zippers #Vector of source arrays of vectors  Result array ÷ų"Slice mapper without restrictions Source separate array Result separate array łćäåęēčéźėģŸąįāęķēčéźėģķīļšńņóōõö÷ųłę÷ųłļšńņóōõöēčéźėģķīęēčéźėģķīļšńņóōõö÷ųłćäåęēčéźėģNoneśO(1) Function from repa. ūO(1)0 Function for in-place zipping vector elements.  Always true:  zipElems f arr == Ņ (  f) ( arr) Example: let Ęs = zipElems (­ ī) coordsüO(1). Maps elements of vectors in array uniformly.  Don't confuse with ļ#, which accepts a vector of mapper  for each slice. %Typical use case -- type conversion:  ' let floatImage :: UArray F Dim2 Float  floatImage = mapElems ļ word8Image żO(1) Monadic version of ü function.  Don't confuse with š.  Example: let domained = mapElemsM (, 0.0 1.0) floatImagežO(1)" Generalized zipping of 2 arrays.  Main basic "zipWith" in Yarr. AAlthough sighature of this function has extremely big predicate,  it is more permissible than Ī$ counterpart, because source arrays  shouldn't be of the same type. Implemented by means of ß$ function (source arrays are simply  delayed before zipping). ’O(1)/ Generalized zipping of 3 arrays, which shouldn't be " of the same representation type. ś"Function to produce result extent  from source extent. .Function to produce elements of result array.  Passed a lookup function  to get elements of the source. Source array itself  Result array ū Unwrapped n-ary zipper function Source array of vectors  Result array ü!Mapper function for all elements Source array of vectors Fused array of vectors ż'Monadic mapper for all vector elements Source array of vectors Fused array of vectors žPure zipping function 1st source array 2nd source array Fused result array ’Pure zipping function 1st source array 2nd source array 3rd source array  Result array )¹ŗ»¼½¾æĄĮĖĢĶĪĻŠŃŅÓŽßęļšńņóōõöśūüżž’)ĖĢĶĪĻŠŃŅÓ¹ŗ»¼½¾æĄĮž’Žßęļšńņóōõöśūüż śūüżž’NoneForeign Slice representation, view slice representation  for oreign arrays. To understand Foreign Slices,  suppose you have standard image array of  Ÿ  g (   Word8) type. It')s layout in memory (with array indices):    r g b | r g b | r g b | ...  (0, 0) (0, 1) (0, 2) ...   " let (VecList [reds, greens, blues]) =  image 0 -- reds, greens, blues :: UArray FS Dim2 Word8 Now blues5 just indexes each third byte on the same underlying  memory block:   ... b | ... b | ... b | ...  (0, 0) (0, 1) (0, 2)... 7Foreign representation is the heart of Yarr framework. !Internally it holds raw pointer (š), which makes indexing # foreign arrays not slower than GHC's built-in primitive arrays,  but without freeze/thaw boilerplate. @Foreign arrays are very permissible, for example you can easily " use them as source and target of  ing operation simultaneously,  achieving old good in-place C-style array modifying:   ! ƒ (Ģ ń arr) arr(Foreign arrays are intented to hold all  types and = vectors of them (because there is a conditional instance of Storalbe  class for s of s too). O(1)+ allocates zero-initialized foreign array. Needed because common ’( function allocates array with garbage.  O(1); Returns pointer to memory block used by the given foreign  array. (May be useful to reuse memory if you don't longer need the given array  in the program:   brandNewData <-    ext (ņ (toForeignPtr arr))  O(1)' Wraps foreign ptr into foreign array. ,The function is unsafe because it simply don' t (and can't) 5 check anything about correctness of produced array. ó  ōõö÷ųłśūüżž’Ÿ¤ąįāķ  ¤  ó  ōõö÷ųłśūüżž’-None                  None O(1)  O(1)  O(1) O(1) O(1) O(1) O(1) O(1) Version of , accepts mutating function ( which additionaly accepts array index. O(1) O(1) O(n) Walk with state,  with non-indexed function (  group of fold combinators, ).  Example: . = walk (  (:)) (return [])O(n) Walk with state,  with indexed function (, , , etc).  Example: res < - iwalk ( (\#s i a -> ...)) foldZero sourceArrayO(n)1 Walk with state, in specified range of indices. O(n)9 Run associative non-indexed stateful walk, in parallel. <Example -- associative image histogram filling in the test:   Fhttps://github.com/leventov/yarr/blob/master/tests/lum-equalization.hs O(n)5 Run associative indexed stateful walk, in parallel. O(n)@ Run associative stateful walk in specified range, in parallel. O(n)- Walk with state, with non-indexed function, & over each slice of array of vectors. O(n)) Walk with state, with indexed function, & over each slice of array of vectors. O(n)1 Walk with state, in specified range of indices, & over each slice of array of vectors. O(n)+ Run associative non-indexed stateful walk / over slices of array of vectors, in parallel. O(n)' Run associative indexed stateful walk / over slices of array of vectors, in parallel.  O(n)3 Run associative stateful walk in specified range, / over slices of array of vectors, in parallel.   or curried € Monadic left reduce "Result stateful walk to be passed  to walk runners   or curried € Pure left reduce "Result stateful walk to be passed  to walk runners   or curried € Pure indexed left reduce "Result stateful walk to be passed  to walk runners  or curried ‚ Monadic right reduce "Result stateful walk to be passed  to walk runners  or curried ‚ Pure right reduce "Result stateful walk to be passed  to walk runners  or curried ‚ Pure indexed right reduce "Result stateful walk to be passed  to walk runners ƒ or curried „.  If mutating is associative,  † is also acceptable. 0(state -> array element -> (state has changed))  -- State mutating function "Result stateful walk to be passed  to walk runners ƒ or curried „.  If mutating is associative,  † is also acceptable.  Indexed state mutating function "Result stateful walk to be passed  to walk runners Stateful walking function #Monadic initial state (fold zero).  Wrap pure state in ¹.  Source array Final state (fold result) Stateful walking function #Monadic initial state (fold zero).  Wrap pure state in ¹.  Source array Final state (fold result) Stateful walking function #Monadic initial state (fold zero).  Wrap pure state in ¹.  Source array  Top-left -and bottom-right corners of range to walk in Final state (fold result) )Number of threads to parallelize walk on &Associative stateful walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function  Source array Gathered state (fold result) )Number of threads to parallelize walk on &Associative stateful walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function  Source array Gathered state (fold result) )Number of threads to parallelize walk on &Associative stateful walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function  Source array  Top-left -and bottom-right corners of range to walk in Gathered state (fold result) %Stateful slice-wise walking function #Monadic initial state (fold zero).  Wrap pure state in ¹. Source array of vectors &Vector of final states (fold results) %Stateful slice-wise walking function #Monadic initial state (fold zero).  Wrap pure state in ¹. Source array of vectors &Vector of final states (fold results) %Stateful slice-wise walking function #Monadic initial state (fold zero).  Wrap pure state in ¹. Source array of vectors  Top-left -and bottom-right corners of range to walk in &Vector of final states (fold results) )Number of threads to parallelize walk on %Stateful slice-wise walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function Source array of vectors %Vector of gathered per slice results )Number of threads to parallelize walk on %Stateful slice-wise walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function Source array of vectors %Vector of gathered per slice results  )Number of threads to parallelize walk on %Stateful slice-wise walking function Monadic zero state.  Wrap pure state in ¹. +Associative monadic state joining function Source array of vectors  Top-left -and bottom-right corners of range to walk in %Vector of gathered per slice results HIJ        JIH    None"Yarr something to stderr. #Yarr something as  message. !"#Ÿ!"#!"# !"#None$Mutable Boxed is a wrapper for . %%%oxed representation is a wrapper for   from  primitive0 package. It may be used to operate with arrays C of variable-lengths or multiconstructor ADTs, for example, lists. For /0$ element types you would better use  $oreign arrays. TODO:/ test this representation at least one time... $% !"#$%&'()*+ Ÿąįāķ$%,-%$$% !"#$%&'()*+'None& ConVolution  0 type is specialized to load convoluted arrays.  It loads . with /% and borders outside the center with  0 separately. JIt is even able to distribute quite expensive border loads evenly between ( available threads while parallel load. +Element-wise Loading convoluted arrays wasn't inlined propely  with unrolled King („, †).  However, with simple ƒ performance was OK. For details see   chttp://stackoverflow.com/questions/14748900/ghc-doesnt-perform-2-stage-partial-application-inlining ALMOST SOLVED:9 you just need to support unrolled filling function with INLINE pragma,  see  :https://github.com/leventov/yarr/blob/master/tests/blur.hs,  ffill function. 'EConvolution fused representation internally keeps 2 element getters:  slow  border get0, which checks every index from applied stencil 5 to lay inside extent of underlying source array.  fast  center get , which doesn't worry about bound checks and . …. (0Retreives fast center get from convoluted array  and wraps it into Želayed array. ;Remember that array indexing in Yarr is always zero-based, C so indices in result array are shifted by top-level corner offset  of given convoluted array. &'(1234567Ÿąįā&'89:;0./( &'(12345671None<=>?@ABC<=>?@ABC2None)Generalized static g stencil. -)Stencil values, packed in nested vectors .Generalized reduce function / Reduce zero 0Generalized static h stencil. 4Generalized reduce function 5 Reduce zero 65QuasiQuoter for producing typical numeric convolving h stencil, 6 which effectively skips unnecessary multiplications.  [dim1St| 1 4 6 4 1 |] Produces  0    (   [\ acc a -> return (acc + a),  \& acc a -> (return $ (acc + (4 * a))),  \& acc a -> (return $ (acc + (6 * a))),  \& acc a -> (return $ (acc + (4 * a))),  \ acc a -> return (acc + a)])  (\ acc a reduce -> reduce acc a)  (return 0) 7 Most useful g stencil producer. Typing    [dim2St| 1 2 1  0 0 0  -1 -2 -1 |]  Results to   )      (   [   [\ acc a -> return (acc + a),  \& acc a -> (return $ (acc + (2 * a))),  \ acc a -> return (acc + a)],     [\ acc _ -> return acc,  \ acc _ -> return acc,  \ acc _ -> return acc],     [\ acc a -> return (acc - a),  \' acc a -> (return $ (acc + (-2 * a))),  \ acc a -> return (acc - a)]])  (\ acc a reduce -> reducej acc a)  (return 0) 8Curried version of 9 3 with border get clamping indices out of bounds to  0 or (  source). 9 Convolves h array with static stencil. :Clamps g7 index out of bounds to the nearest one inside bounds. ; Defined as  #dConvolveShDim2WithStaticStencil = < :  Example:  let gradientX = - dConvolveLinearDim2WithStaticStencil  [7 | -1 0 1  -2 0 2  -1 0 1 |]  image < Convolves g array with £$aped load type with static stencil. = Analog of ;  to convolve arrays with ¤inear load index. > Analog of <  to convolve arrays with ¤inear load index. D)*+,-./0123456E7FG8Convolution stencil  Source array Fused convolved result array 9)(Source array -> Extent of this array -> 2 Index (may be out of bounds) -> Result value): 2 Border index (to treat indices near to bounds) Convolution stencil  Source array Fused convolved result array :;Convolution stencil  Source array Fused convolved result array <)(Source array -> Extent of this array -> 2 Index (may be out of bounds) -> Result value): 2 Border index (to treat indices near to bounds) Convolution stencil  Source array Fused convolved result array =Convolution stencil  Source array Fused convolved result array >)(Source array -> Extent of this array -> 2 Index (may be out of bounds) -> Result value): 2 Border index (to treat indices near to bounds) Convolution stencil  Source array Fused convolved result array HIJ)*+,-./0123456789:;<=>D)*+,-./0123456E7FG89:;<=>HIJNone$Ÿąįā&'89:;0./()*+,-./0123456789:;<=>'&(012345689)*+,-./7:;<=>None?O(n) Covert array to flat list. < Multidimentional arrays are flatten in column-major order: [5(elem at (0, .., 0, 1)), (elem at (0, .., 0, 2)), ...] @O(n)1 Loads manifest array into memory, with elements  from flatten list. :Use this function in the last resort, there are plenty of  methods to ® array, from &elayed array for example. ?@Extent of array Flatten elements Result manifest array ?@?@?@Noneu KfghpŠ‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĖĢĶĪĻŠŃŅÓŽįāßąęļšńņóōõö÷ųśūüżž’  hgf    Žąßę÷ųK340567568569:;<:;=:;>:;?:;@:;@:AB:AC:AC:AD:AE:AF:AG:AH:AIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—,˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ ŗ » ¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą  į ā ! ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’               &        %             ! " # $ % & '())*+,-./0123$456789:;<=>?@ABCDEFGHIJKLMNOPQ''('R2S2S2T2U2V2W2X2Y2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f.ghhijklmnopqrstuvwxyz{|}~€‚ƒ„…††‡ˆ:;g:;.:;':;‰:;Š:;‹:;Œ:;:;ė:;ź:;Ž:;:;:;‘:;’:;“:;”:;•:;–:;—:;˜:;™:;š:;³:;›:;œ:;:;ž:;Ÿ:; :;”:;¢:;£:;¤:;„:;¦:;§:;Ø:;©:;Ŗ:A«:A¬:A­:A®Æ°±Æ°²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢ3ĶĪ3ĶĻŠŃŅÓŌÕÖ×ŲŁ3ŚŪ3ĶÜ Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’               ń  33333 !"#ń$%&'ś()*-+-,---.-/-0-1-2-33456789:;ń<=>?@A?@BCDEFGHIńJKLMNśOPQ'R'S'T'U'V'W'X'ń'Y'Z'['\']'^1_1`1a1b1c1d1e1f2g2h2i2j2k2l2mn yarr-1.3.2Data.Yarr.Repr.ForeignData.Yarr.Base Data.YarrData.Yarr.Utils.FixedVectorData.Yarr.Utils.SplitData.Yarr.ShapeData.Yarr.Utils.ParallelData.Yarr.Utils.PrimitiveData.Yarr.Utils.ForkData.Yarr.EvalData.Yarr.FusionData.Yarr.Repr.DelayedData.Yarr.Repr.SeparateData.Yarr.FlowData.Yarr.Walk Debug.YarrData.Yarr.Repr.BoxedData.Yarr.ConvolutionData.Yarr.IO.List*Data.Yarr.Utils.FixedVector.InlinableArityCVL$Data.Yarr.Utils.FixedVector.VecTuple!Data.Yarr.Utils.FixedVector.Arity3Data.Yarr.Utils.FixedVector.InlinableArityInstances-Data.Yarr.Utils.FixedVector.VecTupleInstancesData.Yarr.WorkTypesLoadShape dim2BlockFillData.Yarr.Utils.LowLevelFlowData.Yarr.Utils.StorablecomputeloadSPreludeunzipFSEDData.Yarr.Convolution.ReprCVmapElems Data.ComplexComplexclampMData.Yarr.Walk.InternaltoListForeignStorableData.Yarr.Convolution.Eval$Data.Yarr.Convolution.StaticStencilsbaseForeign.Storabledeepseq-1.3.0.1Control.DeepSeqdeepseqrnfNFDatafixed-vector-0.1.2.1Data.Vector.FixedN1N2N3N4VecListData.Vector.Fixed.InternalFnFunarityArityDiminspect constructVectorInlinableArityinlinableZipWith inlinableMapmakeInlinableArityInstanceVecTuplemakeVecTupleInstanceN8N7n1n2n3n4n5n6n7n8sel_2_1sel_2_2sel_3_1sel_3_2sel_3_3sel_4_1sel_4_2sel_4_3sel_4_4sel_5_1sel_5_2sel_5_3sel_5_4sel_5_5sel_6_1sel_6_2sel_6_3sel_6_4sel_6_5sel_6_6sel_7_1sel_7_2sel_7_3sel_7_4sel_7_5sel_7_6sel_7_7sel_8_1sel_8_2sel_8_3sel_8_4sel_8_5sel_8_6sel_8_7sel_8_8makeSplitIndex evenChunksFoldrFoldl StatefulWalkFillWalkWorkparallel parallel_vl_1vl_2vl_3vl_4zipWith3 zipWithM_applyallanyzeroiifoldliifoldM PrimitiveOrdminMminM'maxMmaxM'clampM' TouchabletouchnoTouchDim3Dim2Dim1 MultiShapelowerinnercombine BlockShape BorderCount clipBlocksizeincplusminusoffset fromLineartoLinear intersect complementintersectBlocks blockSize insideBlockmakeChunkRangefoldl unrolledFoldlfoldr unrolledFoldrfill unrolledFillBlockmakeForkEachSlicemakeForkSlicesOncemakeForkPreferredWorkIndex WorkIndextoWorkgindexgwritegsize UVecTargetManifestnewfreezethawUTargetwrite linearWrite UVecSourceUSourceindex linearIndex VecRegularslicesRegularUArrayextent touchArrayforceSHL RangeVecLoadrangeLoadSlicesPrangeLoadSlicesSVecLoad loadSlicesP loadSlicesS RangeLoad rangeLoadP rangeLoadS LoadIndexloadPThreadscapsthreads dComputeP dComputeSentireDefaultIFusionimapimapMizip2izip2Mizip3izip3MizipizipMIFusionfimapfimapMfizip2fizip2Mfizip3fizip3MfizipfizipM DefaultFusiondmapdmapMdzip2dzip2Mdzip3dzip3MdzipdzipMFusionfmapfmapMfzip2fzip2Mfzip3fzip3MfzipfzipMDTdelay fromFunctionfromLinearFunction linearConst shapedConst delayShaped delayLinear fmapElems fmapElemsM fzipElems2 fzipElems2M fzipElems3 fzipElems3M fzipElems fzipElemsM dmapElems dmapElemsM dzipElems2 dzipElems2M dzipElems3 dzipElems3M dzipElems dzipElemsM fromSlicesunsafeMapSlicesconverttraversezipElems mapElemsMdzipWith dzipWith3 cartProduct2 icartProduct2icartProduct2M cartProduct3 icartProduct3icartProduct3MFSnewEmpty toForeignPtrunsafeFromForeignPtr reduceLeftMreduceLireduceL reduceRightMreduceRireduceRmutateimutate reduceInner ireduceInnerwalkiwalk rangeWalkwalkPiwalkP rangeWalkPwalkSlicesSeparateiwalkSlicesSeparaterangeWalkSlicesSeparatewalkSlicesSeparatePiwalkSlicesSeparatePrangeWalkSlicesSeparatePCHKyarryerrMBB justCenter Dim2Stencildim2StencilSizeXdim2StencilSizeYdim2StencilValuesdim2StencilReducedim2StencilZero Dim1Stencildim1StencilSizedim1StencilValuesdim1StencilReducedim1StencilZerodim1Stdim2StdConvolveDim1WithStaticStencilconvolveDim1WithStaticStencil dim2OutClamp dConvolveShDim2WithStaticStencilconvolveShDim2WithStaticStencil$dConvolveLinearDim2WithStaticStencil#convolveLinearDim2WithStaticStencilfromListfunD'$fInlinableArityS$fInlinableArityS0$fInlinableArityS1$fInlinableArityS2$fInlinableArityS3$fInlinableArityS4$fInlinableArityS5$fInlinableArityS6$fVectorVecTuplee$fVectorVecTuplee0$fVectorVecTuplee1$fVectorVecTuplee2$fVectorVecTuplee3$fVectorVecTuplee4$fVectorVecTuplee5VT_2 toTuple_2VT_3 toTuple_3VT_4 toTuple_4VT_5 toTuple_5VT_6 toTuple_6VT_7 toTuple_7VT_8 toTuple_8T_ifoldlgifoldlF$fNFDataVecList izipWithMizipWithzipWithMzipWithimapM_mapM_mapM sequence_sequencemapeqminimummaximumsumifoldMifoldlfoldl1foldM!tailWithtailhead generateMgeneratebasis replicateM replicate|>convecconvertContinuationN5N6NewlengthZSVectorNghc-prim GHC.Classesminmax$fPrimitiveOrdFloat$fPrimitiveOrdDouble$fPrimitiveOrdWord$fPrimitiveOrdChar$fPrimitiveOrdInt $fTouchablev$fTouchableDouble$fTouchableFloat$fTouchableWord64$fTouchableWord32$fTouchableWord16$fTouchableWord8$fTouchableWord$fTouchableInt64$fTouchableInt32$fTouchableInt16$fTouchableInt8$fTouchableInt$fTouchableBoolfill# unrolledFill#foldl#unrolledFoldl#foldr#unrolledFoldr# $fStorablevGHC.Baseidflip$fMultiShape(,,)(,) $fShape(,,)$fMultiShape(,)Int$fBlockShape(,) $fShape(,)$fBlockShapeInt $fShapeInt$fWorkIndex(,,)Int$fWorkIndex(,)Int$fWorkIndexshsh GHC.Conc.SyncgetNumCapabilitiesreturn"$fRangeVecLoadrslrSHtrtslrSHshvv2e$fVecLoadrslrSHtrtslrSHshvv2e$fRangeLoadrSHtrSHsha$fLoadrSHtrSHsha!$fRangeVecLoadrslrLtrtslrSHshvv2e$fVecLoadrslrLtrtslrSHshvv2e$fRangeLoadrLtrSHsha$fLoadrLtrSHsha!$fRangeVecLoadrslrSHtrtslrLshvv2e$fVecLoadrslrSHtrtslrLshvv2e$fRangeLoadrSHtrLsha$fLoadrSHtrLsha$fPreferredWorkIndexSHshsh $fRangeVecLoadrslrLtrtslrLshvv2e$fVecLoadrslrLtrtslrLshvv2e$fRangeLoadrLtrLsha$fLoadrLtrLsha$fPreferredWorkIndexLshInt$fFusionrfrlsh$fUTargetDTSHsha$fNFDataUArray$fRegularDTSHsha$fDefaultFusionDDSHsh$fDefaultIFusionDSHDSHsh$fDefaultIFusionDLDSHsh$fIFusionrlDSHsh$fUVecSourceDDSHshve$fVecRegularDDSHshve$fUSourceDSHsha$fNFDataUArray0$fRegularDSHsha$fDefaultFusionDDLsh $fFusionrDLsh$fUVecSourceDDLshve$fVecRegularDDLshve$fUSourceDLsha$fNFDataUArray1$fRegularDLshaShapeDelayedTarget ShapeDelayed LinearDelayed$fUVecTargetSEtrtlshve$fManifestSESElshv$fUTargetSEtlshv$fDefaultIFusionSElDSHsh$fDefaultFusionSEDlsh$fUVecSourceSErlshve$fUSourceSElshv$fVecRegularSErlshve$fRegularSElshvSeparate GHC.Floatatan2GHC.Real fromIntegralGHC.PtrPtrsqrtGHC.ForeignPtrcastForeignPtr internalNew$fUVecTargetFFSLshve$fUTargetFSLshe$fManifestFFLsha$fUTargetFLsha$fUVecSourceSEFLshve$fUVecSourceFFSLshve$fVecRegularFFSLshve$fDefaultIFusionFSLDSHsh$fDefaultFusionFSDLsh$fUSourceFSLshe$fRegularFSLshe$fDefaultIFusionFLDSHsh$fDefaultFusionFDLsh$fUSourceFLsha$fRegularFLsha ForeignSlice ForeignArrayanyReduceInneranyWalk anyRangeWalkanyWalkP anyRangeWalkPanyWalkSlicesSeparateanyRangeWalkSlicesSeparateanyWalkSlicesSeparatePanyRangeWalkSlicesSeparatePGHC.Errerror$fUVecTargetCHKCHKlshve$fManifestCHKCHKlsha$fUTargetCHKtlsha$fUVecSourceCHKCHKlshve$fUSourceCHKlsha$fVecRegularCHKCHKlshve$fRegularCHKlshaChecked uncheckedprimitive-0.5.0.1Data.Primitive.Array MutableArrayArray uninitialized$fManifestBMBLsha$fUTargetMBLsha$fUVecSourceSEMBLshve$fDefaultIFusionMBLDSHsh$fDefaultFusionMBDLsh$fUSourceMBLsha$fRegularMBLsha$fUVecSourceSEBLshve$fDefaultIFusionBLDSHsh$fDefaultFusionBDLsh$fUSourceBLsha$fRegularBLsha MutableBoxedBoxedcenter centerGet borderGet$fDefaultFusionCVCVCVLsh$fDefaultIFusionCVCVLCVCVLsh$fIFusionCVCVLCVCVLsh$fUSourceCVCVLsha$fRegularCVCVLsha$fPreferredWorkIndexCVLshsh Convoluted getExtentgetTouchinheritedForcecvLoadPcvLoadS cvLoadSlicesP cvLoadSlicesS#$fRangeVecLoadSECVCVLtrtslrtlshvv2e$fVecLoadSECVCVLtrtslrtlshvv2e$fRangeLoadCVCVLtrtlsha$fLoadCVCVLtrtlshaStencilOffsetsparseDim1StencilparseDim2Stencil justNonZero$fStencilOffsetsSSS$fStencilOffsetsSZS$fStencilOffsetsSZZ