{-
This is a generated file (generated by genprimopcode).
It is not code to actually be used. Its only purpose is to be
consumed 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 MagicHash, MultiParamTypeClasses, NoImplicitPrelude, UnboxedTuples #-}
module GHC.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#,
	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#,
	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#,
	double2Int#,
	double2Float#,
	expDouble#,
	logDouble#,
	sqrtDouble#,
	sinDouble#,
	cosDouble#,
	tanDouble#,
	asinDouble#,
	acosDouble#,
	atanDouble#,
	sinhDouble#,
	coshDouble#,
	tanhDouble#,
	(**##),
	decodeDouble_2Int#,
	
-- * Float#
-- |Operations on single-precision (32-bit) floating-point numbers.


	Float#,
	gtFloat#,
	geFloat#,
	eqFloat#,
	neFloat#,
	ltFloat#,
	leFloat#,
	plusFloat#,
	minusFloat#,
	timesFloat#,
	divideFloat#,
	negateFloat#,
	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#,
	
-- * 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#,
	byteArrayContents#,
	sameMutableByteArray#,
	unsafeFreezeByteArray#,
	sizeofByteArray#,
	sizeofMutableByteArray#,
	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#,
	copyByteArray#,
	copyMutableByteArray#,
	copyByteArrayToAddr#,
	copyMutableByteArrayToAddr#,
	copyAddrToByteArray#,
	setByteArray#,
	casIntArray#,
	fetchAddIntArray#,
	
-- * 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#,
	
-- * Unsafe pointer equality
-- |


	reallyUnsafePtrEquality#,
	
-- * Parallelism
-- |


	par#,
	spark#,
	seq#,
	getSpark#,
	numSparks#,
	parGlobal#,
	parLocal#,
	parAt#,
	parAtAbs#,
	parAtRel#,
	parAtForNow#,
	
-- * Tag to enum stuff
-- |Convert back and forth between values of enumerated types
-- 	and small integers.


	dataToTag#,
	tagToEnum#,
	
-- * Bytecode operations
-- |Support for the bytecode interpreter and linker.


	BCO#,
	addrToAny#,
	mkApUpd0#,
	newBCO#,
	unpackClosure#,
	getApStackVal#,
	
-- * Misc
-- |These aren\'t nearly as wired in as Etc...


	getCCSOf#,
	getCurrentCCS#,
	
-- * Etc
-- |Miscellaneous built-ins


	Proxy#,
	proxy#,
	seq,
	Any,
	AnyK,
	unsafeCoerce#,
	traceEvent#,
	traceMarker#,
	
-- * Safe coercions
-- |


	coerce,
	Coercible,
	
-- * 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 @prefetchMutableByteArray@ family of operations has the order of operations
--   determined by passing around the @State#@ token.
-- 
--   For the @prefetchByteArray@
--   and @prefetchAddr@ families of operations, consider the following example:
-- 
--   @let a1 = prefetchByteArray2# a n in ...a1... @
-- 
--   In the above fragement, @a@ is the input variable for the prefetch
--   and @a1 == a@ will be true. To ensure that the prefetch is not treated as deadcode,
--   the body of the let should only use @a1@ and NOT @a@. The same principle
--   applies for uses of prefetch in a loop.
-- 
--   


	prefetchByteArray3#,
	prefetchMutableByteArray3#,
	prefetchAddr3#,
	prefetchByteArray2#,
	prefetchMutableByteArray2#,
	prefetchAddr2#,
	prefetchByteArray1#,
	prefetchMutableByteArray1#,
	prefetchAddr1#,
	prefetchByteArray0#,
	prefetchMutableByteArray0#,
	prefetchAddr0#,
) where

{-
has_side_effects = False
out_of_line = False
can_fail = False
commutable = False
code_size = {  primOpCodeSizeDefault }
strictness = {  \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }
fixity = Nothing
llvm_only = False

-}

data Char#

gtChar# :: Char# -> Char# -> Int#
gtChar# = let x = x in x

geChar# :: Char# -> Char# -> Int#
geChar# = let x = x in x

eqChar# :: Char# -> Char# -> Int#
eqChar# = let x = x in x

neChar# :: Char# -> Char# -> Int#
neChar# = let x = x in x

ltChar# :: Char# -> Char# -> Int#
ltChar# = let x = x in x

leChar# :: Char# -> Char# -> Int#
leChar# = let x = x in x

ord# :: Char# -> Int#
ord# = let x = x in x

data Int#

infixl 6 +#
(+#) :: Int# -> Int# -> Int#
(+#) = let x = x in x

infixl 6 -#
(-#) :: Int# -> Int# -> Int#
(-#) = let x = x in x

-- |Low word of signed integer multiply.

infixl 7 *#
(*#) :: Int# -> Int# -> Int#
(*#) = let x = x in x

-- |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 recommmended 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# = let x = x in x

-- |Rounds towards zero.

quotInt# :: Int# -> Int# -> Int#
quotInt# = let x = x in x

-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@.

remInt# :: Int# -> Int# -> Int#
remInt# = let x = x in x

-- |Rounds towards zero.

quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)
quotRemInt# = let x = x in x

andI# :: Int# -> Int# -> Int#
andI# = let x = x in x

orI# :: Int# -> Int# -> Int#
orI# = let x = x in x

xorI# :: Int# -> Int# -> Int#
xorI# = let x = x in x

notI# :: Int# -> Int#
notI# = let x = x in x

negateInt# :: Int# -> Int#
negateInt# = let x = x in x

-- |Add with carry.  First member of result is (wrapped) sum;
--           second member is 0 iff no overflow occured.

addIntC# :: Int# -> Int# -> (# Int#,Int# #)
addIntC# = let x = x in x

-- |Subtract with carry.  First member of result is (wrapped) difference;
--           second member is 0 iff no overflow occured.

subIntC# :: Int# -> Int# -> (# Int#,Int# #)
subIntC# = let x = x in x

infix 4 >#
(>#) :: Int# -> Int# -> Int#
(>#) = let x = x in x

infix 4 >=#
(>=#) :: Int# -> Int# -> Int#
(>=#) = let x = x in x

infix 4 ==#
(==#) :: Int# -> Int# -> Int#
(==#) = let x = x in x

infix 4 /=#
(/=#) :: Int# -> Int# -> Int#
(/=#) = let x = x in x

infix 4 <#
(<#) :: Int# -> Int# -> Int#
(<#) = let x = x in x

infix 4 <=#
(<=#) :: Int# -> Int# -> Int#
(<=#) = let x = x in x

chr# :: Int# -> Char#
chr# = let x = x in x

int2Word# :: Int# -> Word#
int2Word# = let x = x in x

int2Float# :: Int# -> Float#
int2Float# = let x = x in x

int2Double# :: Int# -> Double#
int2Double# = let x = x in x

word2Float# :: Word# -> Float#
word2Float# = let x = x in x

word2Double# :: Word# -> Double#
word2Double# = let x = x in x

-- |Shift left.  Result undefined if shift amount is not
--           in the range 0 to word size - 1 inclusive.

uncheckedIShiftL# :: Int# -> Int# -> Int#
uncheckedIShiftL# = let x = x in x

-- |Shift right arithmetic.  Result undefined if shift amount is not
--           in the range 0 to word size - 1 inclusive.

uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftRA# = let x = x in x

-- |Shift right logical.  Result undefined if shift amount is not
--           in the range 0 to word size - 1 inclusive.

uncheckedIShiftRL# :: Int# -> Int# -> Int#
uncheckedIShiftRL# = let x = x in x

data Word#

plusWord# :: Word# -> Word# -> Word#
plusWord# = let x = x in x

plusWord2# :: Word# -> Word# -> (# Word#,Word# #)
plusWord2# = let x = x in x

minusWord# :: Word# -> Word# -> Word#
minusWord# = let x = x in x

timesWord# :: Word# -> Word# -> Word#
timesWord# = let x = x in x

timesWord2# :: Word# -> Word# -> (# Word#,Word# #)
timesWord2# = let x = x in x

quotWord# :: Word# -> Word# -> Word#
quotWord# = let x = x in x

remWord# :: Word# -> Word# -> Word#
remWord# = let x = x in x

quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)
quotRemWord# = let x = x in x

quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)
quotRemWord2# = let x = x in x

and# :: Word# -> Word# -> Word#
and# = let x = x in x

or# :: Word# -> Word# -> Word#
or# = let x = x in x

xor# :: Word# -> Word# -> Word#
xor# = let x = x in x

not# :: Word# -> Word#
not# = let x = x in x

-- |Shift left logical.   Result undefined if shift amount is not
--           in the range 0 to word size - 1 inclusive.

uncheckedShiftL# :: Word# -> Int# -> Word#
uncheckedShiftL# = let x = x in x

-- |Shift right logical.   Result undefined if shift  amount is not
--           in the range 0 to word size - 1 inclusive.

uncheckedShiftRL# :: Word# -> Int# -> Word#
uncheckedShiftRL# = let x = x in x

word2Int# :: Word# -> Int#
word2Int# = let x = x in x

gtWord# :: Word# -> Word# -> Int#
gtWord# = let x = x in x

geWord# :: Word# -> Word# -> Int#
geWord# = let x = x in x

eqWord# :: Word# -> Word# -> Int#
eqWord# = let x = x in x

neWord# :: Word# -> Word# -> Int#
neWord# = let x = x in x

ltWord# :: Word# -> Word# -> Int#
ltWord# = let x = x in x

leWord# :: Word# -> Word# -> Int#
leWord# = let x = x in x

-- |Count the number of set bits in the lower 8 bits of a word.

popCnt8# :: Word# -> Word#
popCnt8# = let x = x in x

-- |Count the number of set bits in the lower 16 bits of a word.

popCnt16# :: Word# -> Word#
popCnt16# = let x = x in x

-- |Count the number of set bits in the lower 32 bits of a word.

popCnt32# :: Word# -> Word#
popCnt32# = let x = x in x

-- |Count the number of set bits in a 64-bit word.

popCnt64# :: Word# -> Word#
popCnt64# = let x = x in x

-- |Count the number of set bits in a word.

popCnt# :: Word# -> Word#
popCnt# = let x = x in x

-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. 

byteSwap16# :: Word# -> Word#
byteSwap16# = let x = x in x

-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. 

byteSwap32# :: Word# -> Word#
byteSwap32# = let x = x in x

-- |Swap bytes in a 64 bits of a word.

byteSwap64# :: Word# -> Word#
byteSwap64# = let x = x in x

-- |Swap bytes in a word.

byteSwap# :: Word# -> Word#
byteSwap# = let x = x in x

narrow8Int# :: Int# -> Int#
narrow8Int# = let x = x in x

narrow16Int# :: Int# -> Int#
narrow16Int# = let x = x in x

narrow32Int# :: Int# -> Int#
narrow32Int# = let x = x in x

narrow8Word# :: Word# -> Word#
narrow8Word# = let x = x in x

narrow16Word# :: Word# -> Word#
narrow16Word# = let x = x in x

narrow32Word# :: Word# -> Word#
narrow32Word# = let x = x in x

data Double#

infix 4 >##
(>##) :: Double# -> Double# -> Int#
(>##) = let x = x in x

infix 4 >=##
(>=##) :: Double# -> Double# -> Int#
(>=##) = let x = x in x

infix 4 ==##
(==##) :: Double# -> Double# -> Int#
(==##) = let x = x in x

infix 4 /=##
(/=##) :: Double# -> Double# -> Int#
(/=##) = let x = x in x

infix 4 <##
(<##) :: Double# -> Double# -> Int#
(<##) = let x = x in x

infix 4 <=##
(<=##) :: Double# -> Double# -> Int#
(<=##) = let x = x in x

infixl 6 +##
(+##) :: Double# -> Double# -> Double#
(+##) = let x = x in x

infixl 6 -##
(-##) :: Double# -> Double# -> Double#
(-##) = let x = x in x

infixl 7 *##
(*##) :: Double# -> Double# -> Double#
(*##) = let x = x in x

infixl 7 /##
(/##) :: Double# -> Double# -> Double#
(/##) = let x = x in x

negateDouble# :: Double# -> Double#
negateDouble# = let x = x in x

-- |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# = let x = x in x

double2Float# :: Double# -> Float#
double2Float# = let x = x in x

expDouble# :: Double# -> Double#
expDouble# = let x = x in x

logDouble# :: Double# -> Double#
logDouble# = let x = x in x

sqrtDouble# :: Double# -> Double#
sqrtDouble# = let x = x in x

sinDouble# :: Double# -> Double#
sinDouble# = let x = x in x

cosDouble# :: Double# -> Double#
cosDouble# = let x = x in x

tanDouble# :: Double# -> Double#
tanDouble# = let x = x in x

asinDouble# :: Double# -> Double#
asinDouble# = let x = x in x

acosDouble# :: Double# -> Double#
acosDouble# = let x = x in x

atanDouble# :: Double# -> Double#
atanDouble# = let x = x in x

sinhDouble# :: Double# -> Double#
sinhDouble# = let x = x in x

coshDouble# :: Double# -> Double#
coshDouble# = let x = x in x

tanhDouble# :: Double# -> Double#
tanhDouble# = let x = x in x

-- |Exponentiation.

(**##) :: Double# -> Double# -> Double#
(**##) = let x = x in x

-- |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# = let x = x in x

data Float#

gtFloat# :: Float# -> Float# -> Int#
gtFloat# = let x = x in x

geFloat# :: Float# -> Float# -> Int#
geFloat# = let x = x in x

eqFloat# :: Float# -> Float# -> Int#
eqFloat# = let x = x in x

neFloat# :: Float# -> Float# -> Int#
neFloat# = let x = x in x

ltFloat# :: Float# -> Float# -> Int#
ltFloat# = let x = x in x

leFloat# :: Float# -> Float# -> Int#
leFloat# = let x = x in x

plusFloat# :: Float# -> Float# -> Float#
plusFloat# = let x = x in x

minusFloat# :: Float# -> Float# -> Float#
minusFloat# = let x = x in x

timesFloat# :: Float# -> Float# -> Float#
timesFloat# = let x = x in x

divideFloat# :: Float# -> Float# -> Float#
divideFloat# = let x = x in x

negateFloat# :: Float# -> Float#
negateFloat# = let x = x in x

-- |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# = let x = x in x

expFloat# :: Float# -> Float#
expFloat# = let x = x in x

logFloat# :: Float# -> Float#
logFloat# = let x = x in x

sqrtFloat# :: Float# -> Float#
sqrtFloat# = let x = x in x

sinFloat# :: Float# -> Float#
sinFloat# = let x = x in x

cosFloat# :: Float# -> Float#
cosFloat# = let x = x in x

tanFloat# :: Float# -> Float#
tanFloat# = let x = x in x

asinFloat# :: Float# -> Float#
asinFloat# = let x = x in x

acosFloat# :: Float# -> Float#
acosFloat# = let x = x in x

atanFloat# :: Float# -> Float#
atanFloat# = let x = x in x

sinhFloat# :: Float# -> Float#
sinhFloat# = let x = x in x

coshFloat# :: Float# -> Float#
coshFloat# = let x = x in x

tanhFloat# :: Float# -> Float#
tanhFloat# = let x = x in x

powerFloat# :: Float# -> Float# -> Float#
powerFloat# = let x = x in x

float2Double# :: Float# -> Double#
float2Double# = let x = x in x

-- |Convert to integers.
--     First @Int\#@ in result is the mantissa; second is the exponent.

decodeFloat_Int# :: Float# -> (# Int#,Int# #)
decodeFloat_Int# = let x = x in x

data Array# a

data MutableArray# s a

-- |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# s a #)
newArray# = let x = x in x

sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#
sameMutableArray# = let x = x in x

-- |Read from specified index of mutable array. Result is not yet evaluated.

readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)
readArray# = let x = x in x

-- |Write to specified index of mutable array.

writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s
writeArray# = let x = x in x

-- |Return the number of elements in the array.

sizeofArray# :: Array# a -> Int#
sizeofArray# = let x = x in x

-- |Return the number of elements in the array.

sizeofMutableArray# :: MutableArray# s a -> Int#
sizeofMutableArray# = let x = x in x

-- |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# = let x = x in x

-- |Make a mutable array immutable, without copying.

unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)
unsafeFreezeArray# = let x = x in x

-- |Make an immutable array mutable, without copying.

unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)
unsafeThawArray# = let x = x in x

-- |Copy a range of the Array# to the specified region in the MutableArray#.
--    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# s a -> Int# -> Int# -> State# s -> State# s
copyArray# = let x = x in x

-- |Copy a range of the first MutableArray# to the specified region in the second MutableArray#.
--    Both arrays must fully contain the specified ranges, but this is not checked.

copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
copyMutableArray# = let x = x in x

-- |Return a newly allocated Array# with the specified subrange of the provided Array#.
--    The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.

cloneArray# :: Array# a -> Int# -> Int# -> Array# a
cloneArray# = let x = x in x

-- |Return a newly allocated Array# with the specified subrange of the provided Array#.
--    The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.

cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
cloneMutableArray# = let x = x in x

-- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.
--    The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.

freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)
freezeArray# = let x = x in x

-- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.
--    The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.

thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
thawArray# = let x = x in x

-- |Unsafe, machine-level atomic compare and swap on an element within an Array.

casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)
casArray# = let x = x in x

data ByteArray#

data MutableByteArray# 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# = let x = x in x

-- |Create a mutable byte array that the GC guarantees not to move.

newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
newPinnedByteArray# = let x = x in x

-- |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# = let x = x in x

-- |Intended for use with pinned arrays; otherwise very unsafe!

byteArrayContents# :: ByteArray# -> Addr#
byteArrayContents# = let x = x in x

sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
sameMutableByteArray# = let x = x in x

-- |Make a mutable byte array immutable, without copying.

unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)
unsafeFreezeByteArray# = let x = x in x

-- |Return the size of the array in bytes.

sizeofByteArray# :: ByteArray# -> Int#
sizeofByteArray# = let x = x in x

-- |Return the size of the array in bytes.

sizeofMutableByteArray# :: MutableByteArray# s -> Int#
sizeofMutableByteArray# = let x = x in x

-- |Read 8-bit character; offset in bytes.

indexCharArray# :: ByteArray# -> Int# -> Char#
indexCharArray# = let x = x in x

-- |Read 31-bit character; offset in 4-byte words.

indexWideCharArray# :: ByteArray# -> Int# -> Char#
indexWideCharArray# = let x = x in x

indexIntArray# :: ByteArray# -> Int# -> Int#
indexIntArray# = let x = x in x

indexWordArray# :: ByteArray# -> Int# -> Word#
indexWordArray# = let x = x in x

indexAddrArray# :: ByteArray# -> Int# -> Addr#
indexAddrArray# = let x = x in x

indexFloatArray# :: ByteArray# -> Int# -> Float#
indexFloatArray# = let x = x in x

indexDoubleArray# :: ByteArray# -> Int# -> Double#
indexDoubleArray# = let x = x in x

indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
indexStablePtrArray# = let x = x in x

indexInt8Array# :: ByteArray# -> Int# -> Int#
indexInt8Array# = let x = x in x

indexInt16Array# :: ByteArray# -> Int# -> Int#
indexInt16Array# = let x = x in x

indexInt32Array# :: ByteArray# -> Int# -> Int#
indexInt32Array# = let x = x in x

indexInt64Array# :: ByteArray# -> Int# -> Int#
indexInt64Array# = let x = x in x

indexWord8Array# :: ByteArray# -> Int# -> Word#
indexWord8Array# = let x = x in x

indexWord16Array# :: ByteArray# -> Int# -> Word#
indexWord16Array# = let x = x in x

indexWord32Array# :: ByteArray# -> Int# -> Word#
indexWord32Array# = let x = x in x

indexWord64Array# :: ByteArray# -> Int# -> Word#
indexWord64Array# = let x = x in x

-- |Read 8-bit character; offset in bytes.

readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readCharArray# = let x = x in x

-- |Read 31-bit character; offset in 4-byte words.

readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readWideCharArray# = let x = x in x

readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readIntArray# = let x = x in x

readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWordArray# = let x = x in x

readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
readAddrArray# = let x = x in x

readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
readFloatArray# = let x = x in x

readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
readDoubleArray# = let x = x in x

readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
readStablePtrArray# = let x = x in x

readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt8Array# = let x = x in x

readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt16Array# = let x = x in x

readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt32Array# = let x = x in x

readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt64Array# = let x = x in x

readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord8Array# = let x = x in x

readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord16Array# = let x = x in x

readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord32Array# = let x = x in x

readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord64Array# = let x = x in x

-- |Write 8-bit character; offset in bytes.

writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeCharArray# = let x = x in x

-- |Write 31-bit character; offset in 4-byte words.

writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeWideCharArray# = let x = x in x

writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeIntArray# = let x = x in x

writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWordArray# = let x = x in x

writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
writeAddrArray# = let x = x in x

writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
writeFloatArray# = let x = x in x

writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
writeDoubleArray# = let x = x in x

writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
writeStablePtrArray# = let x = x in x

writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt8Array# = let x = x in x

writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt16Array# = let x = x in x

writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt32Array# = let x = x in x

writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt64Array# = let x = x in x

writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord8Array# = let x = x in x

writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord16Array# = let x = x in x

writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord32Array# = let x = x in x

writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord64Array# = let x = x in x

-- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#.
--    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# s
copyByteArray# = let x = x in x

-- |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.

copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyMutableByteArray# = let x = x in x

-- |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# s
copyByteArrayToAddr# = let x = x in x

-- |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# s
copyMutableByteArrayToAddr# = let x = x in x

-- |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# s
copyAddrToByteArray# = let x = x in x

-- |Set the range of the MutableByteArray# to the specified character.

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
setByteArray# = let x = x in x

-- |Machine-level atomic compare and swap on a word within a ByteArray.

casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)
casIntArray# = let x = x in x

-- |Machine-level word-sized fetch-and-add within a ByteArray.

fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchAddIntArray# = let x = x in x

data ArrayArray#

data MutableArrayArray# 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# = let x = x in x

sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#
sameMutableArrayArray# = let x = x in x

-- |Make a mutable array of arrays immutable, without copying.

unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)
unsafeFreezeArrayArray# = let x = x in x

-- |Return the number of elements in the array.

sizeofArrayArray# :: ArrayArray# -> Int#
sizeofArrayArray# = let x = x in x

-- |Return the number of elements in the array.

sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#
sizeofMutableArrayArray# = let x = x in x

indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
indexByteArrayArray# = let x = x in x

indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
indexArrayArrayArray# = let x = x in x

readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)
readByteArrayArray# = let x = x in x

readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
readMutableByteArrayArray# = let x = x in x

readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)
readArrayArrayArray# = let x = x in x

readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)
readMutableArrayArrayArray# = let x = x in x

writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
writeByteArrayArray# = let x = x in x

writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s
writeMutableByteArrayArray# = let x = x in x

writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
writeArrayArrayArray# = let x = x in x

writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
writeMutableArrayArrayArray# = let x = x in x

-- |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# s
copyArrayArray# = let x = x in x

-- |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.

copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
copyMutableArrayArray# = let x = x in x

-- | An arbitrary machine address assumed to point outside
-- 	 the garbage-collected heap. 

data Addr#

-- | The null address. 

nullAddr# :: Addr#
nullAddr# = let x = x in x

plusAddr# :: Addr# -> Int# -> Addr#
plusAddr# = let x = x in x

-- |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# = let x = x in x

-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,
-- 	  is divided by the @Int\#@ arg.

remAddr# :: Addr# -> Int# -> Int#
remAddr# = let x = x in x

-- |Coerce directly from address to int. Strongly deprecated.

addr2Int# :: Addr# -> Int#
addr2Int# = let x = x in x

-- |Coerce directly from int to address. Strongly deprecated.

int2Addr# :: Int# -> Addr#
int2Addr# = let x = x in x

gtAddr# :: Addr# -> Addr# -> Int#
gtAddr# = let x = x in x

geAddr# :: Addr# -> Addr# -> Int#
geAddr# = let x = x in x

eqAddr# :: Addr# -> Addr# -> Int#
eqAddr# = let x = x in x

neAddr# :: Addr# -> Addr# -> Int#
neAddr# = let x = x in x

ltAddr# :: Addr# -> Addr# -> Int#
ltAddr# = let x = x in x

leAddr# :: Addr# -> Addr# -> Int#
leAddr# = let x = x in x

-- |Reads 8-bit character; offset in bytes.

indexCharOffAddr# :: Addr# -> Int# -> Char#
indexCharOffAddr# = let x = x in x

-- |Reads 31-bit character; offset in 4-byte words.

indexWideCharOffAddr# :: Addr# -> Int# -> Char#
indexWideCharOffAddr# = let x = x in x

indexIntOffAddr# :: Addr# -> Int# -> Int#
indexIntOffAddr# = let x = x in x

indexWordOffAddr# :: Addr# -> Int# -> Word#
indexWordOffAddr# = let x = x in x

indexAddrOffAddr# :: Addr# -> Int# -> Addr#
indexAddrOffAddr# = let x = x in x

indexFloatOffAddr# :: Addr# -> Int# -> Float#
indexFloatOffAddr# = let x = x in x

indexDoubleOffAddr# :: Addr# -> Int# -> Double#
indexDoubleOffAddr# = let x = x in x

indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
indexStablePtrOffAddr# = let x = x in x

indexInt8OffAddr# :: Addr# -> Int# -> Int#
indexInt8OffAddr# = let x = x in x

indexInt16OffAddr# :: Addr# -> Int# -> Int#
indexInt16OffAddr# = let x = x in x

indexInt32OffAddr# :: Addr# -> Int# -> Int#
indexInt32OffAddr# = let x = x in x

indexInt64OffAddr# :: Addr# -> Int# -> Int#
indexInt64OffAddr# = let x = x in x

indexWord8OffAddr# :: Addr# -> Int# -> Word#
indexWord8OffAddr# = let x = x in x

indexWord16OffAddr# :: Addr# -> Int# -> Word#
indexWord16OffAddr# = let x = x in x

indexWord32OffAddr# :: Addr# -> Int# -> Word#
indexWord32OffAddr# = let x = x in x

indexWord64OffAddr# :: Addr# -> Int# -> Word#
indexWord64OffAddr# = let x = x in x

-- |Reads 8-bit character; offset in bytes.

readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
readCharOffAddr# = let x = x in x

-- |Reads 31-bit character; offset in 4-byte words.

readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
readWideCharOffAddr# = let x = x in x

readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readIntOffAddr# = let x = x in x

readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWordOffAddr# = let x = x in x

readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)
readAddrOffAddr# = let x = x in x

readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)
readFloatOffAddr# = let x = x in x

readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)
readDoubleOffAddr# = let x = x in x

readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)
readStablePtrOffAddr# = let x = x in x

readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt8OffAddr# = let x = x in x

readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt16OffAddr# = let x = x in x

readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt32OffAddr# = let x = x in x

readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt64OffAddr# = let x = x in x

readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord8OffAddr# = let x = x in x

readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord16OffAddr# = let x = x in x

readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord32OffAddr# = let x = x in x

readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord64OffAddr# = let x = x in x

writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
writeCharOffAddr# = let x = x in x

writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
writeWideCharOffAddr# = let x = x in x

writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeIntOffAddr# = let x = x in x

writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWordOffAddr# = let x = x in x

writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
writeAddrOffAddr# = let x = x in x

writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
writeFloatOffAddr# = let x = x in x

writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
writeDoubleOffAddr# = let x = x in x

writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
writeStablePtrOffAddr# = let x = x in x

writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt8OffAddr# = let x = x in x

writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt16OffAddr# = let x = x in x

writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt32OffAddr# = let x = x in x

writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt64OffAddr# = let x = x in x

writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord8OffAddr# = let x = x in x

writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord16OffAddr# = let x = x in x

writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord32OffAddr# = let x = x in x

writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord64OffAddr# = let x = x in x

-- |A @MutVar\#@ behaves like a single-element mutable array.

data MutVar# s a

-- |Create @MutVar\#@ with specified initial value in specified state thread.

newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)
newMutVar# = let x = x in x

-- |Read contents of @MutVar\#@. Result is not yet evaluated.

readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)
readMutVar# = let x = x in x

-- |Write contents of @MutVar\#@.

writeMutVar# :: MutVar# s a -> a -> State# s -> State# s
writeMutVar# = let x = x in x

sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#
sameMutVar# = let x = x in x

atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)
atomicModifyMutVar# = let x = x in x

casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)
casMutVar# = let x = x in x

catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catch# = let x = x in x

raise# :: a -> b
raise# = let x = x in x

raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)
raiseIO# = let x = x in x

maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
maskAsyncExceptions# = let x = x in x

maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
maskUninterruptible# = let x = x in x

unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
unmaskAsyncExceptions# = let x = x in x

getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
getMaskingState# = let x = x in x

data TVar# s a

atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
atomically# = let x = x in x

retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)
retry# = let x = x in x

catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catchRetry# = let x = x in x

catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catchSTM# = let x = x in x

check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)
check# = let x = x in x

-- |Create a new @TVar\#@ holding a specified initial value.

newTVar# :: a -> State# s -> (# State# s,TVar# s a #)
newTVar# = let x = x in x

-- |Read contents of @TVar\#@.  Result is not yet evaluated.

readTVar# :: TVar# s a -> State# s -> (# State# s,a #)
readTVar# = let x = x in x

-- |Read contents of @TVar\#@ outside an STM transaction

readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)
readTVarIO# = let x = x in x

-- |Write contents of @TVar\#@.

writeTVar# :: TVar# s a -> a -> State# s -> State# s
writeTVar# = let x = x in x

sameTVar# :: TVar# s a -> TVar# s a -> Int#
sameTVar# = let x = x in x

-- | 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))@.) 

data MVar# s a

-- |Create new @MVar\#@; initially empty.

newMVar# :: State# s -> (# State# s,MVar# s a #)
newMVar# = let x = x in x

-- |If @MVar\#@ is empty, block until it becomes full.
--    Then remove and return its contents, and set it empty.

takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)
takeMVar# = let x = x in x

-- |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# s a -> State# s -> (# State# s,Int#,a #)
tryTakeMVar# = let x = x in x

-- |If @MVar\#@ is full, block until it becomes empty.
--    Then store value arg as its new contents.

putMVar# :: MVar# s a -> a -> State# s -> State# s
putMVar# = let x = x in x

-- |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# s a -> a -> State# s -> (# State# s,Int# #)
tryPutMVar# = let x = x in x

-- |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# s a -> State# s -> (# State# s,a #)
readMVar# = let x = x in x

-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.
--    Otherwise, return with integer 1 and contents of @MVar\#@.

tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)
tryReadMVar# = let x = x in x

sameMVar# :: MVar# s a -> MVar# s a -> Int#
sameMVar# = let x = x in x

-- |Return 1 if @MVar\#@ is empty; 0 otherwise.

isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)
isEmptyMVar# = let x = x in x

-- |Sleep specified number of microseconds.

delay# :: Int# -> State# s -> State# s
delay# = let x = x in x

-- |Block until input is available on specified file descriptor.

waitRead# :: Int# -> State# s -> State# s
waitRead# = let x = x in x

-- |Block until output is possible on specified file descriptor.

waitWrite# :: Int# -> State# s -> State# s
waitWrite# = let x = x in x

-- | @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. 

data State# 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\#@. 

data RealWorld

-- |(In a non-concurrent implementation, this can be a singleton
-- 	type, whose (unique) value is returned by @myThreadId\#@.  The
-- 	other operations can be omitted.)

data ThreadId#

fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
fork# = let x = x in x

forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
forkOn# = let x = x in x

killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
killThread# = let x = x in x

yield# :: State# (RealWorld) -> State# (RealWorld)
yield# = let x = x in x

myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
myThreadId# = let x = x in x

labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
labelThread# = let x = x in x

isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
isCurrentThreadBound# = let x = x in x

noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
noDuplicate# = let x = x in x

threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
threadStatus# = let x = x in x

data Weak# b

mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
mkWeak# = let x = x in x

mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
mkWeakNoFinalizer# = let x = x in x

-- | @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# = let x = x in x

deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)
deRefWeak# = let x = x in x

finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)
finalizeWeak# = let x = x in x

touch# :: o -> State# (RealWorld) -> State# (RealWorld)
touch# = let x = x in x

data StablePtr# a

data StableName# a

makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)
makeStablePtr# = let x = x in x

deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)
deRefStablePtr# = let x = x in x

eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
eqStablePtr# = let x = x in x

makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)
makeStableName# = let x = x in x

eqStableName# :: StableName# a -> StableName# b -> Int#
eqStableName# = let x = x in x

stableNameToInt# :: StableName# a -> Int#
stableNameToInt# = let x = x in x

reallyUnsafePtrEquality# :: a -> a -> Int#
reallyUnsafePtrEquality# = let x = x in x

par# :: a -> Int#
par# = let x = x in x

spark# :: a -> State# s -> (# State# s,a #)
spark# = let x = x in x

seq# :: a -> State# s -> (# State# s,a #)
seq# = let x = x in x

getSpark# :: State# s -> (# State# s,Int#,a #)
getSpark# = let x = x in x

-- | Returns the number of sparks in the local spark pool. 

numSparks# :: State# s -> (# State# s,Int# #)
numSparks# = let x = x in x

parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
parGlobal# = let x = x in x

parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
parLocal# = let x = x in x

parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
parAt# = let x = x in x

parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
parAtAbs# = let x = x in x

parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
parAtRel# = let x = x in x

parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
parAtForNow# = let x = x in x

dataToTag# :: a -> Int#
dataToTag# = let x = x in x

tagToEnum# :: Int# -> a
tagToEnum# = let x = x in x

-- |Primitive bytecode type.

data BCO#

-- |Convert an @Addr\#@ to a followable Any type.

addrToAny# :: Addr# -> (# a #)
addrToAny# = let x = x in x

mkApUpd0# :: BCO# -> (# a #)
mkApUpd0# = let x = x in x

newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)
newBCO# = let x = x in x

unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)
unpackClosure# = let x = x in x

getApStackVal# :: a -> Int# -> (# Int#,b #)
getApStackVal# = let x = x in x

getCCSOf# :: a -> State# s -> (# State# s,Addr# #)
getCCSOf# = let x = x in x

-- | Returns the current @CostCentreStack@ (value is @NULL@ if
--      not profiling).  Takes a dummy argument which can be used to
--      avoid the call to @getCCCS\#@ being floated out by the
--      simplifier, which would result in an uninformative stack
--      (\"CAF\"). 

getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)
getCurrentCCS# = let x = x in x

-- | 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. 

data Proxy# a

-- | Witness for an unboxed @Proxy#@ value, which has no runtime
--    representation. 

proxy# :: Proxy# a
proxy# = let x = x in x

-- | Evaluates its first argument to head normal form, and then returns its second
-- 	argument as the result. 

seq :: a -> b -> b
seq = let x = x in x

-- | The type constructor @Any@ is type to which you can unsafely coerce any
-- 	lifted type, and back.
-- 
-- 	  * It is lifted, and hence represented by a pointer
-- 
-- 	  * It does not claim to be a /data/ type, and that\'s important for
-- 	    the code generator, because the code gen may /enter/ a data value
-- 	    but never enters a function value.
-- 
-- 	It\'s also used to instantiate un-constrained type variables after type
-- 	checking.  For example, @length@ has type
-- 
-- 	@length :: forall a. [a] -> Int@
-- 
-- 	and the list datacon for the empty list has type
-- 
-- 	@[] :: forall a. [a]@
-- 
-- 	In order to compose these two terms as @length []@ a type
-- 	application is required, but there is no constraint on the
-- 	choice.  In this situation GHC uses @Any@:
-- 
-- 	@length (Any *) ([] (Any *))@
-- 
--         Note that @Any@ is kind polymorphic, and takes a kind @k@ as its
--         first argument. The kind of @Any@ is thus @forall k. k -> k@.

data Any k

-- | The kind @AnyK@ is the kind level counterpart to @Any@. In a
--         kind polymorphic setting, a similar example to the length of the empty
--         list can be given at the type level:
-- 
--         @type family Length (l :: [k]) :: Nat@
--         @type instance Length [] = Zero@
-- 
--         When @Length@ is applied to the empty (promoted) list it will have
--         the kind @Length AnyK []@.
-- 
--         @AnyK@ is currently not exported and cannot be used directly, but
--         you might see it in debug output from the compiler.
--         

data AnyK

-- | 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
--            (but not coercions between floating-point and integral types)
-- 
--          * 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 congnoscenti, 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 -> b
unsafeCoerce# = let x = x in x

-- | 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# s
traceEvent# = let x = x in x

-- | 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# s
traceMarker# = let x = x in x

-- | 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 :: Coercible a b => a -> b
coerce = let x = x in x

-- | This two-parameter class has instances for types @a@ and @b@ if
--      the compiler can infer that they have the same representation. This class
--      does not have regular instances; instead they are created on-the-fly during
--      type-checking. Trying to manually declare an instance of @Coercible@
--      is an error.
-- 
--      Nevertheless one can pretend that the following three kinds of instances
--      exist. First, as a trivial base-case:
-- 
--      @instance a a@
-- 
--      Furthermore, for every type constructor there is
--      an instance that allows to coerce under the type constructor. For
--      example, let @D@ be a prototypical type constructor (@data@ or @newtype@) with three type arguments, which have roles Nominal,
--      Representational resp. Phantom. Then there is an instance of the form
-- 
--      @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@
-- 
--      Note that the nominal type arguments are equal, the representational type
--      arguments can differ, but need to have a @Coercible@ instance
--      themself, and the phantom type arguments can be changed arbitrarily.
-- 
--      In SafeHaskell code, this instance is only usable if the constructors of
--      every type constructor used in the definition of @D@ (including
--      those of @D@ itself) are in scope.
-- 
--      The third kind of instance exists for every @newtype NT = MkNT T@ and
--      comes in two variants, namely
-- 
--      @instance Coercible a T => Coercible a NT@
-- 
--      @instance Coercible T b => Coercible NT b@
-- 
--      This instance is only usable if the constructor @MkNT@ is in scope.
-- 
--      If, as a library author of a type constructor like @Set a@, you
--      want to prevent a user of your module to write
--      @coerce :: Set T -> Set NT@,
--      you need to set the role of @Set@\'s type parameter to Nominal.
--    

class Coercible a b

data Int8X16#

data Int16X8#

data Int32X4#

data Int64X2#

data Int8X32#

data Int16X16#

data Int32X8#

data Int64X4#

data Int8X64#

data Int16X32#

data Int32X16#

data Int64X8#

data Word8X16#

data Word16X8#

data Word32X4#

data Word64X2#

data Word8X32#

data Word16X16#

data Word32X8#

data Word64X4#

data Word8X64#

data Word16X32#

data Word32X16#

data Word64X8#

data FloatX4#

data DoubleX2#

data FloatX8#

data DoubleX4#

data FloatX16#

data DoubleX8#

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt8X16# :: Int# -> Int8X16#
broadcastInt8X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt16X8# :: Int# -> Int16X8#
broadcastInt16X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt32X4# :: Int# -> Int32X4#
broadcastInt32X4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt64X2# :: Int# -> Int64X2#
broadcastInt64X2# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt8X32# :: Int# -> Int8X32#
broadcastInt8X32# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt16X16# :: Int# -> Int16X16#
broadcastInt16X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt32X8# :: Int# -> Int32X8#
broadcastInt32X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt64X4# :: Int# -> Int64X4#
broadcastInt64X4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt8X64# :: Int# -> Int8X64#
broadcastInt8X64# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt16X32# :: Int# -> Int16X32#
broadcastInt16X32# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt32X16# :: Int# -> Int32X16#
broadcastInt32X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastInt64X8# :: Int# -> Int64X8#
broadcastInt64X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord8X16# :: Word# -> Word8X16#
broadcastWord8X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord16X8# :: Word# -> Word16X8#
broadcastWord16X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord32X4# :: Word# -> Word32X4#
broadcastWord32X4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord64X2# :: Word# -> Word64X2#
broadcastWord64X2# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord8X32# :: Word# -> Word8X32#
broadcastWord8X32# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord16X16# :: Word# -> Word16X16#
broadcastWord16X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord32X8# :: Word# -> Word32X8#
broadcastWord32X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord64X4# :: Word# -> Word64X4#
broadcastWord64X4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord8X64# :: Word# -> Word8X64#
broadcastWord8X64# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord16X32# :: Word# -> Word16X32#
broadcastWord16X32# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord32X16# :: Word# -> Word32X16#
broadcastWord32X16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastWord64X8# :: Word# -> Word64X8#
broadcastWord64X8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastFloatX4# :: Float# -> FloatX4#
broadcastFloatX4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastDoubleX2# :: Double# -> DoubleX2#
broadcastDoubleX2# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastFloatX8# :: Float# -> FloatX8#
broadcastFloatX8# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastDoubleX4# :: Double# -> DoubleX4#
broadcastDoubleX4# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastFloatX16# :: Float# -> FloatX16#
broadcastFloatX16# = let x = x in x

-- | Broadcast a scalar to all elements of a vector. 

broadcastDoubleX8# :: Double# -> DoubleX8#
broadcastDoubleX8# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8#
packInt16X8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4#
packInt32X4# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt64X2# :: (# Int#,Int# #) -> Int64X2#
packInt64X2# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8#
packInt32X8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4#
packInt64X4# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8#
packInt64X8# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8#
packWord16X8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4#
packWord32X4# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord64X2# :: (# Word#,Word# #) -> Word64X2#
packWord64X2# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8#
packWord32X8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4#
packWord64X4# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8#
packWord64X8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4#
packFloatX4# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packDoubleX2# :: (# Double#,Double# #) -> DoubleX2#
packDoubleX2# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8#
packFloatX8# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4#
packDoubleX4# = let x = x in x

-- | 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# = let x = x in x

-- | Pack the elements of an unboxed tuple into a vector. 

packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8#
packDoubleX8# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)
unpackInt16X8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)
unpackInt32X4# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)
unpackInt64X2# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)
unpackInt32X8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #)
unpackInt64X4# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)
unpackInt64X8# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)
unpackWord16X8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #)
unpackWord32X4# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord64X2# :: Word64X2# -> (# Word#,Word# #)
unpackWord64X2# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)
unpackWord32X8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #)
unpackWord64X4# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)
unpackWord64X8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)
unpackFloatX4# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)
unpackDoubleX2# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)
unpackFloatX8# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #)
unpackDoubleX4# = let x = x in x

