am3      !"#$%&'()*+,-./012!None47>L Provides vectorized versions of 3 and 4g. Implementing their type class is not possible for SIMD types as it would require implementing 5.!Rounds towards zero element-wise. Satisfies +(quotVector x y) * y + (remVector x y) == x.This class provides basic operations to create and consume SIMD types. Numeric operations on members of this class should compile to single SIMD instructions although not all operations are (yet) supported by GHC (e.g. 6!, it is currently implemented as mapVector sqrtM which has to unpack the vector, compute the results and pack them again)."Type of the elements in the vector&Type used to pack or unpack the vector-Vector with all elements initialized to zero.TNumber of components (scalar elements) in the vector. The argument is not evaluated.TSize of each (scalar) element in the vector in bytes. The argument is not evaluated. /Broadcast a scalar to all elements of a vector. Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range an exception is thrown. Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range the behavior is undefined. Apply a function to each element of a vector. Be very careful not to map branching functions over a vector as they could lead to quite a bit of code bloat (or make sure they are tagged with NOINLINE). 4Zip two vectors together using a combining function.rFold the elements of a vector to a single value. The order in which the elements are combined is not specified.3Sum up the components of the vector. Equivalent to foldVector (+).Pack some elements to a vector.Unpack a vector.YThe compiler only supports tuples up to 62 elements, so we have to use our own data type. 78 78 78None +7<>L9/Broadcast a scalar to all elements of a vector.:+Pack the elements of a tuple into a vector.;-Unpack the elements of a vector into a tuple.<Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.=MApply a function to each element of a vector (unpacks and repacks the vector)>Unboxed helper function.?UZip two vectors together using a combining function (unpacks and repacks the vectors)@/Fold the elements of a vector to a single valueAAdd two vectors element-wise.B"Subtract two vectors element-wise.C"Multiply two vectors element-wise.D!Rounds towards zero element-wise.E*Satisfies (quot x y) * y + (rem x y) == x.FNegate element-wise.G:Read a vector from specified index of the immutable array.H8Read a vector from specified index of the mutable array.I3Write a vector to specified index of mutable array.J5Reads vector from the specified index of the address.K5Reads vector from the specified index of the address.L3Write vector to the specified index of the address.*MNOPQRS9:;<=>?@ABCDEFGHIJKLTUVWXYZ[\]^_`a'MPQRS9:;<=>?@ABCDEFGHIJKLTUVWNXOYZ[\]^_`aNone +7<>Lb/Broadcast a scalar to all elements of a vector.c+Pack the elements of a tuple into a vector.d-Unpack the elements of a vector into a tuple.eInsert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.fMApply a function to each element of a vector (unpacks and repacks the vector)gUnboxed helper function.hUZip two vectors together using a combining function (unpacks and repacks the vectors)i/Fold the elements of a vector to a single valuej2Sum up the elements of a vector to a single value.kAdd two vectors element-wise.l"Subtract two vectors element-wise.m"Multiply two vectors element-wise.n!Rounds towards zero element-wise.o*Satisfies (quot x y) * y + (rem x y) == x.pNegate element-wise.q:Read a vector from specified index of the immutable array.r8Read a vector from specified index of the mutable array.s3Write a vector to specified index of mutable array.t5Reads vector from the specified index of the address.u5Reads vector from the specified index of the address.v3Write vector to the specified index of the address.+wxyz{|}bcdefghijklmnopqrstuv~(wz{|}bcdefghijklmnopqrstuv~xyNone +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+(None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single valueAdd two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*'None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+(None +7<>L /Broadcast a scalar to all elements of a vector. +Pack the elements of a tuple into a vector. -Unpack the elements of a vector into a tuple. Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined. MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+ !"#$     %&'()*+,-./012(!"#$     %&'() *+,-./012 None +7<>L3/Broadcast a scalar to all elements of a vector.4+Pack the elements of a tuple into a vector.5-Unpack the elements of a vector into a tuple.6Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.7MApply a function to each element of a vector (unpacks and repacks the vector)8Unboxed helper function.9UZip two vectors together using a combining function (unpacks and repacks the vectors):/Fold the elements of a vector to a single value;Add two vectors element-wise.<"Subtract two vectors element-wise.="Multiply two vectors element-wise.>!Rounds towards zero element-wise.?*Satisfies (quot x y) * y + (rem x y) == x.@Negate element-wise.A:Read a vector from specified index of the immutable array.B8Read a vector from specified index of the mutable array.C3Write a vector to specified index of mutable array.D5Reads vector from the specified index of the address.E5Reads vector from the specified index of the address.F3Write vector to the specified index of the address.*GHIJKLM3456789:;<=>?@ABCDEFNOPQRSTUVWXYZ['GJKLM3456789:;<=>?@ABCDEFNOPQHRISTUVWXYZ[ None +7<>L\/Broadcast a scalar to all elements of a vector.]+Pack the elements of a tuple into a vector.^-Unpack the elements of a vector into a tuple._Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.`MApply a function to each element of a vector (unpacks and repacks the vector)aUnboxed helper function.bUZip two vectors together using a combining function (unpacks and repacks the vectors)c/Fold the elements of a vector to a single valued2Sum up the elements of a vector to a single value.eAdd two vectors element-wise.f"Subtract two vectors element-wise.g"Multiply two vectors element-wise.h!Rounds towards zero element-wise.i*Satisfies (quot x y) * y + (rem x y) == x.jNegate element-wise.k:Read a vector from specified index of the immutable array.l8Read a vector from specified index of the mutable array.m3Write a vector to specified index of mutable array.n5Reads vector from the specified index of the address.o5Reads vector from the specified index of the address.p3Write vector to the specified index of the address.+qrstuvw\]^_`abcdefghijklmnopxyz{|}~(qtuvw\]^_`abcdefghijklmnopxyz{r|s}~ None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+( None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single valueAdd two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+( None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.,)None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined. MApply a function to each element of a vector (unpacks and repacks the vector) Unboxed helper function. UZip two vectors together using a combining function (unpacks and repacks the vectors) /Fold the elements of a vector to a single value 2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address., !     "#$%&'()*+,-./) !     "#$%&'()*+,-./None +7<>L0/Broadcast a scalar to all elements of a vector.1+Pack the elements of a tuple into a vector.2-Unpack the elements of a vector into a tuple.3Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.4MApply a function to each element of a vector (unpacks and repacks the vector)5Unboxed helper function.6UZip two vectors together using a combining function (unpacks and repacks the vectors)7/Fold the elements of a vector to a single value8Add two vectors element-wise.9"Subtract two vectors element-wise.:"Multiply two vectors element-wise.;!Rounds towards zero element-wise.<*Satisfies (quot x y) * y + (rem x y) == x.=:Read a vector from specified index of the immutable array.>8Read a vector from specified index of the mutable array.?3Write a vector to specified index of mutable array.@5Reads vector from the specified index of the address.A5Reads vector from the specified index of the address.B3Write vector to the specified index of the address.) CDEFGHI0123456789:;<=>?@ABJKLMNOPQRSTUVW & CFGHI0123456789:;<=>?@ABJKLMDNEOPQRSTUVWNone +7<>LX/Broadcast a scalar to all elements of a vector.Y+Pack the elements of a tuple into a vector.Z-Unpack the elements of a vector into a tuple.[Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.\MApply a function to each element of a vector (unpacks and repacks the vector)]Unboxed helper function.^UZip two vectors together using a combining function (unpacks and repacks the vectors)_/Fold the elements of a vector to a single value`2Sum up the elements of a vector to a single value.aAdd two vectors element-wise.b"Subtract two vectors element-wise.c"Multiply two vectors element-wise.d!Rounds towards zero element-wise.e*Satisfies (quot x y) * y + (rem x y) == x.f:Read a vector from specified index of the immutable array.g8Read a vector from specified index of the mutable array.h3Write a vector to specified index of mutable array.i5Reads vector from the specified index of the address.j5Reads vector from the specified index of the address.k3Write vector to the specified index of the address.*!lmnopqrXYZ[\]^_`abcdefghijkstuvwxyz{|}~!'!lopqrXYZ[\]^_`abcdefghijkstuvmwnxyz{|}~None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*""'"None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single valueAdd two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.)##&#None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*$$'$None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x. :Read a vector from specified index of the immutable array. 8Read a vector from specified index of the mutable array. 3Write a vector to specified index of mutable array. 5Reads vector from the specified index of the address. 5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*%      !"#%'%      !"#None +7<>L$/Broadcast a scalar to all elements of a vector.%+Pack the elements of a tuple into a vector.&-Unpack the elements of a vector into a tuple.'Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.(MApply a function to each element of a vector (unpacks and repacks the vector))Unboxed helper function.*UZip two vectors together using a combining function (unpacks and repacks the vectors)+/Fold the elements of a vector to a single value,Add two vectors element-wise.-"Subtract two vectors element-wise.."Multiply two vectors element-wise./!Rounds towards zero element-wise.0*Satisfies (quot x y) * y + (rem x y) == x.1:Read a vector from specified index of the immutable array.28Read a vector from specified index of the mutable array.33Write a vector to specified index of mutable array.45Reads vector from the specified index of the address.55Reads vector from the specified index of the address.63Write vector to the specified index of the address.)&789:;<=$%&'()*+,-./0123456>?@ABCDEFGHIJK&&&7:;<=$%&'()*+,-./0123456>?@A8B9CDEFGHIJKNone +7<>LL/Broadcast a scalar to all elements of a vector.M+Pack the elements of a tuple into a vector.N-Unpack the elements of a vector into a tuple.OInsert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.PMApply a function to each element of a vector (unpacks and repacks the vector)QUnboxed helper function.RUZip two vectors together using a combining function (unpacks and repacks the vectors)S/Fold the elements of a vector to a single valueT2Sum up the elements of a vector to a single value.UAdd two vectors element-wise.V"Subtract two vectors element-wise.W"Multiply two vectors element-wise.X!Rounds towards zero element-wise.Y*Satisfies (quot x y) * y + (rem x y) == x.Z:Read a vector from specified index of the immutable array.[8Read a vector from specified index of the mutable array.\3Write a vector to specified index of mutable array.]5Reads vector from the specified index of the address.^5Reads vector from the specified index of the address._3Write vector to the specified index of the address.*'`abcdefLMNOPQRSTUVWXYZ[\]^_ghijklmnopqrst'''`cdefLMNOPQRSTUVWXYZ[\]^_ghijakblmnopqrstNone +7<>Lu/Broadcast a scalar to all elements of a vector.v+Pack the elements of a tuple into a vector.w-Unpack the elements of a vector into a tuple.xInsert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.yMApply a function to each element of a vector (unpacks and repacks the vector)zUnboxed helper function.{UZip two vectors together using a combining function (unpacks and repacks the vectors)|/Fold the elements of a vector to a single value}2Sum up the elements of a vector to a single value.~Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*(uvwxyz{|}~('(uvwxyz{|}~None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single valueAdd two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*))')None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.+**(*None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise.!Rounds towards zero element-wise.*Satisfies (quot x y) * y + (rem x y) == x.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.++     +(+     None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector) Unboxed helper function.!UZip two vectors together using a combining function (unpacks and repacks the vectors)"/Fold the elements of a vector to a single value#Add two vectors element-wise.$"Subtract two vectors element-wise.%"Multiply two vectors element-wise.& Divide two vectors element-wise.'Negate element-wise.(:Read a vector from specified index of the immutable array.)8Read a vector from specified index of the mutable array.*3Write a vector to specified index of mutable array.+5Reads vector from the specified index of the address.,5Reads vector from the specified index of the address.-3Write vector to the specified index of the address.),./01234 !"#$%&'()*+,-56789:;<=>?@AB,&,.1234 !"#$%&'()*+,-5678/90:;<=>?@ABNone +7<>LC/Broadcast a scalar to all elements of a vector.D+Pack the elements of a tuple into a vector.E-Unpack the elements of a vector into a tuple.FInsert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.GMApply a function to each element of a vector (unpacks and repacks the vector)HUnboxed helper function.IUZip two vectors together using a combining function (unpacks and repacks the vectors)J/Fold the elements of a vector to a single valueK2Sum up the elements of a vector to a single value.LAdd two vectors element-wise.M"Subtract two vectors element-wise.N"Multiply two vectors element-wise.O Divide two vectors element-wise.PNegate element-wise.Q:Read a vector from specified index of the immutable array.R8Read a vector from specified index of the mutable array.S3Write a vector to specified index of mutable array.T5Reads vector from the specified index of the address.U5Reads vector from the specified index of the address.V3Write vector to the specified index of the address.*-WXYZ[\]CDEFGHIJKLMNOPQRSTUV^_`abcdefghijk-'-WZ[\]CDEFGHIJKLMNOPQRSTUV^_`aXbYcdefghijkNone +7<>Ll/Broadcast a scalar to all elements of a vector.m+Pack the elements of a tuple into a vector.n-Unpack the elements of a vector into a tuple.oInsert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.pMApply a function to each element of a vector (unpacks and repacks the vector)qUnboxed helper function.rUZip two vectors together using a combining function (unpacks and repacks the vectors)s/Fold the elements of a vector to a single valuet2Sum up the elements of a vector to a single value.uAdd two vectors element-wise.v"Subtract two vectors element-wise.w"Multiply two vectors element-wise.x Divide two vectors element-wise.yNegate element-wise.z:Read a vector from specified index of the immutable array.{8Read a vector from specified index of the mutable array.|3Write a vector to specified index of mutable array.}5Reads vector from the specified index of the address.~5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*.lmnopqrstuvwxyz{|}~.'.lmnopqrstuvwxyz{|}~None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single valueAdd two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise. Divide two vectors element-wise.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.)//&/None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise. Divide two vectors element-wise.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*00'0 None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise. Divide two vectors element-wise.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array.5Reads vector from the specified index of the address.5Reads vector from the specified index of the address.3Write vector to the specified index of the address.*1     1'1     !None +7<>L/Broadcast a scalar to all elements of a vector.+Pack the elements of a tuple into a vector.-Unpack the elements of a vector into a tuple.Insert a scalar at the given position (starting from 0) in a vector. If the index is outside of the range, the behavior is undefined.MApply a function to each element of a vector (unpacks and repacks the vector)Unboxed helper function.UZip two vectors together using a combining function (unpacks and repacks the vectors)/Fold the elements of a vector to a single value2Sum up the elements of a vector to a single value.Add two vectors element-wise."Subtract two vectors element-wise."Multiply two vectors element-wise. Divide two vectors element-wise.Negate element-wise.:Read a vector from specified index of the immutable array.8Read a vector from specified index of the mutable array.3Write a vector to specified index of mutable array. 5Reads vector from the specified index of the address.!5Reads vector from the specified index of the address."3Write vector to the specified index of the address.*2#$%&'() !"*+,-./012345672'2#&'() !"*+,-$.%/01234567(c) 2015 Anselm Jonas SchollBSD3anselm.scholl@tu-harburg.de experimentalnon-portable (uses GHC.Prim)None3  !"#$%&'()*+,-./0123  !"#$%&'()*+,-./0128"#$%&'()*+,-./01234456789: ; < = > ?@ABCDEFGHIJKLMNOPQ R!STUVTUWTUXTYZ[\]^_`abcdefghijklmnop5qrstuvwxyz{|}~6stuv7stuv8stuv9 stuv     !"#$%&'()*+,:-.stuv/0123456789:;< = > ? @ A B C D E F G H I J K L M N O P ; Q R s t u v 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 s t u v x y z { | } ~                             =   s t u v                                   >    s t u v                                    ?    s t u v               @  stuv   !"#$%&'()*+,A-.stuv/0123456789:;<=>?@ABCDEFGHIJKLMNOPBQRstuvSTUVWXYZ[\]^_`abcdefghijklmnopqrstCuvstuvwxyz{|}~DstuvEstuvFstuvGstuv      !"#$%&H'(stuv)*+,-./0123456789:;<=>?@ABCDEFGHIJIKLstuvMNOPQRSTUVWXYZ[\]^_`abcdefghijklmJnopstuvqrstuvwxyz{|}~KnstuvLnstuvMstuvNstuv      !O"#stuv$%&'()*+,-./0123456789:;<=>?@ABCDPEFstuvGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghQijstuvklmnopqrstuvwx y z { | } ~               R   s t u v              !!!!!!!!!!!!!!!!!!!!!S!!!s!t!u!v!!!!!!!!!!!!!!primi_Fzf2zaBQ8jZGYWX1yKTWOgData.Primitive.SIMDData.Primitive.SIMD.ClassData.Primitive.SIMD.Int8X16Data.Primitive.SIMD.Int8X32Data.Primitive.SIMD.Int8X64Data.Primitive.SIMD.Int16X8Data.Primitive.SIMD.Int16X16Data.Primitive.SIMD.Int16X32Data.Primitive.SIMD.Int32X4Data.Primitive.SIMD.Int32X8Data.Primitive.SIMD.Int32X16Data.Primitive.SIMD.Int64X2Data.Primitive.SIMD.Int64X4Data.Primitive.SIMD.Int64X8Data.Primitive.SIMD.Word8X16Data.Primitive.SIMD.Word8X32Data.Primitive.SIMD.Word8X64Data.Primitive.SIMD.Word16X8Data.Primitive.SIMD.Word16X16Data.Primitive.SIMD.Word16X32Data.Primitive.SIMD.Word32X4Data.Primitive.SIMD.Word32X8Data.Primitive.SIMD.Word32X16Data.Primitive.SIMD.Word64X2Data.Primitive.SIMD.Word64X4Data.Primitive.SIMD.Word64X8Data.Primitive.SIMD.FloatX4Data.Primitive.SIMD.FloatX8Data.Primitive.SIMD.FloatX16Data.Primitive.SIMD.DoubleX2Data.Primitive.SIMD.DoubleX4Data.Primitive.SIMD.DoubleX8Data.Primitive.SIMD.DoubleX16 SIMDIntVector quotVector remVector SIMDVectorElem ElemTuple nullVector vectorSize elementSizebroadcastVector insertVectorunsafeInsertVector mapVector zipVector foldVector sumVector packVector unpackVectorTuple64Int8X16Int8X32Int8X64Int16X8Int16X16Int16X32Int32X4Int32X8Int32X16Int64X2Int64X4Int64X8Word8X16Word8X32Word8X64Word16X8 Word16X16 Word16X32Word32X4Word32X8 Word32X16Word64X2Word64X4Word64X8FloatX4FloatX8FloatX16DoubleX2DoubleX4DoubleX8 DoubleX16baseGHC.Realquotrem toInteger GHC.FloatsqrtsetByteArrayGenericsetOffAddrGenericbroadcastInt8X16 packInt8X16 unpackInt8X16unsafeInsertInt8X16 mapInt8X16 mapInt8X16# zipInt8X16 foldInt8X16 plusInt8X16 minusInt8X16 timesInt8X16 quotInt8X16 remInt8X16 negateInt8X16indexInt8X16ArrayreadInt8X16ArraywriteInt8X16ArrayindexInt8X16OffAddrreadInt8X16OffAddrwriteInt8X16OffAddr MV_Int8X16 V_Int8X16abs'abs#signum'signum#$fUnboxInt8X16$fMVectorMVectorInt8X16$fVectorVectorInt8X16TFCo:R:MVectorsInt8X16TFCo:R:VectorInt8X16 $fPrimInt8X16$fSIMDIntVectorInt8X16$fSIMDVectorInt8X16$fStorableInt8X16$fBoundedInt8X16 $fNumInt8X16 $fShowInt8X16 $fOrdInt8X16 $fEqInt8X16broadcastInt8X32 packInt8X32 unpackInt8X32unsafeInsertInt8X32 mapInt8X32 mapInt8X32# zipInt8X32 foldInt8X32 sumInt8X32 plusInt8X32 minusInt8X32 timesInt8X32 quotInt8X32 remInt8X32 negateInt8X32indexInt8X32ArrayreadInt8X32ArraywriteInt8X32ArrayindexInt8X32OffAddrreadInt8X32OffAddrwriteInt8X32OffAddr MV_Int8X32 V_Int8X32$fUnboxInt8X32$fMVectorMVectorInt8X32$fVectorVectorInt8X32TFCo:R:MVectorsInt8X32TFCo:R:VectorInt8X32 $fPrimInt8X32$fSIMDIntVectorInt8X32$fSIMDVectorInt8X32$fStorableInt8X32$fBoundedInt8X32 $fNumInt8X32 $fShowInt8X32 $fOrdInt8X32 $fEqInt8X32broadcastInt8X64 packInt8X64 unpackInt8X64unsafeInsertInt8X64 mapInt8X64 mapInt8X64# zipInt8X64 foldInt8X64 sumInt8X64 plusInt8X64 minusInt8X64 timesInt8X64 quotInt8X64 remInt8X64 negateInt8X64indexInt8X64ArrayreadInt8X64ArraywriteInt8X64ArrayindexInt8X64OffAddrreadInt8X64OffAddrwriteInt8X64OffAddr MV_Int8X64 V_Int8X64$fUnboxInt8X64$fMVectorMVectorInt8X64$fVectorVectorInt8X64TFCo:R:MVectorsInt8X64TFCo:R:VectorInt8X64 $fPrimInt8X64$fSIMDIntVectorInt8X64$fSIMDVectorInt8X64$fStorableInt8X64$fBoundedInt8X64 $fNumInt8X64 $fShowInt8X64 $fOrdInt8X64 $fEqInt8X64broadcastInt16X8 packInt16X8 unpackInt16X8unsafeInsertInt16X8 mapInt16X8 mapInt16X8# zipInt16X8 foldInt16X8 plusInt16X8 minusInt16X8 timesInt16X8 quotInt16X8 remInt16X8 negateInt16X8indexInt16X8ArrayreadInt16X8ArraywriteInt16X8ArrayindexInt16X8OffAddrreadInt16X8OffAddrwriteInt16X8OffAddr MV_Int16X8 V_Int16X8$fUnboxInt16X8$fMVectorMVectorInt16X8$fVectorVectorInt16X8TFCo:R:MVectorsInt16X8TFCo:R:VectorInt16X8 $fPrimInt16X8$fSIMDIntVectorInt16X8$fSIMDVectorInt16X8$fStorableInt16X8$fBoundedInt16X8 $fNumInt16X8 $fShowInt16X8 $fOrdInt16X8 $fEqInt16X8broadcastInt16X16 packInt16X16unpackInt16X16unsafeInsertInt16X16 mapInt16X16 mapInt16X16# zipInt16X16 foldInt16X16 sumInt16X16 plusInt16X16 minusInt16X16 timesInt16X16 quotInt16X16 remInt16X16negateInt16X16indexInt16X16ArrayreadInt16X16ArraywriteInt16X16ArrayindexInt16X16OffAddrreadInt16X16OffAddrwriteInt16X16OffAddr MV_Int16X16 V_Int16X16$fUnboxInt16X16$fMVectorMVectorInt16X16$fVectorVectorInt16X16TFCo:R:MVectorsInt16X16TFCo:R:VectorInt16X16$fPrimInt16X16$fSIMDIntVectorInt16X16$fSIMDVectorInt16X16$fStorableInt16X16$fBoundedInt16X16 $fNumInt16X16$fShowInt16X16 $fOrdInt16X16 $fEqInt16X16broadcastInt16X32 packInt16X32unpackInt16X32unsafeInsertInt16X32 mapInt16X32 mapInt16X32# zipInt16X32 foldInt16X32 sumInt16X32 plusInt16X32 minusInt16X32 timesInt16X32 quotInt16X32 remInt16X32negateInt16X32indexInt16X32ArrayreadInt16X32ArraywriteInt16X32ArrayindexInt16X32OffAddrreadInt16X32OffAddrwriteInt16X32OffAddr MV_Int16X32 V_Int16X32$fUnboxInt16X32$fMVectorMVectorInt16X32$fVectorVectorInt16X32TFCo:R:MVectorsInt16X32TFCo:R:VectorInt16X32$fPrimInt16X32$fSIMDIntVectorInt16X32$fSIMDVectorInt16X32$fStorableInt16X32$fBoundedInt16X32 $fNumInt16X32$fShowInt16X32 $fOrdInt16X32 $fEqInt16X32broadcastInt32X4 packInt32X4 unpackInt32X4unsafeInsertInt32X4 mapInt32X4 mapInt32X4# zipInt32X4 foldInt32X4 plusInt32X4 minusInt32X4 timesInt32X4 quotInt32X4 remInt32X4 negateInt32X4indexInt32X4ArrayreadInt32X4ArraywriteInt32X4ArrayindexInt32X4OffAddrreadInt32X4OffAddrwriteInt32X4OffAddr MV_Int32X4 V_Int32X4$fUnboxInt32X4$fMVectorMVectorInt32X4$fVectorVectorInt32X4TFCo:R:MVectorsInt32X4TFCo:R:VectorInt32X4 $fPrimInt32X4$fSIMDIntVectorInt32X4$fSIMDVectorInt32X4$fStorableInt32X4$fBoundedInt32X4 $fNumInt32X4 $fShowInt32X4 $fOrdInt32X4 $fEqInt32X4broadcastInt32X8 packInt32X8 unpackInt32X8unsafeInsertInt32X8 mapInt32X8 mapInt32X8# zipInt32X8 foldInt32X8 sumInt32X8 plusInt32X8 minusInt32X8 timesInt32X8 quotInt32X8 remInt32X8 negateInt32X8indexInt32X8ArrayreadInt32X8ArraywriteInt32X8ArrayindexInt32X8OffAddrreadInt32X8OffAddrwriteInt32X8OffAddr MV_Int32X8 V_Int32X8$fUnboxInt32X8$fMVectorMVectorInt32X8$fVectorVectorInt32X8TFCo:R:MVectorsInt32X8TFCo:R:VectorInt32X8 $fPrimInt32X8$fSIMDIntVectorInt32X8$fSIMDVectorInt32X8$fStorableInt32X8$fBoundedInt32X8 $fNumInt32X8 $fShowInt32X8 $fOrdInt32X8 $fEqInt32X8broadcastInt32X16 packInt32X16unpackInt32X16unsafeInsertInt32X16 mapInt32X16 mapInt32X16# zipInt32X16 foldInt32X16 sumInt32X16 plusInt32X16 minusInt32X16 timesInt32X16 quotInt32X16 remInt32X16negateInt32X16indexInt32X16ArrayreadInt32X16ArraywriteInt32X16ArrayindexInt32X16OffAddrreadInt32X16OffAddrwriteInt32X16OffAddr MV_Int32X16 V_Int32X16$fUnboxInt32X16$fMVectorMVectorInt32X16$fVectorVectorInt32X16TFCo:R:MVectorsInt32X16TFCo:R:VectorInt32X16$fPrimInt32X16$fSIMDIntVectorInt32X16$fSIMDVectorInt32X16$fStorableInt32X16$fBoundedInt32X16 $fNumInt32X16$fShowInt32X16 $fOrdInt32X16 $fEqInt32X16broadcastInt64X2 packInt64X2 unpackInt64X2unsafeInsertInt64X2 mapInt64X2 mapInt64X2# zipInt64X2 foldInt64X2 plusInt64X2 minusInt64X2 timesInt64X2 quotInt64X2 remInt64X2 negateInt64X2indexInt64X2ArrayreadInt64X2ArraywriteInt64X2ArrayindexInt64X2OffAddrreadInt64X2OffAddrwriteInt64X2OffAddr RealInt64# MV_Int64X2 V_Int64X2$fUnboxInt64X2$fMVectorMVectorInt64X2$fVectorVectorInt64X2TFCo:R:MVectorsInt64X2TFCo:R:VectorInt64X2 $fPrimInt64X2$fSIMDIntVectorInt64X2$fSIMDVectorInt64X2$fStorableInt64X2$fBoundedInt64X2 $fNumInt64X2 $fShowInt64X2 $fOrdInt64X2 $fEqInt64X2broadcastInt64X4 packInt64X4 unpackInt64X4unsafeInsertInt64X4 mapInt64X4 mapInt64X4# zipInt64X4 foldInt64X4 sumInt64X4 plusInt64X4 minusInt64X4 timesInt64X4 quotInt64X4 remInt64X4 negateInt64X4indexInt64X4ArrayreadInt64X4ArraywriteInt64X4ArrayindexInt64X4OffAddrreadInt64X4OffAddrwriteInt64X4OffAddr MV_Int64X4 V_Int64X4$fUnboxInt64X4$fMVectorMVectorInt64X4$fVectorVectorInt64X4TFCo:R:MVectorsInt64X4TFCo:R:VectorInt64X4 $fPrimInt64X4$fSIMDIntVectorInt64X4$fSIMDVectorInt64X4$fStorableInt64X4$fBoundedInt64X4 $fNumInt64X4 $fShowInt64X4 $fOrdInt64X4 $fEqInt64X4broadcastInt64X8 packInt64X8 unpackInt64X8unsafeInsertInt64X8 mapInt64X8 mapInt64X8# zipInt64X8 foldInt64X8 sumInt64X8 plusInt64X8 minusInt64X8 timesInt64X8 quotInt64X8 remInt64X8 negateInt64X8indexInt64X8ArrayreadInt64X8ArraywriteInt64X8ArrayindexInt64X8OffAddrreadInt64X8OffAddrwriteInt64X8OffAddr MV_Int64X8 V_Int64X8$fUnboxInt64X8$fMVectorMVectorInt64X8$fVectorVectorInt64X8TFCo:R:MVectorsInt64X8TFCo:R:VectorInt64X8 $fPrimInt64X8$fSIMDIntVectorInt64X8$fSIMDVectorInt64X8$fStorableInt64X8$fBoundedInt64X8 $fNumInt64X8 $fShowInt64X8 $fOrdInt64X8 $fEqInt64X8broadcastWord8X16 packWord8X16unpackWord8X16unsafeInsertWord8X16 mapWord8X16 mapWord8X16# zipWord8X16 foldWord8X16 plusWord8X16 minusWord8X16 timesWord8X16 quotWord8X16 remWord8X16indexWord8X16ArrayreadWord8X16ArraywriteWord8X16ArrayindexWord8X16OffAddrreadWord8X16OffAddrwriteWord8X16OffAddr MV_Word8X16 V_Word8X16$fUnboxWord8X16$fMVectorMVectorWord8X16$fVectorVectorWord8X16TFCo:R:MVectorsWord8X16TFCo:R:VectorWord8X16$fPrimWord8X16$fSIMDIntVectorWord8X16$fSIMDVectorWord8X16$fStorableWord8X16$fBoundedWord8X16 $fNumWord8X16$fShowWord8X16 $fOrdWord8X16 $fEqWord8X16broadcastWord8X32 packWord8X32unpackWord8X32unsafeInsertWord8X32 mapWord8X32 mapWord8X32# zipWord8X32 foldWord8X32 sumWord8X32 plusWord8X32 minusWord8X32 timesWord8X32 quotWord8X32 remWord8X32indexWord8X32ArrayreadWord8X32ArraywriteWord8X32ArrayindexWord8X32OffAddrreadWord8X32OffAddrwriteWord8X32OffAddr MV_Word8X32 V_Word8X32$fUnboxWord8X32$fMVectorMVectorWord8X32$fVectorVectorWord8X32TFCo:R:MVectorsWord8X32TFCo:R:VectorWord8X32$fPrimWord8X32$fSIMDIntVectorWord8X32$fSIMDVectorWord8X32$fStorableWord8X32$fBoundedWord8X32 $fNumWord8X32$fShowWord8X32 $fOrdWord8X32 $fEqWord8X32broadcastWord8X64 packWord8X64unpackWord8X64unsafeInsertWord8X64 mapWord8X64 mapWord8X64# zipWord8X64 foldWord8X64 sumWord8X64 plusWord8X64 minusWord8X64 timesWord8X64 quotWord8X64 remWord8X64indexWord8X64ArrayreadWord8X64ArraywriteWord8X64ArrayindexWord8X64OffAddrreadWord8X64OffAddrwriteWord8X64OffAddr MV_Word8X64 V_Word8X64$fUnboxWord8X64$fMVectorMVectorWord8X64$fVectorVectorWord8X64TFCo:R:MVectorsWord8X64TFCo:R:VectorWord8X64$fPrimWord8X64$fSIMDIntVectorWord8X64$fSIMDVectorWord8X64$fStorableWord8X64$fBoundedWord8X64 $fNumWord8X64$fShowWord8X64 $fOrdWord8X64 $fEqWord8X64broadcastWord16X8 packWord16X8unpackWord16X8unsafeInsertWord16X8 mapWord16X8 mapWord16X8# zipWord16X8 foldWord16X8 plusWord16X8 minusWord16X8 timesWord16X8 quotWord16X8 remWord16X8indexWord16X8ArrayreadWord16X8ArraywriteWord16X8ArrayindexWord16X8OffAddrreadWord16X8OffAddrwriteWord16X8OffAddr MV_Word16X8 V_Word16X8$fUnboxWord16X8$fMVectorMVectorWord16X8$fVectorVectorWord16X8TFCo:R:MVectorsWord16X8TFCo:R:VectorWord16X8$fPrimWord16X8$fSIMDIntVectorWord16X8$fSIMDVectorWord16X8$fStorableWord16X8$fBoundedWord16X8 $fNumWord16X8$fShowWord16X8 $fOrdWord16X8 $fEqWord16X8broadcastWord16X16 packWord16X16unpackWord16X16unsafeInsertWord16X16 mapWord16X16 mapWord16X16# zipWord16X16 foldWord16X16 sumWord16X16 plusWord16X16minusWord16X16timesWord16X16 quotWord16X16 remWord16X16indexWord16X16ArrayreadWord16X16ArraywriteWord16X16ArrayindexWord16X16OffAddrreadWord16X16OffAddrwriteWord16X16OffAddr MV_Word16X16 V_Word16X16$fUnboxWord16X16$fMVectorMVectorWord16X16$fVectorVectorWord16X16TFCo:R:MVectorsWord16X16TFCo:R:VectorWord16X16$fPrimWord16X16$fSIMDIntVectorWord16X16$fSIMDVectorWord16X16$fStorableWord16X16$fBoundedWord16X16$fNumWord16X16$fShowWord16X16$fOrdWord16X16 $fEqWord16X16broadcastWord16X32 packWord16X32unpackWord16X32unsafeInsertWord16X32 mapWord16X32 mapWord16X32# zipWord16X32 foldWord16X32 sumWord16X32 plusWord16X32minusWord16X32timesWord16X32 quotWord16X32 remWord16X32indexWord16X32ArrayreadWord16X32ArraywriteWord16X32ArrayindexWord16X32OffAddrreadWord16X32OffAddrwriteWord16X32OffAddr MV_Word16X32 V_Word16X32$fUnboxWord16X32$fMVectorMVectorWord16X32$fVectorVectorWord16X32TFCo:R:MVectorsWord16X32TFCo:R:VectorWord16X32$fPrimWord16X32$fSIMDIntVectorWord16X32$fSIMDVectorWord16X32$fStorableWord16X32$fBoundedWord16X32$fNumWord16X32$fShowWord16X32$fOrdWord16X32 $fEqWord16X32broadcastWord32X4 packWord32X4unpackWord32X4unsafeInsertWord32X4 mapWord32X4 mapWord32X4# zipWord32X4 foldWord32X4 plusWord32X4 minusWord32X4 timesWord32X4 quotWord32X4 remWord32X4indexWord32X4ArrayreadWord32X4ArraywriteWord32X4ArrayindexWord32X4OffAddrreadWord32X4OffAddrwriteWord32X4OffAddr MV_Word32X4 V_Word32X4$fUnboxWord32X4$fMVectorMVectorWord32X4$fVectorVectorWord32X4TFCo:R:MVectorsWord32X4TFCo:R:VectorWord32X4$fPrimWord32X4$fSIMDIntVectorWord32X4$fSIMDVectorWord32X4$fStorableWord32X4$fBoundedWord32X4 $fNumWord32X4$fShowWord32X4 $fOrdWord32X4 $fEqWord32X4broadcastWord32X8 packWord32X8unpackWord32X8unsafeInsertWord32X8 mapWord32X8 mapWord32X8# zipWord32X8 foldWord32X8 sumWord32X8 plusWord32X8 minusWord32X8 timesWord32X8 quotWord32X8 remWord32X8indexWord32X8ArrayreadWord32X8ArraywriteWord32X8ArrayindexWord32X8OffAddrreadWord32X8OffAddrwriteWord32X8OffAddr MV_Word32X8 V_Word32X8$fUnboxWord32X8$fMVectorMVectorWord32X8$fVectorVectorWord32X8TFCo:R:MVectorsWord32X8TFCo:R:VectorWord32X8$fPrimWord32X8$fSIMDIntVectorWord32X8$fSIMDVectorWord32X8$fStorableWord32X8$fBoundedWord32X8 $fNumWord32X8$fShowWord32X8 $fOrdWord32X8 $fEqWord32X8broadcastWord32X16 packWord32X16unpackWord32X16unsafeInsertWord32X16 mapWord32X16 mapWord32X16# zipWord32X16 foldWord32X16 sumWord32X16 plusWord32X16minusWord32X16timesWord32X16 quotWord32X16 remWord32X16indexWord32X16ArrayreadWord32X16ArraywriteWord32X16ArrayindexWord32X16OffAddrreadWord32X16OffAddrwriteWord32X16OffAddr MV_Word32X16 V_Word32X16$fUnboxWord32X16$fMVectorMVectorWord32X16$fVectorVectorWord32X16TFCo:R:MVectorsWord32X16TFCo:R:VectorWord32X16$fPrimWord32X16$fSIMDIntVectorWord32X16$fSIMDVectorWord32X16$fStorableWord32X16$fBoundedWord32X16$fNumWord32X16$fShowWord32X16$fOrdWord32X16 $fEqWord32X16broadcastWord64X2 packWord64X2unpackWord64X2unsafeInsertWord64X2 mapWord64X2 mapWord64X2# zipWord64X2 foldWord64X2 plusWord64X2 minusWord64X2 timesWord64X2 quotWord64X2 remWord64X2indexWord64X2ArrayreadWord64X2ArraywriteWord64X2ArrayindexWord64X2OffAddrreadWord64X2OffAddrwriteWord64X2OffAddr RealWord64# MV_Word64X2 V_Word64X2$fUnboxWord64X2$fMVectorMVectorWord64X2$fVectorVectorWord64X2TFCo:R:MVectorsWord64X2TFCo:R:VectorWord64X2$fPrimWord64X2$fSIMDIntVectorWord64X2$fSIMDVectorWord64X2$fStorableWord64X2$fBoundedWord64X2 $fNumWord64X2$fShowWord64X2 $fOrdWord64X2 $fEqWord64X2broadcastWord64X4 packWord64X4unpackWord64X4unsafeInsertWord64X4 mapWord64X4 mapWord64X4# zipWord64X4 foldWord64X4 sumWord64X4 plusWord64X4 minusWord64X4 timesWord64X4 quotWord64X4 remWord64X4indexWord64X4ArrayreadWord64X4ArraywriteWord64X4ArrayindexWord64X4OffAddrreadWord64X4OffAddrwriteWord64X4OffAddr MV_Word64X4 V_Word64X4$fUnboxWord64X4$fMVectorMVectorWord64X4$fVectorVectorWord64X4TFCo:R:MVectorsWord64X4TFCo:R:VectorWord64X4$fPrimWord64X4$fSIMDIntVectorWord64X4$fSIMDVectorWord64X4$fStorableWord64X4$fBoundedWord64X4 $fNumWord64X4$fShowWord64X4 $fOrdWord64X4 $fEqWord64X4broadcastWord64X8 packWord64X8unpackWord64X8unsafeInsertWord64X8 mapWord64X8 mapWord64X8# zipWord64X8 foldWord64X8 sumWord64X8 plusWord64X8 minusWord64X8 timesWord64X8 quotWord64X8 remWord64X8indexWord64X8ArrayreadWord64X8ArraywriteWord64X8ArrayindexWord64X8OffAddrreadWord64X8OffAddrwriteWord64X8OffAddr MV_Word64X8 V_Word64X8$fUnboxWord64X8$fMVectorMVectorWord64X8$fVectorVectorWord64X8TFCo:R:MVectorsWord64X8TFCo:R:VectorWord64X8$fPrimWord64X8$fSIMDIntVectorWord64X8$fSIMDVectorWord64X8$fStorableWord64X8$fBoundedWord64X8 $fNumWord64X8$fShowWord64X8 $fOrdWord64X8 $fEqWord64X8broadcastFloatX4 packFloatX4 unpackFloatX4unsafeInsertFloatX4 mapFloatX4 mapFloatX4# zipFloatX4 foldFloatX4 plusFloatX4 minusFloatX4 timesFloatX4 divideFloatX4 negateFloatX4indexFloatX4ArrayreadFloatX4ArraywriteFloatX4ArrayindexFloatX4OffAddrreadFloatX4OffAddrwriteFloatX4OffAddr MV_FloatX4 V_FloatX4$fUnboxFloatX4$fMVectorMVectorFloatX4$fVectorVectorFloatX4TFCo:R:MVectorsFloatX4TFCo:R:VectorFloatX4 $fPrimFloatX4$fSIMDVectorFloatX4$fStorableFloatX4$fFloatingFloatX4$fFractionalFloatX4 $fNumFloatX4 $fShowFloatX4 $fOrdFloatX4 $fEqFloatX4broadcastFloatX8 packFloatX8 unpackFloatX8unsafeInsertFloatX8 mapFloatX8 mapFloatX8# zipFloatX8 foldFloatX8 sumFloatX8 plusFloatX8 minusFloatX8 timesFloatX8 divideFloatX8 negateFloatX8indexFloatX8ArrayreadFloatX8ArraywriteFloatX8ArrayindexFloatX8OffAddrreadFloatX8OffAddrwriteFloatX8OffAddr MV_FloatX8 V_FloatX8$fUnboxFloatX8$fMVectorMVectorFloatX8$fVectorVectorFloatX8TFCo:R:MVectorsFloatX8TFCo:R:VectorFloatX8 $fPrimFloatX8$fSIMDVectorFloatX8$fStorableFloatX8$fFloatingFloatX8$fFractionalFloatX8 $fNumFloatX8 $fShowFloatX8 $fOrdFloatX8 $fEqFloatX8broadcastFloatX16 packFloatX16unpackFloatX16unsafeInsertFloatX16 mapFloatX16 mapFloatX16# zipFloatX16 foldFloatX16 sumFloatX16 plusFloatX16 minusFloatX16 timesFloatX16divideFloatX16negateFloatX16indexFloatX16ArrayreadFloatX16ArraywriteFloatX16ArrayindexFloatX16OffAddrreadFloatX16OffAddrwriteFloatX16OffAddr MV_FloatX16 V_FloatX16$fUnboxFloatX16$fMVectorMVectorFloatX16$fVectorVectorFloatX16TFCo:R:MVectorsFloatX16TFCo:R:VectorFloatX16$fPrimFloatX16$fSIMDVectorFloatX16$fStorableFloatX16$fFloatingFloatX16$fFractionalFloatX16 $fNumFloatX16$fShowFloatX16 $fOrdFloatX16 $fEqFloatX16broadcastDoubleX2 packDoubleX2unpackDoubleX2unsafeInsertDoubleX2 mapDoubleX2 mapDoubleX2# zipDoubleX2 foldDoubleX2 plusDoubleX2 minusDoubleX2 timesDoubleX2divideDoubleX2negateDoubleX2indexDoubleX2ArrayreadDoubleX2ArraywriteDoubleX2ArrayindexDoubleX2OffAddrreadDoubleX2OffAddrwriteDoubleX2OffAddr MV_DoubleX2 V_DoubleX2$fUnboxDoubleX2$fMVectorMVectorDoubleX2$fVectorVectorDoubleX2TFCo:R:MVectorsDoubleX2TFCo:R:VectorDoubleX2$fPrimDoubleX2$fSIMDVectorDoubleX2$fStorableDoubleX2$fFloatingDoubleX2$fFractionalDoubleX2 $fNumDoubleX2$fShowDoubleX2 $fOrdDoubleX2 $fEqDoubleX2broadcastDoubleX4 packDoubleX4unpackDoubleX4unsafeInsertDoubleX4 mapDoubleX4 mapDoubleX4# zipDoubleX4 foldDoubleX4 sumDoubleX4 plusDoubleX4 minusDoubleX4 timesDoubleX4divideDoubleX4negateDoubleX4indexDoubleX4ArrayreadDoubleX4ArraywriteDoubleX4ArrayindexDoubleX4OffAddrreadDoubleX4OffAddrwriteDoubleX4OffAddr MV_DoubleX4 V_DoubleX4$fUnboxDoubleX4$fMVectorMVectorDoubleX4$fVectorVectorDoubleX4TFCo:R:MVectorsDoubleX4TFCo:R:VectorDoubleX4$fPrimDoubleX4$fSIMDVectorDoubleX4$fStorableDoubleX4$fFloatingDoubleX4$fFractionalDoubleX4 $fNumDoubleX4$fShowDoubleX4 $fOrdDoubleX4 $fEqDoubleX4broadcastDoubleX8 packDoubleX8unpackDoubleX8unsafeInsertDoubleX8 mapDoubleX8 mapDoubleX8# zipDoubleX8 foldDoubleX8 sumDoubleX8 plusDoubleX8 minusDoubleX8 timesDoubleX8divideDoubleX8negateDoubleX8indexDoubleX8ArrayreadDoubleX8ArraywriteDoubleX8ArrayindexDoubleX8OffAddrreadDoubleX8OffAddrwriteDoubleX8OffAddr MV_DoubleX8 V_DoubleX8$fUnboxDoubleX8$fMVectorMVectorDoubleX8$fVectorVectorDoubleX8TFCo:R:MVectorsDoubleX8TFCo:R:VectorDoubleX8$fPrimDoubleX8$fSIMDVectorDoubleX8$fStorableDoubleX8$fFloatingDoubleX8$fFractionalDoubleX8 $fNumDoubleX8$fShowDoubleX8 $fOrdDoubleX8 $fEqDoubleX8broadcastDoubleX16 packDoubleX16unpackDoubleX16unsafeInsertDoubleX16 mapDoubleX16 mapDoubleX16# zipDoubleX16 foldDoubleX16 sumDoubleX16 plusDoubleX16minusDoubleX16timesDoubleX16divideDoubleX16negateDoubleX16indexDoubleX16ArrayreadDoubleX16ArraywriteDoubleX16ArrayindexDoubleX16OffAddrreadDoubleX16OffAddrwriteDoubleX16OffAddr MV_DoubleX16 V_DoubleX16$fUnboxDoubleX16$fMVectorMVectorDoubleX16$fVectorVectorDoubleX16TFCo:R:MVectorsDoubleX16TFCo:R:VectorDoubleX16$fPrimDoubleX16$fSIMDVectorDoubleX16$fStorableDoubleX16$fFloatingDoubleX16$fFractionalDoubleX16$fNumDoubleX16$fShowDoubleX16$fOrdDoubleX16 $fEqDoubleX16