Movatterモバイル変換
[0]ホーム
{-This is a generated file (generated by genprimopcode).It is not code to actually be used. Its only purpose is to beconsumed by haddock.-}------------------------------------------------------------------------------- |-- Module : GHC.Prim---- Maintainer : ghc-devs@haskell.org-- Stability : internal-- Portability : non-portable (GHC extensions)---- GHC's primitive types and operations.-- Use GHC.Exts from the base package instead of importing this-- module directly.-------------------------------------------------------------------------------{-# LANGUAGE Unsafe #-}{-# LANGUAGE MagicHash #-}{-# LANGUAGE MultiParamTypeClasses #-}{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE UnboxedTuples #-}{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}moduleGHC.Prim(-- * The word size story.-- |Haskell98 specifies that signed integers (type @Int@)-- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals-- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@.-- This is normally set based on the @config.h@ parameter-- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64-- bits on 64-bit machines. However, it can also be explicitly-- set to a smaller number, e.g., 31 bits, to allow the-- possibility of using tag bits. Currently GHC itself has only-- 32-bit and 64-bit variants, but 30 or 31-bit code can be-- exported as an external core file for use in other back ends.---- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@.---- In addition, GHC supports families of explicit-sized integers-- and words at 8, 16, 32, and 64 bits, with the usual-- arithmetic operations, comparisons, and a range of-- conversions. The 8-bit and 16-bit sizes are always-- represented as @Int\#@ and @Word\#@, and the-- operations implemented in terms of the the primops on these-- types, with suitable range restrictions on the results (using-- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families-- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@-- $\geq$ 32; otherwise, these are represented using distinct-- primitive types @Int32\#@ and @Word32\#@. These (when-- needed) have a complete set of corresponding operations;-- however, nearly all of these are implemented as external C-- functions rather than as primops. Exactly the same story-- applies to the 64-bit sizes. All of these details are hidden-- under the @PrelInt@ and @PrelWord@ modules, which use-- @\#if@-defs to invoke the appropriate types and-- operators.---- Word size also matters for the families of primops for-- indexing\/reading\/writing fixed-size quantities at offsets-- from an array base, address, or foreign pointer. Here, a-- slightly different approach is taken. The names of these-- primops are fixed, but their /types/ vary according to-- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word-- size is at least 32 bits then an operator like-- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed-- in the files that expose these primops.---- Finally, there are strongly deprecated primops for coercing-- between @Addr\#@, the primitive type of machine-- addresses, and @Int\#@. These are pretty bogus anyway,-- but will work on existing 32-bit and 64-bit GHC targets; they-- are completely bogus when tag bits are used in @Int\#@,-- so are not available in this case.-- * Char#-- |Operations on 31-bit characters.Char#,gtChar#,geChar#,eqChar#,neChar#,ltChar#,leChar#,ord#,-- * Int#-- |Operations on native-size integers (30+ bits).Int#,(+#),(-#),(*#),mulIntMayOflo#,quotInt#,remInt#,quotRemInt#,andI#,orI#,xorI#,notI#,negateInt#,addIntC#,subIntC#,(>#),(>=#),(==#),(/=#),(<#),(<=#),chr#,int2Word#,int2Float#,int2Double#,word2Float#,word2Double#,uncheckedIShiftL#,uncheckedIShiftRA#,uncheckedIShiftRL#,-- * Word#-- |Operations on native-sized unsigned words (30+ bits).Word#,plusWord#,subWordC#,plusWord2#,minusWord#,timesWord#,timesWord2#,quotWord#,remWord#,quotRemWord#,quotRemWord2#,and#,or#,xor#,not#,uncheckedShiftL#,uncheckedShiftRL#,word2Int#,gtWord#,geWord#,eqWord#,neWord#,ltWord#,leWord#,popCnt8#,popCnt16#,popCnt32#,popCnt64#,popCnt#,pdep8#,pdep16#,pdep32#,pdep64#,pdep#,pext8#,pext16#,pext32#,pext64#,pext#,clz8#,clz16#,clz32#,clz64#,clz#,ctz8#,ctz16#,ctz32#,ctz64#,ctz#,byteSwap16#,byteSwap32#,byteSwap64#,byteSwap#,-- * Narrowings-- |Explicit narrowing of native-sized ints or words.narrow8Int#,narrow16Int#,narrow32Int#,narrow8Word#,narrow16Word#,narrow32Word#,-- * Double#-- |Operations on double-precision (64 bit) floating-point numbers.Double#,(>##),(>=##),(==##),(/=##),(<##),(<=##),(+##),(-##),(*##),(/##),negateDouble#,fabsDouble#,double2Int#,double2Float#,expDouble#,logDouble#,sqrtDouble#,sinDouble#,cosDouble#,tanDouble#,asinDouble#,acosDouble#,atanDouble#,sinhDouble#,coshDouble#,tanhDouble#,(**##),decodeDouble_2Int#,decodeDouble_Int64#,-- * Float#-- |Operations on single-precision (32-bit) floating-point numbers.Float#,gtFloat#,geFloat#,eqFloat#,neFloat#,ltFloat#,leFloat#,plusFloat#,minusFloat#,timesFloat#,divideFloat#,negateFloat#,fabsFloat#,float2Int#,expFloat#,logFloat#,sqrtFloat#,sinFloat#,cosFloat#,tanFloat#,asinFloat#,acosFloat#,atanFloat#,sinhFloat#,coshFloat#,tanhFloat#,powerFloat#,float2Double#,decodeFloat_Int#,-- * Arrays-- |Operations on @Array\#@.Array#,MutableArray#,newArray#,sameMutableArray#,readArray#,writeArray#,sizeofArray#,sizeofMutableArray#,indexArray#,unsafeFreezeArray#,unsafeThawArray#,copyArray#,copyMutableArray#,cloneArray#,cloneMutableArray#,freezeArray#,thawArray#,casArray#,-- * Small Arrays-- |Operations on @SmallArray\#@. A @SmallArray\#@ works-- just like an @Array\#@, but with different space use and-- performance characteristics (that are often useful with small-- arrays). The @SmallArray\#@ and @SmallMutableArray#@-- lack a \`card table\'. The purpose of a card table is to avoid-- having to scan every element of the array on each GC by-- keeping track of which elements have changed since the last GC-- and only scanning those that have changed. So the consequence-- of there being no card table is that the representation is-- somewhat smaller and the writes are somewhat faster (because-- the card table does not need to be updated). The disadvantage-- of course is that for a @SmallMutableArray#@ the whole-- array has to be scanned on each GC. Thus it is best suited for-- use cases where the mutable array is not long lived, e.g.-- where a mutable array is initialised quickly and then frozen-- to become an immutable @SmallArray\#@.--SmallArray#,SmallMutableArray#,newSmallArray#,sameSmallMutableArray#,readSmallArray#,writeSmallArray#,sizeofSmallArray#,sizeofSmallMutableArray#,indexSmallArray#,unsafeFreezeSmallArray#,unsafeThawSmallArray#,copySmallArray#,copySmallMutableArray#,cloneSmallArray#,cloneSmallMutableArray#,freezeSmallArray#,thawSmallArray#,casSmallArray#,-- * Byte Arrays-- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of-- raw memory in the garbage-collected heap, which is not-- scanned for pointers. It carries its own size (in bytes).-- There are-- three sets of operations for accessing byte array contents:-- index for reading from immutable byte arrays, and read\/write-- for mutable byte arrays. Each set contains operations for a-- range of useful primitive data types. Each operation takes-- an offset measured in terms of the size of the primitive type-- being read or written.ByteArray#,MutableByteArray#,newByteArray#,newPinnedByteArray#,newAlignedPinnedByteArray#,isMutableByteArrayPinned#,isByteArrayPinned#,byteArrayContents#,sameMutableByteArray#,shrinkMutableByteArray#,resizeMutableByteArray#,unsafeFreezeByteArray#,sizeofByteArray#,sizeofMutableByteArray#,getSizeofMutableByteArray#,indexCharArray#,indexWideCharArray#,indexIntArray#,indexWordArray#,indexAddrArray#,indexFloatArray#,indexDoubleArray#,indexStablePtrArray#,indexInt8Array#,indexInt16Array#,indexInt32Array#,indexInt64Array#,indexWord8Array#,indexWord16Array#,indexWord32Array#,indexWord64Array#,readCharArray#,readWideCharArray#,readIntArray#,readWordArray#,readAddrArray#,readFloatArray#,readDoubleArray#,readStablePtrArray#,readInt8Array#,readInt16Array#,readInt32Array#,readInt64Array#,readWord8Array#,readWord16Array#,readWord32Array#,readWord64Array#,writeCharArray#,writeWideCharArray#,writeIntArray#,writeWordArray#,writeAddrArray#,writeFloatArray#,writeDoubleArray#,writeStablePtrArray#,writeInt8Array#,writeInt16Array#,writeInt32Array#,writeInt64Array#,writeWord8Array#,writeWord16Array#,writeWord32Array#,writeWord64Array#,compareByteArrays#,copyByteArray#,copyMutableByteArray#,copyByteArrayToAddr#,copyMutableByteArrayToAddr#,copyAddrToByteArray#,setByteArray#,atomicReadIntArray#,atomicWriteIntArray#,casIntArray#,fetchAddIntArray#,fetchSubIntArray#,fetchAndIntArray#,fetchNandIntArray#,fetchOrIntArray#,fetchXorIntArray#,-- * Arrays of arrays-- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed}-- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types,-- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@.-- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific-- indexing, reading, and writing.ArrayArray#,MutableArrayArray#,newArrayArray#,sameMutableArrayArray#,unsafeFreezeArrayArray#,sizeofArrayArray#,sizeofMutableArrayArray#,indexByteArrayArray#,indexArrayArrayArray#,readByteArrayArray#,readMutableByteArrayArray#,readArrayArrayArray#,readMutableArrayArrayArray#,writeByteArrayArray#,writeMutableByteArrayArray#,writeArrayArrayArray#,writeMutableArrayArrayArray#,copyArrayArray#,copyMutableArrayArray#,-- * Addr#-- |Addr#,nullAddr#,plusAddr#,minusAddr#,remAddr#,addr2Int#,int2Addr#,gtAddr#,geAddr#,eqAddr#,neAddr#,ltAddr#,leAddr#,indexCharOffAddr#,indexWideCharOffAddr#,indexIntOffAddr#,indexWordOffAddr#,indexAddrOffAddr#,indexFloatOffAddr#,indexDoubleOffAddr#,indexStablePtrOffAddr#,indexInt8OffAddr#,indexInt16OffAddr#,indexInt32OffAddr#,indexInt64OffAddr#,indexWord8OffAddr#,indexWord16OffAddr#,indexWord32OffAddr#,indexWord64OffAddr#,readCharOffAddr#,readWideCharOffAddr#,readIntOffAddr#,readWordOffAddr#,readAddrOffAddr#,readFloatOffAddr#,readDoubleOffAddr#,readStablePtrOffAddr#,readInt8OffAddr#,readInt16OffAddr#,readInt32OffAddr#,readInt64OffAddr#,readWord8OffAddr#,readWord16OffAddr#,readWord32OffAddr#,readWord64OffAddr#,writeCharOffAddr#,writeWideCharOffAddr#,writeIntOffAddr#,writeWordOffAddr#,writeAddrOffAddr#,writeFloatOffAddr#,writeDoubleOffAddr#,writeStablePtrOffAddr#,writeInt8OffAddr#,writeInt16OffAddr#,writeInt32OffAddr#,writeInt64OffAddr#,writeWord8OffAddr#,writeWord16OffAddr#,writeWord32OffAddr#,writeWord64OffAddr#,-- * Mutable variables-- |Operations on MutVar\#s.MutVar#,newMutVar#,readMutVar#,writeMutVar#,sameMutVar#,atomicModifyMutVar#,casMutVar#,-- * Exceptions-- |catch#,raise#,raiseIO#,maskAsyncExceptions#,maskUninterruptible#,unmaskAsyncExceptions#,getMaskingState#,-- * STM-accessible Mutable Variables-- |TVar#,atomically#,retry#,catchRetry#,catchSTM#,check#,newTVar#,readTVar#,readTVarIO#,writeTVar#,sameTVar#,-- * Synchronized Mutable Variables-- |Operations on @MVar\#@s.MVar#,newMVar#,takeMVar#,tryTakeMVar#,putMVar#,tryPutMVar#,readMVar#,tryReadMVar#,sameMVar#,isEmptyMVar#,-- * Delay\/wait operations-- |delay#,waitRead#,waitWrite#,-- * Concurrency primitives-- |State#,RealWorld,ThreadId#,fork#,forkOn#,killThread#,yield#,myThreadId#,labelThread#,isCurrentThreadBound#,noDuplicate#,threadStatus#,-- * Weak pointers-- |Weak#,mkWeak#,mkWeakNoFinalizer#,addCFinalizerToWeak#,deRefWeak#,finalizeWeak#,touch#,-- * Stable pointers and names-- |StablePtr#,StableName#,makeStablePtr#,deRefStablePtr#,eqStablePtr#,makeStableName#,eqStableName#,stableNameToInt#,-- * Compact normal form-- |Compact#,compactNew#,compactResize#,compactContains#,compactContainsAny#,compactGetFirstBlock#,compactGetNextBlock#,compactAllocateBlock#,compactFixupPointers#,compactAdd#,compactAddWithSharing#,compactSize#,-- * Unsafe pointer equality-- |reallyUnsafePtrEquality#,-- * Parallelism-- |par#,spark#,seq#,getSpark#,numSparks#,-- * Tag to enum stuff-- |Convert back and forth between values of enumerated types-- and small integers.dataToTag#,tagToEnum#,-- * Bytecode operations-- |Support for manipulating bytecode objects used by the interpreter and-- linker.---- Bytecode objects are heap objects which represent top-level bindings and-- contain a list of instructions and data needed by these instructions.BCO#,addrToAny#,anyToAddr#,mkApUpd0#,newBCO#,unpackClosure#,getApStackVal#,-- * Misc-- |These aren\'t nearly as wired in as Etc...getCCSOf#,getCurrentCCS#,clearCCS#,-- * Etc-- |Miscellaneous built-insProxy#,proxy#,seq,unsafeCoerce#,traceEvent#,traceMarker#,-- * Safe coercions-- |coerce,-- * SIMD Vectors-- |Operations on SIMD vectors.Int8X16#,Int16X8#,Int32X4#,Int64X2#,Int8X32#,Int16X16#,Int32X8#,Int64X4#,Int8X64#,Int16X32#,Int32X16#,Int64X8#,Word8X16#,Word16X8#,Word32X4#,Word64X2#,Word8X32#,Word16X16#,Word32X8#,Word64X4#,Word8X64#,Word16X32#,Word32X16#,Word64X8#,FloatX4#,DoubleX2#,FloatX8#,DoubleX4#,FloatX16#,DoubleX8#,broadcastInt8X16#,broadcastInt16X8#,broadcastInt32X4#,broadcastInt64X2#,broadcastInt8X32#,broadcastInt16X16#,broadcastInt32X8#,broadcastInt64X4#,broadcastInt8X64#,broadcastInt16X32#,broadcastInt32X16#,broadcastInt64X8#,broadcastWord8X16#,broadcastWord16X8#,broadcastWord32X4#,broadcastWord64X2#,broadcastWord8X32#,broadcastWord16X16#,broadcastWord32X8#,broadcastWord64X4#,broadcastWord8X64#,broadcastWord16X32#,broadcastWord32X16#,broadcastWord64X8#,broadcastFloatX4#,broadcastDoubleX2#,broadcastFloatX8#,broadcastDoubleX4#,broadcastFloatX16#,broadcastDoubleX8#,packInt8X16#,packInt16X8#,packInt32X4#,packInt64X2#,packInt8X32#,packInt16X16#,packInt32X8#,packInt64X4#,packInt8X64#,packInt16X32#,packInt32X16#,packInt64X8#,packWord8X16#,packWord16X8#,packWord32X4#,packWord64X2#,packWord8X32#,packWord16X16#,packWord32X8#,packWord64X4#,packWord8X64#,packWord16X32#,packWord32X16#,packWord64X8#,packFloatX4#,packDoubleX2#,packFloatX8#,packDoubleX4#,packFloatX16#,packDoubleX8#,unpackInt8X16#,unpackInt16X8#,unpackInt32X4#,unpackInt64X2#,unpackInt8X32#,unpackInt16X16#,unpackInt32X8#,unpackInt64X4#,unpackInt8X64#,unpackInt16X32#,unpackInt32X16#,unpackInt64X8#,unpackWord8X16#,unpackWord16X8#,unpackWord32X4#,unpackWord64X2#,unpackWord8X32#,unpackWord16X16#,unpackWord32X8#,unpackWord64X4#,unpackWord8X64#,unpackWord16X32#,unpackWord32X16#,unpackWord64X8#,unpackFloatX4#,unpackDoubleX2#,unpackFloatX8#,unpackDoubleX4#,unpackFloatX16#,unpackDoubleX8#,insertInt8X16#,insertInt16X8#,insertInt32X4#,insertInt64X2#,insertInt8X32#,insertInt16X16#,insertInt32X8#,insertInt64X4#,insertInt8X64#,insertInt16X32#,insertInt32X16#,insertInt64X8#,insertWord8X16#,insertWord16X8#,insertWord32X4#,insertWord64X2#,insertWord8X32#,insertWord16X16#,insertWord32X8#,insertWord64X4#,insertWord8X64#,insertWord16X32#,insertWord32X16#,insertWord64X8#,insertFloatX4#,insertDoubleX2#,insertFloatX8#,insertDoubleX4#,insertFloatX16#,insertDoubleX8#,plusInt8X16#,plusInt16X8#,plusInt32X4#,plusInt64X2#,plusInt8X32#,plusInt16X16#,plusInt32X8#,plusInt64X4#,plusInt8X64#,plusInt16X32#,plusInt32X16#,plusInt64X8#,plusWord8X16#,plusWord16X8#,plusWord32X4#,plusWord64X2#,plusWord8X32#,plusWord16X16#,plusWord32X8#,plusWord64X4#,plusWord8X64#,plusWord16X32#,plusWord32X16#,plusWord64X8#,plusFloatX4#,plusDoubleX2#,plusFloatX8#,plusDoubleX4#,plusFloatX16#,plusDoubleX8#,minusInt8X16#,minusInt16X8#,minusInt32X4#,minusInt64X2#,minusInt8X32#,minusInt16X16#,minusInt32X8#,minusInt64X4#,minusInt8X64#,minusInt16X32#,minusInt32X16#,minusInt64X8#,minusWord8X16#,minusWord16X8#,minusWord32X4#,minusWord64X2#,minusWord8X32#,minusWord16X16#,minusWord32X8#,minusWord64X4#,minusWord8X64#,minusWord16X32#,minusWord32X16#,minusWord64X8#,minusFloatX4#,minusDoubleX2#,minusFloatX8#,minusDoubleX4#,minusFloatX16#,minusDoubleX8#,timesInt8X16#,timesInt16X8#,timesInt32X4#,timesInt64X2#,timesInt8X32#,timesInt16X16#,timesInt32X8#,timesInt64X4#,timesInt8X64#,timesInt16X32#,timesInt32X16#,timesInt64X8#,timesWord8X16#,timesWord16X8#,timesWord32X4#,timesWord64X2#,timesWord8X32#,timesWord16X16#,timesWord32X8#,timesWord64X4#,timesWord8X64#,timesWord16X32#,timesWord32X16#,timesWord64X8#,timesFloatX4#,timesDoubleX2#,timesFloatX8#,timesDoubleX4#,timesFloatX16#,timesDoubleX8#,divideFloatX4#,divideDoubleX2#,divideFloatX8#,divideDoubleX4#,divideFloatX16#,divideDoubleX8#,quotInt8X16#,quotInt16X8#,quotInt32X4#,quotInt64X2#,quotInt8X32#,quotInt16X16#,quotInt32X8#,quotInt64X4#,quotInt8X64#,quotInt16X32#,quotInt32X16#,quotInt64X8#,quotWord8X16#,quotWord16X8#,quotWord32X4#,quotWord64X2#,quotWord8X32#,quotWord16X16#,quotWord32X8#,quotWord64X4#,quotWord8X64#,quotWord16X32#,quotWord32X16#,quotWord64X8#,remInt8X16#,remInt16X8#,remInt32X4#,remInt64X2#,remInt8X32#,remInt16X16#,remInt32X8#,remInt64X4#,remInt8X64#,remInt16X32#,remInt32X16#,remInt64X8#,remWord8X16#,remWord16X8#,remWord32X4#,remWord64X2#,remWord8X32#,remWord16X16#,remWord32X8#,remWord64X4#,remWord8X64#,remWord16X32#,remWord32X16#,remWord64X8#,negateInt8X16#,negateInt16X8#,negateInt32X4#,negateInt64X2#,negateInt8X32#,negateInt16X16#,negateInt32X8#,negateInt64X4#,negateInt8X64#,negateInt16X32#,negateInt32X16#,negateInt64X8#,negateFloatX4#,negateDoubleX2#,negateFloatX8#,negateDoubleX4#,negateFloatX16#,negateDoubleX8#,indexInt8X16Array#,indexInt16X8Array#,indexInt32X4Array#,indexInt64X2Array#,indexInt8X32Array#,indexInt16X16Array#,indexInt32X8Array#,indexInt64X4Array#,indexInt8X64Array#,indexInt16X32Array#,indexInt32X16Array#,indexInt64X8Array#,indexWord8X16Array#,indexWord16X8Array#,indexWord32X4Array#,indexWord64X2Array#,indexWord8X32Array#,indexWord16X16Array#,indexWord32X8Array#,indexWord64X4Array#,indexWord8X64Array#,indexWord16X32Array#,indexWord32X16Array#,indexWord64X8Array#,indexFloatX4Array#,indexDoubleX2Array#,indexFloatX8Array#,indexDoubleX4Array#,indexFloatX16Array#,indexDoubleX8Array#,readInt8X16Array#,readInt16X8Array#,readInt32X4Array#,readInt64X2Array#,readInt8X32Array#,readInt16X16Array#,readInt32X8Array#,readInt64X4Array#,readInt8X64Array#,readInt16X32Array#,readInt32X16Array#,readInt64X8Array#,readWord8X16Array#,readWord16X8Array#,readWord32X4Array#,readWord64X2Array#,readWord8X32Array#,readWord16X16Array#,readWord32X8Array#,readWord64X4Array#,readWord8X64Array#,readWord16X32Array#,readWord32X16Array#,readWord64X8Array#,readFloatX4Array#,readDoubleX2Array#,readFloatX8Array#,readDoubleX4Array#,readFloatX16Array#,readDoubleX8Array#,writeInt8X16Array#,writeInt16X8Array#,writeInt32X4Array#,writeInt64X2Array#,writeInt8X32Array#,writeInt16X16Array#,writeInt32X8Array#,writeInt64X4Array#,writeInt8X64Array#,writeInt16X32Array#,writeInt32X16Array#,writeInt64X8Array#,writeWord8X16Array#,writeWord16X8Array#,writeWord32X4Array#,writeWord64X2Array#,writeWord8X32Array#,writeWord16X16Array#,writeWord32X8Array#,writeWord64X4Array#,writeWord8X64Array#,writeWord16X32Array#,writeWord32X16Array#,writeWord64X8Array#,writeFloatX4Array#,writeDoubleX2Array#,writeFloatX8Array#,writeDoubleX4Array#,writeFloatX16Array#,writeDoubleX8Array#,indexInt8X16OffAddr#,indexInt16X8OffAddr#,indexInt32X4OffAddr#,indexInt64X2OffAddr#,indexInt8X32OffAddr#,indexInt16X16OffAddr#,indexInt32X8OffAddr#,indexInt64X4OffAddr#,indexInt8X64OffAddr#,indexInt16X32OffAddr#,indexInt32X16OffAddr#,indexInt64X8OffAddr#,indexWord8X16OffAddr#,indexWord16X8OffAddr#,indexWord32X4OffAddr#,indexWord64X2OffAddr#,indexWord8X32OffAddr#,indexWord16X16OffAddr#,indexWord32X8OffAddr#,indexWord64X4OffAddr#,indexWord8X64OffAddr#,indexWord16X32OffAddr#,indexWord32X16OffAddr#,indexWord64X8OffAddr#,indexFloatX4OffAddr#,indexDoubleX2OffAddr#,indexFloatX8OffAddr#,indexDoubleX4OffAddr#,indexFloatX16OffAddr#,indexDoubleX8OffAddr#,readInt8X16OffAddr#,readInt16X8OffAddr#,readInt32X4OffAddr#,readInt64X2OffAddr#,readInt8X32OffAddr#,readInt16X16OffAddr#,readInt32X8OffAddr#,readInt64X4OffAddr#,readInt8X64OffAddr#,readInt16X32OffAddr#,readInt32X16OffAddr#,readInt64X8OffAddr#,readWord8X16OffAddr#,readWord16X8OffAddr#,readWord32X4OffAddr#,readWord64X2OffAddr#,readWord8X32OffAddr#,readWord16X16OffAddr#,readWord32X8OffAddr#,readWord64X4OffAddr#,readWord8X64OffAddr#,readWord16X32OffAddr#,readWord32X16OffAddr#,readWord64X8OffAddr#,readFloatX4OffAddr#,readDoubleX2OffAddr#,readFloatX8OffAddr#,readDoubleX4OffAddr#,readFloatX16OffAddr#,readDoubleX8OffAddr#,writeInt8X16OffAddr#,writeInt16X8OffAddr#,writeInt32X4OffAddr#,writeInt64X2OffAddr#,writeInt8X32OffAddr#,writeInt16X16OffAddr#,writeInt32X8OffAddr#,writeInt64X4OffAddr#,writeInt8X64OffAddr#,writeInt16X32OffAddr#,writeInt32X16OffAddr#,writeInt64X8OffAddr#,writeWord8X16OffAddr#,writeWord16X8OffAddr#,writeWord32X4OffAddr#,writeWord64X2OffAddr#,writeWord8X32OffAddr#,writeWord16X16OffAddr#,writeWord32X8OffAddr#,writeWord64X4OffAddr#,writeWord8X64OffAddr#,writeWord16X32OffAddr#,writeWord32X16OffAddr#,writeWord64X8OffAddr#,writeFloatX4OffAddr#,writeDoubleX2OffAddr#,writeFloatX8OffAddr#,writeDoubleX4OffAddr#,writeFloatX16OffAddr#,writeDoubleX8OffAddr#,indexInt8ArrayAsInt8X16#,indexInt16ArrayAsInt16X8#,indexInt32ArrayAsInt32X4#,indexInt64ArrayAsInt64X2#,indexInt8ArrayAsInt8X32#,indexInt16ArrayAsInt16X16#,indexInt32ArrayAsInt32X8#,indexInt64ArrayAsInt64X4#,indexInt8ArrayAsInt8X64#,indexInt16ArrayAsInt16X32#,indexInt32ArrayAsInt32X16#,indexInt64ArrayAsInt64X8#,indexWord8ArrayAsWord8X16#,indexWord16ArrayAsWord16X8#,indexWord32ArrayAsWord32X4#,indexWord64ArrayAsWord64X2#,indexWord8ArrayAsWord8X32#,indexWord16ArrayAsWord16X16#,indexWord32ArrayAsWord32X8#,indexWord64ArrayAsWord64X4#,indexWord8ArrayAsWord8X64#,indexWord16ArrayAsWord16X32#,indexWord32ArrayAsWord32X16#,indexWord64ArrayAsWord64X8#,indexFloatArrayAsFloatX4#,indexDoubleArrayAsDoubleX2#,indexFloatArrayAsFloatX8#,indexDoubleArrayAsDoubleX4#,indexFloatArrayAsFloatX16#,indexDoubleArrayAsDoubleX8#,readInt8ArrayAsInt8X16#,readInt16ArrayAsInt16X8#,readInt32ArrayAsInt32X4#,readInt64ArrayAsInt64X2#,readInt8ArrayAsInt8X32#,readInt16ArrayAsInt16X16#,readInt32ArrayAsInt32X8#,readInt64ArrayAsInt64X4#,readInt8ArrayAsInt8X64#,readInt16ArrayAsInt16X32#,readInt32ArrayAsInt32X16#,readInt64ArrayAsInt64X8#,readWord8ArrayAsWord8X16#,readWord16ArrayAsWord16X8#,readWord32ArrayAsWord32X4#,readWord64ArrayAsWord64X2#,readWord8ArrayAsWord8X32#,readWord16ArrayAsWord16X16#,readWord32ArrayAsWord32X8#,readWord64ArrayAsWord64X4#,readWord8ArrayAsWord8X64#,readWord16ArrayAsWord16X32#,readWord32ArrayAsWord32X16#,readWord64ArrayAsWord64X8#,readFloatArrayAsFloatX4#,readDoubleArrayAsDoubleX2#,readFloatArrayAsFloatX8#,readDoubleArrayAsDoubleX4#,readFloatArrayAsFloatX16#,readDoubleArrayAsDoubleX8#,writeInt8ArrayAsInt8X16#,writeInt16ArrayAsInt16X8#,writeInt32ArrayAsInt32X4#,writeInt64ArrayAsInt64X2#,writeInt8ArrayAsInt8X32#,writeInt16ArrayAsInt16X16#,writeInt32ArrayAsInt32X8#,writeInt64ArrayAsInt64X4#,writeInt8ArrayAsInt8X64#,writeInt16ArrayAsInt16X32#,writeInt32ArrayAsInt32X16#,writeInt64ArrayAsInt64X8#,writeWord8ArrayAsWord8X16#,writeWord16ArrayAsWord16X8#,writeWord32ArrayAsWord32X4#,writeWord64ArrayAsWord64X2#,writeWord8ArrayAsWord8X32#,writeWord16ArrayAsWord16X16#,writeWord32ArrayAsWord32X8#,writeWord64ArrayAsWord64X4#,writeWord8ArrayAsWord8X64#,writeWord16ArrayAsWord16X32#,writeWord32ArrayAsWord32X16#,writeWord64ArrayAsWord64X8#,writeFloatArrayAsFloatX4#,writeDoubleArrayAsDoubleX2#,writeFloatArrayAsFloatX8#,writeDoubleArrayAsDoubleX4#,writeFloatArrayAsFloatX16#,writeDoubleArrayAsDoubleX8#,indexInt8OffAddrAsInt8X16#,indexInt16OffAddrAsInt16X8#,indexInt32OffAddrAsInt32X4#,indexInt64OffAddrAsInt64X2#,indexInt8OffAddrAsInt8X32#,indexInt16OffAddrAsInt16X16#,indexInt32OffAddrAsInt32X8#,indexInt64OffAddrAsInt64X4#,indexInt8OffAddrAsInt8X64#,indexInt16OffAddrAsInt16X32#,indexInt32OffAddrAsInt32X16#,indexInt64OffAddrAsInt64X8#,indexWord8OffAddrAsWord8X16#,indexWord16OffAddrAsWord16X8#,indexWord32OffAddrAsWord32X4#,indexWord64OffAddrAsWord64X2#,indexWord8OffAddrAsWord8X32#,indexWord16OffAddrAsWord16X16#,indexWord32OffAddrAsWord32X8#,indexWord64OffAddrAsWord64X4#,indexWord8OffAddrAsWord8X64#,indexWord16OffAddrAsWord16X32#,indexWord32OffAddrAsWord32X16#,indexWord64OffAddrAsWord64X8#,indexFloatOffAddrAsFloatX4#,indexDoubleOffAddrAsDoubleX2#,indexFloatOffAddrAsFloatX8#,indexDoubleOffAddrAsDoubleX4#,indexFloatOffAddrAsFloatX16#,indexDoubleOffAddrAsDoubleX8#,readInt8OffAddrAsInt8X16#,readInt16OffAddrAsInt16X8#,readInt32OffAddrAsInt32X4#,readInt64OffAddrAsInt64X2#,readInt8OffAddrAsInt8X32#,readInt16OffAddrAsInt16X16#,readInt32OffAddrAsInt32X8#,readInt64OffAddrAsInt64X4#,readInt8OffAddrAsInt8X64#,readInt16OffAddrAsInt16X32#,readInt32OffAddrAsInt32X16#,readInt64OffAddrAsInt64X8#,readWord8OffAddrAsWord8X16#,readWord16OffAddrAsWord16X8#,readWord32OffAddrAsWord32X4#,readWord64OffAddrAsWord64X2#,readWord8OffAddrAsWord8X32#,readWord16OffAddrAsWord16X16#,readWord32OffAddrAsWord32X8#,readWord64OffAddrAsWord64X4#,readWord8OffAddrAsWord8X64#,readWord16OffAddrAsWord16X32#,readWord32OffAddrAsWord32X16#,readWord64OffAddrAsWord64X8#,readFloatOffAddrAsFloatX4#,readDoubleOffAddrAsDoubleX2#,readFloatOffAddrAsFloatX8#,readDoubleOffAddrAsDoubleX4#,readFloatOffAddrAsFloatX16#,readDoubleOffAddrAsDoubleX8#,writeInt8OffAddrAsInt8X16#,writeInt16OffAddrAsInt16X8#,writeInt32OffAddrAsInt32X4#,writeInt64OffAddrAsInt64X2#,writeInt8OffAddrAsInt8X32#,writeInt16OffAddrAsInt16X16#,writeInt32OffAddrAsInt32X8#,writeInt64OffAddrAsInt64X4#,writeInt8OffAddrAsInt8X64#,writeInt16OffAddrAsInt16X32#,writeInt32OffAddrAsInt32X16#,writeInt64OffAddrAsInt64X8#,writeWord8OffAddrAsWord8X16#,writeWord16OffAddrAsWord16X8#,writeWord32OffAddrAsWord32X4#,writeWord64OffAddrAsWord64X2#,writeWord8OffAddrAsWord8X32#,writeWord16OffAddrAsWord16X16#,writeWord32OffAddrAsWord32X8#,writeWord64OffAddrAsWord64X4#,writeWord8OffAddrAsWord8X64#,writeWord16OffAddrAsWord16X32#,writeWord32OffAddrAsWord32X16#,writeWord64OffAddrAsWord64X8#,writeFloatOffAddrAsFloatX4#,writeDoubleOffAddrAsDoubleX2#,writeFloatOffAddrAsFloatX8#,writeDoubleOffAddrAsDoubleX4#,writeFloatOffAddrAsFloatX16#,writeDoubleOffAddrAsDoubleX8#,-- * Prefetch-- |Prefetch operations: Note how every prefetch operation has a name-- with the pattern prefetch*N#, where N is either 0,1,2, or 3.---- This suffix number, N, is the \"locality level\" of the prefetch, following the-- convention in GCC and other compilers.-- Higher locality numbers correspond to the memory being loaded in more-- levels of the cpu cache, and being retained after initial use. The naming-- convention follows the naming convention of the prefetch intrinsic found-- in the GCC and Clang C compilers.---- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic-- with locality level N. The code generated by LLVM is target architecture-- dependent, but should agree with the GHC NCG on x86 systems.---- On the Sparc and PPC native backends, prefetch*N is a No-Op.---- On the x86 NCG, N=0 will generate prefetchNTA,-- N=1 generates prefetcht2, N=2 generates prefetcht1, and-- N=3 generates prefetcht0.---- For streaming workloads, the prefetch*0 operations are recommended.-- For workloads which do many reads or writes to a memory location in a short period of time,-- prefetch*3 operations are recommended.---- For further reading about prefetch and associated systems performance optimization,-- the instruction set and optimization manuals by Intel and other CPU vendors are-- excellent starting place.------ The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is-- especially a helpful read, even if your software is meant for other CPU-- architectures or vendor hardware. The manual can be found at-- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html .---- The @prefetch*@ family of operations has the order of operations-- determined by passing around the @State#@ token.---- To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context.---- It is important to note that while the prefetch operations will never change the-- answer to a pure computation, They CAN change the memory locations resident-- in a CPU cache and that may change the performance and timing characteristics-- of an application. The prefetch operations are marked has_side_effects=True-- to reflect that these operations have side effects with respect to the runtime-- performance characteristics of the resulting code. Additionally, if the prefetchValue-- operations did not have this attribute, GHC does a float out transformation that-- results in a let\/app violation, at least with the current design.--prefetchByteArray3#,prefetchMutableByteArray3#,prefetchAddr3#,prefetchValue3#,prefetchByteArray2#,prefetchMutableByteArray2#,prefetchAddr2#,prefetchValue2#,prefetchByteArray1#,prefetchMutableByteArray1#,prefetchAddr1#,prefetchValue1#,prefetchByteArray0#,prefetchMutableByteArray0#,prefetchAddr0#,prefetchValue0#,)where{-has_side_effects = Falseout_of_line = Falsecan_fail = Falsecommutable = Falsecode_size = { primOpCodeSizeDefault }strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }fixity = Nothingllvm_only = False-}importGHC.Types(Coercible)default()dataChar#gtChar#::Char#->Char#->Int#gtChar#=gtChar#geChar#::Char#->Char#->Int#geChar#=geChar#eqChar#::Char#->Char#->Int#eqChar#=eqChar#neChar#::Char#->Char#->Int#neChar#=neChar#ltChar#::Char#->Char#->Int#ltChar#=ltChar#leChar#::Char#->Char#->Int#leChar#=leChar#ord#::Char#->Int#ord#=ord#dataInt#infixl6+#(+#)::Int#->Int#->Int#(+#)=(+#)infixl6-#(-#)::Int#->Int#->Int#(-#)=(-#)-- |Low word of signed integer multiply.infixl7*#(*#)::Int#->Int#->Int#(*#)=(*#)-- |Return non-zero if there is any possibility that the upper word of a-- signed integer multiply might contain useful information. Return-- zero only if you are completely sure that no overflow can occur.-- On a 32-bit platform, the recommended implementation is to do a-- 32 x 32 -> 64 signed multiply, and subtract result[63:32] from-- (result[31] >>signed 31). If this is zero, meaning that the-- upper word is merely a sign extension of the lower one, no-- overflow can occur.---- On a 64-bit platform it is not always possible to-- acquire the top 64 bits of the result. Therefore, a recommended-- implementation is to take the absolute value of both operands, and-- return 0 iff bits[63:31] of them are zero, since that means that their-- magnitudes fit within 31 bits, so the magnitude of the product must fit-- into 62 bits.---- If in doubt, return non-zero, but do make an effort to create the-- correct answer for small args, since otherwise the performance of-- @(*) :: Integer -> Integer -> Integer@ will be poor.--mulIntMayOflo#::Int#->Int#->Int#mulIntMayOflo#=mulIntMayOflo#-- |Rounds towards zero. The behavior is undefined if the second argument is-- zero.--quotInt#::Int#->Int#->Int#quotInt#=quotInt#-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@. The-- behavior is undefined if the second argument is zero.--remInt#::Int#->Int#->Int#remInt#=remInt#-- |Rounds towards zero.quotRemInt#::Int#->Int#->(#Int#,Int##)quotRemInt#=quotRemInt#andI#::Int#->Int#->Int#andI#=andI#orI#::Int#->Int#->Int#orI#=orI#xorI#::Int#->Int#->Int#xorI#=xorI#notI#::Int#->Int#notI#=notI#negateInt#::Int#->Int#negateInt#=negateInt#-- |Add signed integers reporting overflow.-- First member of result is the sum truncated to an @Int#@;-- second member is zero if the true sum fits in an @Int#@,-- nonzero if overflow occurred (the sum is either too large-- or too small to fit in an @Int#@).addIntC#::Int#->Int#->(#Int#,Int##)addIntC#=addIntC#-- |Subtract signed integers reporting overflow.-- First member of result is the difference truncated to an @Int#@;-- second member is zero if the true difference fits in an @Int#@,-- nonzero if overflow occurred (the difference is either too large-- or too small to fit in an @Int#@).subIntC#::Int#->Int#->(#Int#,Int##)subIntC#=subIntC#infix4>#(>#)::Int#->Int#->Int#(>#)=(>#)infix4>=#(>=#)::Int#->Int#->Int#(>=#)=(>=#)infix4==#(==#)::Int#->Int#->Int#(==#)=(==#)infix4/=#(/=#)::Int#->Int#->Int#(/=#)=(/=#)infix4<#(<#)::Int#->Int#->Int#(<#)=(<#)infix4<=#(<=#)::Int#->Int#->Int#(<=#)=(<=#)chr#::Int#->Char#chr#=chr#int2Word#::Int#->Word#int2Word#=int2Word#int2Float#::Int#->Float#int2Float#=int2Float#int2Double#::Int#->Double#int2Double#=int2Double#word2Float#::Word#->Float#word2Float#=word2Float#word2Double#::Word#->Double#word2Double#=word2Double#-- |Shift left. Result undefined if shift amount is not-- in the range 0 to word size - 1 inclusive.uncheckedIShiftL#::Int#->Int#->Int#uncheckedIShiftL#=uncheckedIShiftL#-- |Shift right arithmetic. Result undefined if shift amount is not-- in the range 0 to word size - 1 inclusive.uncheckedIShiftRA#::Int#->Int#->Int#uncheckedIShiftRA#=uncheckedIShiftRA#-- |Shift right logical. Result undefined if shift amount is not-- in the range 0 to word size - 1 inclusive.uncheckedIShiftRL#::Int#->Int#->Int#uncheckedIShiftRL#=uncheckedIShiftRL#dataWord#plusWord#::Word#->Word#->Word#plusWord#=plusWord#-- |Subtract unsigned integers reporting overflow.-- The first element of the pair is the result. The second element is-- the carry flag, which is nonzero on overflow.subWordC#::Word#->Word#->(#Word#,Int##)subWordC#=subWordC#plusWord2#::Word#->Word#->(#Word#,Word##)plusWord2#=plusWord2#minusWord#::Word#->Word#->Word#minusWord#=minusWord#timesWord#::Word#->Word#->Word#timesWord#=timesWord#timesWord2#::Word#->Word#->(#Word#,Word##)timesWord2#=timesWord2#quotWord#::Word#->Word#->Word#quotWord#=quotWord#remWord#::Word#->Word#->Word#remWord#=remWord#quotRemWord#::Word#->Word#->(#Word#,Word##)quotRemWord#=quotRemWord#quotRemWord2#::Word#->Word#->Word#->(#Word#,Word##)quotRemWord2#=quotRemWord2#and#::Word#->Word#->Word#and#=and#or#::Word#->Word#->Word#or#=or#xor#::Word#->Word#->Word#xor#=xor#not#::Word#->Word#not#=not#-- |Shift left logical. Result undefined if shift amount is not-- in the range 0 to word size - 1 inclusive.uncheckedShiftL#::Word#->Int#->Word#uncheckedShiftL#=uncheckedShiftL#-- |Shift right logical. Result undefined if shift amount is not-- in the range 0 to word size - 1 inclusive.uncheckedShiftRL#::Word#->Int#->Word#uncheckedShiftRL#=uncheckedShiftRL#word2Int#::Word#->Int#word2Int#=word2Int#gtWord#::Word#->Word#->Int#gtWord#=gtWord#geWord#::Word#->Word#->Int#geWord#=geWord#eqWord#::Word#->Word#->Int#eqWord#=eqWord#neWord#::Word#->Word#->Int#neWord#=neWord#ltWord#::Word#->Word#->Int#ltWord#=ltWord#leWord#::Word#->Word#->Int#leWord#=leWord#-- |Count the number of set bits in the lower 8 bits of a word.popCnt8#::Word#->Word#popCnt8#=popCnt8#-- |Count the number of set bits in the lower 16 bits of a word.popCnt16#::Word#->Word#popCnt16#=popCnt16#-- |Count the number of set bits in the lower 32 bits of a word.popCnt32#::Word#->Word#popCnt32#=popCnt32#-- |Count the number of set bits in a 64-bit word.popCnt64#::Word#->Word#popCnt64#=popCnt64#-- |Count the number of set bits in a word.popCnt#::Word#->Word#popCnt#=popCnt#-- |Deposit bits to lower 8 bits of a word at locations specified by a mask.pdep8#::Word#->Word#->Word#pdep8#=pdep8#-- |Deposit bits to lower 16 bits of a word at locations specified by a mask.pdep16#::Word#->Word#->Word#pdep16#=pdep16#-- |Deposit bits to lower 32 bits of a word at locations specified by a mask.pdep32#::Word#->Word#->Word#pdep32#=pdep32#-- |Deposit bits to a word at locations specified by a mask.pdep64#::Word#->Word#->Word#pdep64#=pdep64#-- |Deposit bits to a word at locations specified by a mask.pdep#::Word#->Word#->Word#pdep#=pdep#-- |Extract bits from lower 8 bits of a word at locations specified by a mask.pext8#::Word#->Word#->Word#pext8#=pext8#-- |Extract bits from lower 16 bits of a word at locations specified by a mask.pext16#::Word#->Word#->Word#pext16#=pext16#-- |Extract bits from lower 32 bits of a word at locations specified by a mask.pext32#::Word#->Word#->Word#pext32#=pext32#-- |Extract bits from a word at locations specified by a mask.pext64#::Word#->Word#->Word#pext64#=pext64#-- |Extract bits from a word at locations specified by a mask.pext#::Word#->Word#->Word#pext#=pext#-- |Count leading zeros in the lower 8 bits of a word.clz8#::Word#->Word#clz8#=clz8#-- |Count leading zeros in the lower 16 bits of a word.clz16#::Word#->Word#clz16#=clz16#-- |Count leading zeros in the lower 32 bits of a word.clz32#::Word#->Word#clz32#=clz32#-- |Count leading zeros in a 64-bit word.clz64#::Word#->Word#clz64#=clz64#-- |Count leading zeros in a word.clz#::Word#->Word#clz#=clz#-- |Count trailing zeros in the lower 8 bits of a word.ctz8#::Word#->Word#ctz8#=ctz8#-- |Count trailing zeros in the lower 16 bits of a word.ctz16#::Word#->Word#ctz16#=ctz16#-- |Count trailing zeros in the lower 32 bits of a word.ctz32#::Word#->Word#ctz32#=ctz32#-- |Count trailing zeros in a 64-bit word.ctz64#::Word#->Word#ctz64#=ctz64#-- |Count trailing zeros in a word.ctz#::Word#->Word#ctz#=ctz#-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined.byteSwap16#::Word#->Word#byteSwap16#=byteSwap16#-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined.byteSwap32#::Word#->Word#byteSwap32#=byteSwap32#-- |Swap bytes in a 64 bits of a word.byteSwap64#::Word#->Word#byteSwap64#=byteSwap64#-- |Swap bytes in a word.byteSwap#::Word#->Word#byteSwap#=byteSwap#narrow8Int#::Int#->Int#narrow8Int#=narrow8Int#narrow16Int#::Int#->Int#narrow16Int#=narrow16Int#narrow32Int#::Int#->Int#narrow32Int#=narrow32Int#narrow8Word#::Word#->Word#narrow8Word#=narrow8Word#narrow16Word#::Word#->Word#narrow16Word#=narrow16Word#narrow32Word#::Word#->Word#narrow32Word#=narrow32Word#dataDouble#infix4>##(>##)::Double#->Double#->Int#(>##)=(>##)infix4>=##(>=##)::Double#->Double#->Int#(>=##)=(>=##)infix4==##(==##)::Double#->Double#->Int#(==##)=(==##)infix4/=##(/=##)::Double#->Double#->Int#(/=##)=(/=##)infix4<##(<##)::Double#->Double#->Int#(<##)=(<##)infix4<=##(<=##)::Double#->Double#->Int#(<=##)=(<=##)infixl6+##(+##)::Double#->Double#->Double#(+##)=(+##)infixl6-##(-##)::Double#->Double#->Double#(-##)=(-##)infixl7*##(*##)::Double#->Double#->Double#(*##)=(*##)infixl7/##(/##)::Double#->Double#->Double#(/##)=(/##)negateDouble#::Double#->Double#negateDouble#=negateDouble#fabsDouble#::Double#->Double#fabsDouble#=fabsDouble#-- |Truncates a @Double#@ value to the nearest @Int#@.-- Results are undefined if the truncation if truncation yields-- a value outside the range of @Int#@.double2Int#::Double#->Int#double2Int#=double2Int#double2Float#::Double#->Float#double2Float#=double2Float#expDouble#::Double#->Double#expDouble#=expDouble#logDouble#::Double#->Double#logDouble#=logDouble#sqrtDouble#::Double#->Double#sqrtDouble#=sqrtDouble#sinDouble#::Double#->Double#sinDouble#=sinDouble#cosDouble#::Double#->Double#cosDouble#=cosDouble#tanDouble#::Double#->Double#tanDouble#=tanDouble#asinDouble#::Double#->Double#asinDouble#=asinDouble#acosDouble#::Double#->Double#acosDouble#=acosDouble#atanDouble#::Double#->Double#atanDouble#=atanDouble#sinhDouble#::Double#->Double#sinhDouble#=sinhDouble#coshDouble#::Double#->Double#coshDouble#=coshDouble#tanhDouble#::Double#->Double#tanhDouble#=tanhDouble#-- |Exponentiation.(**##)::Double#->Double#->Double#(**##)=(**##)-- |Convert to integer.-- First component of the result is -1 or 1, indicating the sign of the-- mantissa. The next two are the high and low 32 bits of the mantissa-- respectively, and the last is the exponent.decodeDouble_2Int#::Double#->(#Int#,Word#,Word#,Int##)decodeDouble_2Int#=decodeDouble_2Int#-- |Decode @Double\#@ into mantissa and base-2 exponent.decodeDouble_Int64#::Double#->(#Int#,Int##)decodeDouble_Int64#=decodeDouble_Int64#dataFloat#gtFloat#::Float#->Float#->Int#gtFloat#=gtFloat#geFloat#::Float#->Float#->Int#geFloat#=geFloat#eqFloat#::Float#->Float#->Int#eqFloat#=eqFloat#neFloat#::Float#->Float#->Int#neFloat#=neFloat#ltFloat#::Float#->Float#->Int#ltFloat#=ltFloat#leFloat#::Float#->Float#->Int#leFloat#=leFloat#plusFloat#::Float#->Float#->Float#plusFloat#=plusFloat#minusFloat#::Float#->Float#->Float#minusFloat#=minusFloat#timesFloat#::Float#->Float#->Float#timesFloat#=timesFloat#divideFloat#::Float#->Float#->Float#divideFloat#=divideFloat#negateFloat#::Float#->Float#negateFloat#=negateFloat#fabsFloat#::Float#->Float#fabsFloat#=fabsFloat#-- |Truncates a @Float#@ value to the nearest @Int#@.-- Results are undefined if the truncation if truncation yields-- a value outside the range of @Int#@.float2Int#::Float#->Int#float2Int#=float2Int#expFloat#::Float#->Float#expFloat#=expFloat#logFloat#::Float#->Float#logFloat#=logFloat#sqrtFloat#::Float#->Float#sqrtFloat#=sqrtFloat#sinFloat#::Float#->Float#sinFloat#=sinFloat#cosFloat#::Float#->Float#cosFloat#=cosFloat#tanFloat#::Float#->Float#tanFloat#=tanFloat#asinFloat#::Float#->Float#asinFloat#=asinFloat#acosFloat#::Float#->Float#acosFloat#=acosFloat#atanFloat#::Float#->Float#atanFloat#=atanFloat#sinhFloat#::Float#->Float#sinhFloat#=sinhFloat#coshFloat#::Float#->Float#coshFloat#=coshFloat#tanhFloat#::Float#->Float#tanhFloat#=tanhFloat#powerFloat#::Float#->Float#->Float#powerFloat#=powerFloat#float2Double#::Float#->Double#float2Double#=float2Double#-- |Convert to integers.-- First @Int\#@ in result is the mantissa; second is the exponent.decodeFloat_Int#::Float#->(#Int#,Int##)decodeFloat_Int#=decodeFloat_Int#dataArray#adataMutableArray#sa-- |Create a new mutable array with the specified number of elements,-- in the specified state thread,-- with each element containing the specified initial value.newArray#::Int#->a->State#s->(#State#s,MutableArray#sa#)newArray#=newArray#sameMutableArray#::MutableArray#sa->MutableArray#sa->Int#sameMutableArray#=sameMutableArray#-- |Read from specified index of mutable array. Result is not yet evaluated.readArray#::MutableArray#sa->Int#->State#s->(#State#s,a#)readArray#=readArray#-- |Write to specified index of mutable array.writeArray#::MutableArray#sa->Int#->a->State#s->State#swriteArray#=writeArray#-- |Return the number of elements in the array.sizeofArray#::Array#a->Int#sizeofArray#=sizeofArray#-- |Return the number of elements in the array.sizeofMutableArray#::MutableArray#sa->Int#sizeofMutableArray#=sizeofMutableArray#-- |Read from specified index of immutable array. Result is packaged into-- an unboxed singleton; the result itself is not yet evaluated.indexArray#::Array#a->Int#->(#a#)indexArray#=indexArray#-- |Make a mutable array immutable, without copying.unsafeFreezeArray#::MutableArray#sa->State#s->(#State#s,Array#a#)unsafeFreezeArray#=unsafeFreezeArray#-- |Make an immutable array mutable, without copying.unsafeThawArray#::Array#a->State#s->(#State#s,MutableArray#sa#)unsafeThawArray#=unsafeThawArray#-- |Given a source array, an offset into the source array, a-- destination array, an offset into the destination array, and a-- number of elements to copy, copy the elements from the source array-- to the destination array. Both arrays must fully contain the-- specified ranges, but this is not checked. The two arrays must not-- be the same array in different states, but this is not checked-- either.copyArray#::Array#a->Int#->MutableArray#sa->Int#->Int#->State#s->State#scopyArray#=copyArray#-- |Given a source array, an offset into the source array, a-- destination array, an offset into the destination array, and a-- number of elements to copy, copy the elements from the source array-- to the destination array. Both arrays must fully contain the-- specified ranges, but this is not checked. In the case where-- the source and destination are the same array the source and-- destination regions may overlap.copyMutableArray#::MutableArray#sa->Int#->MutableArray#sa->Int#->Int#->State#s->State#scopyMutableArray#=copyMutableArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.cloneArray#::Array#a->Int#->Int#->Array#acloneArray#=cloneArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.cloneMutableArray#::MutableArray#sa->Int#->Int#->State#s->(#State#s,MutableArray#sa#)cloneMutableArray#=cloneMutableArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.freezeArray#::MutableArray#sa->Int#->Int#->State#s->(#State#s,Array#a#)freezeArray#=freezeArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.thawArray#::Array#a->Int#->Int#->State#s->(#State#s,MutableArray#sa#)thawArray#=thawArray#-- |Unsafe, machine-level atomic compare and swap on an element within an Array.casArray#::MutableArray#sa->Int#->a->a->State#s->(#State#s,Int#,a#)casArray#=casArray#dataSmallArray#adataSmallMutableArray#sa-- |Create a new mutable array with the specified number of elements,-- in the specified state thread,-- with each element containing the specified initial value.newSmallArray#::Int#->a->State#s->(#State#s,SmallMutableArray#sa#)newSmallArray#=newSmallArray#sameSmallMutableArray#::SmallMutableArray#sa->SmallMutableArray#sa->Int#sameSmallMutableArray#=sameSmallMutableArray#-- |Read from specified index of mutable array. Result is not yet evaluated.readSmallArray#::SmallMutableArray#sa->Int#->State#s->(#State#s,a#)readSmallArray#=readSmallArray#-- |Write to specified index of mutable array.writeSmallArray#::SmallMutableArray#sa->Int#->a->State#s->State#swriteSmallArray#=writeSmallArray#-- |Return the number of elements in the array.sizeofSmallArray#::SmallArray#a->Int#sizeofSmallArray#=sizeofSmallArray#-- |Return the number of elements in the array.sizeofSmallMutableArray#::SmallMutableArray#sa->Int#sizeofSmallMutableArray#=sizeofSmallMutableArray#-- |Read from specified index of immutable array. Result is packaged into-- an unboxed singleton; the result itself is not yet evaluated.indexSmallArray#::SmallArray#a->Int#->(#a#)indexSmallArray#=indexSmallArray#-- |Make a mutable array immutable, without copying.unsafeFreezeSmallArray#::SmallMutableArray#sa->State#s->(#State#s,SmallArray#a#)unsafeFreezeSmallArray#=unsafeFreezeSmallArray#-- |Make an immutable array mutable, without copying.unsafeThawSmallArray#::SmallArray#a->State#s->(#State#s,SmallMutableArray#sa#)unsafeThawSmallArray#=unsafeThawSmallArray#-- |Given a source array, an offset into the source array, a-- destination array, an offset into the destination array, and a-- number of elements to copy, copy the elements from the source array-- to the destination array. Both arrays must fully contain the-- specified ranges, but this is not checked. The two arrays must not-- be the same array in different states, but this is not checked-- either.copySmallArray#::SmallArray#a->Int#->SmallMutableArray#sa->Int#->Int#->State#s->State#scopySmallArray#=copySmallArray#-- |Given a source array, an offset into the source array, a-- destination array, an offset into the destination array, and a-- number of elements to copy, copy the elements from the source array-- to the destination array. The source and destination arrays can-- refer to the same array. Both arrays must fully contain the-- specified ranges, but this is not checked.-- The regions are allowed to overlap, although this is only possible when the same-- array is provided as both the source and the destination.copySmallMutableArray#::SmallMutableArray#sa->Int#->SmallMutableArray#sa->Int#->Int#->State#s->State#scopySmallMutableArray#=copySmallMutableArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.cloneSmallArray#::SmallArray#a->Int#->Int#->SmallArray#acloneSmallArray#=cloneSmallArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.cloneSmallMutableArray#::SmallMutableArray#sa->Int#->Int#->State#s->(#State#s,SmallMutableArray#sa#)cloneSmallMutableArray#=cloneSmallMutableArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.freezeSmallArray#::SmallMutableArray#sa->Int#->Int#->State#s->(#State#s,SmallArray#a#)freezeSmallArray#=freezeSmallArray#-- |Given a source array, an offset into the source array, and a number-- of elements to copy, create a new array with the elements from the-- source array. The provided array must fully contain the specified-- range, but this is not checked.thawSmallArray#::SmallArray#a->Int#->Int#->State#s->(#State#s,SmallMutableArray#sa#)thawSmallArray#=thawSmallArray#-- |Unsafe, machine-level atomic compare and swap on an element within an array.casSmallArray#::SmallMutableArray#sa->Int#->a->a->State#s->(#State#s,Int#,a#)casSmallArray#=casSmallArray#dataByteArray#dataMutableByteArray#s-- |Create a new mutable byte array of specified size (in bytes), in-- the specified state thread.newByteArray#::Int#->State#s->(#State#s,MutableByteArray#s#)newByteArray#=newByteArray#-- |Create a mutable byte array that the GC guarantees not to move.newPinnedByteArray#::Int#->State#s->(#State#s,MutableByteArray#s#)newPinnedByteArray#=newPinnedByteArray#-- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.newAlignedPinnedByteArray#::Int#->Int#->State#s->(#State#s,MutableByteArray#s#)newAlignedPinnedByteArray#=newAlignedPinnedByteArray#-- |Determine whether a @MutableByteArray\#@ is guaranteed not to move-- during GC.isMutableByteArrayPinned#::MutableByteArray#s->Int#isMutableByteArrayPinned#=isMutableByteArrayPinned#-- |Determine whether a @ByteArray\#@ is guaranteed not to move during GC.isByteArrayPinned#::ByteArray#->Int#isByteArrayPinned#=isByteArrayPinned#-- |Intended for use with pinned arrays; otherwise very unsafe!byteArrayContents#::ByteArray#->Addr#byteArrayContents#=byteArrayContents#sameMutableByteArray#::MutableByteArray#s->MutableByteArray#s->Int#sameMutableByteArray#=sameMutableByteArray#-- |Shrink mutable byte array to new specified size (in bytes), in-- the specified state thread. The new size argument must be less than or-- equal to the current size as reported by @sizeofMutableArray\#@.shrinkMutableByteArray#::MutableByteArray#s->Int#->State#s->State#sshrinkMutableByteArray#=shrinkMutableByteArray#-- |Resize (unpinned) mutable byte array to new specified size (in bytes).-- The returned @MutableByteArray\#@ is either the original-- @MutableByteArray\#@ resized in-place or, if not possible, a newly-- allocated (unpinned) @MutableByteArray\#@ (with the original content-- copied over).---- To avoid undefined behaviour, the original @MutableByteArray\#@ shall-- not be accessed anymore after a @resizeMutableByteArray\#@ has been-- performed. Moreover, no reference to the old one should be kept in order-- to allow garbage collection of the original @MutableByteArray\#@ in-- case a new @MutableByteArray\#@ had to be allocated.resizeMutableByteArray#::MutableByteArray#s->Int#->State#s->(#State#s,MutableByteArray#s#)resizeMutableByteArray#=resizeMutableByteArray#-- |Make a mutable byte array immutable, without copying.unsafeFreezeByteArray#::MutableByteArray#s->State#s->(#State#s,ByteArray##)unsafeFreezeByteArray#=unsafeFreezeByteArray#-- |Return the size of the array in bytes.sizeofByteArray#::ByteArray#->Int#sizeofByteArray#=sizeofByteArray#-- |Return the size of the array in bytes. Note that this is deprecated as it is-- unsafe in the presence of concurrent resize operations on the same byte-- array. See @getSizeofMutableByteArray@.sizeofMutableByteArray#::MutableByteArray#s->Int#sizeofMutableByteArray#=sizeofMutableByteArray#-- |Return the number of elements in the array.getSizeofMutableByteArray#::MutableByteArray#s->State#s->(#State#s,Int##)getSizeofMutableByteArray#=getSizeofMutableByteArray#-- |Read 8-bit character; offset in bytes.indexCharArray#::ByteArray#->Int#->Char#indexCharArray#=indexCharArray#-- |Read 31-bit character; offset in 4-byte words.indexWideCharArray#::ByteArray#->Int#->Char#indexWideCharArray#=indexWideCharArray#indexIntArray#::ByteArray#->Int#->Int#indexIntArray#=indexIntArray#indexWordArray#::ByteArray#->Int#->Word#indexWordArray#=indexWordArray#indexAddrArray#::ByteArray#->Int#->Addr#indexAddrArray#=indexAddrArray#indexFloatArray#::ByteArray#->Int#->Float#indexFloatArray#=indexFloatArray#indexDoubleArray#::ByteArray#->Int#->Double#indexDoubleArray#=indexDoubleArray#indexStablePtrArray#::ByteArray#->Int#->StablePtr#aindexStablePtrArray#=indexStablePtrArray#-- |Read 8-bit integer; offset in bytes.indexInt8Array#::ByteArray#->Int#->Int#indexInt8Array#=indexInt8Array#-- |Read 16-bit integer; offset in 16-bit words.indexInt16Array#::ByteArray#->Int#->Int#indexInt16Array#=indexInt16Array#-- |Read 32-bit integer; offset in 32-bit words.indexInt32Array#::ByteArray#->Int#->Int#indexInt32Array#=indexInt32Array#-- |Read 64-bit integer; offset in 64-bit words.indexInt64Array#::ByteArray#->Int#->Int#indexInt64Array#=indexInt64Array#-- |Read 8-bit word; offset in bytes.indexWord8Array#::ByteArray#->Int#->Word#indexWord8Array#=indexWord8Array#-- |Read 16-bit word; offset in 16-bit words.indexWord16Array#::ByteArray#->Int#->Word#indexWord16Array#=indexWord16Array#-- |Read 32-bit word; offset in 32-bit words.indexWord32Array#::ByteArray#->Int#->Word#indexWord32Array#=indexWord32Array#-- |Read 64-bit word; offset in 64-bit words.indexWord64Array#::ByteArray#->Int#->Word#indexWord64Array#=indexWord64Array#-- |Read 8-bit character; offset in bytes.readCharArray#::MutableByteArray#s->Int#->State#s->(#State#s,Char##)readCharArray#=readCharArray#-- |Read 31-bit character; offset in 4-byte words.readWideCharArray#::MutableByteArray#s->Int#->State#s->(#State#s,Char##)readWideCharArray#=readWideCharArray#-- |Read integer; offset in words.readIntArray#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)readIntArray#=readIntArray#-- |Read word; offset in words.readWordArray#::MutableByteArray#s->Int#->State#s->(#State#s,Word##)readWordArray#=readWordArray#readAddrArray#::MutableByteArray#s->Int#->State#s->(#State#s,Addr##)readAddrArray#=readAddrArray#readFloatArray#::MutableByteArray#s->Int#->State#s->(#State#s,Float##)readFloatArray#=readFloatArray#readDoubleArray#::MutableByteArray#s->Int#->State#s->(#State#s,Double##)readDoubleArray#=readDoubleArray#readStablePtrArray#::MutableByteArray#s->Int#->State#s->(#State#s,StablePtr#a#)readStablePtrArray#=readStablePtrArray#readInt8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)readInt8Array#=readInt8Array#readInt16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)readInt16Array#=readInt16Array#readInt32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)readInt32Array#=readInt32Array#readInt64Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)readInt64Array#=readInt64Array#readWord8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word##)readWord8Array#=readWord8Array#readWord16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word##)readWord16Array#=readWord16Array#readWord32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word##)readWord32Array#=readWord32Array#readWord64Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word##)readWord64Array#=readWord64Array#-- |Write 8-bit character; offset in bytes.writeCharArray#::MutableByteArray#s->Int#->Char#->State#s->State#swriteCharArray#=writeCharArray#-- |Write 31-bit character; offset in 4-byte words.writeWideCharArray#::MutableByteArray#s->Int#->Char#->State#s->State#swriteWideCharArray#=writeWideCharArray#writeIntArray#::MutableByteArray#s->Int#->Int#->State#s->State#swriteIntArray#=writeIntArray#writeWordArray#::MutableByteArray#s->Int#->Word#->State#s->State#swriteWordArray#=writeWordArray#writeAddrArray#::MutableByteArray#s->Int#->Addr#->State#s->State#swriteAddrArray#=writeAddrArray#writeFloatArray#::MutableByteArray#s->Int#->Float#->State#s->State#swriteFloatArray#=writeFloatArray#writeDoubleArray#::MutableByteArray#s->Int#->Double#->State#s->State#swriteDoubleArray#=writeDoubleArray#writeStablePtrArray#::MutableByteArray#s->Int#->StablePtr#a->State#s->State#swriteStablePtrArray#=writeStablePtrArray#writeInt8Array#::MutableByteArray#s->Int#->Int#->State#s->State#swriteInt8Array#=writeInt8Array#writeInt16Array#::MutableByteArray#s->Int#->Int#->State#s->State#swriteInt16Array#=writeInt16Array#writeInt32Array#::MutableByteArray#s->Int#->Int#->State#s->State#swriteInt32Array#=writeInt32Array#writeInt64Array#::MutableByteArray#s->Int#->Int#->State#s->State#swriteInt64Array#=writeInt64Array#writeWord8Array#::MutableByteArray#s->Int#->Word#->State#s->State#swriteWord8Array#=writeWord8Array#writeWord16Array#::MutableByteArray#s->Int#->Word#->State#s->State#swriteWord16Array#=writeWord16Array#writeWord32Array#::MutableByteArray#s->Int#->Word#->State#s->State#swriteWord32Array#=writeWord32Array#writeWord64Array#::MutableByteArray#s->Int#->Word#->State#s->State#swriteWord64Array#=writeWord64Array#-- |@compareByteArrays# src1 src1_ofs src2 src2_ofs n@ compares-- @n@ bytes starting at offset @src1_ofs@ in the first-- @ByteArray#@ @src1@ to the range of @n@ bytes-- (i.e. same length) starting at offset @src2_ofs@ of the second-- @ByteArray#@ @src2@. Both arrays must fully contain the-- specified ranges, but this is not checked. Returns an @Int#@-- less than, equal to, or greater than zero if the range is found,-- respectively, to be byte-wise lexicographically less than, to-- match, or be greater than the second range.compareByteArrays#::ByteArray#->Int#->ByteArray#->Int#->Int#->Int#compareByteArrays#=compareByteArrays#-- |@copyByteArray# src src_ofs dst dst_ofs n@ copies the range-- starting at offset @src_ofs@ of length @n@ from the-- @ByteArray#@ @src@ to the @MutableByteArray#@ @dst@-- starting at offset @dst_ofs@. Both arrays must fully contain-- the specified ranges, but this is not checked. The two arrays must-- not be the same array in different states, but this is not checked-- either.copyByteArray#::ByteArray#->Int#->MutableByteArray#s->Int#->Int#->State#s->State#scopyByteArray#=copyByteArray#-- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#.-- Both arrays must fully contain the specified ranges, but this is not checked. The regions are-- allowed to overlap, although this is only possible when the same array is provided-- as both the source and the destination.copyMutableByteArray#::MutableByteArray#s->Int#->MutableByteArray#s->Int#->Int#->State#s->State#scopyMutableByteArray#=copyMutableByteArray#-- |Copy a range of the ByteArray# to the memory range starting at the Addr#.-- The ByteArray# and the memory region at Addr# must fully contain the-- specified ranges, but this is not checked. The Addr# must not point into the-- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked-- either.copyByteArrayToAddr#::ByteArray#->Int#->Addr#->Int#->State#s->State#scopyByteArrayToAddr#=copyByteArrayToAddr#-- |Copy a range of the MutableByteArray# to the memory range starting at the-- Addr#. The MutableByteArray# and the memory region at Addr# must fully-- contain the specified ranges, but this is not checked. The Addr# must not-- point into the MutableByteArray# (e.g. if the MutableByteArray# were-- pinned), but this is not checked either.copyMutableByteArrayToAddr#::MutableByteArray#s->Int#->Addr#->Int#->State#s->State#scopyMutableByteArrayToAddr#=copyMutableByteArrayToAddr#-- |Copy a memory range starting at the Addr# to the specified range in the-- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully-- contain the specified ranges, but this is not checked. The Addr# must not-- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned),-- but this is not checked either.copyAddrToByteArray#::Addr#->MutableByteArray#s->Int#->Int#->State#s->State#scopyAddrToByteArray#=copyAddrToByteArray#-- |@setByteArray# ba off len c@ sets the byte range @[off, off+len]@ of-- the @MutableByteArray#@ to the byte @c@.setByteArray#::MutableByteArray#s->Int#->Int#->Int#->State#s->State#ssetByteArray#=setByteArray#-- |Given an array and an offset in Int units, read an element. The-- index is assumed to be in bounds. Implies a full memory barrier.atomicReadIntArray#::MutableByteArray#s->Int#->State#s->(#State#s,Int##)atomicReadIntArray#=atomicReadIntArray#-- |Given an array and an offset in Int units, write an element. The-- index is assumed to be in bounds. Implies a full memory barrier.atomicWriteIntArray#::MutableByteArray#s->Int#->Int#->State#s->State#satomicWriteIntArray#=atomicWriteIntArray#-- |Given an array, an offset in Int units, the expected old value, and-- the new value, perform an atomic compare and swap i.e. write the new-- value if the current value matches the provided old value. Returns-- the value of the element before the operation. Implies a full memory-- barrier.casIntArray#::MutableByteArray#s->Int#->Int#->Int#->State#s->(#State#s,Int##)casIntArray#=casIntArray#-- |Given an array, and offset in Int units, and a value to add,-- atomically add the value to the element. Returns the value of the-- element before the operation. Implies a full memory barrier.fetchAddIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchAddIntArray#=fetchAddIntArray#-- |Given an array, and offset in Int units, and a value to subtract,-- atomically substract the value to the element. Returns the value of-- the element before the operation. Implies a full memory barrier.fetchSubIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchSubIntArray#=fetchSubIntArray#-- |Given an array, and offset in Int units, and a value to AND,-- atomically AND the value to the element. Returns the value of the-- element before the operation. Implies a full memory barrier.fetchAndIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchAndIntArray#=fetchAndIntArray#-- |Given an array, and offset in Int units, and a value to NAND,-- atomically NAND the value to the element. Returns the value of the-- element before the operation. Implies a full memory barrier.fetchNandIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchNandIntArray#=fetchNandIntArray#-- |Given an array, and offset in Int units, and a value to OR,-- atomically OR the value to the element. Returns the value of the-- element before the operation. Implies a full memory barrier.fetchOrIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchOrIntArray#=fetchOrIntArray#-- |Given an array, and offset in Int units, and a value to XOR,-- atomically XOR the value to the element. Returns the value of the-- element before the operation. Implies a full memory barrier.fetchXorIntArray#::MutableByteArray#s->Int#->Int#->State#s->(#State#s,Int##)fetchXorIntArray#=fetchXorIntArray#dataArrayArray#dataMutableArrayArray#s-- |Create a new mutable array of arrays with the specified number of elements,-- in the specified state thread, with each element recursively referring to the-- newly created array.newArrayArray#::Int#->State#s->(#State#s,MutableArrayArray#s#)newArrayArray#=newArrayArray#sameMutableArrayArray#::MutableArrayArray#s->MutableArrayArray#s->Int#sameMutableArrayArray#=sameMutableArrayArray#-- |Make a mutable array of arrays immutable, without copying.unsafeFreezeArrayArray#::MutableArrayArray#s->State#s->(#State#s,ArrayArray##)unsafeFreezeArrayArray#=unsafeFreezeArrayArray#-- |Return the number of elements in the array.sizeofArrayArray#::ArrayArray#->Int#sizeofArrayArray#=sizeofArrayArray#-- |Return the number of elements in the array.sizeofMutableArrayArray#::MutableArrayArray#s->Int#sizeofMutableArrayArray#=sizeofMutableArrayArray#indexByteArrayArray#::ArrayArray#->Int#->ByteArray#indexByteArrayArray#=indexByteArrayArray#indexArrayArrayArray#::ArrayArray#->Int#->ArrayArray#indexArrayArrayArray#=indexArrayArrayArray#readByteArrayArray#::MutableArrayArray#s->Int#->State#s->(#State#s,ByteArray##)readByteArrayArray#=readByteArrayArray#readMutableByteArrayArray#::MutableArrayArray#s->Int#->State#s->(#State#s,MutableByteArray#s#)readMutableByteArrayArray#=readMutableByteArrayArray#readArrayArrayArray#::MutableArrayArray#s->Int#->State#s->(#State#s,ArrayArray##)readArrayArrayArray#=readArrayArrayArray#readMutableArrayArrayArray#::MutableArrayArray#s->Int#->State#s->(#State#s,MutableArrayArray#s#)readMutableArrayArrayArray#=readMutableArrayArrayArray#writeByteArrayArray#::MutableArrayArray#s->Int#->ByteArray#->State#s->State#swriteByteArrayArray#=writeByteArrayArray#writeMutableByteArrayArray#::MutableArrayArray#s->Int#->MutableByteArray#s->State#s->State#swriteMutableByteArrayArray#=writeMutableByteArrayArray#writeArrayArrayArray#::MutableArrayArray#s->Int#->ArrayArray#->State#s->State#swriteArrayArrayArray#=writeArrayArrayArray#writeMutableArrayArrayArray#::MutableArrayArray#s->Int#->MutableArrayArray#s->State#s->State#swriteMutableArrayArrayArray#=writeMutableArrayArrayArray#-- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#.-- Both arrays must fully contain the specified ranges, but this is not checked.-- The two arrays must not be the same array in different states, but this is not checked either.copyArrayArray#::ArrayArray#->Int#->MutableArrayArray#s->Int#->Int#->State#s->State#scopyArrayArray#=copyArrayArray#-- |Copy a range of the first MutableArrayArray# to the specified region in the second-- MutableArrayArray#.-- Both arrays must fully contain the specified ranges, but this is not checked.-- The regions are allowed to overlap, although this is only possible when the same-- array is provided as both the source and the destination.--copyMutableArrayArray#::MutableArrayArray#s->Int#->MutableArrayArray#s->Int#->Int#->State#s->State#scopyMutableArrayArray#=copyMutableArrayArray#-- | An arbitrary machine address assumed to point outside-- the garbage-collected heap.dataAddr#-- | The null address.nullAddr#::Addr#nullAddr#=nullAddr#plusAddr#::Addr#->Int#->Addr#plusAddr#=plusAddr#-- |Result is meaningless if two @Addr\#@s are so far apart that their-- difference doesn\'t fit in an @Int\#@.minusAddr#::Addr#->Addr#->Int#minusAddr#=minusAddr#-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,-- is divided by the @Int\#@ arg.remAddr#::Addr#->Int#->Int#remAddr#=remAddr#-- |Coerce directly from address to int. Strongly deprecated.addr2Int#::Addr#->Int#addr2Int#=addr2Int#-- |Coerce directly from int to address. Strongly deprecated.int2Addr#::Int#->Addr#int2Addr#=int2Addr#gtAddr#::Addr#->Addr#->Int#gtAddr#=gtAddr#geAddr#::Addr#->Addr#->Int#geAddr#=geAddr#eqAddr#::Addr#->Addr#->Int#eqAddr#=eqAddr#neAddr#::Addr#->Addr#->Int#neAddr#=neAddr#ltAddr#::Addr#->Addr#->Int#ltAddr#=ltAddr#leAddr#::Addr#->Addr#->Int#leAddr#=leAddr#-- |Reads 8-bit character; offset in bytes.indexCharOffAddr#::Addr#->Int#->Char#indexCharOffAddr#=indexCharOffAddr#-- |Reads 31-bit character; offset in 4-byte words.indexWideCharOffAddr#::Addr#->Int#->Char#indexWideCharOffAddr#=indexWideCharOffAddr#indexIntOffAddr#::Addr#->Int#->Int#indexIntOffAddr#=indexIntOffAddr#indexWordOffAddr#::Addr#->Int#->Word#indexWordOffAddr#=indexWordOffAddr#indexAddrOffAddr#::Addr#->Int#->Addr#indexAddrOffAddr#=indexAddrOffAddr#indexFloatOffAddr#::Addr#->Int#->Float#indexFloatOffAddr#=indexFloatOffAddr#indexDoubleOffAddr#::Addr#->Int#->Double#indexDoubleOffAddr#=indexDoubleOffAddr#indexStablePtrOffAddr#::Addr#->Int#->StablePtr#aindexStablePtrOffAddr#=indexStablePtrOffAddr#indexInt8OffAddr#::Addr#->Int#->Int#indexInt8OffAddr#=indexInt8OffAddr#indexInt16OffAddr#::Addr#->Int#->Int#indexInt16OffAddr#=indexInt16OffAddr#indexInt32OffAddr#::Addr#->Int#->Int#indexInt32OffAddr#=indexInt32OffAddr#indexInt64OffAddr#::Addr#->Int#->Int#indexInt64OffAddr#=indexInt64OffAddr#indexWord8OffAddr#::Addr#->Int#->Word#indexWord8OffAddr#=indexWord8OffAddr#indexWord16OffAddr#::Addr#->Int#->Word#indexWord16OffAddr#=indexWord16OffAddr#indexWord32OffAddr#::Addr#->Int#->Word#indexWord32OffAddr#=indexWord32OffAddr#indexWord64OffAddr#::Addr#->Int#->Word#indexWord64OffAddr#=indexWord64OffAddr#-- |Reads 8-bit character; offset in bytes.readCharOffAddr#::Addr#->Int#->State#s->(#State#s,Char##)readCharOffAddr#=readCharOffAddr#-- |Reads 31-bit character; offset in 4-byte words.readWideCharOffAddr#::Addr#->Int#->State#s->(#State#s,Char##)readWideCharOffAddr#=readWideCharOffAddr#readIntOffAddr#::Addr#->Int#->State#s->(#State#s,Int##)readIntOffAddr#=readIntOffAddr#readWordOffAddr#::Addr#->Int#->State#s->(#State#s,Word##)readWordOffAddr#=readWordOffAddr#readAddrOffAddr#::Addr#->Int#->State#s->(#State#s,Addr##)readAddrOffAddr#=readAddrOffAddr#readFloatOffAddr#::Addr#->Int#->State#s->(#State#s,Float##)readFloatOffAddr#=readFloatOffAddr#readDoubleOffAddr#::Addr#->Int#->State#s->(#State#s,Double##)readDoubleOffAddr#=readDoubleOffAddr#readStablePtrOffAddr#::Addr#->Int#->State#s->(#State#s,StablePtr#a#)readStablePtrOffAddr#=readStablePtrOffAddr#readInt8OffAddr#::Addr#->Int#->State#s->(#State#s,Int##)readInt8OffAddr#=readInt8OffAddr#readInt16OffAddr#::Addr#->Int#->State#s->(#State#s,Int##)readInt16OffAddr#=readInt16OffAddr#readInt32OffAddr#::Addr#->Int#->State#s->(#State#s,Int##)readInt32OffAddr#=readInt32OffAddr#readInt64OffAddr#::Addr#->Int#->State#s->(#State#s,Int##)readInt64OffAddr#=readInt64OffAddr#readWord8OffAddr#::Addr#->Int#->State#s->(#State#s,Word##)readWord8OffAddr#=readWord8OffAddr#readWord16OffAddr#::Addr#->Int#->State#s->(#State#s,Word##)readWord16OffAddr#=readWord16OffAddr#readWord32OffAddr#::Addr#->Int#->State#s->(#State#s,Word##)readWord32OffAddr#=readWord32OffAddr#readWord64OffAddr#::Addr#->Int#->State#s->(#State#s,Word##)readWord64OffAddr#=readWord64OffAddr#writeCharOffAddr#::Addr#->Int#->Char#->State#s->State#swriteCharOffAddr#=writeCharOffAddr#writeWideCharOffAddr#::Addr#->Int#->Char#->State#s->State#swriteWideCharOffAddr#=writeWideCharOffAddr#writeIntOffAddr#::Addr#->Int#->Int#->State#s->State#swriteIntOffAddr#=writeIntOffAddr#writeWordOffAddr#::Addr#->Int#->Word#->State#s->State#swriteWordOffAddr#=writeWordOffAddr#writeAddrOffAddr#::Addr#->Int#->Addr#->State#s->State#swriteAddrOffAddr#=writeAddrOffAddr#writeFloatOffAddr#::Addr#->Int#->Float#->State#s->State#swriteFloatOffAddr#=writeFloatOffAddr#writeDoubleOffAddr#::Addr#->Int#->Double#->State#s->State#swriteDoubleOffAddr#=writeDoubleOffAddr#writeStablePtrOffAddr#::Addr#->Int#->StablePtr#a->State#s->State#swriteStablePtrOffAddr#=writeStablePtrOffAddr#writeInt8OffAddr#::Addr#->Int#->Int#->State#s->State#swriteInt8OffAddr#=writeInt8OffAddr#writeInt16OffAddr#::Addr#->Int#->Int#->State#s->State#swriteInt16OffAddr#=writeInt16OffAddr#writeInt32OffAddr#::Addr#->Int#->Int#->State#s->State#swriteInt32OffAddr#=writeInt32OffAddr#writeInt64OffAddr#::Addr#->Int#->Int#->State#s->State#swriteInt64OffAddr#=writeInt64OffAddr#writeWord8OffAddr#::Addr#->Int#->Word#->State#s->State#swriteWord8OffAddr#=writeWord8OffAddr#writeWord16OffAddr#::Addr#->Int#->Word#->State#s->State#swriteWord16OffAddr#=writeWord16OffAddr#writeWord32OffAddr#::Addr#->Int#->Word#->State#s->State#swriteWord32OffAddr#=writeWord32OffAddr#writeWord64OffAddr#::Addr#->Int#->Word#->State#s->State#swriteWord64OffAddr#=writeWord64OffAddr#-- |A @MutVar\#@ behaves like a single-element mutable array.dataMutVar#sa-- |Create @MutVar\#@ with specified initial value in specified state thread.newMutVar#::a->State#s->(#State#s,MutVar#sa#)newMutVar#=newMutVar#-- |Read contents of @MutVar\#@. Result is not yet evaluated.readMutVar#::MutVar#sa->State#s->(#State#s,a#)readMutVar#=readMutVar#-- |Write contents of @MutVar\#@.writeMutVar#::MutVar#sa->a->State#s->State#swriteMutVar#=writeMutVar#sameMutVar#::MutVar#sa->MutVar#sa->Int#sameMutVar#=sameMutVar#-- | Modify the contents of a @MutVar\#@. Note that this isn\'t strictly-- speaking the correct type for this function, it should really be-- @MutVar# s a -> (a -> (a,b)) -> State# s -> (# State# s, b #)@, however-- we don\'t know about pairs here.atomicModifyMutVar#::MutVar#sa->(a->b)->State#s->(#State#s,c#)atomicModifyMutVar#=atomicModifyMutVar#casMutVar#::MutVar#sa->a->a->State#s->(#State#s,Int#,a#)casMutVar#=casMutVar#catch#::(State#(RealWorld)->(#State#(RealWorld),a#))->(b->State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)catch#=catch#raise#::b->oraise#=raise#raiseIO#::a->State#(RealWorld)->(#State#(RealWorld),b#)raiseIO#=raiseIO#maskAsyncExceptions#::(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)maskAsyncExceptions#=maskAsyncExceptions#maskUninterruptible#::(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)maskUninterruptible#=maskUninterruptible#unmaskAsyncExceptions#::(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)unmaskAsyncExceptions#=unmaskAsyncExceptions#getMaskingState#::State#(RealWorld)->(#State#(RealWorld),Int##)getMaskingState#=getMaskingState#dataTVar#saatomically#::(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)atomically#=atomically#retry#::State#(RealWorld)->(#State#(RealWorld),a#)retry#=retry#catchRetry#::(State#(RealWorld)->(#State#(RealWorld),a#))->(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)catchRetry#=catchRetry#catchSTM#::(State#(RealWorld)->(#State#(RealWorld),a#))->(b->State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->(#State#(RealWorld),a#)catchSTM#=catchSTM#check#::(State#(RealWorld)->(#State#(RealWorld),a#))->State#(RealWorld)->State#(RealWorld)check#=check#-- |Create a new @TVar\#@ holding a specified initial value.newTVar#::a->State#s->(#State#s,TVar#sa#)newTVar#=newTVar#-- |Read contents of @TVar\#@. Result is not yet evaluated.readTVar#::TVar#sa->State#s->(#State#s,a#)readTVar#=readTVar#-- |Read contents of @TVar\#@ outside an STM transactionreadTVarIO#::TVar#sa->State#s->(#State#s,a#)readTVarIO#=readTVarIO#-- |Write contents of @TVar\#@.writeTVar#::TVar#sa->a->State#s->State#swriteTVar#=writeTVar#sameTVar#::TVar#sa->TVar#sa->Int#sameTVar#=sameTVar#-- | A shared mutable variable (/not/ the same as a @MutVar\#@!).-- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be-- represented by @(MutVar\# (Maybe a))@.)dataMVar#sa-- |Create new @MVar\#@; initially empty.newMVar#::State#s->(#State#s,MVar#sa#)newMVar#=newMVar#-- |If @MVar\#@ is empty, block until it becomes full.-- Then remove and return its contents, and set it empty.takeMVar#::MVar#sa->State#s->(#State#s,a#)takeMVar#=takeMVar#-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.-- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty.tryTakeMVar#::MVar#sa->State#s->(#State#s,Int#,a#)tryTakeMVar#=tryTakeMVar#-- |If @MVar\#@ is full, block until it becomes empty.-- Then store value arg as its new contents.putMVar#::MVar#sa->a->State#s->State#sputMVar#=putMVar#-- |If @MVar\#@ is full, immediately return with integer 0.-- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1.tryPutMVar#::MVar#sa->a->State#s->(#State#s,Int##)tryPutMVar#=tryPutMVar#-- |If @MVar\#@ is empty, block until it becomes full.-- Then read its contents without modifying the MVar, without possibility-- of intervention from other threads.readMVar#::MVar#sa->State#s->(#State#s,a#)readMVar#=readMVar#-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.-- Otherwise, return with integer 1 and contents of @MVar\#@.tryReadMVar#::MVar#sa->State#s->(#State#s,Int#,a#)tryReadMVar#=tryReadMVar#sameMVar#::MVar#sa->MVar#sa->Int#sameMVar#=sameMVar#-- |Return 1 if @MVar\#@ is empty; 0 otherwise.isEmptyMVar#::MVar#sa->State#s->(#State#s,Int##)isEmptyMVar#=isEmptyMVar#-- |Sleep specified number of microseconds.delay#::Int#->State#s->State#sdelay#=delay#-- |Block until input is available on specified file descriptor.waitRead#::Int#->State#s->State#swaitRead#=waitRead#-- |Block until output is possible on specified file descriptor.waitWrite#::Int#->State#s->State#swaitWrite#=waitWrite#-- | @State\#@ is the primitive, unlifted type of states. It has-- one type parameter, thus @State\# RealWorld@, or @State\# s@,-- where s is a type variable. The only purpose of the type parameter-- is to keep different state threads separate. It is represented by-- nothing at all.dataState#s-- | @RealWorld@ is deeply magical. It is /primitive/, but it is not-- /unlifted/ (hence @ptrArg@). We never manipulate values of type-- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@.dataRealWorld-- |(In a non-concurrent implementation, this can be a singleton-- type, whose (unique) value is returned by @myThreadId\#@. The-- other operations can be omitted.)dataThreadId#fork#::a->State#(RealWorld)->(#State#(RealWorld),ThreadId##)fork#=fork#forkOn#::Int#->a->State#(RealWorld)->(#State#(RealWorld),ThreadId##)forkOn#=forkOn#killThread#::ThreadId#->a->State#(RealWorld)->State#(RealWorld)killThread#=killThread#yield#::State#(RealWorld)->State#(RealWorld)yield#=yield#myThreadId#::State#(RealWorld)->(#State#(RealWorld),ThreadId##)myThreadId#=myThreadId#labelThread#::ThreadId#->Addr#->State#(RealWorld)->State#(RealWorld)labelThread#=labelThread#isCurrentThreadBound#::State#(RealWorld)->(#State#(RealWorld),Int##)isCurrentThreadBound#=isCurrentThreadBound#noDuplicate#::State#s->State#snoDuplicate#=noDuplicate#threadStatus#::ThreadId#->State#(RealWorld)->(#State#(RealWorld),Int#,Int#,Int##)threadStatus#=threadStatus#dataWeak#b-- | @mkWeak# k v finalizer s@ creates a weak reference to value @k@,-- with an associated reference to some value @v@. If @k@ is still-- alive then @v@ can be retrieved using @deRefWeak#@. Note that-- the type of @k@ must be represented by a pointer (i.e. of kind @TYPE \'LiftedRep@ or @TYPE \'UnliftedRep@).mkWeak#::o->b->(State#(RealWorld)->(#State#(RealWorld),c#))->State#(RealWorld)->(#State#(RealWorld),Weak#b#)mkWeak#=mkWeak#mkWeakNoFinalizer#::o->b->State#(RealWorld)->(#State#(RealWorld),Weak#b#)mkWeakNoFinalizer#=mkWeakNoFinalizer#-- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C-- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If-- @flag@ is zero, @fptr@ will be called with one argument,-- @ptr@. Otherwise, it will be called with two arguments,-- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns-- 1 on success, or 0 if @w@ is already dead.addCFinalizerToWeak#::Addr#->Addr#->Int#->Addr#->Weak#b->State#(RealWorld)->(#State#(RealWorld),Int##)addCFinalizerToWeak#=addCFinalizerToWeak#deRefWeak#::Weak#a->State#(RealWorld)->(#State#(RealWorld),Int#,a#)deRefWeak#=deRefWeak#-- | Finalize a weak pointer. The return value is an unboxed tuple-- containing the new state of the world and an \"unboxed Maybe\",-- represented by an @Int#@ and a (possibly invalid) finalization-- action. An @Int#@ of @1@ indicates that the finalizer is valid. The-- return value @b@ from the finalizer should be ignored.finalizeWeak#::Weak#a->State#(RealWorld)->(#State#(RealWorld),Int#,State#(RealWorld)->(#State#(RealWorld),b#)#)finalizeWeak#=finalizeWeak#touch#::o->State#(RealWorld)->State#(RealWorld)touch#=touch#dataStablePtr#adataStableName#amakeStablePtr#::a->State#(RealWorld)->(#State#(RealWorld),StablePtr#a#)makeStablePtr#=makeStablePtr#deRefStablePtr#::StablePtr#a->State#(RealWorld)->(#State#(RealWorld),a#)deRefStablePtr#=deRefStablePtr#eqStablePtr#::StablePtr#a->StablePtr#a->Int#eqStablePtr#=eqStablePtr#makeStableName#::a->State#(RealWorld)->(#State#(RealWorld),StableName#a#)makeStableName#=makeStableName#eqStableName#::StableName#a->StableName#b->Int#eqStableName#=eqStableName#stableNameToInt#::StableName#a->Int#stableNameToInt#=stableNameToInt#dataCompact#-- | Create a new Compact with the given size (in bytes, not words).-- The size is rounded up to a multiple of the allocator block size,-- and capped to one mega block.compactNew#::Word#->State#(RealWorld)->(#State#(RealWorld),Compact##)compactNew#=compactNew#-- | Set the new allocation size of the compact. This value (in bytes)-- determines the size of each block in the compact chain.compactResize#::Compact#->Word#->State#(RealWorld)->State#(RealWorld)compactResize#=compactResize#-- | Returns 1# if the object is contained in the compact, 0# otherwise.compactContains#::Compact#->a->State#(RealWorld)->(#State#(RealWorld),Int##)compactContains#=compactContains#-- | Returns 1# if the object is in any compact at all, 0# otherwise.compactContainsAny#::a->State#(RealWorld)->(#State#(RealWorld),Int##)compactContainsAny#=compactContainsAny#-- | Returns the address and the size (in bytes) of the first block of-- a compact.compactGetFirstBlock#::Compact#->State#(RealWorld)->(#State#(RealWorld),Addr#,Word##)compactGetFirstBlock#=compactGetFirstBlock#-- | Given a compact and the address of one its blocks, returns the-- next block and its size, or #nullAddr if the argument was the-- last block in the compact.compactGetNextBlock#::Compact#->Addr#->State#(RealWorld)->(#State#(RealWorld),Addr#,Word##)compactGetNextBlock#=compactGetNextBlock#-- | Attempt to allocate a compact block with the given size (in-- bytes) at the given address. The first argument is a hint to-- the allocator, allocation might be satisfied at a different-- address (which is returned).-- The resulting block is not known to the GC until-- compactFixupPointers# is called on it, and care must be taken-- so that the address does not escape or memory will be leaked.--compactAllocateBlock#::Word#->Addr#->State#(RealWorld)->(#State#(RealWorld),Addr##)compactAllocateBlock#=compactAllocateBlock#-- | Given the pointer to the first block of a compact, and the-- address of the root object in the old address space, fix up-- the internal pointers inside the compact to account for-- a different position in memory than when it was serialized.-- This method must be called exactly once after importing-- a serialized compact, and returns the new compact and-- the new adjusted root address.compactFixupPointers#::Addr#->Addr#->State#(RealWorld)->(#State#(RealWorld),Compact#,Addr##)compactFixupPointers#=compactFixupPointers#-- | Recursively add a closure and its transitive closure to a-- {\texttt Compact\#}, evaluating any unevaluated components at the-- same time. Note: {\texttt compactAdd\#} is not thread-safe, so-- only one thread may call {\texttt compactAdd\#} with a particular-- {\texttt Compact#} at any given time. The primop does not-- enforce any mutual exclusion; the caller is expected to-- arrange this.compactAdd#::Compact#->a->State#(RealWorld)->(#State#(RealWorld),a#)compactAdd#=compactAdd#-- | Like {\texttt compactAdd\#}, but retains sharing and cycles-- during compaction.compactAddWithSharing#::Compact#->a->State#(RealWorld)->(#State#(RealWorld),a#)compactAddWithSharing#=compactAddWithSharing#-- | Return the size (in bytes) of the total amount of data in the Compact#compactSize#::Compact#->State#(RealWorld)->(#State#(RealWorld),Word##)compactSize#=compactSize#-- | Returns {\texttt 1\#} if the given pointers are equal and {\texttt 0\#} otherwise.reallyUnsafePtrEquality#::a->a->Int#reallyUnsafePtrEquality#=reallyUnsafePtrEquality#par#::a->Int#par#=par#spark#::a->State#s->(#State#s,a#)spark#=spark#seq#::a->State#s->(#State#s,a#)seq#=seq#getSpark#::State#s->(#State#s,Int#,a#)getSpark#=getSpark#-- | Returns the number of sparks in the local spark pool.numSparks#::State#s->(#State#s,Int##)numSparks#=numSparks#dataToTag#::a->Int#dataToTag#=dataToTag#-- |- Note [dataToTag#]-- ~~~~~~~~~~~~~~~~~~~~-- The dataToTag# primop should always be applied to an evaluated argument.-- The way to ensure this is to invoke it via the \'getTag\' wrapper in GHC.Base:-- getTag :: a -> Int#-- getTag !x = dataToTag# x---- But now consider-- \z. case x of y -> let v = dataToTag# y in ...---- To improve floating, the FloatOut pass (deliberately) does a-- binder-swap on the case, to give-- \z. case x of y -> let v = dataToTag# x in ...---- Now FloatOut might float that v-binding outside the \z. But that is-- bad because that might mean x gest evaluated much too early! (CorePrep-- adds an eval to a dataToTag# call, to ensure that the argument really is-- evaluated; see CorePrep Note [dataToTag magic].)---- Solution: make DataToTag into a can_fail primop. That will stop it floating-- (see Note [PrimOp can_fail and has_side_effects] in PrimOp). It\'s a bit of-- a hack but never mind.-- -tagToEnum#::Int#->atagToEnum#=letx=xinx-- | Primitive bytecode type.dataBCO#-- | Convert an @Addr\#@ to a followable Any type.addrToAny#::Addr#->(#a#)addrToAny#=addrToAny#-- | Retrieve the address of any Haskell value. This is-- essentially an {\texttt unsafeCoerce\#}, but if implemented as such-- the core lint pass complains and fails to compile.-- As a primop, it is opaque to core\/stg, and only appears-- in cmm (where the copy propagation pass will get rid of it).-- Note that \"a\" must be a value, not a thunk! It\'s too late-- for strictness analysis to enforce this, so you\'re on your-- own to guarantee this. Also note that {\texttt Addr\#} is not a GC-- pointer - up to you to guarantee that it does not become-- a dangling pointer immediately after you get it.anyToAddr#::a->State#(RealWorld)->(#State#(RealWorld),Addr##)anyToAddr#=anyToAddr#-- | Wrap a BCO in a @AP_UPD@ thunk which will be updated with the value of-- the BCO when evaluated.mkApUpd0#::BCO#->(#a#)mkApUpd0#=mkApUpd0#-- | @newBCO\# instrs lits ptrs arity bitmap@ creates a new bytecode object. The-- resulting object encodes a function of the given arity with the instructions-- encoded in @instrs@, and a static reference table usage bitmap given by-- @bitmap@.newBCO#::ByteArray#->ByteArray#->Array#a->Int#->ByteArray#->State#s->(#State#s,BCO##)newBCO#=newBCO#-- | @unpackClosure\# closure@ copies non-pointers and pointers in the-- payload of the given closure into two new arrays, and returns a pointer to-- the first word of the closure\'s info table, a pointer array for the-- pointers in the payload, and a non-pointer array for the non-pointers in-- the payload.unpackClosure#::a->(#Addr#,Array#b,ByteArray##)unpackClosure#=unpackClosure#getApStackVal#::a->Int#->(#Int#,b#)getApStackVal#=getApStackVal#getCCSOf#::a->State#s->(#State#s,Addr##)getCCSOf#=getCCSOf#-- | Returns the current @CostCentreStack@ (value is @NULL@ if-- not profiling). Takes a dummy argument which can be used to-- avoid the call to @getCurrentCCS\#@ being floated out by the-- simplifier, which would result in an uninformative stack-- (\"CAF\").getCurrentCCS#::a->State#s->(#State#s,Addr##)getCurrentCCS#=getCurrentCCS#-- | Run the supplied IO action with an empty CCS. For example, this-- is used by the interpreter to run an interpreted computation-- without the call stack showing that it was invoked from GHC.clearCCS#::(State#s->(#State#s,a#))->State#s->(#State#s,a#)clearCCS#=clearCCS#-- | The type constructor @Proxy#@ is used to bear witness to some-- type variable. It\'s used when you want to pass around proxy values-- for doing things like modelling type applications. A @Proxy#@-- is not only unboxed, it also has a polymorphic kind, and has no-- runtime representation, being totally free.dataProxy#a-- | Witness for an unboxed @Proxy#@ value, which has no runtime-- representation.proxy#::Proxy#aproxy#=proxy#-- | The value of @seq a b@ is bottom if @a@ is bottom, and-- otherwise equal to @b@. In other words, it evaluates the first-- argument @a@ to weak head normal form (WHNF). @seq@ is usually-- introduced to improve performance by avoiding unneeded laziness.---- A note on evaluation order: the expression @seq a b@ does-- /not/ guarantee that @a@ will be evaluated before @b@.-- The only guarantee given by @seq@ is that the both @a@-- and @b@ will be evaluated before @seq@ returns a value.-- In particular, this means that @b@ may be evaluated before-- @a@. If you need to guarantee a specific order of evaluation,-- you must use the function @pseq@ from the \"parallel\" package.seq::a->b->bseq=seq-- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That-- is, it allows you to coerce any type into any other type. If you use this function,-- you had better get it right, otherwise segmentation faults await. It is generally-- used when you want to write a program that you know is well-typed, but where Haskell\'s-- type system is not expressive enough to prove that it is well typed.---- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to-- spurious compile-time or run-time crashes):---- * Casting any lifted type to @Any@---- * Casting @Any@ back to the real type---- * Casting an unboxed type to another unboxed type of the same size.-- (Casting between floating-point and integral types does not work.-- See the @GHC.Float@ module for functions to do work.)---- * Casting between two types that have the same runtime representation. One case is when-- the two types differ only in \"phantom\" type parameters, for example-- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is-- known to be empty. Also, a @newtype@ of a type @T@ has the same representation-- at runtime as @T@.---- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use-- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also-- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if-- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons-- have to do with GHC\'s internal representation details (for the cognoscenti, data values-- can be entered but function closures cannot). If you want a safe type to cast things-- to, use @Any@, which is not an algebraic data type.----unsafeCoerce#::a->bunsafeCoerce#=unsafeCoerce#-- | Emits an event via the RTS tracing framework. The contents-- of the event is the zero-terminated byte string passed as the first-- argument. The event will be emitted either to the .eventlog file,-- or to stderr, depending on the runtime RTS flags.traceEvent#::Addr#->State#s->State#straceEvent#=traceEvent#-- | Emits a marker event via the RTS tracing framework. The contents-- of the event is the zero-terminated byte string passed as the first-- argument. The event will be emitted either to the .eventlog file,-- or to stderr, depending on the runtime RTS flags.traceMarker#::Addr#->State#s->State#straceMarker#=traceMarker#-- | The function @coerce@ allows you to safely convert between values of-- types that have the same representation with no run-time overhead. In the-- simplest case you can use it instead of a newtype constructor, to go from-- the newtype\'s concrete type to the abstract type. But it also works in-- more complicated settings, e.g. converting a list of newtypes to a list of-- concrete types.--coerce::Coercibleab=>a->bcoerce=coercedataInt8X16#dataInt16X8#dataInt32X4#dataInt64X2#dataInt8X32#dataInt16X16#dataInt32X8#dataInt64X4#dataInt8X64#dataInt16X32#dataInt32X16#dataInt64X8#dataWord8X16#dataWord16X8#dataWord32X4#dataWord64X2#dataWord8X32#dataWord16X16#dataWord32X8#dataWord64X4#dataWord8X64#dataWord16X32#dataWord32X16#dataWord64X8#dataFloatX4#dataDoubleX2#dataFloatX8#dataDoubleX4#dataFloatX16#dataDoubleX8#-- | Broadcast a scalar to all elements of a vector.broadcastInt8X16#::Int#->Int8X16#broadcastInt8X16#=broadcastInt8X16#-- | Broadcast a scalar to all elements of a vector.broadcastInt16X8#::Int#->Int16X8#broadcastInt16X8#=broadcastInt16X8#-- | Broadcast a scalar to all elements of a vector.broadcastInt32X4#::Int#->Int32X4#broadcastInt32X4#=broadcastInt32X4#-- | Broadcast a scalar to all elements of a vector.broadcastInt64X2#::Int#->Int64X2#broadcastInt64X2#=broadcastInt64X2#-- | Broadcast a scalar to all elements of a vector.broadcastInt8X32#::Int#->Int8X32#broadcastInt8X32#=broadcastInt8X32#-- | Broadcast a scalar to all elements of a vector.broadcastInt16X16#::Int#->Int16X16#broadcastInt16X16#=broadcastInt16X16#-- | Broadcast a scalar to all elements of a vector.broadcastInt32X8#::Int#->Int32X8#broadcastInt32X8#=broadcastInt32X8#-- | Broadcast a scalar to all elements of a vector.broadcastInt64X4#::Int#->Int64X4#broadcastInt64X4#=broadcastInt64X4#-- | Broadcast a scalar to all elements of a vector.broadcastInt8X64#::Int#->Int8X64#broadcastInt8X64#=broadcastInt8X64#-- | Broadcast a scalar to all elements of a vector.broadcastInt16X32#::Int#->Int16X32#broadcastInt16X32#=broadcastInt16X32#-- | Broadcast a scalar to all elements of a vector.broadcastInt32X16#::Int#->Int32X16#broadcastInt32X16#=broadcastInt32X16#-- | Broadcast a scalar to all elements of a vector.broadcastInt64X8#::Int#->Int64X8#broadcastInt64X8#=broadcastInt64X8#-- | Broadcast a scalar to all elements of a vector.broadcastWord8X16#::Word#->Word8X16#broadcastWord8X16#=broadcastWord8X16#-- | Broadcast a scalar to all elements of a vector.broadcastWord16X8#::Word#->Word16X8#broadcastWord16X8#=broadcastWord16X8#-- | Broadcast a scalar to all elements of a vector.broadcastWord32X4#::Word#->Word32X4#broadcastWord32X4#=broadcastWord32X4#-- | Broadcast a scalar to all elements of a vector.broadcastWord64X2#::Word#->Word64X2#broadcastWord64X2#=broadcastWord64X2#-- | Broadcast a scalar to all elements of a vector.broadcastWord8X32#::Word#->Word8X32#broadcastWord8X32#=broadcastWord8X32#-- | Broadcast a scalar to all elements of a vector.broadcastWord16X16#::Word#->Word16X16#broadcastWord16X16#=broadcastWord16X16#-- | Broadcast a scalar to all elements of a vector.broadcastWord32X8#::Word#->Word32X8#broadcastWord32X8#=broadcastWord32X8#-- | Broadcast a scalar to all elements of a vector.broadcastWord64X4#::Word#->Word64X4#broadcastWord64X4#=broadcastWord64X4#-- | Broadcast a scalar to all elements of a vector.broadcastWord8X64#::Word#->Word8X64#broadcastWord8X64#=broadcastWord8X64#-- | Broadcast a scalar to all elements of a vector.broadcastWord16X32#::Word#->Word16X32#broadcastWord16X32#=broadcastWord16X32#-- | Broadcast a scalar to all elements of a vector.broadcastWord32X16#::Word#->Word32X16#broadcastWord32X16#=broadcastWord32X16#-- | Broadcast a scalar to all elements of a vector.broadcastWord64X8#::Word#->Word64X8#broadcastWord64X8#=broadcastWord64X8#-- | Broadcast a scalar to all elements of a vector.broadcastFloatX4#::Float#->FloatX4#broadcastFloatX4#=broadcastFloatX4#-- | Broadcast a scalar to all elements of a vector.broadcastDoubleX2#::Double#->DoubleX2#broadcastDoubleX2#=broadcastDoubleX2#-- | Broadcast a scalar to all elements of a vector.broadcastFloatX8#::Float#->FloatX8#broadcastFloatX8#=broadcastFloatX8#-- | Broadcast a scalar to all elements of a vector.broadcastDoubleX4#::Double#->DoubleX4#broadcastDoubleX4#=broadcastDoubleX4#-- | Broadcast a scalar to all elements of a vector.broadcastFloatX16#::Float#->FloatX16#broadcastFloatX16#=broadcastFloatX16#-- | Broadcast a scalar to all elements of a vector.broadcastDoubleX8#::Double#->DoubleX8#broadcastDoubleX8#=broadcastDoubleX8#-- | Pack the elements of an unboxed tuple into a vector.packInt8X16#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int8X16#packInt8X16#=packInt8X16#-- | Pack the elements of an unboxed tuple into a vector.packInt16X8#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int16X8#packInt16X8#=packInt16X8#-- | Pack the elements of an unboxed tuple into a vector.packInt32X4#::(#Int#,Int#,Int#,Int##)->Int32X4#packInt32X4#=packInt32X4#-- | Pack the elements of an unboxed tuple into a vector.packInt64X2#::(#Int#,Int##)->Int64X2#packInt64X2#=packInt64X2#-- | Pack the elements of an unboxed tuple into a vector.packInt8X32#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int8X32#packInt8X32#=packInt8X32#-- | Pack the elements of an unboxed tuple into a vector.packInt16X16#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int16X16#packInt16X16#=packInt16X16#-- | Pack the elements of an unboxed tuple into a vector.packInt32X8#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int32X8#packInt32X8#=packInt32X8#-- | Pack the elements of an unboxed tuple into a vector.packInt64X4#::(#Int#,Int#,Int#,Int##)->Int64X4#packInt64X4#=packInt64X4#-- | Pack the elements of an unboxed tuple into a vector.packInt8X64#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int8X64#packInt8X64#=packInt8X64#-- | Pack the elements of an unboxed tuple into a vector.packInt16X32#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int16X32#packInt16X32#=packInt16X32#-- | Pack the elements of an unboxed tuple into a vector.packInt32X16#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int32X16#packInt32X16#=packInt32X16#-- | Pack the elements of an unboxed tuple into a vector.packInt64X8#::(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)->Int64X8#packInt64X8#=packInt64X8#-- | Pack the elements of an unboxed tuple into a vector.packWord8X16#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word8X16#packWord8X16#=packWord8X16#-- | Pack the elements of an unboxed tuple into a vector.packWord16X8#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word16X8#packWord16X8#=packWord16X8#-- | Pack the elements of an unboxed tuple into a vector.packWord32X4#::(#Word#,Word#,Word#,Word##)->Word32X4#packWord32X4#=packWord32X4#-- | Pack the elements of an unboxed tuple into a vector.packWord64X2#::(#Word#,Word##)->Word64X2#packWord64X2#=packWord64X2#-- | Pack the elements of an unboxed tuple into a vector.packWord8X32#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word8X32#packWord8X32#=packWord8X32#-- | Pack the elements of an unboxed tuple into a vector.packWord16X16#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word16X16#packWord16X16#=packWord16X16#-- | Pack the elements of an unboxed tuple into a vector.packWord32X8#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word32X8#packWord32X8#=packWord32X8#-- | Pack the elements of an unboxed tuple into a vector.packWord64X4#::(#Word#,Word#,Word#,Word##)->Word64X4#packWord64X4#=packWord64X4#-- | Pack the elements of an unboxed tuple into a vector.packWord8X64#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word8X64#packWord8X64#=packWord8X64#-- | Pack the elements of an unboxed tuple into a vector.packWord16X32#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word16X32#packWord16X32#=packWord16X32#-- | Pack the elements of an unboxed tuple into a vector.packWord32X16#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word32X16#packWord32X16#=packWord32X16#-- | Pack the elements of an unboxed tuple into a vector.packWord64X8#::(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)->Word64X8#packWord64X8#=packWord64X8#-- | Pack the elements of an unboxed tuple into a vector.packFloatX4#::(#Float#,Float#,Float#,Float##)->FloatX4#packFloatX4#=packFloatX4#-- | Pack the elements of an unboxed tuple into a vector.packDoubleX2#::(#Double#,Double##)->DoubleX2#packDoubleX2#=packDoubleX2#-- | Pack the elements of an unboxed tuple into a vector.packFloatX8#::(#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)->FloatX8#packFloatX8#=packFloatX8#-- | Pack the elements of an unboxed tuple into a vector.packDoubleX4#::(#Double#,Double#,Double#,Double##)->DoubleX4#packDoubleX4#=packDoubleX4#-- | Pack the elements of an unboxed tuple into a vector.packFloatX16#::(#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)->FloatX16#packFloatX16#=packFloatX16#-- | Pack the elements of an unboxed tuple into a vector.packDoubleX8#::(#Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double##)->DoubleX8#packDoubleX8#=packDoubleX8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt8X16#::Int8X16#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt8X16#=unpackInt8X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt16X8#::Int16X8#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt16X8#=unpackInt16X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt32X4#::Int32X4#->(#Int#,Int#,Int#,Int##)unpackInt32X4#=unpackInt32X4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt64X2#::Int64X2#->(#Int#,Int##)unpackInt64X2#=unpackInt64X2#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt8X32#::Int8X32#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt8X32#=unpackInt8X32#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt16X16#::Int16X16#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt16X16#=unpackInt16X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt32X8#::Int32X8#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt32X8#=unpackInt32X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt64X4#::Int64X4#->(#Int#,Int#,Int#,Int##)unpackInt64X4#=unpackInt64X4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt8X64#::Int8X64#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt8X64#=unpackInt8X64#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt16X32#::Int16X32#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt16X32#=unpackInt16X32#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt32X16#::Int32X16#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt32X16#=unpackInt32X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackInt64X8#::Int64X8#->(#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)unpackInt64X8#=unpackInt64X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord8X16#::Word8X16#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord8X16#=unpackWord8X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord16X8#::Word16X8#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord16X8#=unpackWord16X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord32X4#::Word32X4#->(#Word#,Word#,Word#,Word##)unpackWord32X4#=unpackWord32X4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord64X2#::Word64X2#->(#Word#,Word##)unpackWord64X2#=unpackWord64X2#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord8X32#::Word8X32#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord8X32#=unpackWord8X32#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord16X16#::Word16X16#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord16X16#=unpackWord16X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord32X8#::Word32X8#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord32X8#=unpackWord32X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord64X4#::Word64X4#->(#Word#,Word#,Word#,Word##)unpackWord64X4#=unpackWord64X4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord8X64#::Word8X64#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord8X64#=unpackWord8X64#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord16X32#::Word16X32#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord16X32#=unpackWord16X32#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord32X16#::Word32X16#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord32X16#=unpackWord32X16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackWord64X8#::Word64X8#->(#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)unpackWord64X8#=unpackWord64X8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackFloatX4#::FloatX4#->(#Float#,Float#,Float#,Float##)unpackFloatX4#=unpackFloatX4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackDoubleX2#::DoubleX2#->(#Double#,Double##)unpackDoubleX2#=unpackDoubleX2#-- | Unpack the elements of a vector into an unboxed tuple. #unpackFloatX8#::FloatX8#->(#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)unpackFloatX8#=unpackFloatX8#-- | Unpack the elements of a vector into an unboxed tuple. #unpackDoubleX4#::DoubleX4#->(#Double#,Double#,Double#,Double##)unpackDoubleX4#=unpackDoubleX4#-- | Unpack the elements of a vector into an unboxed tuple. #unpackFloatX16#::FloatX16#->(#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)unpackFloatX16#=unpackFloatX16#-- | Unpack the elements of a vector into an unboxed tuple. #unpackDoubleX8#::DoubleX8#->(#Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double##)unpackDoubleX8#=unpackDoubleX8#-- | Insert a scalar at the given position in a vector.insertInt8X16#::Int8X16#->Int#->Int#->Int8X16#insertInt8X16#=insertInt8X16#-- | Insert a scalar at the given position in a vector.insertInt16X8#::Int16X8#->Int#->Int#->Int16X8#insertInt16X8#=insertInt16X8#-- | Insert a scalar at the given position in a vector.insertInt32X4#::Int32X4#->Int#->Int#->Int32X4#insertInt32X4#=insertInt32X4#-- | Insert a scalar at the given position in a vector.insertInt64X2#::Int64X2#->Int#->Int#->Int64X2#insertInt64X2#=insertInt64X2#-- | Insert a scalar at the given position in a vector.insertInt8X32#::Int8X32#->Int#->Int#->Int8X32#insertInt8X32#=insertInt8X32#-- | Insert a scalar at the given position in a vector.insertInt16X16#::Int16X16#->Int#->Int#->Int16X16#insertInt16X16#=insertInt16X16#-- | Insert a scalar at the given position in a vector.insertInt32X8#::Int32X8#->Int#->Int#->Int32X8#insertInt32X8#=insertInt32X8#-- | Insert a scalar at the given position in a vector.insertInt64X4#::Int64X4#->Int#->Int#->Int64X4#insertInt64X4#=insertInt64X4#-- | Insert a scalar at the given position in a vector.insertInt8X64#::Int8X64#->Int#->Int#->Int8X64#insertInt8X64#=insertInt8X64#-- | Insert a scalar at the given position in a vector.insertInt16X32#::Int16X32#->Int#->Int#->Int16X32#insertInt16X32#=insertInt16X32#-- | Insert a scalar at the given position in a vector.insertInt32X16#::Int32X16#->Int#->Int#->Int32X16#insertInt32X16#=insertInt32X16#-- | Insert a scalar at the given position in a vector.insertInt64X8#::Int64X8#->Int#->Int#->Int64X8#insertInt64X8#=insertInt64X8#-- | Insert a scalar at the given position in a vector.insertWord8X16#::Word8X16#->Word#->Int#->Word8X16#insertWord8X16#=insertWord8X16#-- | Insert a scalar at the given position in a vector.insertWord16X8#::Word16X8#->Word#->Int#->Word16X8#insertWord16X8#=insertWord16X8#-- | Insert a scalar at the given position in a vector.insertWord32X4#::Word32X4#->Word#->Int#->Word32X4#insertWord32X4#=insertWord32X4#-- | Insert a scalar at the given position in a vector.insertWord64X2#::Word64X2#->Word#->Int#->Word64X2#insertWord64X2#=insertWord64X2#-- | Insert a scalar at the given position in a vector.insertWord8X32#::Word8X32#->Word#->Int#->Word8X32#insertWord8X32#=insertWord8X32#-- | Insert a scalar at the given position in a vector.insertWord16X16#::Word16X16#->Word#->Int#->Word16X16#insertWord16X16#=insertWord16X16#-- | Insert a scalar at the given position in a vector.insertWord32X8#::Word32X8#->Word#->Int#->Word32X8#insertWord32X8#=insertWord32X8#-- | Insert a scalar at the given position in a vector.insertWord64X4#::Word64X4#->Word#->Int#->Word64X4#insertWord64X4#=insertWord64X4#-- | Insert a scalar at the given position in a vector.insertWord8X64#::Word8X64#->Word#->Int#->Word8X64#insertWord8X64#=insertWord8X64#-- | Insert a scalar at the given position in a vector.insertWord16X32#::Word16X32#->Word#->Int#->Word16X32#insertWord16X32#=insertWord16X32#-- | Insert a scalar at the given position in a vector.insertWord32X16#::Word32X16#->Word#->Int#->Word32X16#insertWord32X16#=insertWord32X16#-- | Insert a scalar at the given position in a vector.insertWord64X8#::Word64X8#->Word#->Int#->Word64X8#insertWord64X8#=insertWord64X8#-- | Insert a scalar at the given position in a vector.insertFloatX4#::FloatX4#->Float#->Int#->FloatX4#insertFloatX4#=insertFloatX4#-- | Insert a scalar at the given position in a vector.insertDoubleX2#::DoubleX2#->Double#->Int#->DoubleX2#insertDoubleX2#=insertDoubleX2#-- | Insert a scalar at the given position in a vector.insertFloatX8#::FloatX8#->Float#->Int#->FloatX8#insertFloatX8#=insertFloatX8#-- | Insert a scalar at the given position in a vector.insertDoubleX4#::DoubleX4#->Double#->Int#->DoubleX4#insertDoubleX4#=insertDoubleX4#-- | Insert a scalar at the given position in a vector.insertFloatX16#::FloatX16#->Float#->Int#->FloatX16#insertFloatX16#=insertFloatX16#-- | Insert a scalar at the given position in a vector.insertDoubleX8#::DoubleX8#->Double#->Int#->DoubleX8#insertDoubleX8#=insertDoubleX8#-- | Add two vectors element-wise.plusInt8X16#::Int8X16#->Int8X16#->Int8X16#plusInt8X16#=plusInt8X16#-- | Add two vectors element-wise.plusInt16X8#::Int16X8#->Int16X8#->Int16X8#plusInt16X8#=plusInt16X8#-- | Add two vectors element-wise.plusInt32X4#::Int32X4#->Int32X4#->Int32X4#plusInt32X4#=plusInt32X4#-- | Add two vectors element-wise.plusInt64X2#::Int64X2#->Int64X2#->Int64X2#plusInt64X2#=plusInt64X2#-- | Add two vectors element-wise.plusInt8X32#::Int8X32#->Int8X32#->Int8X32#plusInt8X32#=plusInt8X32#-- | Add two vectors element-wise.plusInt16X16#::Int16X16#->Int16X16#->Int16X16#plusInt16X16#=plusInt16X16#-- | Add two vectors element-wise.plusInt32X8#::Int32X8#->Int32X8#->Int32X8#plusInt32X8#=plusInt32X8#-- | Add two vectors element-wise.plusInt64X4#::Int64X4#->Int64X4#->Int64X4#plusInt64X4#=plusInt64X4#-- | Add two vectors element-wise.plusInt8X64#::Int8X64#->Int8X64#->Int8X64#plusInt8X64#=plusInt8X64#-- | Add two vectors element-wise.plusInt16X32#::Int16X32#->Int16X32#->Int16X32#plusInt16X32#=plusInt16X32#-- | Add two vectors element-wise.plusInt32X16#::Int32X16#->Int32X16#->Int32X16#plusInt32X16#=plusInt32X16#-- | Add two vectors element-wise.plusInt64X8#::Int64X8#->Int64X8#->Int64X8#plusInt64X8#=plusInt64X8#-- | Add two vectors element-wise.plusWord8X16#::Word8X16#->Word8X16#->Word8X16#plusWord8X16#=plusWord8X16#-- | Add two vectors element-wise.plusWord16X8#::Word16X8#->Word16X8#->Word16X8#plusWord16X8#=plusWord16X8#-- | Add two vectors element-wise.plusWord32X4#::Word32X4#->Word32X4#->Word32X4#plusWord32X4#=plusWord32X4#-- | Add two vectors element-wise.plusWord64X2#::Word64X2#->Word64X2#->Word64X2#plusWord64X2#=plusWord64X2#-- | Add two vectors element-wise.plusWord8X32#::Word8X32#->Word8X32#->Word8X32#plusWord8X32#=plusWord8X32#-- | Add two vectors element-wise.plusWord16X16#::Word16X16#->Word16X16#->Word16X16#plusWord16X16#=plusWord16X16#-- | Add two vectors element-wise.plusWord32X8#::Word32X8#->Word32X8#->Word32X8#plusWord32X8#=plusWord32X8#-- | Add two vectors element-wise.plusWord64X4#::Word64X4#->Word64X4#->Word64X4#plusWord64X4#=plusWord64X4#-- | Add two vectors element-wise.plusWord8X64#::Word8X64#->Word8X64#->Word8X64#plusWord8X64#=plusWord8X64#-- | Add two vectors element-wise.plusWord16X32#::Word16X32#->Word16X32#->Word16X32#plusWord16X32#=plusWord16X32#-- | Add two vectors element-wise.plusWord32X16#::Word32X16#->Word32X16#->Word32X16#plusWord32X16#=plusWord32X16#-- | Add two vectors element-wise.plusWord64X8#::Word64X8#->Word64X8#->Word64X8#plusWord64X8#=plusWord64X8#-- | Add two vectors element-wise.plusFloatX4#::FloatX4#->FloatX4#->FloatX4#plusFloatX4#=plusFloatX4#-- | Add two vectors element-wise.plusDoubleX2#::DoubleX2#->DoubleX2#->DoubleX2#plusDoubleX2#=plusDoubleX2#-- | Add two vectors element-wise.plusFloatX8#::FloatX8#->FloatX8#->FloatX8#plusFloatX8#=plusFloatX8#-- | Add two vectors element-wise.plusDoubleX4#::DoubleX4#->DoubleX4#->DoubleX4#plusDoubleX4#=plusDoubleX4#-- | Add two vectors element-wise.plusFloatX16#::FloatX16#->FloatX16#->FloatX16#plusFloatX16#=plusFloatX16#-- | Add two vectors element-wise.plusDoubleX8#::DoubleX8#->DoubleX8#->DoubleX8#plusDoubleX8#=plusDoubleX8#-- | Subtract two vectors element-wise.minusInt8X16#::Int8X16#->Int8X16#->Int8X16#minusInt8X16#=minusInt8X16#-- | Subtract two vectors element-wise.minusInt16X8#::Int16X8#->Int16X8#->Int16X8#minusInt16X8#=minusInt16X8#-- | Subtract two vectors element-wise.minusInt32X4#::Int32X4#->Int32X4#->Int32X4#minusInt32X4#=minusInt32X4#-- | Subtract two vectors element-wise.minusInt64X2#::Int64X2#->Int64X2#->Int64X2#minusInt64X2#=minusInt64X2#-- | Subtract two vectors element-wise.minusInt8X32#::Int8X32#->Int8X32#->Int8X32#minusInt8X32#=minusInt8X32#-- | Subtract two vectors element-wise.minusInt16X16#::Int16X16#->Int16X16#->Int16X16#minusInt16X16#=minusInt16X16#-- | Subtract two vectors element-wise.minusInt32X8#::Int32X8#->Int32X8#->Int32X8#minusInt32X8#=minusInt32X8#-- | Subtract two vectors element-wise.minusInt64X4#::Int64X4#->Int64X4#->Int64X4#minusInt64X4#=minusInt64X4#-- | Subtract two vectors element-wise.minusInt8X64#::Int8X64#->Int8X64#->Int8X64#minusInt8X64#=minusInt8X64#-- | Subtract two vectors element-wise.minusInt16X32#::Int16X32#->Int16X32#->Int16X32#minusInt16X32#=minusInt16X32#-- | Subtract two vectors element-wise.minusInt32X16#::Int32X16#->Int32X16#->Int32X16#minusInt32X16#=minusInt32X16#-- | Subtract two vectors element-wise.minusInt64X8#::Int64X8#->Int64X8#->Int64X8#minusInt64X8#=minusInt64X8#-- | Subtract two vectors element-wise.minusWord8X16#::Word8X16#->Word8X16#->Word8X16#minusWord8X16#=minusWord8X16#-- | Subtract two vectors element-wise.minusWord16X8#::Word16X8#->Word16X8#->Word16X8#minusWord16X8#=minusWord16X8#-- | Subtract two vectors element-wise.minusWord32X4#::Word32X4#->Word32X4#->Word32X4#minusWord32X4#=minusWord32X4#-- | Subtract two vectors element-wise.minusWord64X2#::Word64X2#->Word64X2#->Word64X2#minusWord64X2#=minusWord64X2#-- | Subtract two vectors element-wise.minusWord8X32#::Word8X32#->Word8X32#->Word8X32#minusWord8X32#=minusWord8X32#-- | Subtract two vectors element-wise.minusWord16X16#::Word16X16#->Word16X16#->Word16X16#minusWord16X16#=minusWord16X16#-- | Subtract two vectors element-wise.minusWord32X8#::Word32X8#->Word32X8#->Word32X8#minusWord32X8#=minusWord32X8#-- | Subtract two vectors element-wise.minusWord64X4#::Word64X4#->Word64X4#->Word64X4#minusWord64X4#=minusWord64X4#-- | Subtract two vectors element-wise.minusWord8X64#::Word8X64#->Word8X64#->Word8X64#minusWord8X64#=minusWord8X64#-- | Subtract two vectors element-wise.minusWord16X32#::Word16X32#->Word16X32#->Word16X32#minusWord16X32#=minusWord16X32#-- | Subtract two vectors element-wise.minusWord32X16#::Word32X16#->Word32X16#->Word32X16#minusWord32X16#=minusWord32X16#-- | Subtract two vectors element-wise.minusWord64X8#::Word64X8#->Word64X8#->Word64X8#minusWord64X8#=minusWord64X8#-- | Subtract two vectors element-wise.minusFloatX4#::FloatX4#->FloatX4#->FloatX4#minusFloatX4#=minusFloatX4#-- | Subtract two vectors element-wise.minusDoubleX2#::DoubleX2#->DoubleX2#->DoubleX2#minusDoubleX2#=minusDoubleX2#-- | Subtract two vectors element-wise.minusFloatX8#::FloatX8#->FloatX8#->FloatX8#minusFloatX8#=minusFloatX8#-- | Subtract two vectors element-wise.minusDoubleX4#::DoubleX4#->DoubleX4#->DoubleX4#minusDoubleX4#=minusDoubleX4#-- | Subtract two vectors element-wise.minusFloatX16#::FloatX16#->FloatX16#->FloatX16#minusFloatX16#=minusFloatX16#-- | Subtract two vectors element-wise.minusDoubleX8#::DoubleX8#->DoubleX8#->DoubleX8#minusDoubleX8#=minusDoubleX8#-- | Multiply two vectors element-wise.timesInt8X16#::Int8X16#->Int8X16#->Int8X16#timesInt8X16#=timesInt8X16#-- | Multiply two vectors element-wise.timesInt16X8#::Int16X8#->Int16X8#->Int16X8#timesInt16X8#=timesInt16X8#-- | Multiply two vectors element-wise.timesInt32X4#::Int32X4#->Int32X4#->Int32X4#timesInt32X4#=timesInt32X4#-- | Multiply two vectors element-wise.timesInt64X2#::Int64X2#->Int64X2#->Int64X2#timesInt64X2#=timesInt64X2#-- | Multiply two vectors element-wise.timesInt8X32#::Int8X32#->Int8X32#->Int8X32#timesInt8X32#=timesInt8X32#-- | Multiply two vectors element-wise.timesInt16X16#::Int16X16#->Int16X16#->Int16X16#timesInt16X16#=timesInt16X16#-- | Multiply two vectors element-wise.timesInt32X8#::Int32X8#->Int32X8#->Int32X8#timesInt32X8#=timesInt32X8#-- | Multiply two vectors element-wise.timesInt64X4#::Int64X4#->Int64X4#->Int64X4#timesInt64X4#=timesInt64X4#-- | Multiply two vectors element-wise.timesInt8X64#::Int8X64#->Int8X64#->Int8X64#timesInt8X64#=timesInt8X64#-- | Multiply two vectors element-wise.timesInt16X32#::Int16X32#->Int16X32#->Int16X32#timesInt16X32#=timesInt16X32#-- | Multiply two vectors element-wise.timesInt32X16#::Int32X16#->Int32X16#->Int32X16#timesInt32X16#=timesInt32X16#-- | Multiply two vectors element-wise.timesInt64X8#::Int64X8#->Int64X8#->Int64X8#timesInt64X8#=timesInt64X8#-- | Multiply two vectors element-wise.timesWord8X16#::Word8X16#->Word8X16#->Word8X16#timesWord8X16#=timesWord8X16#-- | Multiply two vectors element-wise.timesWord16X8#::Word16X8#->Word16X8#->Word16X8#timesWord16X8#=timesWord16X8#-- | Multiply two vectors element-wise.timesWord32X4#::Word32X4#->Word32X4#->Word32X4#timesWord32X4#=timesWord32X4#-- | Multiply two vectors element-wise.timesWord64X2#::Word64X2#->Word64X2#->Word64X2#timesWord64X2#=timesWord64X2#-- | Multiply two vectors element-wise.timesWord8X32#::Word8X32#->Word8X32#->Word8X32#timesWord8X32#=timesWord8X32#-- | Multiply two vectors element-wise.timesWord16X16#::Word16X16#->Word16X16#->Word16X16#timesWord16X16#=timesWord16X16#-- | Multiply two vectors element-wise.timesWord32X8#::Word32X8#->Word32X8#->Word32X8#timesWord32X8#=timesWord32X8#-- | Multiply two vectors element-wise.timesWord64X4#::Word64X4#->Word64X4#->Word64X4#timesWord64X4#=timesWord64X4#-- | Multiply two vectors element-wise.timesWord8X64#::Word8X64#->Word8X64#->Word8X64#timesWord8X64#=timesWord8X64#-- | Multiply two vectors element-wise.timesWord16X32#::Word16X32#->Word16X32#->Word16X32#timesWord16X32#=timesWord16X32#-- | Multiply two vectors element-wise.timesWord32X16#::Word32X16#->Word32X16#->Word32X16#timesWord32X16#=timesWord32X16#-- | Multiply two vectors element-wise.timesWord64X8#::Word64X8#->Word64X8#->Word64X8#timesWord64X8#=timesWord64X8#-- | Multiply two vectors element-wise.timesFloatX4#::FloatX4#->FloatX4#->FloatX4#timesFloatX4#=timesFloatX4#-- | Multiply two vectors element-wise.timesDoubleX2#::DoubleX2#->DoubleX2#->DoubleX2#timesDoubleX2#=timesDoubleX2#-- | Multiply two vectors element-wise.timesFloatX8#::FloatX8#->FloatX8#->FloatX8#timesFloatX8#=timesFloatX8#-- | Multiply two vectors element-wise.timesDoubleX4#::DoubleX4#->DoubleX4#->DoubleX4#timesDoubleX4#=timesDoubleX4#-- | Multiply two vectors element-wise.timesFloatX16#::FloatX16#->FloatX16#->FloatX16#timesFloatX16#=timesFloatX16#-- | Multiply two vectors element-wise.timesDoubleX8#::DoubleX8#->DoubleX8#->DoubleX8#timesDoubleX8#=timesDoubleX8#-- | Divide two vectors element-wise.divideFloatX4#::FloatX4#->FloatX4#->FloatX4#divideFloatX4#=divideFloatX4#-- | Divide two vectors element-wise.divideDoubleX2#::DoubleX2#->DoubleX2#->DoubleX2#divideDoubleX2#=divideDoubleX2#-- | Divide two vectors element-wise.divideFloatX8#::FloatX8#->FloatX8#->FloatX8#divideFloatX8#=divideFloatX8#-- | Divide two vectors element-wise.divideDoubleX4#::DoubleX4#->DoubleX4#->DoubleX4#divideDoubleX4#=divideDoubleX4#-- | Divide two vectors element-wise.divideFloatX16#::FloatX16#->FloatX16#->FloatX16#divideFloatX16#=divideFloatX16#-- | Divide two vectors element-wise.divideDoubleX8#::DoubleX8#->DoubleX8#->DoubleX8#divideDoubleX8#=divideDoubleX8#-- | Rounds towards zero element-wise.quotInt8X16#::Int8X16#->Int8X16#->Int8X16#quotInt8X16#=quotInt8X16#-- | Rounds towards zero element-wise.quotInt16X8#::Int16X8#->Int16X8#->Int16X8#quotInt16X8#=quotInt16X8#-- | Rounds towards zero element-wise.quotInt32X4#::Int32X4#->Int32X4#->Int32X4#quotInt32X4#=quotInt32X4#-- | Rounds towards zero element-wise.quotInt64X2#::Int64X2#->Int64X2#->Int64X2#quotInt64X2#=quotInt64X2#-- | Rounds towards zero element-wise.quotInt8X32#::Int8X32#->Int8X32#->Int8X32#quotInt8X32#=quotInt8X32#-- | Rounds towards zero element-wise.quotInt16X16#::Int16X16#->Int16X16#->Int16X16#quotInt16X16#=quotInt16X16#-- | Rounds towards zero element-wise.quotInt32X8#::Int32X8#->Int32X8#->Int32X8#quotInt32X8#=quotInt32X8#-- | Rounds towards zero element-wise.quotInt64X4#::Int64X4#->Int64X4#->Int64X4#quotInt64X4#=quotInt64X4#-- | Rounds towards zero element-wise.quotInt8X64#::Int8X64#->Int8X64#->Int8X64#quotInt8X64#=quotInt8X64#-- | Rounds towards zero element-wise.quotInt16X32#::Int16X32#->Int16X32#->Int16X32#quotInt16X32#=quotInt16X32#-- | Rounds towards zero element-wise.quotInt32X16#::Int32X16#->Int32X16#->Int32X16#quotInt32X16#=quotInt32X16#-- | Rounds towards zero element-wise.quotInt64X8#::Int64X8#->Int64X8#->Int64X8#quotInt64X8#=quotInt64X8#-- | Rounds towards zero element-wise.quotWord8X16#::Word8X16#->Word8X16#->Word8X16#quotWord8X16#=quotWord8X16#-- | Rounds towards zero element-wise.quotWord16X8#::Word16X8#->Word16X8#->Word16X8#quotWord16X8#=quotWord16X8#-- | Rounds towards zero element-wise.quotWord32X4#::Word32X4#->Word32X4#->Word32X4#quotWord32X4#=quotWord32X4#-- | Rounds towards zero element-wise.quotWord64X2#::Word64X2#->Word64X2#->Word64X2#quotWord64X2#=quotWord64X2#-- | Rounds towards zero element-wise.quotWord8X32#::Word8X32#->Word8X32#->Word8X32#quotWord8X32#=quotWord8X32#-- | Rounds towards zero element-wise.quotWord16X16#::Word16X16#->Word16X16#->Word16X16#quotWord16X16#=quotWord16X16#-- | Rounds towards zero element-wise.quotWord32X8#::Word32X8#->Word32X8#->Word32X8#quotWord32X8#=quotWord32X8#-- | Rounds towards zero element-wise.quotWord64X4#::Word64X4#->Word64X4#->Word64X4#quotWord64X4#=quotWord64X4#-- | Rounds towards zero element-wise.quotWord8X64#::Word8X64#->Word8X64#->Word8X64#quotWord8X64#=quotWord8X64#-- | Rounds towards zero element-wise.quotWord16X32#::Word16X32#->Word16X32#->Word16X32#quotWord16X32#=quotWord16X32#-- | Rounds towards zero element-wise.quotWord32X16#::Word32X16#->Word32X16#->Word32X16#quotWord32X16#=quotWord32X16#-- | Rounds towards zero element-wise.quotWord64X8#::Word64X8#->Word64X8#->Word64X8#quotWord64X8#=quotWord64X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt8X16#::Int8X16#->Int8X16#->Int8X16#remInt8X16#=remInt8X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt16X8#::Int16X8#->Int16X8#->Int16X8#remInt16X8#=remInt16X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt32X4#::Int32X4#->Int32X4#->Int32X4#remInt32X4#=remInt32X4#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt64X2#::Int64X2#->Int64X2#->Int64X2#remInt64X2#=remInt64X2#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt8X32#::Int8X32#->Int8X32#->Int8X32#remInt8X32#=remInt8X32#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt16X16#::Int16X16#->Int16X16#->Int16X16#remInt16X16#=remInt16X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt32X8#::Int32X8#->Int32X8#->Int32X8#remInt32X8#=remInt32X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt64X4#::Int64X4#->Int64X4#->Int64X4#remInt64X4#=remInt64X4#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt8X64#::Int8X64#->Int8X64#->Int8X64#remInt8X64#=remInt8X64#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt16X32#::Int16X32#->Int16X32#->Int16X32#remInt16X32#=remInt16X32#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt32X16#::Int32X16#->Int32X16#->Int32X16#remInt32X16#=remInt32X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remInt64X8#::Int64X8#->Int64X8#->Int64X8#remInt64X8#=remInt64X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord8X16#::Word8X16#->Word8X16#->Word8X16#remWord8X16#=remWord8X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord16X8#::Word16X8#->Word16X8#->Word16X8#remWord16X8#=remWord16X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord32X4#::Word32X4#->Word32X4#->Word32X4#remWord32X4#=remWord32X4#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord64X2#::Word64X2#->Word64X2#->Word64X2#remWord64X2#=remWord64X2#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord8X32#::Word8X32#->Word8X32#->Word8X32#remWord8X32#=remWord8X32#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord16X16#::Word16X16#->Word16X16#->Word16X16#remWord16X16#=remWord16X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord32X8#::Word32X8#->Word32X8#->Word32X8#remWord32X8#=remWord32X8#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord64X4#::Word64X4#->Word64X4#->Word64X4#remWord64X4#=remWord64X4#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord8X64#::Word8X64#->Word8X64#->Word8X64#remWord8X64#=remWord8X64#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord16X32#::Word16X32#->Word16X32#->Word16X32#remWord16X32#=remWord16X32#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord32X16#::Word32X16#->Word32X16#->Word32X16#remWord32X16#=remWord32X16#-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@.remWord64X8#::Word64X8#->Word64X8#->Word64X8#remWord64X8#=remWord64X8#-- | Negate element-wise.negateInt8X16#::Int8X16#->Int8X16#negateInt8X16#=negateInt8X16#-- | Negate element-wise.negateInt16X8#::Int16X8#->Int16X8#negateInt16X8#=negateInt16X8#-- | Negate element-wise.negateInt32X4#::Int32X4#->Int32X4#negateInt32X4#=negateInt32X4#-- | Negate element-wise.negateInt64X2#::Int64X2#->Int64X2#negateInt64X2#=negateInt64X2#-- | Negate element-wise.negateInt8X32#::Int8X32#->Int8X32#negateInt8X32#=negateInt8X32#-- | Negate element-wise.negateInt16X16#::Int16X16#->Int16X16#negateInt16X16#=negateInt16X16#-- | Negate element-wise.negateInt32X8#::Int32X8#->Int32X8#negateInt32X8#=negateInt32X8#-- | Negate element-wise.negateInt64X4#::Int64X4#->Int64X4#negateInt64X4#=negateInt64X4#-- | Negate element-wise.negateInt8X64#::Int8X64#->Int8X64#negateInt8X64#=negateInt8X64#-- | Negate element-wise.negateInt16X32#::Int16X32#->Int16X32#negateInt16X32#=negateInt16X32#-- | Negate element-wise.negateInt32X16#::Int32X16#->Int32X16#negateInt32X16#=negateInt32X16#-- | Negate element-wise.negateInt64X8#::Int64X8#->Int64X8#negateInt64X8#=negateInt64X8#-- | Negate element-wise.negateFloatX4#::FloatX4#->FloatX4#negateFloatX4#=negateFloatX4#-- | Negate element-wise.negateDoubleX2#::DoubleX2#->DoubleX2#negateDoubleX2#=negateDoubleX2#-- | Negate element-wise.negateFloatX8#::FloatX8#->FloatX8#negateFloatX8#=negateFloatX8#-- | Negate element-wise.negateDoubleX4#::DoubleX4#->DoubleX4#negateDoubleX4#=negateDoubleX4#-- | Negate element-wise.negateFloatX16#::FloatX16#->FloatX16#negateFloatX16#=negateFloatX16#-- | Negate element-wise.negateDoubleX8#::DoubleX8#->DoubleX8#negateDoubleX8#=negateDoubleX8#-- | Read a vector from specified index of immutable array.indexInt8X16Array#::ByteArray#->Int#->Int8X16#indexInt8X16Array#=indexInt8X16Array#-- | Read a vector from specified index of immutable array.indexInt16X8Array#::ByteArray#->Int#->Int16X8#indexInt16X8Array#=indexInt16X8Array#-- | Read a vector from specified index of immutable array.indexInt32X4Array#::ByteArray#->Int#->Int32X4#indexInt32X4Array#=indexInt32X4Array#-- | Read a vector from specified index of immutable array.indexInt64X2Array#::ByteArray#->Int#->Int64X2#indexInt64X2Array#=indexInt64X2Array#-- | Read a vector from specified index of immutable array.indexInt8X32Array#::ByteArray#->Int#->Int8X32#indexInt8X32Array#=indexInt8X32Array#-- | Read a vector from specified index of immutable array.indexInt16X16Array#::ByteArray#->Int#->Int16X16#indexInt16X16Array#=indexInt16X16Array#-- | Read a vector from specified index of immutable array.indexInt32X8Array#::ByteArray#->Int#->Int32X8#indexInt32X8Array#=indexInt32X8Array#-- | Read a vector from specified index of immutable array.indexInt64X4Array#::ByteArray#->Int#->Int64X4#indexInt64X4Array#=indexInt64X4Array#-- | Read a vector from specified index of immutable array.indexInt8X64Array#::ByteArray#->Int#->Int8X64#indexInt8X64Array#=indexInt8X64Array#-- | Read a vector from specified index of immutable array.indexInt16X32Array#::ByteArray#->Int#->Int16X32#indexInt16X32Array#=indexInt16X32Array#-- | Read a vector from specified index of immutable array.indexInt32X16Array#::ByteArray#->Int#->Int32X16#indexInt32X16Array#=indexInt32X16Array#-- | Read a vector from specified index of immutable array.indexInt64X8Array#::ByteArray#->Int#->Int64X8#indexInt64X8Array#=indexInt64X8Array#-- | Read a vector from specified index of immutable array.indexWord8X16Array#::ByteArray#->Int#->Word8X16#indexWord8X16Array#=indexWord8X16Array#-- | Read a vector from specified index of immutable array.indexWord16X8Array#::ByteArray#->Int#->Word16X8#indexWord16X8Array#=indexWord16X8Array#-- | Read a vector from specified index of immutable array.indexWord32X4Array#::ByteArray#->Int#->Word32X4#indexWord32X4Array#=indexWord32X4Array#-- | Read a vector from specified index of immutable array.indexWord64X2Array#::ByteArray#->Int#->Word64X2#indexWord64X2Array#=indexWord64X2Array#-- | Read a vector from specified index of immutable array.indexWord8X32Array#::ByteArray#->Int#->Word8X32#indexWord8X32Array#=indexWord8X32Array#-- | Read a vector from specified index of immutable array.indexWord16X16Array#::ByteArray#->Int#->Word16X16#indexWord16X16Array#=indexWord16X16Array#-- | Read a vector from specified index of immutable array.indexWord32X8Array#::ByteArray#->Int#->Word32X8#indexWord32X8Array#=indexWord32X8Array#-- | Read a vector from specified index of immutable array.indexWord64X4Array#::ByteArray#->Int#->Word64X4#indexWord64X4Array#=indexWord64X4Array#-- | Read a vector from specified index of immutable array.indexWord8X64Array#::ByteArray#->Int#->Word8X64#indexWord8X64Array#=indexWord8X64Array#-- | Read a vector from specified index of immutable array.indexWord16X32Array#::ByteArray#->Int#->Word16X32#indexWord16X32Array#=indexWord16X32Array#-- | Read a vector from specified index of immutable array.indexWord32X16Array#::ByteArray#->Int#->Word32X16#indexWord32X16Array#=indexWord32X16Array#-- | Read a vector from specified index of immutable array.indexWord64X8Array#::ByteArray#->Int#->Word64X8#indexWord64X8Array#=indexWord64X8Array#-- | Read a vector from specified index of immutable array.indexFloatX4Array#::ByteArray#->Int#->FloatX4#indexFloatX4Array#=indexFloatX4Array#-- | Read a vector from specified index of immutable array.indexDoubleX2Array#::ByteArray#->Int#->DoubleX2#indexDoubleX2Array#=indexDoubleX2Array#-- | Read a vector from specified index of immutable array.indexFloatX8Array#::ByteArray#->Int#->FloatX8#indexFloatX8Array#=indexFloatX8Array#-- | Read a vector from specified index of immutable array.indexDoubleX4Array#::ByteArray#->Int#->DoubleX4#indexDoubleX4Array#=indexDoubleX4Array#-- | Read a vector from specified index of immutable array.indexFloatX16Array#::ByteArray#->Int#->FloatX16#indexFloatX16Array#=indexFloatX16Array#-- | Read a vector from specified index of immutable array.indexDoubleX8Array#::ByteArray#->Int#->DoubleX8#indexDoubleX8Array#=indexDoubleX8Array#-- | Read a vector from specified index of mutable array.readInt8X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X16##)readInt8X16Array#=readInt8X16Array#-- | Read a vector from specified index of mutable array.readInt16X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X8##)readInt16X8Array#=readInt16X8Array#-- | Read a vector from specified index of mutable array.readInt32X4Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X4##)readInt32X4Array#=readInt32X4Array#-- | Read a vector from specified index of mutable array.readInt64X2Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X2##)readInt64X2Array#=readInt64X2Array#-- | Read a vector from specified index of mutable array.readInt8X32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X32##)readInt8X32Array#=readInt8X32Array#-- | Read a vector from specified index of mutable array.readInt16X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X16##)readInt16X16Array#=readInt16X16Array#-- | Read a vector from specified index of mutable array.readInt32X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X8##)readInt32X8Array#=readInt32X8Array#-- | Read a vector from specified index of mutable array.readInt64X4Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X4##)readInt64X4Array#=readInt64X4Array#-- | Read a vector from specified index of mutable array.readInt8X64Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X64##)readInt8X64Array#=readInt8X64Array#-- | Read a vector from specified index of mutable array.readInt16X32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X32##)readInt16X32Array#=readInt16X32Array#-- | Read a vector from specified index of mutable array.readInt32X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X16##)readInt32X16Array#=readInt32X16Array#-- | Read a vector from specified index of mutable array.readInt64X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X8##)readInt64X8Array#=readInt64X8Array#-- | Read a vector from specified index of mutable array.readWord8X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X16##)readWord8X16Array#=readWord8X16Array#-- | Read a vector from specified index of mutable array.readWord16X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X8##)readWord16X8Array#=readWord16X8Array#-- | Read a vector from specified index of mutable array.readWord32X4Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X4##)readWord32X4Array#=readWord32X4Array#-- | Read a vector from specified index of mutable array.readWord64X2Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X2##)readWord64X2Array#=readWord64X2Array#-- | Read a vector from specified index of mutable array.readWord8X32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X32##)readWord8X32Array#=readWord8X32Array#-- | Read a vector from specified index of mutable array.readWord16X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X16##)readWord16X16Array#=readWord16X16Array#-- | Read a vector from specified index of mutable array.readWord32X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X8##)readWord32X8Array#=readWord32X8Array#-- | Read a vector from specified index of mutable array.readWord64X4Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X4##)readWord64X4Array#=readWord64X4Array#-- | Read a vector from specified index of mutable array.readWord8X64Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X64##)readWord8X64Array#=readWord8X64Array#-- | Read a vector from specified index of mutable array.readWord16X32Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X32##)readWord16X32Array#=readWord16X32Array#-- | Read a vector from specified index of mutable array.readWord32X16Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X16##)readWord32X16Array#=readWord32X16Array#-- | Read a vector from specified index of mutable array.readWord64X8Array#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X8##)readWord64X8Array#=readWord64X8Array#-- | Read a vector from specified index of mutable array.readFloatX4Array#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX4##)readFloatX4Array#=readFloatX4Array#-- | Read a vector from specified index of mutable array.readDoubleX2Array#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX2##)readDoubleX2Array#=readDoubleX2Array#-- | Read a vector from specified index of mutable array.readFloatX8Array#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX8##)readFloatX8Array#=readFloatX8Array#-- | Read a vector from specified index of mutable array.readDoubleX4Array#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX4##)readDoubleX4Array#=readDoubleX4Array#-- | Read a vector from specified index of mutable array.readFloatX16Array#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX16##)readFloatX16Array#=readFloatX16Array#-- | Read a vector from specified index of mutable array.readDoubleX8Array#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX8##)readDoubleX8Array#=readDoubleX8Array#-- | Write a vector to specified index of mutable array.writeInt8X16Array#::MutableByteArray#s->Int#->Int8X16#->State#s->State#swriteInt8X16Array#=writeInt8X16Array#-- | Write a vector to specified index of mutable array.writeInt16X8Array#::MutableByteArray#s->Int#->Int16X8#->State#s->State#swriteInt16X8Array#=writeInt16X8Array#-- | Write a vector to specified index of mutable array.writeInt32X4Array#::MutableByteArray#s->Int#->Int32X4#->State#s->State#swriteInt32X4Array#=writeInt32X4Array#-- | Write a vector to specified index of mutable array.writeInt64X2Array#::MutableByteArray#s->Int#->Int64X2#->State#s->State#swriteInt64X2Array#=writeInt64X2Array#-- | Write a vector to specified index of mutable array.writeInt8X32Array#::MutableByteArray#s->Int#->Int8X32#->State#s->State#swriteInt8X32Array#=writeInt8X32Array#-- | Write a vector to specified index of mutable array.writeInt16X16Array#::MutableByteArray#s->Int#->Int16X16#->State#s->State#swriteInt16X16Array#=writeInt16X16Array#-- | Write a vector to specified index of mutable array.writeInt32X8Array#::MutableByteArray#s->Int#->Int32X8#->State#s->State#swriteInt32X8Array#=writeInt32X8Array#-- | Write a vector to specified index of mutable array.writeInt64X4Array#::MutableByteArray#s->Int#->Int64X4#->State#s->State#swriteInt64X4Array#=writeInt64X4Array#-- | Write a vector to specified index of mutable array.writeInt8X64Array#::MutableByteArray#s->Int#->Int8X64#->State#s->State#swriteInt8X64Array#=writeInt8X64Array#-- | Write a vector to specified index of mutable array.writeInt16X32Array#::MutableByteArray#s->Int#->Int16X32#->State#s->State#swriteInt16X32Array#=writeInt16X32Array#-- | Write a vector to specified index of mutable array.writeInt32X16Array#::MutableByteArray#s->Int#->Int32X16#->State#s->State#swriteInt32X16Array#=writeInt32X16Array#-- | Write a vector to specified index of mutable array.writeInt64X8Array#::MutableByteArray#s->Int#->Int64X8#->State#s->State#swriteInt64X8Array#=writeInt64X8Array#-- | Write a vector to specified index of mutable array.writeWord8X16Array#::MutableByteArray#s->Int#->Word8X16#->State#s->State#swriteWord8X16Array#=writeWord8X16Array#-- | Write a vector to specified index of mutable array.writeWord16X8Array#::MutableByteArray#s->Int#->Word16X8#->State#s->State#swriteWord16X8Array#=writeWord16X8Array#-- | Write a vector to specified index of mutable array.writeWord32X4Array#::MutableByteArray#s->Int#->Word32X4#->State#s->State#swriteWord32X4Array#=writeWord32X4Array#-- | Write a vector to specified index of mutable array.writeWord64X2Array#::MutableByteArray#s->Int#->Word64X2#->State#s->State#swriteWord64X2Array#=writeWord64X2Array#-- | Write a vector to specified index of mutable array.writeWord8X32Array#::MutableByteArray#s->Int#->Word8X32#->State#s->State#swriteWord8X32Array#=writeWord8X32Array#-- | Write a vector to specified index of mutable array.writeWord16X16Array#::MutableByteArray#s->Int#->Word16X16#->State#s->State#swriteWord16X16Array#=writeWord16X16Array#-- | Write a vector to specified index of mutable array.writeWord32X8Array#::MutableByteArray#s->Int#->Word32X8#->State#s->State#swriteWord32X8Array#=writeWord32X8Array#-- | Write a vector to specified index of mutable array.writeWord64X4Array#::MutableByteArray#s->Int#->Word64X4#->State#s->State#swriteWord64X4Array#=writeWord64X4Array#-- | Write a vector to specified index of mutable array.writeWord8X64Array#::MutableByteArray#s->Int#->Word8X64#->State#s->State#swriteWord8X64Array#=writeWord8X64Array#-- | Write a vector to specified index of mutable array.writeWord16X32Array#::MutableByteArray#s->Int#->Word16X32#->State#s->State#swriteWord16X32Array#=writeWord16X32Array#-- | Write a vector to specified index of mutable array.writeWord32X16Array#::MutableByteArray#s->Int#->Word32X16#->State#s->State#swriteWord32X16Array#=writeWord32X16Array#-- | Write a vector to specified index of mutable array.writeWord64X8Array#::MutableByteArray#s->Int#->Word64X8#->State#s->State#swriteWord64X8Array#=writeWord64X8Array#-- | Write a vector to specified index of mutable array.writeFloatX4Array#::MutableByteArray#s->Int#->FloatX4#->State#s->State#swriteFloatX4Array#=writeFloatX4Array#-- | Write a vector to specified index of mutable array.writeDoubleX2Array#::MutableByteArray#s->Int#->DoubleX2#->State#s->State#swriteDoubleX2Array#=writeDoubleX2Array#-- | Write a vector to specified index of mutable array.writeFloatX8Array#::MutableByteArray#s->Int#->FloatX8#->State#s->State#swriteFloatX8Array#=writeFloatX8Array#-- | Write a vector to specified index of mutable array.writeDoubleX4Array#::MutableByteArray#s->Int#->DoubleX4#->State#s->State#swriteDoubleX4Array#=writeDoubleX4Array#-- | Write a vector to specified index of mutable array.writeFloatX16Array#::MutableByteArray#s->Int#->FloatX16#->State#s->State#swriteFloatX16Array#=writeFloatX16Array#-- | Write a vector to specified index of mutable array.writeDoubleX8Array#::MutableByteArray#s->Int#->DoubleX8#->State#s->State#swriteDoubleX8Array#=writeDoubleX8Array#-- | Reads vector; offset in bytes.indexInt8X16OffAddr#::Addr#->Int#->Int8X16#indexInt8X16OffAddr#=indexInt8X16OffAddr#-- | Reads vector; offset in bytes.indexInt16X8OffAddr#::Addr#->Int#->Int16X8#indexInt16X8OffAddr#=indexInt16X8OffAddr#-- | Reads vector; offset in bytes.indexInt32X4OffAddr#::Addr#->Int#->Int32X4#indexInt32X4OffAddr#=indexInt32X4OffAddr#-- | Reads vector; offset in bytes.indexInt64X2OffAddr#::Addr#->Int#->Int64X2#indexInt64X2OffAddr#=indexInt64X2OffAddr#-- | Reads vector; offset in bytes.indexInt8X32OffAddr#::Addr#->Int#->Int8X32#indexInt8X32OffAddr#=indexInt8X32OffAddr#-- | Reads vector; offset in bytes.indexInt16X16OffAddr#::Addr#->Int#->Int16X16#indexInt16X16OffAddr#=indexInt16X16OffAddr#-- | Reads vector; offset in bytes.indexInt32X8OffAddr#::Addr#->Int#->Int32X8#indexInt32X8OffAddr#=indexInt32X8OffAddr#-- | Reads vector; offset in bytes.indexInt64X4OffAddr#::Addr#->Int#->Int64X4#indexInt64X4OffAddr#=indexInt64X4OffAddr#-- | Reads vector; offset in bytes.indexInt8X64OffAddr#::Addr#->Int#->Int8X64#indexInt8X64OffAddr#=indexInt8X64OffAddr#-- | Reads vector; offset in bytes.indexInt16X32OffAddr#::Addr#->Int#->Int16X32#indexInt16X32OffAddr#=indexInt16X32OffAddr#-- | Reads vector; offset in bytes.indexInt32X16OffAddr#::Addr#->Int#->Int32X16#indexInt32X16OffAddr#=indexInt32X16OffAddr#-- | Reads vector; offset in bytes.indexInt64X8OffAddr#::Addr#->Int#->Int64X8#indexInt64X8OffAddr#=indexInt64X8OffAddr#-- | Reads vector; offset in bytes.indexWord8X16OffAddr#::Addr#->Int#->Word8X16#indexWord8X16OffAddr#=indexWord8X16OffAddr#-- | Reads vector; offset in bytes.indexWord16X8OffAddr#::Addr#->Int#->Word16X8#indexWord16X8OffAddr#=indexWord16X8OffAddr#-- | Reads vector; offset in bytes.indexWord32X4OffAddr#::Addr#->Int#->Word32X4#indexWord32X4OffAddr#=indexWord32X4OffAddr#-- | Reads vector; offset in bytes.indexWord64X2OffAddr#::Addr#->Int#->Word64X2#indexWord64X2OffAddr#=indexWord64X2OffAddr#-- | Reads vector; offset in bytes.indexWord8X32OffAddr#::Addr#->Int#->Word8X32#indexWord8X32OffAddr#=indexWord8X32OffAddr#-- | Reads vector; offset in bytes.indexWord16X16OffAddr#::Addr#->Int#->Word16X16#indexWord16X16OffAddr#=indexWord16X16OffAddr#-- | Reads vector; offset in bytes.indexWord32X8OffAddr#::Addr#->Int#->Word32X8#indexWord32X8OffAddr#=indexWord32X8OffAddr#-- | Reads vector; offset in bytes.indexWord64X4OffAddr#::Addr#->Int#->Word64X4#indexWord64X4OffAddr#=indexWord64X4OffAddr#-- | Reads vector; offset in bytes.indexWord8X64OffAddr#::Addr#->Int#->Word8X64#indexWord8X64OffAddr#=indexWord8X64OffAddr#-- | Reads vector; offset in bytes.indexWord16X32OffAddr#::Addr#->Int#->Word16X32#indexWord16X32OffAddr#=indexWord16X32OffAddr#-- | Reads vector; offset in bytes.indexWord32X16OffAddr#::Addr#->Int#->Word32X16#indexWord32X16OffAddr#=indexWord32X16OffAddr#-- | Reads vector; offset in bytes.indexWord64X8OffAddr#::Addr#->Int#->Word64X8#indexWord64X8OffAddr#=indexWord64X8OffAddr#-- | Reads vector; offset in bytes.indexFloatX4OffAddr#::Addr#->Int#->FloatX4#indexFloatX4OffAddr#=indexFloatX4OffAddr#-- | Reads vector; offset in bytes.indexDoubleX2OffAddr#::Addr#->Int#->DoubleX2#indexDoubleX2OffAddr#=indexDoubleX2OffAddr#-- | Reads vector; offset in bytes.indexFloatX8OffAddr#::Addr#->Int#->FloatX8#indexFloatX8OffAddr#=indexFloatX8OffAddr#-- | Reads vector; offset in bytes.indexDoubleX4OffAddr#::Addr#->Int#->DoubleX4#indexDoubleX4OffAddr#=indexDoubleX4OffAddr#-- | Reads vector; offset in bytes.indexFloatX16OffAddr#::Addr#->Int#->FloatX16#indexFloatX16OffAddr#=indexFloatX16OffAddr#-- | Reads vector; offset in bytes.indexDoubleX8OffAddr#::Addr#->Int#->DoubleX8#indexDoubleX8OffAddr#=indexDoubleX8OffAddr#-- | Reads vector; offset in bytes.readInt8X16OffAddr#::Addr#->Int#->State#s->(#State#s,Int8X16##)readInt8X16OffAddr#=readInt8X16OffAddr#-- | Reads vector; offset in bytes.readInt16X8OffAddr#::Addr#->Int#->State#s->(#State#s,Int16X8##)readInt16X8OffAddr#=readInt16X8OffAddr#-- | Reads vector; offset in bytes.readInt32X4OffAddr#::Addr#->Int#->State#s->(#State#s,Int32X4##)readInt32X4OffAddr#=readInt32X4OffAddr#-- | Reads vector; offset in bytes.readInt64X2OffAddr#::Addr#->Int#->State#s->(#State#s,Int64X2##)readInt64X2OffAddr#=readInt64X2OffAddr#-- | Reads vector; offset in bytes.readInt8X32OffAddr#::Addr#->Int#->State#s->(#State#s,Int8X32##)readInt8X32OffAddr#=readInt8X32OffAddr#-- | Reads vector; offset in bytes.readInt16X16OffAddr#::Addr#->Int#->State#s->(#State#s,Int16X16##)readInt16X16OffAddr#=readInt16X16OffAddr#-- | Reads vector; offset in bytes.readInt32X8OffAddr#::Addr#->Int#->State#s->(#State#s,Int32X8##)readInt32X8OffAddr#=readInt32X8OffAddr#-- | Reads vector; offset in bytes.readInt64X4OffAddr#::Addr#->Int#->State#s->(#State#s,Int64X4##)readInt64X4OffAddr#=readInt64X4OffAddr#-- | Reads vector; offset in bytes.readInt8X64OffAddr#::Addr#->Int#->State#s->(#State#s,Int8X64##)readInt8X64OffAddr#=readInt8X64OffAddr#-- | Reads vector; offset in bytes.readInt16X32OffAddr#::Addr#->Int#->State#s->(#State#s,Int16X32##)readInt16X32OffAddr#=readInt16X32OffAddr#-- | Reads vector; offset in bytes.readInt32X16OffAddr#::Addr#->Int#->State#s->(#State#s,Int32X16##)readInt32X16OffAddr#=readInt32X16OffAddr#-- | Reads vector; offset in bytes.readInt64X8OffAddr#::Addr#->Int#->State#s->(#State#s,Int64X8##)readInt64X8OffAddr#=readInt64X8OffAddr#-- | Reads vector; offset in bytes.readWord8X16OffAddr#::Addr#->Int#->State#s->(#State#s,Word8X16##)readWord8X16OffAddr#=readWord8X16OffAddr#-- | Reads vector; offset in bytes.readWord16X8OffAddr#::Addr#->Int#->State#s->(#State#s,Word16X8##)readWord16X8OffAddr#=readWord16X8OffAddr#-- | Reads vector; offset in bytes.readWord32X4OffAddr#::Addr#->Int#->State#s->(#State#s,Word32X4##)readWord32X4OffAddr#=readWord32X4OffAddr#-- | Reads vector; offset in bytes.readWord64X2OffAddr#::Addr#->Int#->State#s->(#State#s,Word64X2##)readWord64X2OffAddr#=readWord64X2OffAddr#-- | Reads vector; offset in bytes.readWord8X32OffAddr#::Addr#->Int#->State#s->(#State#s,Word8X32##)readWord8X32OffAddr#=readWord8X32OffAddr#-- | Reads vector; offset in bytes.readWord16X16OffAddr#::Addr#->Int#->State#s->(#State#s,Word16X16##)readWord16X16OffAddr#=readWord16X16OffAddr#-- | Reads vector; offset in bytes.readWord32X8OffAddr#::Addr#->Int#->State#s->(#State#s,Word32X8##)readWord32X8OffAddr#=readWord32X8OffAddr#-- | Reads vector; offset in bytes.readWord64X4OffAddr#::Addr#->Int#->State#s->(#State#s,Word64X4##)readWord64X4OffAddr#=readWord64X4OffAddr#-- | Reads vector; offset in bytes.readWord8X64OffAddr#::Addr#->Int#->State#s->(#State#s,Word8X64##)readWord8X64OffAddr#=readWord8X64OffAddr#-- | Reads vector; offset in bytes.readWord16X32OffAddr#::Addr#->Int#->State#s->(#State#s,Word16X32##)readWord16X32OffAddr#=readWord16X32OffAddr#-- | Reads vector; offset in bytes.readWord32X16OffAddr#::Addr#->Int#->State#s->(#State#s,Word32X16##)readWord32X16OffAddr#=readWord32X16OffAddr#-- | Reads vector; offset in bytes.readWord64X8OffAddr#::Addr#->Int#->State#s->(#State#s,Word64X8##)readWord64X8OffAddr#=readWord64X8OffAddr#-- | Reads vector; offset in bytes.readFloatX4OffAddr#::Addr#->Int#->State#s->(#State#s,FloatX4##)readFloatX4OffAddr#=readFloatX4OffAddr#-- | Reads vector; offset in bytes.readDoubleX2OffAddr#::Addr#->Int#->State#s->(#State#s,DoubleX2##)readDoubleX2OffAddr#=readDoubleX2OffAddr#-- | Reads vector; offset in bytes.readFloatX8OffAddr#::Addr#->Int#->State#s->(#State#s,FloatX8##)readFloatX8OffAddr#=readFloatX8OffAddr#-- | Reads vector; offset in bytes.readDoubleX4OffAddr#::Addr#->Int#->State#s->(#State#s,DoubleX4##)readDoubleX4OffAddr#=readDoubleX4OffAddr#-- | Reads vector; offset in bytes.readFloatX16OffAddr#::Addr#->Int#->State#s->(#State#s,FloatX16##)readFloatX16OffAddr#=readFloatX16OffAddr#-- | Reads vector; offset in bytes.readDoubleX8OffAddr#::Addr#->Int#->State#s->(#State#s,DoubleX8##)readDoubleX8OffAddr#=readDoubleX8OffAddr#-- | Write vector; offset in bytes.writeInt8X16OffAddr#::Addr#->Int#->Int8X16#->State#s->State#swriteInt8X16OffAddr#=writeInt8X16OffAddr#-- | Write vector; offset in bytes.writeInt16X8OffAddr#::Addr#->Int#->Int16X8#->State#s->State#swriteInt16X8OffAddr#=writeInt16X8OffAddr#-- | Write vector; offset in bytes.writeInt32X4OffAddr#::Addr#->Int#->Int32X4#->State#s->State#swriteInt32X4OffAddr#=writeInt32X4OffAddr#-- | Write vector; offset in bytes.writeInt64X2OffAddr#::Addr#->Int#->Int64X2#->State#s->State#swriteInt64X2OffAddr#=writeInt64X2OffAddr#-- | Write vector; offset in bytes.writeInt8X32OffAddr#::Addr#->Int#->Int8X32#->State#s->State#swriteInt8X32OffAddr#=writeInt8X32OffAddr#-- | Write vector; offset in bytes.writeInt16X16OffAddr#::Addr#->Int#->Int16X16#->State#s->State#swriteInt16X16OffAddr#=writeInt16X16OffAddr#-- | Write vector; offset in bytes.writeInt32X8OffAddr#::Addr#->Int#->Int32X8#->State#s->State#swriteInt32X8OffAddr#=writeInt32X8OffAddr#-- | Write vector; offset in bytes.writeInt64X4OffAddr#::Addr#->Int#->Int64X4#->State#s->State#swriteInt64X4OffAddr#=writeInt64X4OffAddr#-- | Write vector; offset in bytes.writeInt8X64OffAddr#::Addr#->Int#->Int8X64#->State#s->State#swriteInt8X64OffAddr#=writeInt8X64OffAddr#-- | Write vector; offset in bytes.writeInt16X32OffAddr#::Addr#->Int#->Int16X32#->State#s->State#swriteInt16X32OffAddr#=writeInt16X32OffAddr#-- | Write vector; offset in bytes.writeInt32X16OffAddr#::Addr#->Int#->Int32X16#->State#s->State#swriteInt32X16OffAddr#=writeInt32X16OffAddr#-- | Write vector; offset in bytes.writeInt64X8OffAddr#::Addr#->Int#->Int64X8#->State#s->State#swriteInt64X8OffAddr#=writeInt64X8OffAddr#-- | Write vector; offset in bytes.writeWord8X16OffAddr#::Addr#->Int#->Word8X16#->State#s->State#swriteWord8X16OffAddr#=writeWord8X16OffAddr#-- | Write vector; offset in bytes.writeWord16X8OffAddr#::Addr#->Int#->Word16X8#->State#s->State#swriteWord16X8OffAddr#=writeWord16X8OffAddr#-- | Write vector; offset in bytes.writeWord32X4OffAddr#::Addr#->Int#->Word32X4#->State#s->State#swriteWord32X4OffAddr#=writeWord32X4OffAddr#-- | Write vector; offset in bytes.writeWord64X2OffAddr#::Addr#->Int#->Word64X2#->State#s->State#swriteWord64X2OffAddr#=writeWord64X2OffAddr#-- | Write vector; offset in bytes.writeWord8X32OffAddr#::Addr#->Int#->Word8X32#->State#s->State#swriteWord8X32OffAddr#=writeWord8X32OffAddr#-- | Write vector; offset in bytes.writeWord16X16OffAddr#::Addr#->Int#->Word16X16#->State#s->State#swriteWord16X16OffAddr#=writeWord16X16OffAddr#-- | Write vector; offset in bytes.writeWord32X8OffAddr#::Addr#->Int#->Word32X8#->State#s->State#swriteWord32X8OffAddr#=writeWord32X8OffAddr#-- | Write vector; offset in bytes.writeWord64X4OffAddr#::Addr#->Int#->Word64X4#->State#s->State#swriteWord64X4OffAddr#=writeWord64X4OffAddr#-- | Write vector; offset in bytes.writeWord8X64OffAddr#::Addr#->Int#->Word8X64#->State#s->State#swriteWord8X64OffAddr#=writeWord8X64OffAddr#-- | Write vector; offset in bytes.writeWord16X32OffAddr#::Addr#->Int#->Word16X32#->State#s->State#swriteWord16X32OffAddr#=writeWord16X32OffAddr#-- | Write vector; offset in bytes.writeWord32X16OffAddr#::Addr#->Int#->Word32X16#->State#s->State#swriteWord32X16OffAddr#=writeWord32X16OffAddr#-- | Write vector; offset in bytes.writeWord64X8OffAddr#::Addr#->Int#->Word64X8#->State#s->State#swriteWord64X8OffAddr#=writeWord64X8OffAddr#-- | Write vector; offset in bytes.writeFloatX4OffAddr#::Addr#->Int#->FloatX4#->State#s->State#swriteFloatX4OffAddr#=writeFloatX4OffAddr#-- | Write vector; offset in bytes.writeDoubleX2OffAddr#::Addr#->Int#->DoubleX2#->State#s->State#swriteDoubleX2OffAddr#=writeDoubleX2OffAddr#-- | Write vector; offset in bytes.writeFloatX8OffAddr#::Addr#->Int#->FloatX8#->State#s->State#swriteFloatX8OffAddr#=writeFloatX8OffAddr#-- | Write vector; offset in bytes.writeDoubleX4OffAddr#::Addr#->Int#->DoubleX4#->State#s->State#swriteDoubleX4OffAddr#=writeDoubleX4OffAddr#-- | Write vector; offset in bytes.writeFloatX16OffAddr#::Addr#->Int#->FloatX16#->State#s->State#swriteFloatX16OffAddr#=writeFloatX16OffAddr#-- | Write vector; offset in bytes.writeDoubleX8OffAddr#::Addr#->Int#->DoubleX8#->State#s->State#swriteDoubleX8OffAddr#=writeDoubleX8OffAddr#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt8ArrayAsInt8X16#::ByteArray#->Int#->Int8X16#indexInt8ArrayAsInt8X16#=indexInt8ArrayAsInt8X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt16ArrayAsInt16X8#::ByteArray#->Int#->Int16X8#indexInt16ArrayAsInt16X8#=indexInt16ArrayAsInt16X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt32ArrayAsInt32X4#::ByteArray#->Int#->Int32X4#indexInt32ArrayAsInt32X4#=indexInt32ArrayAsInt32X4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt64ArrayAsInt64X2#::ByteArray#->Int#->Int64X2#indexInt64ArrayAsInt64X2#=indexInt64ArrayAsInt64X2#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt8ArrayAsInt8X32#::ByteArray#->Int#->Int8X32#indexInt8ArrayAsInt8X32#=indexInt8ArrayAsInt8X32#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt16ArrayAsInt16X16#::ByteArray#->Int#->Int16X16#indexInt16ArrayAsInt16X16#=indexInt16ArrayAsInt16X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt32ArrayAsInt32X8#::ByteArray#->Int#->Int32X8#indexInt32ArrayAsInt32X8#=indexInt32ArrayAsInt32X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt64ArrayAsInt64X4#::ByteArray#->Int#->Int64X4#indexInt64ArrayAsInt64X4#=indexInt64ArrayAsInt64X4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt8ArrayAsInt8X64#::ByteArray#->Int#->Int8X64#indexInt8ArrayAsInt8X64#=indexInt8ArrayAsInt8X64#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt16ArrayAsInt16X32#::ByteArray#->Int#->Int16X32#indexInt16ArrayAsInt16X32#=indexInt16ArrayAsInt16X32#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt32ArrayAsInt32X16#::ByteArray#->Int#->Int32X16#indexInt32ArrayAsInt32X16#=indexInt32ArrayAsInt32X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexInt64ArrayAsInt64X8#::ByteArray#->Int#->Int64X8#indexInt64ArrayAsInt64X8#=indexInt64ArrayAsInt64X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord8ArrayAsWord8X16#::ByteArray#->Int#->Word8X16#indexWord8ArrayAsWord8X16#=indexWord8ArrayAsWord8X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord16ArrayAsWord16X8#::ByteArray#->Int#->Word16X8#indexWord16ArrayAsWord16X8#=indexWord16ArrayAsWord16X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord32ArrayAsWord32X4#::ByteArray#->Int#->Word32X4#indexWord32ArrayAsWord32X4#=indexWord32ArrayAsWord32X4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord64ArrayAsWord64X2#::ByteArray#->Int#->Word64X2#indexWord64ArrayAsWord64X2#=indexWord64ArrayAsWord64X2#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord8ArrayAsWord8X32#::ByteArray#->Int#->Word8X32#indexWord8ArrayAsWord8X32#=indexWord8ArrayAsWord8X32#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord16ArrayAsWord16X16#::ByteArray#->Int#->Word16X16#indexWord16ArrayAsWord16X16#=indexWord16ArrayAsWord16X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord32ArrayAsWord32X8#::ByteArray#->Int#->Word32X8#indexWord32ArrayAsWord32X8#=indexWord32ArrayAsWord32X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord64ArrayAsWord64X4#::ByteArray#->Int#->Word64X4#indexWord64ArrayAsWord64X4#=indexWord64ArrayAsWord64X4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord8ArrayAsWord8X64#::ByteArray#->Int#->Word8X64#indexWord8ArrayAsWord8X64#=indexWord8ArrayAsWord8X64#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord16ArrayAsWord16X32#::ByteArray#->Int#->Word16X32#indexWord16ArrayAsWord16X32#=indexWord16ArrayAsWord16X32#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord32ArrayAsWord32X16#::ByteArray#->Int#->Word32X16#indexWord32ArrayAsWord32X16#=indexWord32ArrayAsWord32X16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexWord64ArrayAsWord64X8#::ByteArray#->Int#->Word64X8#indexWord64ArrayAsWord64X8#=indexWord64ArrayAsWord64X8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexFloatArrayAsFloatX4#::ByteArray#->Int#->FloatX4#indexFloatArrayAsFloatX4#=indexFloatArrayAsFloatX4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexDoubleArrayAsDoubleX2#::ByteArray#->Int#->DoubleX2#indexDoubleArrayAsDoubleX2#=indexDoubleArrayAsDoubleX2#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexFloatArrayAsFloatX8#::ByteArray#->Int#->FloatX8#indexFloatArrayAsFloatX8#=indexFloatArrayAsFloatX8#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexDoubleArrayAsDoubleX4#::ByteArray#->Int#->DoubleX4#indexDoubleArrayAsDoubleX4#=indexDoubleArrayAsDoubleX4#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexFloatArrayAsFloatX16#::ByteArray#->Int#->FloatX16#indexFloatArrayAsFloatX16#=indexFloatArrayAsFloatX16#-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements.indexDoubleArrayAsDoubleX8#::ByteArray#->Int#->DoubleX8#indexDoubleArrayAsDoubleX8#=indexDoubleArrayAsDoubleX8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt8ArrayAsInt8X16#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X16##)readInt8ArrayAsInt8X16#=readInt8ArrayAsInt8X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt16ArrayAsInt16X8#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X8##)readInt16ArrayAsInt16X8#=readInt16ArrayAsInt16X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt32ArrayAsInt32X4#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X4##)readInt32ArrayAsInt32X4#=readInt32ArrayAsInt32X4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt64ArrayAsInt64X2#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X2##)readInt64ArrayAsInt64X2#=readInt64ArrayAsInt64X2#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt8ArrayAsInt8X32#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X32##)readInt8ArrayAsInt8X32#=readInt8ArrayAsInt8X32#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt16ArrayAsInt16X16#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X16##)readInt16ArrayAsInt16X16#=readInt16ArrayAsInt16X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt32ArrayAsInt32X8#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X8##)readInt32ArrayAsInt32X8#=readInt32ArrayAsInt32X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt64ArrayAsInt64X4#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X4##)readInt64ArrayAsInt64X4#=readInt64ArrayAsInt64X4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt8ArrayAsInt8X64#::MutableByteArray#s->Int#->State#s->(#State#s,Int8X64##)readInt8ArrayAsInt8X64#=readInt8ArrayAsInt8X64#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt16ArrayAsInt16X32#::MutableByteArray#s->Int#->State#s->(#State#s,Int16X32##)readInt16ArrayAsInt16X32#=readInt16ArrayAsInt16X32#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt32ArrayAsInt32X16#::MutableByteArray#s->Int#->State#s->(#State#s,Int32X16##)readInt32ArrayAsInt32X16#=readInt32ArrayAsInt32X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readInt64ArrayAsInt64X8#::MutableByteArray#s->Int#->State#s->(#State#s,Int64X8##)readInt64ArrayAsInt64X8#=readInt64ArrayAsInt64X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord8ArrayAsWord8X16#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X16##)readWord8ArrayAsWord8X16#=readWord8ArrayAsWord8X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord16ArrayAsWord16X8#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X8##)readWord16ArrayAsWord16X8#=readWord16ArrayAsWord16X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord32ArrayAsWord32X4#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X4##)readWord32ArrayAsWord32X4#=readWord32ArrayAsWord32X4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord64ArrayAsWord64X2#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X2##)readWord64ArrayAsWord64X2#=readWord64ArrayAsWord64X2#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord8ArrayAsWord8X32#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X32##)readWord8ArrayAsWord8X32#=readWord8ArrayAsWord8X32#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord16ArrayAsWord16X16#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X16##)readWord16ArrayAsWord16X16#=readWord16ArrayAsWord16X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord32ArrayAsWord32X8#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X8##)readWord32ArrayAsWord32X8#=readWord32ArrayAsWord32X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord64ArrayAsWord64X4#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X4##)readWord64ArrayAsWord64X4#=readWord64ArrayAsWord64X4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord8ArrayAsWord8X64#::MutableByteArray#s->Int#->State#s->(#State#s,Word8X64##)readWord8ArrayAsWord8X64#=readWord8ArrayAsWord8X64#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord16ArrayAsWord16X32#::MutableByteArray#s->Int#->State#s->(#State#s,Word16X32##)readWord16ArrayAsWord16X32#=readWord16ArrayAsWord16X32#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord32ArrayAsWord32X16#::MutableByteArray#s->Int#->State#s->(#State#s,Word32X16##)readWord32ArrayAsWord32X16#=readWord32ArrayAsWord32X16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readWord64ArrayAsWord64X8#::MutableByteArray#s->Int#->State#s->(#State#s,Word64X8##)readWord64ArrayAsWord64X8#=readWord64ArrayAsWord64X8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readFloatArrayAsFloatX4#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX4##)readFloatArrayAsFloatX4#=readFloatArrayAsFloatX4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readDoubleArrayAsDoubleX2#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX2##)readDoubleArrayAsDoubleX2#=readDoubleArrayAsDoubleX2#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readFloatArrayAsFloatX8#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX8##)readFloatArrayAsFloatX8#=readFloatArrayAsFloatX8#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readDoubleArrayAsDoubleX4#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX4##)readDoubleArrayAsDoubleX4#=readDoubleArrayAsDoubleX4#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readFloatArrayAsFloatX16#::MutableByteArray#s->Int#->State#s->(#State#s,FloatX16##)readFloatArrayAsFloatX16#=readFloatArrayAsFloatX16#-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements.readDoubleArrayAsDoubleX8#::MutableByteArray#s->Int#->State#s->(#State#s,DoubleX8##)readDoubleArrayAsDoubleX8#=readDoubleArrayAsDoubleX8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt8ArrayAsInt8X16#::MutableByteArray#s->Int#->Int8X16#->State#s->State#swriteInt8ArrayAsInt8X16#=writeInt8ArrayAsInt8X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt16ArrayAsInt16X8#::MutableByteArray#s->Int#->Int16X8#->State#s->State#swriteInt16ArrayAsInt16X8#=writeInt16ArrayAsInt16X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt32ArrayAsInt32X4#::MutableByteArray#s->Int#->Int32X4#->State#s->State#swriteInt32ArrayAsInt32X4#=writeInt32ArrayAsInt32X4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt64ArrayAsInt64X2#::MutableByteArray#s->Int#->Int64X2#->State#s->State#swriteInt64ArrayAsInt64X2#=writeInt64ArrayAsInt64X2#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt8ArrayAsInt8X32#::MutableByteArray#s->Int#->Int8X32#->State#s->State#swriteInt8ArrayAsInt8X32#=writeInt8ArrayAsInt8X32#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt16ArrayAsInt16X16#::MutableByteArray#s->Int#->Int16X16#->State#s->State#swriteInt16ArrayAsInt16X16#=writeInt16ArrayAsInt16X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt32ArrayAsInt32X8#::MutableByteArray#s->Int#->Int32X8#->State#s->State#swriteInt32ArrayAsInt32X8#=writeInt32ArrayAsInt32X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt64ArrayAsInt64X4#::MutableByteArray#s->Int#->Int64X4#->State#s->State#swriteInt64ArrayAsInt64X4#=writeInt64ArrayAsInt64X4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt8ArrayAsInt8X64#::MutableByteArray#s->Int#->Int8X64#->State#s->State#swriteInt8ArrayAsInt8X64#=writeInt8ArrayAsInt8X64#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt16ArrayAsInt16X32#::MutableByteArray#s->Int#->Int16X32#->State#s->State#swriteInt16ArrayAsInt16X32#=writeInt16ArrayAsInt16X32#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt32ArrayAsInt32X16#::MutableByteArray#s->Int#->Int32X16#->State#s->State#swriteInt32ArrayAsInt32X16#=writeInt32ArrayAsInt32X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeInt64ArrayAsInt64X8#::MutableByteArray#s->Int#->Int64X8#->State#s->State#swriteInt64ArrayAsInt64X8#=writeInt64ArrayAsInt64X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord8ArrayAsWord8X16#::MutableByteArray#s->Int#->Word8X16#->State#s->State#swriteWord8ArrayAsWord8X16#=writeWord8ArrayAsWord8X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord16ArrayAsWord16X8#::MutableByteArray#s->Int#->Word16X8#->State#s->State#swriteWord16ArrayAsWord16X8#=writeWord16ArrayAsWord16X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord32ArrayAsWord32X4#::MutableByteArray#s->Int#->Word32X4#->State#s->State#swriteWord32ArrayAsWord32X4#=writeWord32ArrayAsWord32X4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord64ArrayAsWord64X2#::MutableByteArray#s->Int#->Word64X2#->State#s->State#swriteWord64ArrayAsWord64X2#=writeWord64ArrayAsWord64X2#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord8ArrayAsWord8X32#::MutableByteArray#s->Int#->Word8X32#->State#s->State#swriteWord8ArrayAsWord8X32#=writeWord8ArrayAsWord8X32#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord16ArrayAsWord16X16#::MutableByteArray#s->Int#->Word16X16#->State#s->State#swriteWord16ArrayAsWord16X16#=writeWord16ArrayAsWord16X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord32ArrayAsWord32X8#::MutableByteArray#s->Int#->Word32X8#->State#s->State#swriteWord32ArrayAsWord32X8#=writeWord32ArrayAsWord32X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord64ArrayAsWord64X4#::MutableByteArray#s->Int#->Word64X4#->State#s->State#swriteWord64ArrayAsWord64X4#=writeWord64ArrayAsWord64X4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord8ArrayAsWord8X64#::MutableByteArray#s->Int#->Word8X64#->State#s->State#swriteWord8ArrayAsWord8X64#=writeWord8ArrayAsWord8X64#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord16ArrayAsWord16X32#::MutableByteArray#s->Int#->Word16X32#->State#s->State#swriteWord16ArrayAsWord16X32#=writeWord16ArrayAsWord16X32#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord32ArrayAsWord32X16#::MutableByteArray#s->Int#->Word32X16#->State#s->State#swriteWord32ArrayAsWord32X16#=writeWord32ArrayAsWord32X16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeWord64ArrayAsWord64X8#::MutableByteArray#s->Int#->Word64X8#->State#s->State#swriteWord64ArrayAsWord64X8#=writeWord64ArrayAsWord64X8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeFloatArrayAsFloatX4#::MutableByteArray#s->Int#->FloatX4#->State#s->State#swriteFloatArrayAsFloatX4#=writeFloatArrayAsFloatX4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeDoubleArrayAsDoubleX2#::MutableByteArray#s->Int#->DoubleX2#->State#s->State#swriteDoubleArrayAsDoubleX2#=writeDoubleArrayAsDoubleX2#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeFloatArrayAsFloatX8#::MutableByteArray#s->Int#->FloatX8#->State#s->State#swriteFloatArrayAsFloatX8#=writeFloatArrayAsFloatX8#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeDoubleArrayAsDoubleX4#::MutableByteArray#s->Int#->DoubleX4#->State#s->State#swriteDoubleArrayAsDoubleX4#=writeDoubleArrayAsDoubleX4#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeFloatArrayAsFloatX16#::MutableByteArray#s->Int#->FloatX16#->State#s->State#swriteFloatArrayAsFloatX16#=writeFloatArrayAsFloatX16#-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements.writeDoubleArrayAsDoubleX8#::MutableByteArray#s->Int#->DoubleX8#->State#s->State#swriteDoubleArrayAsDoubleX8#=writeDoubleArrayAsDoubleX8#-- | Reads vector; offset in scalar elements.indexInt8OffAddrAsInt8X16#::Addr#->Int#->Int8X16#indexInt8OffAddrAsInt8X16#=indexInt8OffAddrAsInt8X16#-- | Reads vector; offset in scalar elements.indexInt16OffAddrAsInt16X8#::Addr#->Int#->Int16X8#indexInt16OffAddrAsInt16X8#=indexInt16OffAddrAsInt16X8#-- | Reads vector; offset in scalar elements.indexInt32OffAddrAsInt32X4#::Addr#->Int#->Int32X4#indexInt32OffAddrAsInt32X4#=indexInt32OffAddrAsInt32X4#-- | Reads vector; offset in scalar elements.indexInt64OffAddrAsInt64X2#::Addr#->Int#->Int64X2#indexInt64OffAddrAsInt64X2#=indexInt64OffAddrAsInt64X2#-- | Reads vector; offset in scalar elements.indexInt8OffAddrAsInt8X32#::Addr#->Int#->Int8X32#indexInt8OffAddrAsInt8X32#=indexInt8OffAddrAsInt8X32#-- | Reads vector; offset in scalar elements.indexInt16OffAddrAsInt16X16#::Addr#->Int#->Int16X16#indexInt16OffAddrAsInt16X16#=indexInt16OffAddrAsInt16X16#-- | Reads vector; offset in scalar elements.indexInt32OffAddrAsInt32X8#::Addr#->Int#->Int32X8#indexInt32OffAddrAsInt32X8#=indexInt32OffAddrAsInt32X8#-- | Reads vector; offset in scalar elements.indexInt64OffAddrAsInt64X4#::Addr#->Int#->Int64X4#indexInt64OffAddrAsInt64X4#=indexInt64OffAddrAsInt64X4#-- | Reads vector; offset in scalar elements.indexInt8OffAddrAsInt8X64#::Addr#->Int#->Int8X64#indexInt8OffAddrAsInt8X64#=indexInt8OffAddrAsInt8X64#-- | Reads vector; offset in scalar elements.indexInt16OffAddrAsInt16X32#::Addr#->Int#->Int16X32#indexInt16OffAddrAsInt16X32#=indexInt16OffAddrAsInt16X32#-- | Reads vector; offset in scalar elements.indexInt32OffAddrAsInt32X16#::Addr#->Int#->Int32X16#indexInt32OffAddrAsInt32X16#=indexInt32OffAddrAsInt32X16#-- | Reads vector; offset in scalar elements.indexInt64OffAddrAsInt64X8#::Addr#->Int#->Int64X8#indexInt64OffAddrAsInt64X8#=indexInt64OffAddrAsInt64X8#-- | Reads vector; offset in scalar elements.indexWord8OffAddrAsWord8X16#::Addr#->Int#->Word8X16#indexWord8OffAddrAsWord8X16#=indexWord8OffAddrAsWord8X16#-- | Reads vector; offset in scalar elements.indexWord16OffAddrAsWord16X8#::Addr#->Int#->Word16X8#indexWord16OffAddrAsWord16X8#=indexWord16OffAddrAsWord16X8#-- | Reads vector; offset in scalar elements.indexWord32OffAddrAsWord32X4#::Addr#->Int#->Word32X4#indexWord32OffAddrAsWord32X4#=indexWord32OffAddrAsWord32X4#-- | Reads vector; offset in scalar elements.indexWord64OffAddrAsWord64X2#::Addr#->Int#->Word64X2#indexWord64OffAddrAsWord64X2#=indexWord64OffAddrAsWord64X2#-- | Reads vector; offset in scalar elements.indexWord8OffAddrAsWord8X32#::Addr#->Int#->Word8X32#indexWord8OffAddrAsWord8X32#=indexWord8OffAddrAsWord8X32#-- | Reads vector; offset in scalar elements.indexWord16OffAddrAsWord16X16#::Addr#->Int#->Word16X16#indexWord16OffAddrAsWord16X16#=indexWord16OffAddrAsWord16X16#-- | Reads vector; offset in scalar elements.indexWord32OffAddrAsWord32X8#::Addr#->Int#->Word32X8#indexWord32OffAddrAsWord32X8#=indexWord32OffAddrAsWord32X8#-- | Reads vector; offset in scalar elements.indexWord64OffAddrAsWord64X4#::Addr#->Int#->Word64X4#indexWord64OffAddrAsWord64X4#=indexWord64OffAddrAsWord64X4#-- | Reads vector; offset in scalar elements.indexWord8OffAddrAsWord8X64#::Addr#->Int#->Word8X64#indexWord8OffAddrAsWord8X64#=indexWord8OffAddrAsWord8X64#-- | Reads vector; offset in scalar elements.indexWord16OffAddrAsWord16X32#::Addr#->Int#->Word16X32#indexWord16OffAddrAsWord16X32#=indexWord16OffAddrAsWord16X32#-- | Reads vector; offset in scalar elements.indexWord32OffAddrAsWord32X16#::Addr#->Int#->Word32X16#indexWord32OffAddrAsWord32X16#=indexWord32OffAddrAsWord32X16#-- | Reads vector; offset in scalar elements.indexWord64OffAddrAsWord64X8#::Addr#->Int#->Word64X8#indexWord64OffAddrAsWord64X8#=indexWord64OffAddrAsWord64X8#-- | Reads vector; offset in scalar elements.indexFloatOffAddrAsFloatX4#::Addr#->Int#->FloatX4#indexFloatOffAddrAsFloatX4#=indexFloatOffAddrAsFloatX4#-- | Reads vector; offset in scalar elements.indexDoubleOffAddrAsDoubleX2#::Addr#->Int#->DoubleX2#indexDoubleOffAddrAsDoubleX2#=indexDoubleOffAddrAsDoubleX2#-- | Reads vector; offset in scalar elements.indexFloatOffAddrAsFloatX8#::Addr#->Int#->FloatX8#indexFloatOffAddrAsFloatX8#=indexFloatOffAddrAsFloatX8#-- | Reads vector; offset in scalar elements.indexDoubleOffAddrAsDoubleX4#::Addr#->Int#->DoubleX4#indexDoubleOffAddrAsDoubleX4#=indexDoubleOffAddrAsDoubleX4#-- | Reads vector; offset in scalar elements.indexFloatOffAddrAsFloatX16#::Addr#->Int#->FloatX16#indexFloatOffAddrAsFloatX16#=indexFloatOffAddrAsFloatX16#-- | Reads vector; offset in scalar elements.indexDoubleOffAddrAsDoubleX8#::Addr#->Int#->DoubleX8#indexDoubleOffAddrAsDoubleX8#=indexDoubleOffAddrAsDoubleX8#-- | Reads vector; offset in scalar elements.readInt8OffAddrAsInt8X16#::Addr#->Int#->State#s->(#State#s,Int8X16##)readInt8OffAddrAsInt8X16#=readInt8OffAddrAsInt8X16#-- | Reads vector; offset in scalar elements.readInt16OffAddrAsInt16X8#::Addr#->Int#->State#s->(#State#s,Int16X8##)readInt16OffAddrAsInt16X8#=readInt16OffAddrAsInt16X8#-- | Reads vector; offset in scalar elements.readInt32OffAddrAsInt32X4#::Addr#->Int#->State#s->(#State#s,Int32X4##)readInt32OffAddrAsInt32X4#=readInt32OffAddrAsInt32X4#-- | Reads vector; offset in scalar elements.readInt64OffAddrAsInt64X2#::Addr#->Int#->State#s->(#State#s,Int64X2##)readInt64OffAddrAsInt64X2#=readInt64OffAddrAsInt64X2#-- | Reads vector; offset in scalar elements.readInt8OffAddrAsInt8X32#::Addr#->Int#->State#s->(#State#s,Int8X32##)readInt8OffAddrAsInt8X32#=readInt8OffAddrAsInt8X32#-- | Reads vector; offset in scalar elements.readInt16OffAddrAsInt16X16#::Addr#->Int#->State#s->(#State#s,Int16X16##)readInt16OffAddrAsInt16X16#=readInt16OffAddrAsInt16X16#-- | Reads vector; offset in scalar elements.readInt32OffAddrAsInt32X8#::Addr#->Int#->State#s->(#State#s,Int32X8##)readInt32OffAddrAsInt32X8#=readInt32OffAddrAsInt32X8#-- | Reads vector; offset in scalar elements.readInt64OffAddrAsInt64X4#::Addr#->Int#->State#s->(#State#s,Int64X4##)readInt64OffAddrAsInt64X4#=readInt64OffAddrAsInt64X4#-- | Reads vector; offset in scalar elements.readInt8OffAddrAsInt8X64#::Addr#->Int#->State#s->(#State#s,Int8X64##)readInt8OffAddrAsInt8X64#=readInt8OffAddrAsInt8X64#-- | Reads vector; offset in scalar elements.readInt16OffAddrAsInt16X32#::Addr#->Int#->State#s->(#State#s,Int16X32##)readInt16OffAddrAsInt16X32#=readInt16OffAddrAsInt16X32#-- | Reads vector; offset in scalar elements.readInt32OffAddrAsInt32X16#::Addr#->Int#->State#s->(#State#s,Int32X16##)readInt32OffAddrAsInt32X16#=readInt32OffAddrAsInt32X16#-- | Reads vector; offset in scalar elements.readInt64OffAddrAsInt64X8#::Addr#->Int#->State#s->(#State#s,Int64X8##)readInt64OffAddrAsInt64X8#=readInt64OffAddrAsInt64X8#-- | Reads vector; offset in scalar elements.readWord8OffAddrAsWord8X16#::Addr#->Int#->State#s->(#State#s,Word8X16##)readWord8OffAddrAsWord8X16#=readWord8OffAddrAsWord8X16#-- | Reads vector; offset in scalar elements.readWord16OffAddrAsWord16X8#::Addr#->Int#->State#s->(#State#s,Word16X8##)readWord16OffAddrAsWord16X8#=readWord16OffAddrAsWord16X8#-- | Reads vector; offset in scalar elements.readWord32OffAddrAsWord32X4#::Addr#->Int#->State#s->(#State#s,Word32X4##)readWord32OffAddrAsWord32X4#=readWord32OffAddrAsWord32X4#-- | Reads vector; offset in scalar elements.readWord64OffAddrAsWord64X2#::Addr#->Int#->State#s->(#State#s,Word64X2##)readWord64OffAddrAsWord64X2#=readWord64OffAddrAsWord64X2#-- | Reads vector; offset in scalar elements.readWord8OffAddrAsWord8X32#::Addr#->Int#->State#s->(#State#s,Word8X32##)readWord8OffAddrAsWord8X32#=readWord8OffAddrAsWord8X32#-- | Reads vector; offset in scalar elements.readWord16OffAddrAsWord16X16#::Addr#->Int#->State#s->(#State#s,Word16X16##)readWord16OffAddrAsWord16X16#=readWord16OffAddrAsWord16X16#-- | Reads vector; offset in scalar elements.readWord32OffAddrAsWord32X8#::Addr#->Int#->State#s->(#State#s,Word32X8##)readWord32OffAddrAsWord32X8#=readWord32OffAddrAsWord32X8#-- | Reads vector; offset in scalar elements.readWord64OffAddrAsWord64X4#::Addr#->Int#->State#s->(#State#s,Word64X4##)readWord64OffAddrAsWord64X4#=readWord64OffAddrAsWord64X4#-- | Reads vector; offset in scalar elements.readWord8OffAddrAsWord8X64#::Addr#->Int#->State#s->(#State#s,Word8X64##)readWord8OffAddrAsWord8X64#=readWord8OffAddrAsWord8X64#-- | Reads vector; offset in scalar elements.readWord16OffAddrAsWord16X32#::Addr#->Int#->State#s->(#State#s,Word16X32##)readWord16OffAddrAsWord16X32#=readWord16OffAddrAsWord16X32#-- | Reads vector; offset in scalar elements.readWord32OffAddrAsWord32X16#::Addr#->Int#->State#s->(#State#s,Word32X16##)readWord32OffAddrAsWord32X16#=readWord32OffAddrAsWord32X16#-- | Reads vector; offset in scalar elements.readWord64OffAddrAsWord64X8#::Addr#->Int#->State#s->(#State#s,Word64X8##)readWord64OffAddrAsWord64X8#=readWord64OffAddrAsWord64X8#-- | Reads vector; offset in scalar elements.readFloatOffAddrAsFloatX4#::Addr#->Int#->State#s->(#State#s,FloatX4##)readFloatOffAddrAsFloatX4#=readFloatOffAddrAsFloatX4#-- | Reads vector; offset in scalar elements.readDoubleOffAddrAsDoubleX2#::Addr#->Int#->State#s->(#State#s,DoubleX2##)readDoubleOffAddrAsDoubleX2#=readDoubleOffAddrAsDoubleX2#-- | Reads vector; offset in scalar elements.readFloatOffAddrAsFloatX8#::Addr#->Int#->State#s->(#State#s,FloatX8##)readFloatOffAddrAsFloatX8#=readFloatOffAddrAsFloatX8#-- | Reads vector; offset in scalar elements.readDoubleOffAddrAsDoubleX4#::Addr#->Int#->State#s->(#State#s,DoubleX4##)readDoubleOffAddrAsDoubleX4#=readDoubleOffAddrAsDoubleX4#-- | Reads vector; offset in scalar elements.readFloatOffAddrAsFloatX16#::Addr#->Int#->State#s->(#State#s,FloatX16##)readFloatOffAddrAsFloatX16#=readFloatOffAddrAsFloatX16#-- | Reads vector; offset in scalar elements.readDoubleOffAddrAsDoubleX8#::Addr#->Int#->State#s->(#State#s,DoubleX8##)readDoubleOffAddrAsDoubleX8#=readDoubleOffAddrAsDoubleX8#-- | Write vector; offset in scalar elements.writeInt8OffAddrAsInt8X16#::Addr#->Int#->Int8X16#->State#s->State#swriteInt8OffAddrAsInt8X16#=writeInt8OffAddrAsInt8X16#-- | Write vector; offset in scalar elements.writeInt16OffAddrAsInt16X8#::Addr#->Int#->Int16X8#->State#s->State#swriteInt16OffAddrAsInt16X8#=writeInt16OffAddrAsInt16X8#-- | Write vector; offset in scalar elements.writeInt32OffAddrAsInt32X4#::Addr#->Int#->Int32X4#->State#s->State#swriteInt32OffAddrAsInt32X4#=writeInt32OffAddrAsInt32X4#-- | Write vector; offset in scalar elements.writeInt64OffAddrAsInt64X2#::Addr#->Int#->Int64X2#->State#s->State#swriteInt64OffAddrAsInt64X2#=writeInt64OffAddrAsInt64X2#-- | Write vector; offset in scalar elements.writeInt8OffAddrAsInt8X32#::Addr#->Int#->Int8X32#->State#s->State#swriteInt8OffAddrAsInt8X32#=writeInt8OffAddrAsInt8X32#-- | Write vector; offset in scalar elements.writeInt16OffAddrAsInt16X16#::Addr#->Int#->Int16X16#->State#s->State#swriteInt16OffAddrAsInt16X16#=writeInt16OffAddrAsInt16X16#-- | Write vector; offset in scalar elements.writeInt32OffAddrAsInt32X8#::Addr#->Int#->Int32X8#->State#s->State#swriteInt32OffAddrAsInt32X8#=writeInt32OffAddrAsInt32X8#-- | Write vector; offset in scalar elements.writeInt64OffAddrAsInt64X4#::Addr#->Int#->Int64X4#->State#s->State#swriteInt64OffAddrAsInt64X4#=writeInt64OffAddrAsInt64X4#-- | Write vector; offset in scalar elements.writeInt8OffAddrAsInt8X64#::Addr#->Int#->Int8X64#->State#s->State#swriteInt8OffAddrAsInt8X64#=writeInt8OffAddrAsInt8X64#-- | Write vector; offset in scalar elements.writeInt16OffAddrAsInt16X32#::Addr#->Int#->Int16X32#->State#s->State#swriteInt16OffAddrAsInt16X32#=writeInt16OffAddrAsInt16X32#-- | Write vector; offset in scalar elements.writeInt32OffAddrAsInt32X16#::Addr#->Int#->Int32X16#->State#s->State#swriteInt32OffAddrAsInt32X16#=writeInt32OffAddrAsInt32X16#-- | Write vector; offset in scalar elements.writeInt64OffAddrAsInt64X8#::Addr#->Int#->Int64X8#->State#s->State#swriteInt64OffAddrAsInt64X8#=writeInt64OffAddrAsInt64X8#-- | Write vector; offset in scalar elements.writeWord8OffAddrAsWord8X16#::Addr#->Int#->Word8X16#->State#s->State#swriteWord8OffAddrAsWord8X16#=writeWord8OffAddrAsWord8X16#-- | Write vector; offset in scalar elements.writeWord16OffAddrAsWord16X8#::Addr#->Int#->Word16X8#->State#s->State#swriteWord16OffAddrAsWord16X8#=writeWord16OffAddrAsWord16X8#-- | Write vector; offset in scalar elements.writeWord32OffAddrAsWord32X4#::Addr#->Int#->Word32X4#->State#s->State#swriteWord32OffAddrAsWord32X4#=writeWord32OffAddrAsWord32X4#-- | Write vector; offset in scalar elements.writeWord64OffAddrAsWord64X2#::Addr#->Int#->Word64X2#->State#s->State#swriteWord64OffAddrAsWord64X2#=writeWord64OffAddrAsWord64X2#-- | Write vector; offset in scalar elements.writeWord8OffAddrAsWord8X32#::Addr#->Int#->Word8X32#->State#s->State#swriteWord8OffAddrAsWord8X32#=writeWord8OffAddrAsWord8X32#-- | Write vector; offset in scalar elements.writeWord16OffAddrAsWord16X16#::Addr#->Int#->Word16X16#->State#s->State#swriteWord16OffAddrAsWord16X16#=writeWord16OffAddrAsWord16X16#-- | Write vector; offset in scalar elements.writeWord32OffAddrAsWord32X8#::Addr#->Int#->Word32X8#->State#s->State#swriteWord32OffAddrAsWord32X8#=writeWord32OffAddrAsWord32X8#-- | Write vector; offset in scalar elements.writeWord64OffAddrAsWord64X4#::Addr#->Int#->Word64X4#->State#s->State#swriteWord64OffAddrAsWord64X4#=writeWord64OffAddrAsWord64X4#-- | Write vector; offset in scalar elements.writeWord8OffAddrAsWord8X64#::Addr#->Int#->Word8X64#->State#s->State#swriteWord8OffAddrAsWord8X64#=writeWord8OffAddrAsWord8X64#-- | Write vector; offset in scalar elements.writeWord16OffAddrAsWord16X32#::Addr#->Int#->Word16X32#->State#s->State#swriteWord16OffAddrAsWord16X32#=writeWord16OffAddrAsWord16X32#-- | Write vector; offset in scalar elements.writeWord32OffAddrAsWord32X16#::Addr#->Int#->Word32X16#->State#s->State#swriteWord32OffAddrAsWord32X16#=writeWord32OffAddrAsWord32X16#-- | Write vector; offset in scalar elements.writeWord64OffAddrAsWord64X8#::Addr#->Int#->Word64X8#->State#s->State#swriteWord64OffAddrAsWord64X8#=writeWord64OffAddrAsWord64X8#-- | Write vector; offset in scalar elements.writeFloatOffAddrAsFloatX4#::Addr#->Int#->FloatX4#->State#s->State#swriteFloatOffAddrAsFloatX4#=writeFloatOffAddrAsFloatX4#-- | Write vector; offset in scalar elements.writeDoubleOffAddrAsDoubleX2#::Addr#->Int#->DoubleX2#->State#s->State#swriteDoubleOffAddrAsDoubleX2#=writeDoubleOffAddrAsDoubleX2#-- | Write vector; offset in scalar elements.writeFloatOffAddrAsFloatX8#::Addr#->Int#->FloatX8#->State#s->State#swriteFloatOffAddrAsFloatX8#=writeFloatOffAddrAsFloatX8#-- | Write vector; offset in scalar elements.writeDoubleOffAddrAsDoubleX4#::Addr#->Int#->DoubleX4#->State#s->State#swriteDoubleOffAddrAsDoubleX4#=writeDoubleOffAddrAsDoubleX4#-- | Write vector; offset in scalar elements.writeFloatOffAddrAsFloatX16#::Addr#->Int#->FloatX16#->State#s->State#swriteFloatOffAddrAsFloatX16#=writeFloatOffAddrAsFloatX16#-- | Write vector; offset in scalar elements.writeDoubleOffAddrAsDoubleX8#::Addr#->Int#->DoubleX8#->State#s->State#swriteDoubleOffAddrAsDoubleX8#=writeDoubleOffAddrAsDoubleX8#prefetchByteArray3#::ByteArray#->Int#->State#s->State#sprefetchByteArray3#=prefetchByteArray3#prefetchMutableByteArray3#::MutableByteArray#s->Int#->State#s->State#sprefetchMutableByteArray3#=prefetchMutableByteArray3#prefetchAddr3#::Addr#->Int#->State#s->State#sprefetchAddr3#=prefetchAddr3#prefetchValue3#::a->State#s->State#sprefetchValue3#=prefetchValue3#prefetchByteArray2#::ByteArray#->Int#->State#s->State#sprefetchByteArray2#=prefetchByteArray2#prefetchMutableByteArray2#::MutableByteArray#s->Int#->State#s->State#sprefetchMutableByteArray2#=prefetchMutableByteArray2#prefetchAddr2#::Addr#->Int#->State#s->State#sprefetchAddr2#=prefetchAddr2#prefetchValue2#::a->State#s->State#sprefetchValue2#=prefetchValue2#prefetchByteArray1#::ByteArray#->Int#->State#s->State#sprefetchByteArray1#=prefetchByteArray1#prefetchMutableByteArray1#::MutableByteArray#s->Int#->State#s->State#sprefetchMutableByteArray1#=prefetchMutableByteArray1#prefetchAddr1#::Addr#->Int#->State#s->State#sprefetchAddr1#=prefetchAddr1#prefetchValue1#::a->State#s->State#sprefetchValue1#=prefetchValue1#prefetchByteArray0#::ByteArray#->Int#->State#s->State#sprefetchByteArray0#=prefetchByteArray0#prefetchMutableByteArray0#::MutableByteArray#s->Int#->State#s->State#sprefetchMutableByteArray0#=prefetchMutableByteArray0#prefetchAddr0#::Addr#->Int#->State#s->State#sprefetchAddr0#=prefetchAddr0#prefetchValue0#::a->State#s->State#sprefetchValue0#=prefetchValue0#
[8]ページ先頭