-- | 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# = let x = x in x

-- | Unpack the elements of a vector into an unboxed tuple. #

unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #)
unpackDoubleX8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#
insertInt8X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#
insertInt16X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#
insertInt32X4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#
insertInt64X2# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#
insertInt8X32# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#
insertInt16X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#
insertInt32X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#
insertInt64X4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#
insertInt8X64# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#
insertInt16X32# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#
insertInt32X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#
insertInt64X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#
insertWord8X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#
insertWord16X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#
insertWord32X4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#
insertWord64X2# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#
insertWord8X32# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#
insertWord16X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#
insertWord32X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#
insertWord64X4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#
insertWord8X64# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#
insertWord16X32# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#
insertWord32X16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#
insertWord64X8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
insertFloatX4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
insertDoubleX2# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
insertFloatX8# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
insertDoubleX4# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
insertFloatX16# = let x = x in x

-- | Insert a scalar at the given position in a vector. 

insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
insertDoubleX8# = let x = x in x

-- | Add two vectors element-wise. 

plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
plusInt8X16# = let x = x in x

-- | Add two vectors element-wise. 

plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
plusInt16X8# = let x = x in x

-- | Add two vectors element-wise. 

plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
plusInt32X4# = let x = x in x

-- | Add two vectors element-wise. 

plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
plusInt64X2# = let x = x in x

-- | Add two vectors element-wise. 

plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
plusInt8X32# = let x = x in x

-- | Add two vectors element-wise. 

plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
plusInt16X16# = let x = x in x

-- | Add two vectors element-wise. 

plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
plusInt32X8# = let x = x in x

-- | Add two vectors element-wise. 

plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
plusInt64X4# = let x = x in x

-- | Add two vectors element-wise. 

plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
plusInt8X64# = let x = x in x

-- | Add two vectors element-wise. 

plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
plusInt16X32# = let x = x in x

-- | Add two vectors element-wise. 

plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
plusInt32X16# = let x = x in x

-- | Add two vectors element-wise. 

plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
plusInt64X8# = let x = x in x

-- | Add two vectors element-wise. 

plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
plusWord8X16# = let x = x in x

-- | Add two vectors element-wise. 

plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
plusWord16X8# = let x = x in x

-- | Add two vectors element-wise. 

plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
plusWord32X4# = let x = x in x

-- | Add two vectors element-wise. 

plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
plusWord64X2# = let x = x in x

-- | Add two vectors element-wise. 

plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
plusWord8X32# = let x = x in x

-- | Add two vectors element-wise. 

plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
plusWord16X16# = let x = x in x

