9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None  non-portable (GHC extensions) /Scalar types supported in array computations/ Integral types: Int, Int8, Int16, Int32, Int64, Word, Word8, Word16, Word32, Word64, CShort, CUShort, CInt, CUInt, CLong, CULong, CLLong, CULLong Floating types: Float, Double, CFloat, CDouble Non-numeric types: Bool, Char, CChar, CSChar, CUChar 'Int' has the same bitwidth as in plain Haskell computations, and 'Float' and 'Double' represent IEEE single and double precision floating point numbers, respectively. experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None9Boundary condition specification for stencil operations. /use a constant value for outlying coordinates *wrap coordinates around on each dimension +mirror coordinates beyond the array extent -clamp coordinates to the extent of the array $All scalar type &Bounded types (Numeric types *Non-numeric types ,Floating types .Integral types 0+All scalar element types implement Eq, Ord & Enum 3(Bounded element types implement Bounded 6$Numeric element types implement Num & Real 93Non-numeric types supported in array computations. ?6Floating-point types supported in array computations. D0Integral types supported in array computations.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefc  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefLa_`b]^c[\YZWXDVUTSRQPONMLKJIHGFE?CBA@9>=<;:687354021./,-*+()&'$%def #"! #"!$%&'()*+,-./0213546879>=<;:?CBA@DVUTSRQPONMLKJIHGFEWXYZ[\]^_`abcdefnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneqGADT to reify the g class. Mutable array representation Immutable array representation >Safe combination of creating and fast freezing of array data. Bghijklmnopqrstuvwxyz{|}~      !"#$%&'(2ghijklmnopqrstuvwxyz{|}~     "ghijklmnopq~}|{zyxwvutsrg hijklmnopq~}|{zyxwvutsr !"#$%&'(non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneLGeneralised array index, which may index only in a subset of the dimensions  of a shape. Slice representation 8Class of slice representations (which are nested pairs) Index representation 8Class of index representations (which are nested pairs) /number of dimensions (>= 0); rank of the array -total number of elements in an array of this shape )*+,-.  )*+,-.non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneCSlices -aka generalised indices- as n-tuples and mappings of slice 5 indicies to slices, co-slices, and slice dimensions /Shapes and indices of multi-dimensional arrays Number of dimensions of a shape or index (>= 0). 2Total number of elements in an array of the given shape. ,Magic value identifying elements ignored in permute. ?Map a multi-dimensional index into one in a linear, row-major 4 representation of the array (first argument is the shape , second  argument is the index). (Apply a boundary condition to an index. HIterate through the entire shape, applying the function; third argument G combines results and fourth is returned in case of an empty iteration 9 space; the index space is traversed in row-major order. )Convert a minpoint-maxpoint index into a shape.  Convert a shape! into a minpoint-maxpoint index. )Convert a shape to a list of dimensions. +Convert a list of dimensions into a shape. $The slice index for slice specifier 'Any sh' Segment descriptor Vectors Scalars .Multi-dimensional arrays for array processing K If device and host memory are separate, arrays will be transferred to the J device when necessary (if possible asynchronously and in parallel with L other tasks) and cached on the device if sufficient memory is available. ^Class that characterises the types of values that can be array elements, and hence, appear in  scalar Accelerate expressions. .Representation change for array element types 0 ---------------------------------------------- Type representation mapping We represent tuples by using '()' and '(,)'* as type-level nil and snoc to construct  snoc-lists of types. 1Marker for arbitrary shapes in slice descriptors 2Marker for entire dimensions in slice descriptors (Increase an index rank by one dimension 4Surface types representing array indices and slices 6 ---------------------------------------------------- "Array indices are snoc type lists 1For example, the type of a rank-2 array index is 'Z :.Int :. Int'.  Rank-0 index Yield an array's shape Array indexing 1Create an array from its representation function /Creates a new, uninitialized Accelerate array.  Convert an / to an accelerated array. #Convert an accelerated array to an / KConvert a list (with elements in row-major order) to an accelerated array. ;Convert an accelerated array to a list in row-major order. `0123456789:;<=>?@ABCDEFGHIJKLMNOPQR==F 0123456789:;<=>?@ABCDEFGHIJKLMNOPQRnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneSTUVWXY STUVZ[\]^STUVWXYnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneBConversion between surface n-tuples and our tuple representation. *Type-safe projection indicies for tuples. ;NB: We index tuples by starting to count from the *right*! AWe represent tuples as heterogenous lists, typed by a type list. _`abcdefg _`abcdefgnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NonePrimitive scalar operations Primitive GPU constants !1Vanilla expression without free scalar variables "6Parametrised expression without free scalar variables #Vanilla open expression $XParametrised open expressions using de Bruijn indices for variables ranging over tuples G of scalars and arrays of tuples. All code, except Cond, is evaluated 6 eagerly. N-tuples are represented as nested pairs. MThe data type is parametrised over the surface types (not the representation  type). 4/Vanilla function without free scalar variables 54Parametrised function without free scalar variables 6"Vanilla open function abstraction 7'Parametrised open function abstraction :GADT reifying the C class. COperations on stencils. F-Closed array expression aka an array program I@Collective array computations parametrised over array variables % represented with de Bruijn indices. @ Scalar functions and expressions embedded in well-formed array I computations cannot contain free scalar variable indices. The latter J cannot be bound in array computations, and hence, cannot appear in any  well-formed program. D The let-form is used to represent the sharing discovered by common J subexpression elimination as well as to control evaluation order. (We M need to hoist array expressions out of scalar expressions - they occur in 8 scalar indexing and in determining an arrays shape.) NThe data type is parameterised over the surface types (not the representation  type). `We use a non-recursive variant parametrised over the recursive closure, to facilitate attribute  calculation in the backend. f@Vanilla array-computation function without free array variables gEParametrised array-computation function without free array variables i:Function abstraction over parametrised array computations lGADT reifying the p class. pTuples of arrays (of type ' Array dim e'0). This characterises the domain of results of  Accelerate array computations.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyhijklmnopqr      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyuwvrtsxypqlonmikjhgfIedcba`_^]\[ZYXWVUTSRQPONMLKJGHFCDE:BA@?>=<;798654$3210/.-,+*)('&%#"!      $6      !"#$3210/.-,+*)('&%456798:BA@?>=<;CDEFGHIedcba`_^]\[ZYXWVUTSRQPONMLKJfghikjlonmpqrtsuwvxyhijklmnopqrnon-partable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NonesJCalculate the offset coordinates for each stencil element relative to the H focal point. The coordinates are returned as a flattened list from the ' top-left element to the bottom-right. stststnon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None|DReify the dimensionality of the result type of an array computation }MReify dimensionality of a computation parameterised over a recursive closure ~IReify the dimensionality of the results of a computation that yields two  arrays z{|}~z{|}~{z|~}z{|}~ non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None %Determine the type of an expressions ' ------------------------------------- Determine an array type  ------------------------ $Reify the element type of an array. >Reify the element type of the result of an array computation. ]Reify the element type of the result of an array computation using the array computation AST  before tying the knot. KReify the element types of the results of an array computation that yields  two arrays. KReify the element types of the results of an array computation that yields C two arrays using the array computation AST before tying the knot. .Reify the result type of a scalar expression. [Reify the result types of of a scalar expression using the expression AST before tying the  knot. Size of a tuple type, in bytes    non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None uvwxyz{|}~ uvwxyz{|}~ uvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneShow instances  --------------- non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NoneInitialise the  trace flag?, which determines whether tracing messages should be emitted. Read the value of the  trace flag. Emit a trace message if the  trace flag5 is set. The first string indicates the location of a the message. The second one is the message itself. The output is formatted to be on one line. Emit a trace message if the  trace flag5 is set. The first string indicates the location of \ the message. The second one is the message itself. The output is formatted over multiple  lines.  non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None+Smart constructors for stencil reification - ------------------------------------------- 1Scalar expressions for plain array computations. ]Scalar expressions to parametrise collective array operations, themselves parameterised over * the type of collective array operations. %Array-valued collective computations >Array-valued collective computations without a recursive knot Note [Pipe and sharing recovery] " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  The Q constructor is special. It is the only form that contains functions over array ? computations and these functions are fixed to be over vanilla  types. This enables us to C perform sharing recovery independently from the context for them. 2Conversion from HOAS to de Bruijn computation AST  - UConvert a closed array expression to de Bruijn form while also incorporating sharing  information. 1Convert a unary function over array computations Constant scalar expression             c     non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None GRun a complete embedded array program using the reference interpreter. EStream a lazily read list of input arrays through the given program,  collecting results as we go  p p  non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None='Unlift the outmost constructor through /. This is only possible if the constructor is 9 fully determined by its type - i.e., it is a singleton. Lift the given value into 3. The value may already contain subexpressions in . 'JArray inlet: makes an array available for processing using the Accelerate E language; triggers asynchronous host->device transfer if necessary. (HScalar inlet: injects a scalar (or a tuple of scalars) into a singleton + array for use in the Accelerate language. )EReplicate an array across one or more dimensions as specified by the ; *generalised* array index provided as the first argument. For example, assuming arr& is a vector (one-dimensional array),  ! replicate (Z :.2 :.All :.3) arr (yields a three dimensional array, where arr is replicated twice across the 3 first and three times across the third dimension. *<Construct a new array by applying a function to each index. +BChange the shape of an array without altering its contents, where # precondition: size ix == size ix' ,HIndex an array with a *generalised* array index (supplied as the second I argument). The result is a new array (possibly a singleton) containing # all dimensions in their entirety. -9Apply the given function elementwise to the given array. .\Apply the given binary function elementwise to the two arrays. The extent of the resulting D array is the intersection of the extents of the two source arrays. /aReduction of the innermost dimension of an array of arbitrary rank. The first argument needs to  be an  associative: function to enable an efficient parallel implementation. 0 Variant of /: that requires the reduced array to be non-empty and doesn't need an default  value. 1ZSegmented reduction along the innermost dimension. Performs one individual reduction per E segment of the source array. These reductions proceed in parallel. ,The source array must have at least rank 1. 2 Variant of 1 that requires all3 segments of the reduced array to be non-empty and  doesn't need a default value. ,The source array must have at least rank 1. 3N-style left-to-right scan, but with the additional restriction that the first  argument needs to be an  associative: function to enable an efficient parallel implementation. 7 The initial value (second argument) may be arbitrary. 4 Variant of 3C, where the final result of the reduction is returned separately.  Denotationally, we have 9 scanl' f e arr = (crop 0 (len - 1) res, unit (res!len))  where  len = shape arr  res = scanl f e arr 5T style left-to-right scan without an intial value (aka inclusive scan). Again, the  first argument needs to be an  associative$ function. Denotationally, we have ! scanl1 f e arr = crop 1 len res  where  len = shape arr  res = scanl f e arr 6Right-to-left variant of 3. 7Right-to-left variant of  'scanl\''. 8Right-to-left variant of 5. 9HForward permutation specified by an index mapping. The result array is N initialised with the given defaults and any further values that are permuted F into the result array are added to the current value using the given  combination function. !The combination function must be  associative. Eltents that are mapped to  the magic value o0 by the permutation function are being dropped. :Backward permutation ;-Map a stencil over an array. In contrast to -), the domain of a stencil function is an  entire  neighbourhoodH of each array element. Neighbourhoods are sub-arrays centred around a _ focal point. They are not necessarily rectangular, but they are symmetric in each dimension a and have an extent of at least three in each dimensions  due to the symmetry requirement, the ^ extent is necessarily odd. The focal point is the array position that is determined by the  stencil. \For those array positions where the neighbourhood extends past the boundaries of the source Y array, a boundary condition determines the contents of the out-of-bounds neighbourhood  positions. <\Map a binary stencil of an array. The extent of the resulting array is the intersection of ' the extents of the two source arrays. =&Pipelining of two array computations. Denotationally, we have  8 (acc1 >-> acc2) arrs = let tmp = acc1 arrs in acc2 tmp &Operationally, the array computations acc1 and acc2% will not share any subcomputations, ` neither between each other nor with the environment. This makes them truly independent stages / that only communicate by way of the result of acc1& which is being fed as an argument to acc2. >'An array-level if-then-else construct. ?Infix version of >. @.Extract the first component of an array pair. A/Extract the second component of an array pair. B/Create an array pair from two separate arrays. CLift a unary function into . DLift a binary function into . E<Lift a unary function to a computation over rank-1 indices. F=Lift a binary function to a computation over rank-1 indices. G'Extract the first component of a pair. H(Extract the second component of a pair. I6Converts an uncurried function to a curried function. J4Converts a curried function to a function on pairs. K"The one index for a rank-0 array. LTurn an / expression into a rank-1 indexing expression. MTurn an / expression into a rank-1 indexing expression. NConditional expression. O6Expression form that extracts a scalar from an array. P0Extraction of the element in a singleton array. Q3Expression form that yields the shape of an array. R2Expression form that yields the size of an array. ^-Equality lifted into Accelerate expressions. _/Inequality lifted into Accelerate expressions. `1Smaller-than lifted into Accelerate expressions. a5Greater-or-equal lifted into Accelerate expressions. b1Greater-than lifted into Accelerate expressions. c5Smaller-or-equal lifted into Accelerate expressions. d&Determine the maximum of two scalars. e&Determine the minimum of two scalars. f$Conversions from the RealFrac class j Conjunction k Disjunction l Negation mConvert a Boolean value to an , where  turns into '0' and   into '1'. n%General coercion from integral types oKMagic value identifying elements that are ignored in a forward permutation  !"#$%&'()*+,-./0123456789combination function array of default values  permutation permuted array :shape of the result array  permutation permuted array ;stencil function boundary condition  source array destination array <binary stencil function boundary condition #1  source array #1 boundary condition #2  source array #2 destination array => if-condition  then-array  else-array ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnog !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnonon-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>NonepJCombine the elements of two arrays pairwise. The shape of the result is . the intersection of the two argument shapes. qThe converse of p7, but the shape of the two results is identical to the  shape of the argument. rbReduction of an array of arbitrary rank to a single scalar value. The first argument needs to be  an  associative: function to enable an efficient parallel implementation. s Variant of r: that requires the reduced array to be non-empty and doesn't need an default  value. t4Left-to-right prescan (aka exclusive scan). As for scan , the first argument must be an   associative$ function. Denotationally, we have ) prescanl f e = Prelude.fst . scanl' f e u%Left-to-right postscan, a variant of 51 with an initial value. Denotationally, we have ( postscanl f e = map (e `f`) . scanl1 f v4Right-to-left prescan (aka exclusive scan). As for scan , the first argument must be an   associative$ function. Denotationally, we have ) prescanr f e = Prelude.fst . scanr' f e w%Right-to-left postscan, a variant of 81 with an initial value. Denotationally, we have ( postscanr f e = map (e `f`) . scanr1 f xSegmented version of 3. ySegmented version of  'scanl\''. LThe first element of the resulting tuple is a vector of scanned values. The L second element is a vector of segment scan totals and has the same size as  the segment vector. zSegmented version of 5. {Segmented version of t. |Segmented version of u. }Segmented version of 6. ~Segmented version of  'scanrSeg\''. Segmented version of 8. Segmented version of v. Segmented version of w. pqrstuvwxyz{|}~pqrstuvwxyz{|}~pqrstuvwxyz{|}~non-portable (GHC extensions) experimental-Manuel M T Chakravarty <chak@cse.unsw.edu.au>None%Array indexing in plain Haskell code "Array shape in plain Haskell code  $&(*,.p !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ $(&.,*p&%$#"! '()*@AB+,-./0123456789:;<=>?CDEFGHIJKLMNOPQR^_`cbadeYZ\[]SUTVXWfghijklmnopqrstuvwxyz{|}~  ! " # $%&%'%(%)%*+,+-+.+/+0+1+2+3+4+5+6+7+89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuuvvwwxyz{|}~      !"#$%&'()*+,-#./0123456789:;<=>?@ABCDEFGHIJJKLFMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~           F   ' ( +  , - # . / 0 1 2 3 4  5  I I  L F M N O P Q R S T U V W X Y Z [ \ ^ ] _ ` d   a                                                                                            G !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \ ] ^ _ ` a b c d e f g h i j k lmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX ; < = > ? @ A B Y Z [ \ ] ^__`abcdefghijklmnopqrstuvwxyz{|}~accelerate-0.9.0.1Data.Array.AccelerateData.Array.Accelerate.Type Data.Array.Accelerate.Array.Data*Data.Array.Accelerate.Array.Representation!Data.Array.Accelerate.Array.SugarData.Array.Accelerate.TupleData.Array.Accelerate.AST$Data.Array.Accelerate.Analysis.Shape#Data.Array.Accelerate.Analysis.TypeData.Array.Accelerate.Smart!Data.Array.Accelerate.InterpreterPaths_accelerate$Data.Array.Accelerate.Internal.Check#Data.Array.Accelerate.Array.Delayed&Data.Array.Accelerate.Analysis.Stencil"Data.Array.Accelerate.Pretty.PrintData.Array.Accelerate.PrettyData.Array.Accelerate.Debug%Data.Array.Accelerate.Pretty.TraverseData.Array.Accelerate.LanguageDataListData.Array.Accelerate.Preludeghc-prim GHC.TypesBoolCharDoubleFloatIntbaseGHC.IntInt8Int16Int32Int64GHC.WordWordWord8Word16Word32Word64Foreign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleBoundaryConstantWrapMirrorClamp TupleType PairTuple SingleTuple UnitTupleIsScalar scalarType IsBounded boundedTypeIsNumnumTypeIsNonNum nonNumType IsFloating floatingType IsIntegral integralType ScalarTypeNonNumScalarType NumScalarType BoundedTypeNonNumBoundedTypeIntegralBoundedTypeNumTypeFloatingNumTypeIntegralNumType NonNumType TypeCUChar TypeCSChar TypeCCharTypeCharTypeBool FloatingType TypeCDouble TypeCFloat TypeDouble TypeFloat IntegralType TypeCULLong TypeCLLong TypeCULong TypeCLong TypeCUIntTypeCInt TypeCUShort TypeCShort TypeWord64 TypeWord32 TypeWord16 TypeWord8TypeWord TypeInt64 TypeInt32 TypeInt16TypeInt8TypeInt NonNumDict FloatingDict IntegralDict Typeable9typeOf9 Typeable8typeOf8 myMkTyContypeOf7DefaulttypeOf8Default integralDict floatingDict nonNumDictArrayElt ArrayPtrsindexArrayDataptrsOfArrayData newArrayData readArrayDatawriteArrayDataunsafeFreezeArrayDataptrsOfMutableArrayDataarrayElt ArrayEltR ArrayEltRpair ArrayEltRchar ArrayEltRboolArrayEltRdoubleArrayEltRfloatArrayEltRword64ArrayEltRword32ArrayEltRword16ArrayEltRword8 ArrayEltRwordArrayEltRint64ArrayEltRint32ArrayEltRint16 ArrayEltRint8 ArrayEltRint ArrayEltRunit GArrayDataMutableArrayData ArrayData runArrayData fstArrayData sndArrayData pairArrayData SliceIndex SliceFixedSliceAllSliceNilSlice SliceShape CoSliceShape FullShape sliceIndexShapedimsize intersectignoreindexbounditeriter1 rangeToShape shapeToRange shapeToList listToShape sliceAnyIndexDIM9DIM8DIM7DIM6DIM5DIM4DIM3DIM2DIM1DIM0SegmentsVectorScalarArrayElteltTypefromElttoElteltType'fromElt'toElt'EltRepr'EltReprAnyAll:.Z liftToElt liftToElt2 sinkFromElt sinkFromElt2shape!newArray allocateArray fromIArraytoIArrayfromListtoListIsTuple TupleRepr fromTupletoTupleTupleIdx SuccTupIdx ZeroTupIdxTupleSnocTupNilTupPrimFunPrimFromIntegral PrimBoolToIntPrimChrPrimOrdPrimLNotPrimLOrPrimLAndPrimMinPrimMaxPrimNEqPrimEqPrimGtEqPrimLtEqPrimGtPrimLt PrimCeiling PrimFloor PrimRound PrimTruncate PrimAtan2 PrimLogBasePrimFPowPrimLogPrimSqrtPrimExpFloating PrimAtanh PrimAcosh PrimAsinhPrimAtanPrimAcosPrimAsinPrimTanPrimCosPrimSin PrimRecipPrimFDiv PrimBRotateR PrimBRotateL PrimBShiftR PrimBShiftLPrimBNotPrimBXorPrimBOrPrimBAndPrimModPrimIDivPrimRemPrimQuotPrimSigPrimAbsPrimNegPrimMulPrimSubPrimAdd PrimConstPrimPi PrimMaxBound PrimMinBoundExpPreExpOpenExp PreOpenExpSize IndexScalarPrimAppCondIndexAny IndexTail IndexHead IndexConsIndexNilPrjConstVarFunPreFunOpenFun PreOpenFunLamBodyStencilR StencilRtup9 StencilRtup7 StencilRtup5 StencilRtup3 StencilRunit9 StencilRunit7 StencilRunit5 StencilRunit3Stencilstencil stencilAccessAccOpenAcc PreOpenAccStencil2 BackpermutePermuteScanr1Scanr'ScanrScanl1Scanl'ScanlFold1SegFoldSegFold1FoldZipWithMapIndex ReplicateGenerateReshapeUnitUseAcondApplyAvar PairArraysLet2LetAfunPreAfunOpenAfun PreOpenAfunAlamAbodyArraysR ArraysRpair ArraysRarray ArraysRunitArraysarraysValPushEmptyIdxSuccIdxZeroIdxprjidxToIntAccDim2AccDimaccDim preAccDimaccDim2 preAccDim2AccType2AccType arrayTypeaccType preAccTypeaccType2 preAccType2expType preExpTypesizeOf StencilRepr stencilPrjTagPreAccSndArrayFstArrayPipeAtag convertAccconvertAccFun1unpairpairconstanttup2tup3tup4tup5tup6tup7tup8tup9untup2untup3untup4untup5untup6untup7untup8untup9 mkMinBound mkMaxBoundmkPimkSinmkCosmkTanmkAsinmkAcosmkAtanmkAsinhmkAcoshmkAtanh mkExpFloatingmkSqrtmkLogmkFPow mkLogBasemkAddmkSubmkMulmkNegmkAbsmkSigmkQuotmkRemmkIDivmkModmkBAndmkBOrmkBXormkBNot mkBShiftL mkBShiftR mkBRotateL mkBRotateRmkFDivmkRecip mkTruncatemkRoundmkFloor mkCeilingmkAtan2mkLtmkGtmkLtEqmkGtEqmkEqmkNEqmkMaxmkMinmkLAndmkLOrmkLNotmkFromIntegral mkBoolToInt$$$$$$$$$$$$$$runstream evalPrimConstevalPrimevalPrjUnliftunliftLiftPlainlift Stencil5x5x5 Stencil3x5x5 Stencil5x3x5 Stencil5x5x3 Stencil3x3x5 Stencil3x5x3 Stencil5x3x3 Stencil3x3x3 Stencil5x5 Stencil3x5 Stencil5x3 Stencil3x3Stencil9Stencil7Stencil5Stencil3useunit replicategeneratereshapeslicemapzipWithfoldfold1foldSegfold1Segscanlscanl'scanl1scanrscanr'scanr1permute backpermutestencil2>->cond?|fstAsndApairAlift1lift2ilift1ilift2fstsndcurryuncurryindex0index1unindex1?theshiftshiftLshiftRrotaterotateLrotateRbitsetBitclearBit complementBittestBit==*/=*<*>=*>*<=*maxmintruncateroundfloorceiling&&*||*not boolToInt fromIntegralzipunzipfoldAllfold1Allprescanl postscanlprescanr postscanrscanlSeg scanlSeg' scanl1Seg prescanlSeg postscanlSegscanrSeg scanrSeg' scanr1Seg prescanrSeg postscanrSegSliceIxIxElem indexArray arrayShapearrayDim arraySizetupleuntupleversion getBinDir getLibDir getDataDir getLibexecDirgetDataFileNameChecksInternalUnsafeBoundsdoCheckserrorcheckassert checkIndex checkLength checkSlice$fIsScalarCUChar$fIsScalarCSChar$fIsScalarCChar$fIsScalarChar$fIsScalarBool$fIsScalarCDouble$fIsScalarCFloat$fIsScalarDouble$fIsScalarFloat$fIsScalarCULLong$fIsScalarCLLong$fIsScalarCULong$fIsScalarCLong$fIsScalarCUInt$fIsScalarCInt$fIsScalarCUShort$fIsScalarCShort$fIsScalarWord64$fIsScalarWord32$fIsScalarWord16$fIsScalarWord8$fIsScalarWord$fIsScalarInt64$fIsScalarInt32$fIsScalarInt16$fIsScalarInt8 $fIsScalarInt$fIsBoundedCUChar$fIsBoundedCSChar$fIsBoundedCChar$fIsBoundedChar$fIsBoundedBool$fIsBoundedCULLong$fIsBoundedCLLong$fIsBoundedCULong$fIsBoundedCLong$fIsBoundedCUInt$fIsBoundedCInt$fIsBoundedCUShort$fIsBoundedCShort$fIsBoundedWord64$fIsBoundedWord32$fIsBoundedWord16$fIsBoundedWord8$fIsBoundedWord$fIsBoundedInt64$fIsBoundedInt32$fIsBoundedInt16$fIsBoundedInt8$fIsBoundedInt$fIsNumCDouble $fIsNumCFloat $fIsNumDouble $fIsNumFloat$fIsNumCULLong $fIsNumCLLong $fIsNumCULong $fIsNumCLong $fIsNumCUInt $fIsNumCInt$fIsNumCUShort $fIsNumCShort $fIsNumWord64 $fIsNumWord32 $fIsNumWord16 $fIsNumWord8 $fIsNumWord $fIsNumInt64 $fIsNumInt32 $fIsNumInt16 $fIsNumInt8 $fIsNumInt$fIsNonNumCUChar$fIsNonNumCSChar$fIsNonNumCChar$fIsNonNumChar$fIsNonNumBool$fIsFloatingCDouble$fIsFloatingCFloat$fIsFloatingDouble$fIsFloatingFloat$fIsIntegralCULLong$fIsIntegralCLLong$fIsIntegralCULong$fIsIntegralCLong$fIsIntegralCUInt$fIsIntegralCInt$fIsIntegralCUShort$fIsIntegralCShort$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fShowScalarType$fShowBoundedType $fShowNumType$fShowNonNumType$fShowFloatingType$fShowIntegralType $fTypeable8s$fTypeable9(,,,,,,,,) $fTypeable7s$fTypeable8(,,,,,,,)AD_PairAD_CharAD_Bool AD_DoubleAD_Float AD_Word64 AD_Word32 AD_Word16AD_Word8AD_WordAD_Int64AD_Int32AD_Int16AD_Int8AD_IntAD_Unit $fArrayElt(,)$fArrayEltChar$fArrayEltBool$fArrayEltDouble$fArrayEltFloat$fArrayEltWord64$fArrayEltWord32$fArrayEltWord16$fArrayEltWord8$fArrayEltWord$fArrayEltInt64$fArrayEltInt32$fArrayEltInt16$fArrayEltInt8 $fArrayEltInt $fArrayElt()$fShowSliceIndex $fSlice(,) $fSlice(,)0 $fSlice() $fShape(,) $fShape() array-0.4.0.0Data.Array.BaseIArray $fShowArray $fSliceAny $fSlice:. $fSlice:.0$fSliceZ $fShape:.$fShapeZ$fElt(,,,,,,,,)$fElt(,,,,,,,) $fElt(,,,,,,) $fElt(,,,,,) $fElt(,,,,) $fElt(,,,) $fElt(,,)$fElt(,) $fEltChar $fEltBool $fEltDouble $fEltFloat $fEltWord64 $fEltWord32 $fEltWord16 $fEltWord8 $fEltWord $fEltInt64 $fEltInt32 $fEltInt16 $fEltInt8$fEltInt$fEltAny $fEltAny0$fEltAll$fElt:.$fEltZ$fElt() DelayableDelayeddelayforce$fDelayable(,)$fDelayableArray $fDelayable() DelayedPair DelayedArrayshapeDArepfDA DelayedUnit$fIsTuple(,,,,,,,,)$fIsTuple(,,,,,,,)$fIsTuple(,,,,,,)$fIsTuple(,,,,,)$fIsTuple(,,,,)$fIsTuple(,,,) $fIsTuple(,,) $fIsTuple(,) $fIsTuple()$fStencil:.a(,,,,,,,,)$fStencil:.a(,,,,,,)$fStencil:.a(,,,,)$fStencil:.a(,,)$fStencil:.e(,,,,,,,,)$fStencil:.e(,,,,,,)$fStencil:.e(,,,,)$fStencil:.e(,,) $fArrays(,) $fArraysArray $fArrays()offsetsoffsets2 PrettyAcc prettyAcc prettyPreAcc prettyAfun prettyPreAfun prettyFun prettyPreFun prettyExp prettyPreExpnoParens $fShowOpenAcc$fShowPreOpenExp$fShowPreOpenFun initTrace queryTrace traceLine traceChunk $fShowPreExp $fShowAcc$fEqStableSharingAcc$fShowStableSharingAcc$fEqStableAccName$fShowStableAccNameLabels accFormat expFormat funFormat tupleFormat arrayFormatboundaryFormat primFunFormatcattravAcctravExptravAfuntravFun travArray travBoundary travTuplelabelForPrimFun labelForConst tupleIdxToIntFalseTrue$fRealFloatPreExp$fRealFracPreExp$fFractionalPreExp$fFloatingPreExp$fIntegralPreExp $fRealPreExp $fNumPreExp $fBitsPreExp $fOrdPreExp $fEqPreExp $fEnumPreExp$fBoundedPreExp $fLiftPreExp$fUnlift(,,,,,,,,)$fLift(,,,,,,,,)$fUnlift(,,,,,,,)$fLift(,,,,,,,)$fUnlift(,,,,,,)$fLift(,,,,,,)$fUnlift(,,,,,) $fLift(,,,,,)$fUnlift(,,,,) $fLift(,,,,) $fUnlift(,,,) $fLift(,,,) $fUnlift(,,) $fLift(,,) $fUnlift(,) $fLift(,) $fLiftChar $fLiftBool $fLiftDouble $fLiftFloat $fLiftWord64 $fLiftWord32 $fLiftWord16 $fLiftWord8 $fLiftWord $fLiftInt64 $fLiftInt32 $fLiftInt16 $fLiftInt8 $fLiftInt $fLiftAny $fUnlift:.$fLift:. $fLift:.0 $fLift:.1 $fUnliftZ$fLiftZ $fUnlift()$fLift() $fSliceIxsh$fIxsh$fEleme