-- | Add two vectors element-wise. 

plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
plusWord32X8# = let x = x in x

-- | Add two vectors element-wise. 

plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
plusWord64X4# = let x = x in x

-- | Add two vectors element-wise. 

plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
plusWord8X64# = let x = x in x

-- | Add two vectors element-wise. 

plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
plusWord16X32# = let x = x in x

-- | Add two vectors element-wise. 

plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
plusWord32X16# = let x = x in x

-- | Add two vectors element-wise. 

plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
plusWord64X8# = let x = x in x

-- | Add two vectors element-wise. 

plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
plusFloatX4# = let x = x in x

-- | Add two vectors element-wise. 

plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
plusDoubleX2# = let x = x in x

-- | Add two vectors element-wise. 

plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
plusFloatX8# = let x = x in x

-- | Add two vectors element-wise. 

plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
plusDoubleX4# = let x = x in x

-- | Add two vectors element-wise. 

plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
plusFloatX16# = let x = x in x

-- | Add two vectors element-wise. 

plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
plusDoubleX8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
minusInt8X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
minusInt16X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
minusInt32X4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
minusInt64X2# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
minusInt8X32# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
minusInt16X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
minusInt32X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
minusInt64X4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
minusInt8X64# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
minusInt16X32# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
minusInt32X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
minusInt64X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
minusWord8X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
minusWord16X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
minusWord32X4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
minusWord64X2# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
minusWord8X32# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
minusWord16X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
minusWord32X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
minusWord64X4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
minusWord8X64# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
minusWord16X32# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
minusWord32X16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
minusWord64X8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
minusFloatX4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
minusDoubleX2# = let x = x in x

-- | Subtract two vectors element-wise. 

minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
minusFloatX8# = let x = x in x

-- | Subtract two vectors element-wise. 

minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
minusDoubleX4# = let x = x in x

-- | Subtract two vectors element-wise. 

minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
minusFloatX16# = let x = x in x

-- | Subtract two vectors element-wise. 

minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
minusDoubleX8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
timesInt8X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
timesInt16X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
timesInt32X4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
timesInt64X2# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
timesInt8X32# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
timesInt16X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
timesInt32X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
timesInt64X4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
timesInt8X64# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
timesInt16X32# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
timesInt32X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
timesInt64X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
timesWord8X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
timesWord16X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
timesWord32X4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
timesWord64X2# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
timesWord8X32# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
timesWord16X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
timesWord32X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
timesWord64X4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
timesWord8X64# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
timesWord16X32# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
timesWord32X16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
timesWord64X8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesFloatX4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
timesDoubleX2# = let x = x in x

-- | Multiply two vectors element-wise. 

timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
timesFloatX8# = let x = x in x

-- | Multiply two vectors element-wise. 

timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
timesDoubleX4# = let x = x in x

-- | Multiply two vectors element-wise. 

timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
timesFloatX16# = let x = x in x

-- | Multiply two vectors element-wise. 

timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
timesDoubleX8# = let x = x in x

-- | Divide two vectors element-wise. 

divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
divideFloatX4# = let x = x in x

-- | Divide two vectors element-wise. 

divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
divideDoubleX2# = let x = x in x

-- | Divide two vectors element-wise. 

divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
divideFloatX8# = let x = x in x

-- | Divide two vectors element-wise. 

divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
divideDoubleX4# = let x = x in x

-- | Divide two vectors element-wise. 

divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
divideFloatX16# = let x = x in x

-- | Divide two vectors element-wise. 

divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
divideDoubleX8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
quotInt8X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
quotInt16X8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
quotInt32X4# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
quotInt64X2# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
quotInt8X32# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
quotInt16X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
quotInt32X8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
quotInt64X4# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
quotInt8X64# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
quotInt16X32# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
quotInt32X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
quotInt64X8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
quotWord8X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
quotWord16X8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
quotWord32X4# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
quotWord64X2# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
quotWord8X32# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
quotWord16X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
quotWord32X8# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
quotWord64X4# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
quotWord8X64# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
quotWord16X32# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
quotWord32X16# = let x = x in x

-- | Rounds towards zero element-wise. 

quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
quotWord64X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
remInt8X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
remInt16X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
remInt32X4# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
remInt64X2# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
remInt8X32# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
remInt16X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
remInt32X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
remInt64X4# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
remInt8X64# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
remInt16X32# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
remInt32X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
remInt64X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
remWord8X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
remWord16X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
remWord32X4# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
remWord64X2# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
remWord8X32# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
remWord16X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
remWord32X8# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
remWord64X4# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
remWord8X64# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
remWord16X32# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
remWord32X16# = let x = x in x

-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. 

remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
remWord64X8# = let x = x in x

-- | Negate element-wise. 

negateInt8X16# :: Int8X16# -> Int8X16#
negateInt8X16# = let x = x in x

-- | Negate element-wise. 

negateInt16X8# :: Int16X8# -> Int16X8#
negateInt16X8# = let x = x in x

-- | Negate element-wise. 

negateInt32X4# :: Int32X4# -> Int32X4#
negateInt32X4# = let x = x in x

-- | Negate element-wise. 

negateInt64X2# :: Int64X2# -> Int64X2#
negateInt64X2# = let x = x in x

-- | Negate element-wise. 

negateInt8X32# :: Int8X32# -> Int8X32#
negateInt8X32# = let x = x in x

-- | Negate element-wise. 

negateInt16X16# :: Int16X16# -> Int16X16#
negateInt16X16# = let x = x in x

-- | Negate element-wise. 

negateInt32X8# :: Int32X8# -> Int32X8#
negateInt32X8# = let x = x in x

-- | Negate element-wise. 

negateInt64X4# :: Int64X4# -> Int64X4#
negateInt64X4# = let x = x in x

-- | Negate element-wise. 

negateInt8X64# :: Int8X64# -> Int8X64#
negateInt8X64# = let x = x in x

-- | Negate element-wise. 

negateInt16X32# :: Int16X32# -> Int16X32#
negateInt16X32# = let x = x in x

-- | Negate element-wise. 

negateInt32X16# :: Int32X16# -> Int32X16#
negateInt32X16# = let x = x in x

-- | Negate element-wise. 

negateInt64X8# :: Int64X8# -> Int64X8#
negateInt64X8# = let x = x in x

-- | Negate element-wise. 

negateFloatX4# :: FloatX4# -> FloatX4#
negateFloatX4# = let x = x in x

-- | Negate element-wise. 

negateDoubleX2# :: DoubleX2# -> DoubleX2#
negateDoubleX2# = let x = x in x

-- | Negate element-wise. 

negateFloatX8# :: FloatX8# -> FloatX8#
negateFloatX8# = let x = x in x

-- | Negate element-wise. 

negateDoubleX4# :: DoubleX4# -> DoubleX4#
negateDoubleX4# = let x = x in x

-- | Negate element-wise. 

negateFloatX16# :: FloatX16# -> FloatX16#
negateFloatX16# = let x = x in x

-- | Negate element-wise. 

negateDoubleX8# :: DoubleX8# -> DoubleX8#
negateDoubleX8# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
indexInt8X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
indexInt16X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
indexInt32X4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
indexInt64X2Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
indexInt8X32Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
indexInt16X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
indexInt32X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
indexInt64X4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
indexInt8X64Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
indexInt16X32Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
indexInt32X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
indexInt64X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
indexWord8X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
indexWord16X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
indexWord32X4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
indexWord64X2Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
indexWord8X32Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
indexWord16X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
indexWord32X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
indexWord64X4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
indexWord8X64Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
indexWord16X32Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
indexWord32X16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
indexWord64X8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
indexFloatX4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
indexDoubleX2Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
indexFloatX8Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
indexDoubleX4Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
indexFloatX16Array# = let x = x in x

-- | Read a vector from specified index of immutable array. 

indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
indexDoubleX8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)
readInt8X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)
readInt16X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32X4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64X2Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)
readInt8X32Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)
readInt16X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)
readInt32X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)
readInt64X4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)
readInt8X64Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)
readInt16X32Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)
readInt32X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)
readInt64X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)
readWord8X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)
readWord16X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)
readWord32X4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)
readWord64X2Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)
readWord8X32Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)
readWord16X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)
readWord32X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)
readWord64X4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)
readWord8X64Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)
readWord16X32Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)
readWord32X16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)
readWord64X8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatX4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleX2Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)
readFloatX8Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)
readDoubleX4Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)
readFloatX16Array# = let x = x in x

-- | Read a vector from specified index of mutable array. 

readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)
readDoubleX8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s
writeInt8X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s
writeInt16X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
writeInt32X4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
writeInt64X2Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s
writeInt8X32Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s
writeInt16X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s
writeInt32X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s
writeInt64X4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s
writeInt8X64Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s
writeInt16X32Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s
writeInt32X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s
writeInt64X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s
writeWord8X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s
writeWord16X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s
writeWord32X4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s
writeWord64X2Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s
writeWord8X32Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s
writeWord16X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s
writeWord32X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s
writeWord64X4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s
writeWord8X64Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s
writeWord16X32Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s
writeWord32X16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s
writeWord64X8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
writeFloatX4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleX2Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s
writeFloatX8Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s
writeDoubleX4Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s
writeFloatX16Array# = let x = x in x

-- | Write a vector to specified index of mutable array. 

writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s
writeDoubleX8Array# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
indexInt8X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
indexInt16X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
indexInt32X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
indexInt64X2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
indexInt8X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
indexInt16X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
indexInt32X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
indexInt64X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
indexInt8X64OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
indexInt16X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
indexInt32X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
indexInt64X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
indexWord8X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
indexWord16X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
indexWord32X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
indexWord64X2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
indexWord8X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
indexWord16X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
indexWord32X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
indexWord64X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
indexWord8X64OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
indexWord16X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
indexWord32X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
indexWord64X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
indexFloatX4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
indexDoubleX2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
indexFloatX8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
indexDoubleX4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
indexFloatX16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
indexDoubleX8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)
readInt8X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)
readInt16X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64X2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)
readInt8X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)
readInt16X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)
readInt32X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)
readInt64X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)
readInt8X64OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)
readInt16X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)
readInt32X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)
readInt64X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)
readWord8X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)
readWord16X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)
readWord32X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)
readWord64X2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)
readWord8X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)
readWord16X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)
readWord32X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)
readWord64X4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)
readWord8X64OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)
readWord16X32OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)
readWord32X16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)
readWord64X8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatX4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleX2OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)
readFloatX8OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)
readDoubleX4OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)
readFloatX16OffAddr# = let x = x in x

-- | Reads vector; offset in bytes. 

readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)
readDoubleX8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s
writeInt8X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s
writeInt16X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s
writeInt32X4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s
writeInt64X2OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s
writeInt8X32OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s
writeInt16X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s
writeInt32X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s
writeInt64X4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s
writeInt8X64OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s
writeInt16X32OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s
writeInt32X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s
writeInt64X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s
writeWord8X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s
writeWord16X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s
writeWord32X4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s
writeWord64X2OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s
writeWord8X32OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s
writeWord16X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s
writeWord32X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s
writeWord64X4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s
writeWord8X64OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s
writeWord16X32OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s
writeWord32X16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s
writeWord64X8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s
writeFloatX4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleX2OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s
writeFloatX8OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s
writeDoubleX4OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s
writeFloatX16OffAddr# = let x = x in x

-- | Write vector; offset in bytes. 

writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s
writeDoubleX8OffAddr# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
indexInt8ArrayAsInt8X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
indexInt16ArrayAsInt16X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
indexInt32ArrayAsInt32X4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
indexInt64ArrayAsInt64X2# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
indexInt8ArrayAsInt8X32# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
indexInt16ArrayAsInt16X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
indexInt32ArrayAsInt32X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
indexInt64ArrayAsInt64X4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
indexInt8ArrayAsInt8X64# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
indexInt16ArrayAsInt16X32# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
indexInt32ArrayAsInt32X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
indexInt64ArrayAsInt64X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
indexWord8ArrayAsWord8X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
indexWord16ArrayAsWord16X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
indexWord32ArrayAsWord32X4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
indexWord64ArrayAsWord64X2# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
indexWord8ArrayAsWord8X32# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
indexWord16ArrayAsWord16X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
indexWord32ArrayAsWord32X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
indexWord64ArrayAsWord64X4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
indexWord8ArrayAsWord8X64# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
indexWord16ArrayAsWord16X32# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
indexWord32ArrayAsWord32X16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
indexWord64ArrayAsWord64X8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
indexFloatArrayAsFloatX4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
indexDoubleArrayAsDoubleX2# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
indexFloatArrayAsFloatX8# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
indexDoubleArrayAsDoubleX4# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
indexFloatArrayAsFloatX16# = let x = x in x

-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. 

indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
indexDoubleArrayAsDoubleX8# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | 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# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s
writeInt8ArrayAsInt8X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s
writeInt16ArrayAsInt16X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
writeInt32ArrayAsInt32X4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
writeInt64ArrayAsInt64X2# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s
writeInt8ArrayAsInt8X32# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s
writeInt16ArrayAsInt16X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s
writeInt32ArrayAsInt32X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s
writeInt64ArrayAsInt64X4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s
writeInt8ArrayAsInt8X64# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s
writeInt16ArrayAsInt16X32# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s
writeInt32ArrayAsInt32X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s
writeInt64ArrayAsInt64X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s
writeWord8ArrayAsWord8X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s
writeWord16ArrayAsWord16X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s
writeWord32ArrayAsWord32X4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s
writeWord64ArrayAsWord64X2# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s
writeWord8ArrayAsWord8X32# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s
writeWord16ArrayAsWord16X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s
writeWord32ArrayAsWord32X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s
writeWord64ArrayAsWord64X4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s
writeWord8ArrayAsWord8X64# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s
writeWord16ArrayAsWord16X32# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s
writeWord32ArrayAsWord32X16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s
writeWord64ArrayAsWord64X8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
writeFloatArrayAsFloatX4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleArrayAsDoubleX2# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s
writeFloatArrayAsFloatX8# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s
writeDoubleArrayAsDoubleX4# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s
writeFloatArrayAsFloatX16# = let x = x in x

-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. 

writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s
writeDoubleArrayAsDoubleX8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
indexInt8OffAddrAsInt8X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
indexInt16OffAddrAsInt16X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
indexInt32OffAddrAsInt32X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
indexInt64OffAddrAsInt64X2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
indexInt8OffAddrAsInt8X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
indexInt16OffAddrAsInt16X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
indexInt32OffAddrAsInt32X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
indexInt64OffAddrAsInt64X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
indexInt8OffAddrAsInt8X64# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
indexInt16OffAddrAsInt16X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
indexInt32OffAddrAsInt32X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
indexInt64OffAddrAsInt64X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
indexWord8OffAddrAsWord8X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
indexWord16OffAddrAsWord16X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
indexWord32OffAddrAsWord32X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
indexWord64OffAddrAsWord64X2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
indexWord8OffAddrAsWord8X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
indexWord16OffAddrAsWord16X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
indexWord32OffAddrAsWord32X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
indexWord64OffAddrAsWord64X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
indexWord8OffAddrAsWord8X64# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
indexWord16OffAddrAsWord16X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
indexWord32OffAddrAsWord32X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
indexWord64OffAddrAsWord64X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
indexFloatOffAddrAsFloatX4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
indexDoubleOffAddrAsDoubleX2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
indexFloatOffAddrAsFloatX8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
indexDoubleOffAddrAsDoubleX4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
indexFloatOffAddrAsFloatX16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
indexDoubleOffAddrAsDoubleX8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)
readInt8OffAddrAsInt8X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)
readInt16OffAddrAsInt16X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32OffAddrAsInt32X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64OffAddrAsInt64X2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)
readInt8OffAddrAsInt8X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)
readInt16OffAddrAsInt16X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)
readInt32OffAddrAsInt32X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)
readInt64OffAddrAsInt64X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)
readInt8OffAddrAsInt8X64# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)
readInt16OffAddrAsInt16X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)
readInt32OffAddrAsInt32X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)
readInt64OffAddrAsInt64X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)
readWord8OffAddrAsWord8X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)
readWord16OffAddrAsWord16X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)
readWord32OffAddrAsWord32X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)
readWord64OffAddrAsWord64X2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)
readWord8OffAddrAsWord8X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)
readWord16OffAddrAsWord16X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)
readWord32OffAddrAsWord32X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)
readWord64OffAddrAsWord64X4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)
readWord8OffAddrAsWord8X64# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)
readWord16OffAddrAsWord16X32# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)
readWord32OffAddrAsWord32X16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)
readWord64OffAddrAsWord64X8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatOffAddrAsFloatX4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleOffAddrAsDoubleX2# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)
readFloatOffAddrAsFloatX8# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)
readDoubleOffAddrAsDoubleX4# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)
readFloatOffAddrAsFloatX16# = let x = x in x

-- | Reads vector; offset in scalar elements. 

readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)
readDoubleOffAddrAsDoubleX8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s
writeInt8OffAddrAsInt8X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s
writeInt16OffAddrAsInt16X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s
writeInt32OffAddrAsInt32X4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s
writeInt64OffAddrAsInt64X2# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s
writeInt8OffAddrAsInt8X32# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s
writeInt16OffAddrAsInt16X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s
writeInt32OffAddrAsInt32X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s
writeInt64OffAddrAsInt64X4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s
writeInt8OffAddrAsInt8X64# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s
writeInt16OffAddrAsInt16X32# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s
writeInt32OffAddrAsInt32X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s
writeInt64OffAddrAsInt64X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s
writeWord8OffAddrAsWord8X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s
writeWord16OffAddrAsWord16X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s
writeWord32OffAddrAsWord32X4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s
writeWord64OffAddrAsWord64X2# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s
writeWord8OffAddrAsWord8X32# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s
writeWord16OffAddrAsWord16X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s
writeWord32OffAddrAsWord32X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s
writeWord64OffAddrAsWord64X4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s
writeWord8OffAddrAsWord8X64# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s
writeWord16OffAddrAsWord16X32# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s
writeWord32OffAddrAsWord32X16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s
writeWord64OffAddrAsWord64X8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s
writeFloatOffAddrAsFloatX4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleOffAddrAsDoubleX2# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s
writeFloatOffAddrAsFloatX8# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s
writeDoubleOffAddrAsDoubleX4# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s
writeFloatOffAddrAsFloatX16# = let x = x in x

-- | Write vector; offset in scalar elements. 

writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s
writeDoubleOffAddrAsDoubleX8# = let x = x in x

prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#
prefetchByteArray3# = let x = x in x

prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray3# = let x = x in x

prefetchAddr3# :: Addr# -> Int# -> Addr#
prefetchAddr3# = let x = x in x

prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#
prefetchByteArray2# = let x = x in x

prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray2# = let x = x in x

prefetchAddr2# :: Addr# -> Int# -> Addr#
prefetchAddr2# = let x = x in x

prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#
prefetchByteArray1# = let x = x in x

prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray1# = let x = x in x

prefetchAddr1# :: Addr# -> Int# -> Addr#
prefetchAddr1# = let x = x in x

prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#
prefetchByteArray0# = let x = x in x

prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray0# = let x = x in x

prefetchAddr0# :: Addr# -> Int# -> Addr#
prefetchAddr0# = let x = x in x