Export (0) Print
Expand All
0 out of 1 rated this helpful - Rate this topic

x86 Intrinsics List

This document lists intrinsics that the Visual C++ compiler supports when x86 is targeted.

For information about individual intrinsics, see these resources, as appropriate for the processor you're targeting:

Intrinsic name

Function prototype

__addfsbyte

void __addfsbyte(unsigned long, unsigned char);

__addfsdword

void __addfsdword(unsigned long, unsigned long);

__addfsword

void __addfsword(unsigned long, unsigned short);

__code_seg

void __code_seg(const char *);

__cpuid

void __cpuid(int[4], int);

__cpuidex

void __cpuidex(int[4], int, int);

__debugbreak

void __cdecl __debugbreak(void);

__emul

__int64 __emul(int, int);

__emulu

unsigned __int64 __emulu(unsigned int, unsigned int);

__fastfail

void __fastfail(unsigned int);

__getcallerseflags

unsigned int __getcallerseflags(void);

__halt

void __halt(void);

__inbyte

unsigned char __inbyte(unsigned short);

__inbytestring

void __inbytestring(unsigned short, unsigned char *, unsigned long);

__incfsbyte

void __incfsbyte(unsigned long);

__incfsdword

void __incfsdword(unsigned long);

__incfsword

void __incfsword(unsigned long);

__indword

unsigned long __indword(unsigned short);

__indwordstring

void __indwordstring(unsigned short, unsigned long *, unsigned long);

__int2c

void __int2c(void);

__invlpg

void __invlpg(void *);

__inword

unsigned short __inword(unsigned short);

__inwordstring

void __inwordstring(unsigned short, unsigned short *, unsigned long);

__lidt

void __lidt(void *);

__ll_lshift

unsigned __int64 __ll_lshift(unsigned __int64, int);

__ll_rshift

__int64 __ll_rshift(__int64, int);

__llwpcb

void __llwpcb(void *);

__lwpins32

unsigned char __lwpins32(unsigned int, unsigned int, unsigned int);

__lwpval32

void __lwpval32(unsigned int, unsigned int, unsigned int);

__lzcnt

unsigned int __lzcnt(unsigned int);

__lzcnt16

unsigned short __lzcnt16(unsigned short);

__movsb

void __movsb(unsigned char *, unsigned char const *, size_t);

__movsd

void __movsd(unsigned long *, unsigned long const *, size_t);

__movsw

void __movsw(unsigned short *, unsigned short const *, size_t);

__nop

void __nop(void);

__nvreg_restore_fence

void __nvreg_restore_fence(void);

__nvreg_save_fence

void __nvreg_save_fence(void);

__outbyte

void __outbyte(unsigned short, unsigned char);

__outbytestring

void __outbytestring(unsigned short, unsigned char *, unsigned long);

__outdword

void __outdword(unsigned short, unsigned long);

__outdwordstring

void __outdwordstring(unsigned short, unsigned long *, unsigned long);

__outword

void __outword(unsigned short, unsigned short);

__outwordstring

void __outwordstring(unsigned short, unsigned short *, unsigned long);

__popcnt

unsigned int __popcnt(unsigned int);

__popcnt16

unsigned short __popcnt16(unsigned short);

__rdtsc

unsigned __int64 __rdtsc(void);

__rdtscp

unsigned __int64 __rdtscp(unsigned int *);

__readcr0

unsigned long __readcr0(void);

__readcr2

unsigned long __readcr2(void);

__readcr3

unsigned long __readcr3(void);

__readcr4

unsigned long __readcr4(void);

__readcr8

unsigned long __readcr8(void);

__readdr

unsigned int __readdr(unsigned int);

__readeflags

unsigned int __readeflags(void);

__readfsbyte

unsigned char __readfsbyte(unsigned long);

__readfsdword

unsigned long __readfsdword(unsigned long);

__readfsqword

unsigned __int64 __readfsqword(unsigned long);

__readfsword

unsigned short __readfsword(unsigned long);

__readmsr

unsigned __int64 __readmsr(unsigned long);

__readpmc

unsigned __int64 __readpmc(unsigned long);

__segmentlimit

unsigned long __segmentlimit(unsigned long);

__sidt

void __sidt(void *);

__slwpcb

void *__slwpcb();

__stosb

void __stosb(unsigned char *, unsigned char, size_t);

__stosd

void __stosd(unsigned long *, unsigned long, size_t);

__stosw

void __stosw(unsigned short *, unsigned short, size_t);

__svm_clgi

void __svm_clgi(void);

__svm_invlpga

void __svm_invlpga(void *, int);

__svm_skinit

void __svm_skinit(int);

__svm_stgi

void __svm_stgi(void);

__svm_vmload

void __svm_vmload(size_t);

__svm_vmrun

void __svm_vmrun(size_t);

__svm_vmsave

void __svm_vmsave(size_t);

__ud2

void __ud2(void);

__ull_rshift

unsigned __int64 __ull_rshift(unsigned __int64, int);

__vmx_off

void __vmx_off(void);

__vmx_vmptrst

void __vmx_vmptrst(unsigned __int64 *);

__wbinvd

void __wbinvd(void);

__writecr0

void __writecr0(unsigned int);

__writecr3

void __writecr3(unsigned int);

__writecr4

void __writecr4(unsigned int);

__writecr8

void __writecr8(unsigned int);

__writedr

void __writedr(unsigned int, unsigned int);

__writeeflags

void __writeeflags(unsigned int);

__writefsbyte

void __writefsbyte(unsigned long, unsigned char);

__writefsdword

void __writefsdword(unsigned long, unsigned long);

__writefsqword

void __writefsqword(unsigned long, unsigned __int64);

__writefsword

void __writefsword(unsigned long, unsigned short);

__writemsr

void __writemsr(unsigned long, unsigned __int64);

_AddressOfReturnAddress

void * _AddressOfReturnAddress(void);

_andn_u32

unsigned int _andn_u32(unsigned int, unsigned int);

_bextr_u32

unsigned int _bextr_u32(unsigned int, unsigned int, unsigned int );

_bextr_u32

unsigned int _bextr_u32(unsigned int, unsigned int, unsigned int);

_bextri_u32

unsigned int _bextri_u32(unsigned int, unsigned int);

_BitScanForward

unsigned char _BitScanForward(unsigned long * _Index, unsigned long _Mask);

_BitScanReverse

unsigned char _BitScanReverse(unsigned long * _Index, unsigned long _Mask);

_bittest

unsigned char _bittest(long const *, long);

_bittestandcomplement

unsigned char _bittestandcomplement(long *, long);

_bittestandreset

unsigned char _bittestandreset(long *, long);

_bittestandset

unsigned char _bittestandset(long *, long);

_blcfill_u32

unsigned int _blcfill_u32(unsigned int);

_blci_u32

unsigned int _blci_u32(unsigned int);

_blcic_u32

unsigned int _blcic_u32(unsigned int);

_blcmsk_u32

unsigned int _blcmsk_u32(unsigned int);

_blcs_u32

unsigned int _blcs_u32(unsigned int);

_blsfill_u32

unsigned int _blsfill_u32(unsigned int);

_blsi_u32

unsigned int _blsi_u32(unsigned int);

_blsi_u32

unsigned int _blsi_u32(unsigned int);

_blsic_u32

unsigned int _blsic_u32(unsigned int);

_blsmsk_u32

unsigned int _blsmsk_u32(unsigned int);

_blsmsk_u32

unsigned int _blsmsk_u32(unsigned int);

_blsr_u32

unsigned int _blsr_u32(unsigned int);

_blsr_u32

unsigned int _blsr_u32(unsigned int);

_byteswap_uint64

unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64);

_byteswap_ulong

unsigned long __cdecl _byteswap_ulong(unsigned long);

_byteswap_ushort

unsigned short __cdecl _byteswap_ushort(unsigned short);

_bzhi_u32

unsigned int _bzhi_u32(unsigned int, unsigned int );

_disable

void __cdecl _disable(void);

_enable

void __cdecl _enable(void);

_fxrstor

void __cdecl _fxrstor(void const *);

_fxsave

void __cdecl _fxsave(void *);

_InterlockedAddLargeStatistic

long _InterlockedAddLargeStatistic(__int64 volatile * _Addend, long _Value);

_InterlockedAnd

long _InterlockedAnd(long volatile * _Value, long _Mask);

_InterlockedAnd16

short _InterlockedAnd16(short volatile * _Value, short _Mask);

_InterlockedAnd8

char _InterlockedAnd8(char volatile * _Value, char _Mask);

_interlockedbittestandreset

unsigned char _interlockedbittestandreset(long volatile *, long);

_interlockedbittestandset

unsigned char _interlockedbittestandset(long volatile *, long);

_InterlockedCompareExchange

long __cdecl _InterlockedCompareExchange(long volatile * _Destination, long _Exchange, long _Comparand);

_InterlockedCompareExchange_HLEAcquire

long _InterlockedCompareExchange_HLEAcquire(long volatile *,long,long);

_InterlockedCompareExchange_HLERelease

long _InterlockedCompareExchange_HLERelease(long volatile *,long,long);

_InterlockedCompareExchange16

short _InterlockedCompareExchange16(short volatile * _Destination, short _Exchange, short _Comparand);

_InterlockedCompareExchange64

__int64 _InterlockedCompareExchange64(__int64 volatile * _Destination, __int64 _Exchange, __int64 _Comparand);

_InterlockedCompareExchange64_HLEAcquire

__int64 _InterlockedCompareExchange64_HLEAcquire(__int64 volatile *,__int64,__int64);

_InterlockedCompareExchange64_HLERelease

__int64 _InterlockedCompareExchange64_HLERelease(__int64 volatile *,__int64,__int64);

_InterlockedCompareExchange8

char _InterlockedCompareExchange8(char volatile * _Destination, char _Exchange, char _Comparand);

_InterlockedCompareExchangePointer_HLEAcquire

void *_InterlockedCompareExchangePointer_HLEAcquire(void *volatile *,void *,void *);

_InterlockedCompareExchangePointer_HLERelease

void *_InterlockedCompareExchangePointer_HLERelease(void *volatile *,void *,void *);

_InterlockedDecrement

long __cdecl _InterlockedDecrement(long volatile * _Addend);

_InterlockedDecrement16

short _InterlockedDecrement16(short volatile * _Addend);

_InterlockedExchange

long __cdecl _InterlockedExchange(long volatile * _Target, long _Value);

_InterlockedExchange16

short _InterlockedExchange16(short volatile * _Target, short _Value);

_InterlockedExchange8

char _InterlockedExchange8(char volatile * _Target, char _Value);

_InterlockedExchangeAdd

long __cdecl _InterlockedExchangeAdd(long volatile * _Addend, long _Value);

_InterlockedExchangeAdd_HLEAcquire

long _InterlockedExchangeAdd_HLEAcquire(long volatile *,long);

_InterlockedExchangeAdd_HLERelease

long _InterlockedExchangeAdd_HLERelease(long volatile *,long);

_InterlockedExchangeAdd16

short _InterlockedExchangeAdd16(short volatile * _Addend, short _Value);

_InterlockedExchangeAdd64_HLEAcquire

__int64 _InterlockedExchangeAdd64_HLEAcquire(__int64 volatile *,__int64);

_InterlockedExchangeAdd64_HLERelease

__int64 _InterlockedExchangeAdd64_HLERelease(__int64 volatile *,__int64);

_InterlockedExchangeAdd8

char _InterlockedExchangeAdd8(char volatile * _Addend, char _Value);

_InterlockedIncrement

long __cdecl _InterlockedIncrement(long volatile * _Addend);

_InterlockedIncrement16

short _InterlockedIncrement16(short volatile * _Addend);

_InterlockedOr

long _InterlockedOr(long volatile * _Value, long _Mask);

_InterlockedOr16

short _InterlockedOr16(short volatile * _Value, short _Mask);

_InterlockedOr8

char _InterlockedOr8(char volatile * _Value, char _Mask);

_InterlockedXor

long _InterlockedXor(long volatile * _Value, long _Mask);

_InterlockedXor16

short _InterlockedXor16(short volatile * _Value, short _Mask);

_InterlockedXor8

char _InterlockedXor8(char volatile * _Value, char _Mask);

_invpcid

void __cdecl _invpcid(unsigned int, void * );

_lrotl

unsigned long __cdecl _lrotl(unsigned long, int);

_lrotr

unsigned long __cdecl _lrotr(unsigned long, int);

_lzcnt_u32

unsigned int _lzcnt_u32(unsigned int);

_lzcnt_u32

unsigned int _lzcnt_u32(unsigned int);

_m_empty

void _m_empty(void);

_m_empty

void _m_empty(void);

_m_femms

void _m_femms(void);

_m_femms

void _m_femms(void);

_m_from_float

__m64 _m_from_float(float);

_m_from_float

__m64 _m_from_float(float);

_m_from_int

__m64 _m_from_int(int _I);

_m_from_int

__m64 _m_from_int(int);

_m_maskmovq

void _m_maskmovq(__m64, __m64, char *);

_m_maskmovq

void _m_maskmovq(__m64, __m64, char *);

_m_packssdw

__m64 _m_packssdw(__m64 _MM1, __m64 _MM2);

_m_packssdw

__m64 _m_packssdw(__m64, __m64);

_m_packsswb

__m64 _m_packsswb(__m64 _MM1, __m64 _MM2);

_m_packsswb

__m64 _m_packsswb(__m64, __m64);

_m_packuswb

__m64 _m_packuswb(__m64 _MM1, __m64 _MM2);

_m_packuswb

__m64 _m_packuswb(__m64, __m64);

_m_paddb

__m64 _m_paddb(__m64 _MM1, __m64 _MM2);

_m_paddb

__m64 _m_paddb(__m64, __m64);

_m_paddd

__m64 _m_paddd(__m64 _MM1, __m64 _MM2);

_m_paddd

__m64 _m_paddd(__m64, __m64);

_m_paddsb

__m64 _m_paddsb(__m64 _MM1, __m64 _MM2);

_m_paddsb

__m64 _m_paddsb(__m64, __m64);

_m_paddsw

__m64 _m_paddsw(__m64 _MM1, __m64 _MM2);

_m_paddsw

__m64 _m_paddsw(__m64, __m64);

_m_paddusb

__m64 _m_paddusb(__m64 _MM1, __m64 _MM2);

_m_paddusb

__m64 _m_paddusb(__m64, __m64);

_m_paddusw

__m64 _m_paddusw(__m64 _MM1, __m64 _MM2);

_m_paddusw

__m64 _m_paddusw(__m64, __m64);

_m_paddw

__m64 _m_paddw(__m64 _MM1, __m64 _MM2);

_m_paddw

__m64 _m_paddw(__m64, __m64);

_m_pand

__m64 _m_pand(__m64 _MM1, __m64 _MM2);

_m_pand

__m64 _m_pand(__m64, __m64);

_m_pandn

__m64 _m_pandn(__m64 _MM1, __m64 _MM2);

_m_pandn

__m64 _m_pandn(__m64, __m64);

_m_pavgb

__m64 _m_pavgb(__m64, __m64);

_m_pavgb

__m64 _m_pavgb(__m64, __m64);

_m_pavgusb

__m64 _m_pavgusb(__m64, __m64);

_m_pavgusb

__m64 _m_pavgusb(__m64, __m64);

_m_pavgw

__m64 _m_pavgw(__m64, __m64);

_m_pavgw

__m64 _m_pavgw(__m64, __m64);

_m_pcmpeqb

__m64 _m_pcmpeqb(__m64 _MM1, __m64 _MM2);

_m_pcmpeqb

__m64 _m_pcmpeqb(__m64, __m64);

_m_pcmpeqd

__m64 _m_pcmpeqd(__m64 _MM1, __m64 _MM2);

_m_pcmpeqd

__m64 _m_pcmpeqd(__m64, __m64);

_m_pcmpeqw

__m64 _m_pcmpeqw(__m64 _MM1, __m64 _MM2);

_m_pcmpeqw

__m64 _m_pcmpeqw(__m64, __m64);

_m_pcmpgtb

__m64 _m_pcmpgtb(__m64 _MM1, __m64 _MM2);

_m_pcmpgtb

__m64 _m_pcmpgtb(__m64, __m64);

_m_pcmpgtd

__m64 _m_pcmpgtd(__m64 _MM1, __m64 _MM2);

_m_pcmpgtd

__m64 _m_pcmpgtd(__m64, __m64);

_m_pcmpgtw

__m64 _m_pcmpgtw(__m64 _MM1, __m64 _MM2);

_m_pcmpgtw

__m64 _m_pcmpgtw(__m64, __m64);

_m_pextrw

int _m_pextrw(__m64, int);

_m_pextrw

int _m_pextrw(__m64, int);

_m_pf2id

__m64 _m_pf2id(__m64);

_m_pf2id

__m64 _m_pf2id(__m64);

_m_pf2iw

__m64 _m_pf2iw(__m64);

_m_pf2iw

__m64 _m_pf2iw(__m64);

_m_pfacc

__m64 _m_pfacc(__m64, __m64);

_m_pfacc

__m64 _m_pfacc(__m64, __m64);

_m_pfadd

__m64 _m_pfadd(__m64, __m64);

_m_pfadd

__m64 _m_pfadd(__m64, __m64);

_m_pfcmpeq

__m64 _m_pfcmpeq(__m64, __m64);

_m_pfcmpeq

__m64 _m_pfcmpeq(__m64, __m64);

_m_pfcmpge

__m64 _m_pfcmpge(__m64, __m64);

_m_pfcmpge

__m64 _m_pfcmpge(__m64, __m64);

_m_pfcmpgt

__m64 _m_pfcmpgt(__m64, __m64);

_m_pfcmpgt

__m64 _m_pfcmpgt(__m64, __m64);

_m_pfmax

__m64 _m_pfmax(__m64, __m64);

_m_pfmax

__m64 _m_pfmax(__m64, __m64);

_m_pfmin

__m64 _m_pfmin(__m64, __m64);

_m_pfmin

__m64 _m_pfmin(__m64, __m64);

_m_pfmul

__m64 _m_pfmul(__m64, __m64);

_m_pfmul

__m64 _m_pfmul(__m64, __m64);

_m_pfnacc

__m64 _m_pfnacc(__m64, __m64);

_m_pfnacc

__m64 _m_pfnacc(__m64, __m64);

_m_pfpnacc

__m64 _m_pfpnacc(__m64, __m64);

_m_pfpnacc

__m64 _m_pfpnacc(__m64, __m64);

_m_pfrcp

__m64 _m_pfrcp(__m64);

_m_pfrcp

__m64 _m_pfrcp(__m64);

_m_pfrcpit1

__m64 _m_pfrcpit1(__m64, __m64);

_m_pfrcpit1

__m64 _m_pfrcpit1(__m64, __m64);

_m_pfrcpit2

__m64 _m_pfrcpit2(__m64, __m64);

_m_pfrcpit2

__m64 _m_pfrcpit2(__m64, __m64);

_m_pfrsqit1

__m64 _m_pfrsqit1(__m64, __m64);

_m_pfrsqit1

__m64 _m_pfrsqit1(__m64, __m64);

_m_pfrsqrt

__m64 _m_pfrsqrt(__m64);

_m_pfrsqrt

__m64 _m_pfrsqrt(__m64);

_m_pfsub

__m64 _m_pfsub(__m64, __m64);

_m_pfsub

__m64 _m_pfsub(__m64, __m64);

_m_pfsubr

__m64 _m_pfsubr(__m64, __m64);

_m_pfsubr

__m64 _m_pfsubr(__m64, __m64);

_m_pi2fd

__m64 _m_pi2fd(__m64);

_m_pi2fd

__m64 _m_pi2fd(__m64);

_m_pi2fw

__m64 _m_pi2fw(__m64);

_m_pi2fw

__m64 _m_pi2fw(__m64);

_m_pinsrw

__m64 _m_pinsrw(__m64, int, int);

_m_pinsrw

__m64 _m_pinsrw(__m64, int, int);

_m_pmaddwd

__m64 _m_pmaddwd(__m64 _MM1, __m64 _MM2);

_m_pmaddwd

__m64 _m_pmaddwd(__m64, __m64);

_m_pmaxsw

__m64 _m_pmaxsw(__m64, __m64);

_m_pmaxsw

__m64 _m_pmaxsw(__m64, __m64);

_m_pmaxub

__m64 _m_pmaxub(__m64, __m64);

_m_pmaxub

__m64 _m_pmaxub(__m64, __m64);

_m_pminsw

__m64 _m_pminsw(__m64, __m64);

_m_pminsw

__m64 _m_pminsw(__m64, __m64);

_m_pminub

__m64 _m_pminub(__m64, __m64);

_m_pminub

__m64 _m_pminub(__m64, __m64);

_m_pmovmskb

int _m_pmovmskb(__m64);

_m_pmovmskb

int _m_pmovmskb(__m64);

_m_pmulhrw

__m64 _m_pmulhrw(__m64, __m64);

_m_pmulhrw

__m64 _m_pmulhrw(__m64, __m64);

_m_pmulhuw

__m64 _m_pmulhuw(__m64, __m64);

_m_pmulhuw

__m64 _m_pmulhuw(__m64, __m64);

_m_pmulhw

__m64 _m_pmulhw(__m64 _MM1, __m64 _MM2);

_m_pmulhw

__m64 _m_pmulhw(__m64, __m64);

_m_pmullw

__m64 _m_pmullw(__m64 _MM1, __m64 _MM2);

_m_pmullw

__m64 _m_pmullw(__m64, __m64);

_m_por

__m64 _m_por(__m64 _MM1, __m64 _MM2);

_m_por

__m64 _m_por(__m64, __m64);

_m_prefetch

void _m_prefetch(void *);

_m_prefetch

void _m_prefetch(void*);

_m_prefetchw

void _m_prefetchw(volatile const void *);

_m_prefetchw

void _m_prefetchw(volatile const void*_Source);

_m_psadbw

__m64 _m_psadbw(__m64, __m64);

_m_psadbw

__m64 _m_psadbw(__m64, __m64);

_m_pshufw

__m64 _m_pshufw(__m64, int);

_m_pshufw

__m64 _m_pshufw(__m64, int);

_m_pslld

__m64 _m_pslld(__m64 _M, __m64 _Count);

_m_pslld

__m64 _m_pslld(__m64, __m64);

_m_pslldi

__m64 _m_pslldi(__m64 _M, int _Count);

_m_pslldi

__m64 _m_pslldi(__m64, int);

_m_psllq

__m64 _m_psllq(__m64 _M, __m64 _Count);

_m_psllq

__m64 _m_psllq(__m64, __m64);

_m_psllqi

__m64 _m_psllqi(__m64 _M, int _Count);

_m_psllqi

__m64 _m_psllqi(__m64, int);

_m_psllw

__m64 _m_psllw(__m64 _M, __m64 _Count);

_m_psllw

__m64 _m_psllw(__m64, __m64);

_m_psllwi

__m64 _m_psllwi(__m64 _M, int _Count);

_m_psllwi

__m64 _m_psllwi(__m64, int);

_m_psrad

__m64 _m_psrad(__m64 _M, __m64 _Count);

_m_psrad

__m64 _m_psrad(__m64, __m64);

_m_psradi

__m64 _m_psradi(__m64 _M, int _Count);

_m_psradi

__m64 _m_psradi(__m64, int);

_m_psraw

__m64 _m_psraw(__m64 _M, __m64 _Count);

_m_psraw

__m64 _m_psraw(__m64, __m64);

_m_psrawi

__m64 _m_psrawi(__m64 _M, int _Count);

_m_psrawi

__m64 _m_psrawi(__m64, int);

_m_psrld

__m64 _m_psrld(__m64 _M, __m64 _Count);

_m_psrld

__m64 _m_psrld(__m64, __m64);

_m_psrldi

__m64 _m_psrldi(__m64 _M, int _Count);

_m_psrldi

__m64 _m_psrldi(__m64, int);

_m_psrlq

__m64 _m_psrlq(__m64 _M, __m64 _Count);

_m_psrlq

__m64 _m_psrlq(__m64, __m64);

_m_psrlqi

__m64 _m_psrlqi(__m64 _M, int _Count);

_m_psrlqi

__m64 _m_psrlqi(__m64, int);

_m_psrlw

__m64 _m_psrlw(__m64 _M, __m64 _Count);

_m_psrlw

__m64 _m_psrlw(__m64, __m64);

_m_psrlwi

__m64 _m_psrlwi(__m64 _M, int _Count);

_m_psrlwi

__m64 _m_psrlwi(__m64, int);

_m_psubb

__m64 _m_psubb(__m64 _MM1, __m64 _MM2);

_m_psubb

__m64 _m_psubb(__m64, __m64);

_m_psubd

__m64 _m_psubd(__m64 _MM1, __m64 _MM2);

_m_psubd

__m64 _m_psubd(__m64, __m64);

_m_psubsb

__m64 _m_psubsb(__m64 _MM1, __m64 _MM2);

_m_psubsb

__m64 _m_psubsb(__m64, __m64);

_m_psubsw

__m64 _m_psubsw(__m64 _MM1, __m64 _MM2);

_m_psubsw

__m64 _m_psubsw(__m64, __m64);

_m_psubusb

__m64 _m_psubusb(__m64 _MM1, __m64 _MM2);

_m_psubusb

__m64 _m_psubusb(__m64, __m64);

_m_psubusw

__m64 _m_psubusw(__m64 _MM1, __m64 _MM2);

_m_psubusw

__m64 _m_psubusw(__m64, __m64);

_m_psubw

__m64 _m_psubw(__m64 _MM1, __m64 _MM2);

_m_psubw

__m64 _m_psubw(__m64, __m64);

_m_pswapd

__m64 _m_pswapd(__m64);

_m_pswapd

__m64 _m_pswapd(__m64);

_m_punpckhbw

__m64 _m_punpckhbw(__m64 _MM1, __m64 _MM2);

_m_punpckhbw

__m64 _m_punpckhbw(__m64, __m64);

_m_punpckhdq

__m64 _m_punpckhdq(__m64 _MM1, __m64 _MM2);

_m_punpckhdq

__m64 _m_punpckhdq(__m64, __m64);

_m_punpckhwd

__m64 _m_punpckhwd(__m64 _MM1, __m64 _MM2);

_m_punpckhwd

__m64 _m_punpckhwd(__m64, __m64);

_m_punpcklbw

__m64 _m_punpcklbw(__m64 _MM1, __m64 _MM2);

_m_punpcklbw

__m64 _m_punpcklbw(__m64, __m64);

_m_punpckldq

__m64 _m_punpckldq(__m64 _MM1, __m64 _MM2);

_m_punpckldq

__m64 _m_punpckldq(__m64, __m64);

_m_punpcklwd

__m64 _m_punpcklwd(__m64 _MM1, __m64 _MM2);

_m_punpcklwd

__m64 _m_punpcklwd(__m64, __m64);

_m_pxor

__m64 _m_pxor(__m64 _MM1, __m64 _MM2);

_m_pxor

__m64 _m_pxor(__m64, __m64);

_m_to_float

float _m_to_float(__m64);

_m_to_float

float _m_to_float(__m64);

_m_to_int

int _m_to_int(__m64 _M);

_m_to_int

int _m_to_int(__m64);

_mm_abs_epi16

__m128i _mm_abs_epi16(__m128i a);

_mm_abs_epi16

__m128i _mm_abs_epi16(__m128i);

_mm_abs_epi32

__m128i _mm_abs_epi32(__m128i a);

_mm_abs_epi32

__m128i _mm_abs_epi32(__m128i);

_mm_abs_epi8

__m128i _mm_abs_epi8(__m128i a);

_mm_abs_epi8

__m128i _mm_abs_epi8(__m128i);

_mm_abs_pi16

__m64 _mm_abs_pi16(__m64 a);

_mm_abs_pi16

__m64 _mm_abs_pi16(__m64);

_mm_abs_pi32

__m64 _mm_abs_pi32(__m64 a);

_mm_abs_pi32

__m64 _mm_abs_pi32(__m64);

_mm_abs_pi8

__m64 _mm_abs_pi8(__m64 a);

_mm_abs_pi8

__m64 _mm_abs_pi8(__m64);

_mm_add_epi16

__m128i _mm_add_epi16(__m128i _A, __m128i _B);

_mm_add_epi16

__m128i _mm_add_epi16(__m128i, __m128i);

_mm_add_epi32

__m128i _mm_add_epi32(__m128i _A, __m128i _B);

_mm_add_epi32

__m128i _mm_add_epi32(__m128i, __m128i);

_mm_add_epi64

__m128i _mm_add_epi64(__m128i _A, __m128i _B);

_mm_add_epi64

__m128i _mm_add_epi64(__m128i, __m128i);

_mm_add_epi8

__m128i _mm_add_epi8(__m128i _A, __m128i _B);

_mm_add_epi8

__m128i _mm_add_epi8(__m128i, __m128i);

_mm_add_pd

__m128d _mm_add_pd(__m128d _A, __m128d _B);

_mm_add_pd

__m128d _mm_add_pd(__m128d, __m128d);

_mm_add_ps

__m128 _mm_add_ps(__m128 _A, __m128 _B);

_mm_add_ps

__m128 _mm_add_ps(__m128, __m128);

_mm_add_sd

__m128d _mm_add_sd(__m128d _A, __m128d _B);

_mm_add_sd

__m128d _mm_add_sd(__m128d, __m128d);

_mm_add_si64

__m64 _mm_add_si64(__m64 _A, __m64 _B);

_mm_add_si64

__m64 _mm_add_si64(__m64, __m64);

_mm_add_ss

__m128 _mm_add_ss(__m128 _A, __m128 _B);

_mm_add_ss

__m128 _mm_add_ss(__m128, __m128);

_mm_adds_epi16

__m128i _mm_adds_epi16(__m128i _A, __m128i _B);

_mm_adds_epi16

__m128i _mm_adds_epi16(__m128i, __m128i);

_mm_adds_epi8

__m128i _mm_adds_epi8(__m128i _A, __m128i _B);

_mm_adds_epi8

__m128i _mm_adds_epi8(__m128i, __m128i);

_mm_adds_epu16

__m128i _mm_adds_epu16(__m128i _A, __m128i _B);

_mm_adds_epu16

__m128i _mm_adds_epu16(__m128i, __m128i);

_mm_adds_epu8

__m128i _mm_adds_epu8(__m128i _A, __m128i _B);

_mm_adds_epu8

__m128i _mm_adds_epu8(__m128i, __m128i);

_mm_addsub_pd

__m128d _mm_addsub_pd(__m128d a, __m128d b);

_mm_addsub_pd

__m128d _mm_addsub_pd(__m128d, __m128d);

_mm_addsub_ps

__m128 _mm_addsub_ps(__m128 a, __m128 b);

_mm_addsub_ps

__m128 _mm_addsub_ps(__m128, __m128);

_mm_aesdec_si128

__m128i _mm_aesdec_si128(__m128i v, __m128i rkey);

_mm_aesdeclast_si128

__m128i _mm_aesdeclast_si128(__m128i v, __m128i rkey);

_mm_aesenc_si128

__m128i _mm_aesenc_si128(__m128i v, __m128i rkey);

_mm_aesenclast_si128

__m128i _mm_aesenclast_si128(__m128i v, __m128i rkey);

_mm_aesimc_si128

__m128i _mm_aesimc_si128(__m128i v);

_mm_aeskeygenassist_si128

__m128i _mm_aeskeygenassist_si128(__m128i ckey, const int rcon);

_mm_alignr_epi8

__m128i _mm_alignr_epi8(__m128i a, __m128i b, int n);

_mm_alignr_epi8

__m128i _mm_alignr_epi8(__m128i, __m128i, int);

_mm_alignr_pi8

__m64 _mm_alignr_pi8(__m64 a, __m64 b, int n);

_mm_alignr_pi8

__m64 _mm_alignr_pi8(__m64, __m64, int);

_mm_and_pd

__m128d _mm_and_pd(__m128d _A, __m128d _B);

_mm_and_pd

__m128d _mm_and_pd(__m128d, __m128d);

_mm_and_ps

__m128 _mm_and_ps(__m128 _A, __m128 _B);

_mm_and_ps

__m128 _mm_and_ps(__m128, __m128);

_mm_and_si128

__m128i _mm_and_si128(__m128i _A, __m128i _B);

_mm_and_si128

__m128i _mm_and_si128(__m128i, __m128i);

_mm_andnot_pd

__m128d _mm_andnot_pd(__m128d _A, __m128d _B);

_mm_andnot_pd

__m128d _mm_andnot_pd(__m128d, __m128d);

_mm_andnot_ps

__m128 _mm_andnot_ps(__m128 _A, __m128 _B);

_mm_andnot_ps

__m128 _mm_andnot_ps(__m128, __m128);

_mm_andnot_si128

__m128i _mm_andnot_si128(__m128i _A, __m128i _B);

_mm_andnot_si128

__m128i _mm_andnot_si128(__m128i, __m128i);

_mm_avg_epu16

__m128i _mm_avg_epu16(__m128i _A, __m128i _B);

_mm_avg_epu16

__m128i _mm_avg_epu16(__m128i, __m128i);

_mm_avg_epu8

__m128i _mm_avg_epu8(__m128i _A, __m128i _B);

_mm_avg_epu8

__m128i _mm_avg_epu8(__m128i, __m128i);

_mm_blend_epi16

__m128i _mm_blend_epi16(__m128i v1, __m128i v2, const int mask);

_mm_blend_epi16

__m128i _mm_blend_epi16(__m128i, __m128i, int);

_mm_blend_epi32

__m128i __cdecl _mm_blend_epi32(__m128i, __m128i, const int);

_mm_blend_pd

__m128d _mm_blend_pd(__m128d v1, __m128d v2, const int mask);

_mm_blend_pd

__m128d _mm_blend_pd(__m128d, __m128d, int);

_mm_blend_ps

__m128 _mm_blend_ps(__m128 v1, __m128 v2, const int mask);

_mm_blend_ps

__m128 _mm_blend_ps(__m128, __m128, int);

_mm_blendv_epi8

__m128i _mm_blendv_epi8(__m128i v1, __m128i v2, __m128i mask);

_mm_blendv_epi8

__m128i _mm_blendv_epi8(__m128i, __m128i, __m128i);

_mm_blendv_pd

__m128d _mm_blendv_pd(__m128d v1, __m128d v2, __m128d v3);

_mm_blendv_pd

__m128d _mm_blendv_pd(__m128d, __m128d, __m128d);

_mm_blendv_ps

__m128 _mm_blendv_ps(__m128 v1, __m128 v2, __m128 v3);

_mm_blendv_ps

__m128 _mm_blendv_ps(__m128, __m128, __m128);

_mm_broadcast_ss

__m128 __cdecl _mm_broadcast_ss(float const *);

_mm_broadcastb_epi8

__m128i __cdecl _mm_broadcastb_epi8(__m128i);

_mm_broadcastd_epi32

__m128i __cdecl _mm_broadcastd_epi32(__m128i);

_mm_broadcastq_epi64

__m128i __cdecl _mm_broadcastq_epi64(__m128i);

_mm_broadcastsd_pd

__m128d __cdecl _mm_broadcastsd_pd(__m128d);

_mm_broadcastss_ps

__m128 __cdecl _mm_broadcastss_ps(__m128);

_mm_broadcastw_epi16

__m128i __cdecl _mm_broadcastw_epi16(__m128i);

_mm_castpd_ps

__m128 _mm_castpd_ps(__m128d);

_mm_castpd_si128

__m128i _mm_castpd_si128(__m128d);

_mm_castps_pd

__m128d _mm_castps_pd(__m128);

_mm_castps_si128

__m128i _mm_castps_si128(__m128);

_mm_castsi128_pd

__m128d _mm_castsi128_pd(__m128i);

_mm_castsi128_ps

__m128 _mm_castsi128_ps(__m128i);

_mm_clflush

void _mm_clflush(void const *);

_mm_clflush

void _mm_clflush(void const*_P);

_mm_clmulepi64_si128

__m128i _mm_clmulepi64_si128(__m128i v1, __m128i v2, const int imm8);

_mm_cmov_si128

__m128i _mm_cmov_si128(__m128i, __m128i, __m128i);

_mm_cmp_pd

__m128d __cdecl _mm_cmp_pd(__m128d, __m128d, const int);

_mm_cmp_ps

__m128 __cdecl _mm_cmp_ps(__m128, __m128, const int);

_mm_cmp_sd

__m128d __cdecl _mm_cmp_sd(__m128d, __m128d, const int);

_mm_cmp_ss

__m128 __cdecl _mm_cmp_ss(__m128, __m128, const int);

_mm_cmpeq_epi16

__m128i _mm_cmpeq_epi16(__m128i _A, __m128i _B);

_mm_cmpeq_epi16

__m128i _mm_cmpeq_epi16(__m128i, __m128i);

_mm_cmpeq_epi32

__m128i _mm_cmpeq_epi32(__m128i _A, __m128i _B);

_mm_cmpeq_epi32

__m128i _mm_cmpeq_epi32(__m128i, __m128i);

_mm_cmpeq_epi64

__m128i _mm_cmpeq_epi64(__m128i val1, __m128i val2);

_mm_cmpeq_epi64

__m128i _mm_cmpeq_epi64(__m128i, __m128i);

_mm_cmpeq_epi8

__m128i _mm_cmpeq_epi8(__m128i _A, __m128i _B);

_mm_cmpeq_epi8

__m128i _mm_cmpeq_epi8(__m128i, __m128i);

_mm_cmpeq_pd

__m128d _mm_cmpeq_pd(__m128d _A, __m128d _B);

_mm_cmpeq_pd

__m128d _mm_cmpeq_pd(__m128d, __m128d);

_mm_cmpeq_ps

__m128 _mm_cmpeq_ps(__m128 _A, __m128 _B);

_mm_cmpeq_ps

__m128 _mm_cmpeq_ps(__m128, __m128);

_mm_cmpeq_sd

__m128d _mm_cmpeq_sd(__m128d _A, __m128d _B);

_mm_cmpeq_sd

__m128d _mm_cmpeq_sd(__m128d, __m128d);

_mm_cmpeq_ss

__m128 _mm_cmpeq_ss(__m128 _A, __m128 _B);

_mm_cmpeq_ss

__m128 _mm_cmpeq_ss(__m128, __m128);

_mm_cmpestra

int _mm_cmpestra(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestra

int _mm_cmpestra(__m128i, int, __m128i, int, int);

_mm_cmpestrc

int _mm_cmpestrc(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestrc

int _mm_cmpestrc(__m128i, int, __m128i, int, int);

_mm_cmpestri

int _mm_cmpestri(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestri

int _mm_cmpestri(__m128i, int, __m128i, int, int);

_mm_cmpestrm

__m128i _mm_cmpestrm(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestrm

__m128i _mm_cmpestrm(__m128i, int, __m128i, int, int);

_mm_cmpestro

int _mm_cmpestro(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestro

int _mm_cmpestro(__m128i, int, __m128i, int, int);

_mm_cmpestrs

int _mm_cmpestrs(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestrs

int _mm_cmpestrs(__m128i, int, __m128i, int, int);

_mm_cmpestrz

int _mm_cmpestrz(__m128i a, int la, __m128i b, int lb, const int mode);

_mm_cmpestrz

int _mm_cmpestrz(__m128i, int, __m128i, int, int);

_mm_cmpge_pd

__m128d _mm_cmpge_pd(__m128d _A, __m128d _B);

_mm_cmpge_pd

__m128d _mm_cmpge_pd(__m128d, __m128d);

_mm_cmpge_ps

__m128 _mm_cmpge_ps(__m128 _A, __m128 _B);

_mm_cmpge_ps

__m128 _mm_cmpge_ps(__m128, __m128);

_mm_cmpge_sd

__m128d _mm_cmpge_sd(__m128d _A, __m128d _B);

_mm_cmpge_sd

__m128d _mm_cmpge_sd(__m128d, __m128d);

_mm_cmpge_ss

__m128 _mm_cmpge_ss(__m128 _A, __m128 _B);

_mm_cmpge_ss

__m128 _mm_cmpge_ss(__m128, __m128);

_mm_cmpgt_epi16

__m128i _mm_cmpgt_epi16(__m128i _A, __m128i _B);

_mm_cmpgt_epi16

__m128i _mm_cmpgt_epi16(__m128i, __m128i);

_mm_cmpgt_epi32

__m128i _mm_cmpgt_epi32(__m128i _A, __m128i _B);

_mm_cmpgt_epi32

__m128i _mm_cmpgt_epi32(__m128i, __m128i);

_mm_cmpgt_epi64

__m128i _mm_cmpgt_epi64(__m128i val1, __m128i val2);

_mm_cmpgt_epi64

__m128i _mm_cmpgt_epi64(__m128i, __m128i);

_mm_cmpgt_epi8

__m128i _mm_cmpgt_epi8(__m128i _A, __m128i _B);

_mm_cmpgt_epi8

__m128i _mm_cmpgt_epi8(__m128i, __m128i);

_mm_cmpgt_pd

__m128d _mm_cmpgt_pd(__m128d _A, __m128d _B);

_mm_cmpgt_pd

__m128d _mm_cmpgt_pd(__m128d, __m128d);

_mm_cmpgt_ps

__m128 _mm_cmpgt_ps(__m128 _A, __m128 _B);

_mm_cmpgt_ps

__m128 _mm_cmpgt_ps(__m128, __m128);

_mm_cmpgt_sd

__m128d _mm_cmpgt_sd(__m128d _A, __m128d _B);

_mm_cmpgt_sd

__m128d _mm_cmpgt_sd(__m128d, __m128d);

_mm_cmpgt_ss

__m128 _mm_cmpgt_ss(__m128 _A, __m128 _B);

_mm_cmpgt_ss

__m128 _mm_cmpgt_ss(__m128, __m128);

_mm_cmpistra

int _mm_cmpistra(__m128i a, __m128i b, const int mode);

_mm_cmpistra

int _mm_cmpistra(__m128i, __m128i, int);

_mm_cmpistrc

int _mm_cmpistrc(__m128i a, __m128i b, const int mode);

_mm_cmpistrc

int _mm_cmpistrc(__m128i, __m128i, int);

_mm_cmpistri

int _mm_cmpistri(__m128i a, __m128i b, const int mode);

_mm_cmpistri

int _mm_cmpistri(__m128i, __m128i, int);

_mm_cmpistrm

__m128i _mm_cmpistrm(__m128i a, __m128i b, const int mode);

_mm_cmpistrm

__m128i _mm_cmpistrm(__m128i, __m128i, int);

_mm_cmpistro

int _mm_cmpistro(__m128i a, __m128i b, const int mode);

_mm_cmpistro

int _mm_cmpistro(__m128i, __m128i, int);

_mm_cmpistrs

int _mm_cmpistrs(__m128i a, __m128i b, const int mode);

_mm_cmpistrs

int _mm_cmpistrs(__m128i, __m128i, int);

_mm_cmpistrz

int _mm_cmpistrz(__m128i a, __m128i b, const int mode);

_mm_cmpistrz

int _mm_cmpistrz(__m128i, __m128i, int);

_mm_cmple_pd

__m128d _mm_cmple_pd(__m128d _A, __m128d _B);

_mm_cmple_pd

__m128d _mm_cmple_pd(__m128d, __m128d);

_mm_cmple_ps

__m128 _mm_cmple_ps(__m128 _A, __m128 _B);

_mm_cmple_ps

__m128 _mm_cmple_ps(__m128, __m128);

_mm_cmple_sd

__m128d _mm_cmple_sd(__m128d _A, __m128d _B);

_mm_cmple_sd

__m128d _mm_cmple_sd(__m128d, __m128d);

_mm_cmple_ss

__m128 _mm_cmple_ss(__m128 _A, __m128 _B);

_mm_cmple_ss

__m128 _mm_cmple_ss(__m128, __m128);

_mm_cmplt_epi16

__m128i _mm_cmplt_epi16(__m128i _A, __m128i _B);

_mm_cmplt_epi16

__m128i _mm_cmplt_epi16(__m128i, __m128i);

_mm_cmplt_epi32

__m128i _mm_cmplt_epi32(__m128i _A, __m128i _B);

_mm_cmplt_epi32

__m128i _mm_cmplt_epi32(__m128i, __m128i);

_mm_cmplt_epi8

__m128i _mm_cmplt_epi8(__m128i _A, __m128i _B);

_mm_cmplt_epi8

__m128i _mm_cmplt_epi8(__m128i, __m128i);

_mm_cmplt_pd

__m128d _mm_cmplt_pd(__m128d _A, __m128d _B);

_mm_cmplt_pd

__m128d _mm_cmplt_pd(__m128d, __m128d);

_mm_cmplt_ps

__m128 _mm_cmplt_ps(__m128 _A, __m128 _B);

_mm_cmplt_ps

__m128 _mm_cmplt_ps(__m128, __m128);

_mm_cmplt_sd

__m128d _mm_cmplt_sd(__m128d _A, __m128d _B);

_mm_cmplt_sd

__m128d _mm_cmplt_sd(__m128d, __m128d);

_mm_cmplt_ss

__m128 _mm_cmplt_ss(__m128 _A, __m128 _B);

_mm_cmplt_ss

__m128 _mm_cmplt_ss(__m128, __m128);

_mm_cmpneq_pd

__m128d _mm_cmpneq_pd(__m128d _A, __m128d _B);

_mm_cmpneq_pd

__m128d _mm_cmpneq_pd(__m128d, __m128d);

_mm_cmpneq_ps

__m128 _mm_cmpneq_ps(__m128 _A, __m128 _B);

_mm_cmpneq_ps

__m128 _mm_cmpneq_ps(__m128, __m128);

_mm_cmpneq_sd

__m128d _mm_cmpneq_sd(__m128d _A, __m128d _B);

_mm_cmpneq_sd

__m128d _mm_cmpneq_sd(__m128d, __m128d);

_mm_cmpneq_ss

__m128 _mm_cmpneq_ss(__m128 _A, __m128 _B);

_mm_cmpneq_ss

__m128 _mm_cmpneq_ss(__m128, __m128);

_mm_cmpnge_pd

__m128d _mm_cmpnge_pd(__m128d _A, __m128d _B);

_mm_cmpnge_pd

__m128d _mm_cmpnge_pd(__m128d, __m128d);

_mm_cmpnge_ps

__m128 _mm_cmpnge_ps(__m128 _A, __m128 _B);

_mm_cmpnge_ps

__m128 _mm_cmpnge_ps(__m128, __m128);

_mm_cmpnge_sd

__m128d _mm_cmpnge_sd(__m128d _A, __m128d _B);

_mm_cmpnge_sd

__m128d _mm_cmpnge_sd(__m128d, __m128d);

_mm_cmpnge_ss

__m128 _mm_cmpnge_ss(__m128 _A, __m128 _B);

_mm_cmpnge_ss

__m128 _mm_cmpnge_ss(__m128, __m128);

_mm_cmpngt_pd

__m128d _mm_cmpngt_pd(__m128d _A, __m128d _B);

_mm_cmpngt_pd

__m128d _mm_cmpngt_pd(__m128d, __m128d);

_mm_cmpngt_ps

__m128 _mm_cmpngt_ps(__m128 _A, __m128 _B);

_mm_cmpngt_ps

__m128 _mm_cmpngt_ps(__m128, __m128);

_mm_cmpngt_sd

__m128d _mm_cmpngt_sd(__m128d _A, __m128d _B);

_mm_cmpngt_sd

__m128d _mm_cmpngt_sd(__m128d, __m128d);

_mm_cmpngt_ss

__m128 _mm_cmpngt_ss(__m128 _A, __m128 _B);

_mm_cmpngt_ss

__m128 _mm_cmpngt_ss(__m128, __m128);

_mm_cmpnle_pd

__m128d _mm_cmpnle_pd(__m128d _A, __m128d _B);

_mm_cmpnle_pd

__m128d _mm_cmpnle_pd(__m128d, __m128d);

_mm_cmpnle_ps

__m128 _mm_cmpnle_ps(__m128 _A, __m128 _B);

_mm_cmpnle_ps

__m128 _mm_cmpnle_ps(__m128, __m128);

_mm_cmpnle_sd

__m128d _mm_cmpnle_sd(__m128d _A, __m128d _B);

_mm_cmpnle_sd

__m128d _mm_cmpnle_sd(__m128d, __m128d);

_mm_cmpnle_ss

__m128 _mm_cmpnle_ss(__m128 _A, __m128 _B);

_mm_cmpnle_ss

__m128 _mm_cmpnle_ss(__m128, __m128);

_mm_cmpnlt_pd

__m128d _mm_cmpnlt_pd(__m128d _A, __m128d _B);

_mm_cmpnlt_pd

__m128d _mm_cmpnlt_pd(__m128d, __m128d);

_mm_cmpnlt_ps

__m128 _mm_cmpnlt_ps(__m128 _A, __m128 _B);

_mm_cmpnlt_ps

__m128 _mm_cmpnlt_ps(__m128, __m128);

_mm_cmpnlt_sd

__m128d _mm_cmpnlt_sd(__m128d _A, __m128d _B);

_mm_cmpnlt_sd

__m128d _mm_cmpnlt_sd(__m128d, __m128d);

_mm_cmpnlt_ss

__m128 _mm_cmpnlt_ss(__m128 _A, __m128 _B);

_mm_cmpnlt_ss

__m128 _mm_cmpnlt_ss(__m128, __m128);

_mm_cmpord_pd

__m128d _mm_cmpord_pd(__m128d _A, __m128d _B);

_mm_cmpord_pd

__m128d _mm_cmpord_pd(__m128d, __m128d);

_mm_cmpord_ps

__m128 _mm_cmpord_ps(__m128 _A, __m128 _B);

_mm_cmpord_ps

__m128 _mm_cmpord_ps(__m128, __m128);

_mm_cmpord_sd

__m128d _mm_cmpord_sd(__m128d _A, __m128d _B);

_mm_cmpord_sd

__m128d _mm_cmpord_sd(__m128d, __m128d);

_mm_cmpord_ss

__m128 _mm_cmpord_ss(__m128 _A, __m128 _B);

_mm_cmpord_ss

__m128 _mm_cmpord_ss(__m128, __m128);

_mm_cmpunord_pd

__m128d _mm_cmpunord_pd(__m128d _A, __m128d _B);

_mm_cmpunord_pd

__m128d _mm_cmpunord_pd(__m128d, __m128d);

_mm_cmpunord_ps

__m128 _mm_cmpunord_ps(__m128 _A, __m128 _B);

_mm_cmpunord_ps

__m128 _mm_cmpunord_ps(__m128, __m128);

_mm_cmpunord_sd

__m128d _mm_cmpunord_sd(__m128d _A, __m128d _B);

_mm_cmpunord_sd

__m128d _mm_cmpunord_sd(__m128d, __m128d);

_mm_cmpunord_ss

__m128 _mm_cmpunord_ss(__m128 _A, __m128 _B);

_mm_cmpunord_ss

__m128 _mm_cmpunord_ss(__m128, __m128);

_mm_com_epi16

__m128i _mm_com_epi16(__m128i, __m128i, int);

_mm_com_epi32

__m128i _mm_com_epi32(__m128i, __m128i, int);

_mm_com_epi64

__m128i _mm_com_epi64(__m128i, __m128i, int);

_mm_com_epi8

__m128i _mm_com_epi8(__m128i, __m128i, int);

_mm_com_epu16

__m128i _mm_com_epu16(__m128i, __m128i, int);

_mm_com_epu32

__m128i _mm_com_epu32(__m128i, __m128i, int);

_mm_com_epu64

__m128i _mm_com_epu64(__m128i, __m128i, int);

_mm_com_epu8

__m128i _mm_com_epu8(__m128i, __m128i, int);

_mm_comieq_sd

int _mm_comieq_sd(__m128d _A, __m128d _B);

_mm_comieq_sd

int _mm_comieq_sd(__m128d, __m128d);

_mm_comieq_ss

int _mm_comieq_ss(__m128 _A, __m128 _B);

_mm_comieq_ss

int _mm_comieq_ss(__m128, __m128);

_mm_comige_sd

int _mm_comige_sd(__m128d _A, __m128d _B);

_mm_comige_sd

int _mm_comige_sd(__m128d, __m128d);

_mm_comige_ss

int _mm_comige_ss(__m128 _A, __m128 _B);

_mm_comige_ss

int _mm_comige_ss(__m128, __m128);

_mm_comigt_sd

int _mm_comigt_sd(__m128d _A, __m128d _B);

_mm_comigt_sd

int _mm_comigt_sd(__m128d, __m128d);

_mm_comigt_ss

int _mm_comigt_ss(__m128 _A, __m128 _B);

_mm_comigt_ss

int _mm_comigt_ss(__m128, __m128);

_mm_comile_sd

int _mm_comile_sd(__m128d _A, __m128d _B);

_mm_comile_sd

int _mm_comile_sd(__m128d, __m128d);

_mm_comile_ss

int _mm_comile_ss(__m128 _A, __m128 _B);

_mm_comile_ss

int _mm_comile_ss(__m128, __m128);

_mm_comilt_sd

int _mm_comilt_sd(__m128d _A, __m128d _B);

_mm_comilt_sd

int _mm_comilt_sd(__m128d, __m128d);

_mm_comilt_ss

int _mm_comilt_ss(__m128 _A, __m128 _B);

_mm_comilt_ss

int _mm_comilt_ss(__m128, __m128);

_mm_comineq_sd

int _mm_comineq_sd(__m128d _A, __m128d _B);

_mm_comineq_sd

int _mm_comineq_sd(__m128d, __m128d);

_mm_comineq_ss

int _mm_comineq_ss(__m128 _A, __m128 _B);

_mm_comineq_ss

int _mm_comineq_ss(__m128, __m128);

_mm_crc32_u16

unsigned int _mm_crc32_u16(unsigned int crc, unsigned short v);

_mm_crc32_u16

unsigned int _mm_crc32_u16(unsigned int, unsigned short);

_mm_crc32_u32

unsigned int _mm_crc32_u32(unsigned int crc, unsigned int v);

_mm_crc32_u32

unsigned int _mm_crc32_u32(unsigned int, unsigned int);

_mm_crc32_u8

unsigned int _mm_crc32_u8(unsigned int crc, unsigned char v);

_mm_crc32_u8

unsigned int _mm_crc32_u8(unsigned int, unsigned char);

_mm_cvt_pi2ps

__m128 _mm_cvt_pi2ps(__m128, __m64);

_mm_cvt_pi2ps

__m128 _mm_cvt_pi2ps(__m128, __m64);

_mm_cvt_ps2pi

__m64 _mm_cvt_ps2pi(__m128 _A);

_mm_cvt_ps2pi

__m64 _mm_cvt_ps2pi(__m128);

_mm_cvt_si2ss

__m128 _mm_cvt_si2ss(__m128, int);

_mm_cvt_si2ss

__m128 _mm_cvt_si2ss(__m128, int);

_mm_cvt_ss2si

int _mm_cvt_ss2si(__m128 _A);

_mm_cvt_ss2si

int _mm_cvt_ss2si(__m128);

_mm_cvtepi16_epi32

__m128i _mm_cvtepi16_epi32(__m128i shortValues);

_mm_cvtepi16_epi32

__m128i _mm_cvtepi16_epi32(__m128i);

_mm_cvtepi16_epi64

__m128i _mm_cvtepi16_epi64(__m128i shortValues);

_mm_cvtepi16_epi64

__m128i _mm_cvtepi16_epi64(__m128i);

_mm_cvtepi32_epi64

__m128i _mm_cvtepi32_epi64(__m128i intValues);

_mm_cvtepi32_epi64

__m128i _mm_cvtepi32_epi64(__m128i);

_mm_cvtepi32_pd

__m128d _mm_cvtepi32_pd(__m128i _A);

_mm_cvtepi32_pd

__m128d _mm_cvtepi32_pd(__m128i);

_mm_cvtepi32_ps

__m128 _mm_cvtepi32_ps(__m128i _A);

_mm_cvtepi32_ps

__m128 _mm_cvtepi32_ps(__m128i);

_mm_cvtepi8_epi16

__m128i _mm_cvtepi8_epi16(__m128i byteValues);

_mm_cvtepi8_epi16

__m128i _mm_cvtepi8_epi16(__m128i);

_mm_cvtepi8_epi32

__m128i _mm_cvtepi8_epi32(__m128i byteValues);

_mm_cvtepi8_epi32

__m128i _mm_cvtepi8_epi32(__m128i);

_mm_cvtepi8_epi64

__m128i _mm_cvtepi8_epi64(__m128i byteValues);

_mm_cvtepi8_epi64

__m128i _mm_cvtepi8_epi64(__m128i);

_mm_cvtepu16_epi32

__m128i _mm_cvtepu16_epi32(__m128i shortValues);

_mm_cvtepu16_epi32

__m128i _mm_cvtepu16_epi32(__m128i);

_mm_cvtepu16_epi64

__m128i _mm_cvtepu16_epi64(__m128i shortValues);

_mm_cvtepu16_epi64

__m128i _mm_cvtepu16_epi64(__m128i);

_mm_cvtepu32_epi64

__m128i _mm_cvtepu32_epi64(__m128i intValues);

_mm_cvtepu32_epi64

__m128i _mm_cvtepu32_epi64(__m128i);

_mm_cvtepu8_epi16

__m128i _mm_cvtepu8_epi16(__m128i byteValues);

_mm_cvtepu8_epi16

__m128i _mm_cvtepu8_epi16(__m128i);

_mm_cvtepu8_epi32

__m128i _mm_cvtepu8_epi32(__m128i byteValues);

_mm_cvtepu8_epi32

__m128i _mm_cvtepu8_epi32(__m128i);

_mm_cvtepu8_epi64

__m128i _mm_cvtepu8_epi64(__m128i shortValues);

_mm_cvtepu8_epi64

__m128i _mm_cvtepu8_epi64(__m128i);

_mm_cvtpd_epi32

__m128i _mm_cvtpd_epi32(__m128d _A);

_mm_cvtpd_epi32

__m128i _mm_cvtpd_epi32(__m128d);

_mm_cvtpd_pi32

__m64 _mm_cvtpd_pi32(__m128d _A);

_mm_cvtpd_pi32

__m64 _mm_cvtpd_pi32(__m128d);

_mm_cvtpd_ps

__m128 _mm_cvtpd_ps(__m128d _A);

_mm_cvtpd_ps

__m128 _mm_cvtpd_ps(__m128d);

_mm_cvtph_ps

__m128 __cdecl _mm_cvtph_ps(__m128i);

_mm_cvtpi16_ps

__inline __m128 _mm_cvtpi16_ps(__m64 a);

_mm_cvtpi32_pd

__m128d _mm_cvtpi32_pd(__m64 _A);

_mm_cvtpi32_pd

__m128d _mm_cvtpi32_pd(__m64);

_mm_cvtpi32x2_ps

__inline __m128 _mm_cvtpi32x2_ps(__m64 a, __m64 b);

_mm_cvtpi8_ps

__inline __m128 _mm_cvtpi8_ps(__m64 a);

_mm_cvtps_epi32

__m128i _mm_cvtps_epi32(__m128 _A);

_mm_cvtps_epi32

__m128i _mm_cvtps_epi32(__m128);

_mm_cvtps_pd

__m128d _mm_cvtps_pd(__m128 _A);

_mm_cvtps_pd

__m128d _mm_cvtps_pd(__m128);

_mm_cvtps_ph

__m128i __cdecl _mm_cvtps_ph(__m128 m1, const int imm);

_mm_cvtps_pi16

__inline __m64 _mm_cvtps_pi16(__m128 a);

_mm_cvtps_pi8

__inline __m64 _mm_cvtps_pi8(__m128 a);

_mm_cvtpu16_ps

__inline __m128 _mm_cvtpu16_ps(__m64 a);

_mm_cvtpu8_ps

__inline __m128 _mm_cvtpu8_ps(__m64 a);

_mm_cvtsd_f64

double _mm_cvtsd_f64(__m128d _A);

_mm_cvtsd_si32

int _mm_cvtsd_si32(__m128d _A);

_mm_cvtsd_si32

int _mm_cvtsd_si32(__m128d);

_mm_cvtsd_ss

__m128 _mm_cvtsd_ss(__m128 _A, __m128d _B);

_mm_cvtsd_ss

__m128 _mm_cvtsd_ss(__m128, __m128d);

_mm_cvtsi128_si32

int _mm_cvtsi128_si32(__m128i _A);

_mm_cvtsi128_si32

int _mm_cvtsi128_si32(__m128i);

_mm_cvtsi32_sd

__m128d _mm_cvtsi32_sd(__m128d _A, int _B);

_mm_cvtsi32_sd

__m128d _mm_cvtsi32_sd(__m128d, int);

_mm_cvtsi32_si128

__m128i _mm_cvtsi32_si128(int _A);

_mm_cvtsi32_si128

__m128i _mm_cvtsi32_si128(int);

_mm_cvtss_f32

float _mm_cvtss_f32(__m128 _A);

_mm_cvtss_sd

__m128d _mm_cvtss_sd(__m128d _A, __m128 _B);

_mm_cvtss_sd

__m128d _mm_cvtss_sd(__m128d, __m128);

_mm_cvtt_ps2pi

__m64 _mm_cvtt_ps2pi(__m128 _A);

_mm_cvtt_ps2pi

__m64 _mm_cvtt_ps2pi(__m128);

_mm_cvtt_ss2si

int _mm_cvtt_ss2si(__m128 _A);

_mm_cvtt_ss2si

int _mm_cvtt_ss2si(__m128);

_mm_cvttpd_epi32

__m128i _mm_cvttpd_epi32(__m128d _A);

_mm_cvttpd_epi32

__m128i _mm_cvttpd_epi32(__m128d);

_mm_cvttpd_pi32

__m64 _mm_cvttpd_pi32(__m128d _A);

_mm_cvttpd_pi32

__m64 _mm_cvttpd_pi32(__m128d);

_mm_cvttps_epi32

__m128i _mm_cvttps_epi32(__m128 _A);

_mm_cvttps_epi32

__m128i _mm_cvttps_epi32(__m128);

_mm_cvttsd_si32

int _mm_cvttsd_si32(__m128d _A);

_mm_cvttsd_si32

int _mm_cvttsd_si32(__m128d);

_mm_div_pd

__m128d _mm_div_pd(__m128d _A, __m128d _B);

_mm_div_pd

__m128d _mm_div_pd(__m128d, __m128d);

_mm_div_ps

__m128 _mm_div_ps(__m128 _A, __m128 _B);

_mm_div_ps

__m128 _mm_div_ps(__m128, __m128);

_mm_div_sd

__m128d _mm_div_sd(__m128d _A, __m128d _B);

_mm_div_sd

__m128d _mm_div_sd(__m128d, __m128d);

_mm_div_ss

__m128 _mm_div_ss(__m128 _A, __m128 _B);

_mm_div_ss

__m128 _mm_div_ss(__m128, __m128);

_mm_dp_pd

__m128d _mm_dp_pd(__m128d val1, __m128d val2, const int mask);

_mm_dp_pd

__m128d _mm_dp_pd(__m128d, __m128d, int);

_mm_dp_ps

__m128 _mm_dp_ps(__m128 val1, __m128 val2, const int mask);

_mm_dp_ps

__m128 _mm_dp_ps(__m128, __m128, int);

_mm_extract_epi16

int _mm_extract_epi16(__m128i _A, int _Imm);

_mm_extract_epi16

int _mm_extract_epi16(__m128i, int);

_mm_extract_epi32

int _mm_extract_epi32(__m128i src, const int ndx);

_mm_extract_epi32

int _mm_extract_epi32(__m128i, int);

_mm_extract_epi8

int _mm_extract_epi8(__m128i src, const int ndx);

_mm_extract_epi8

int _mm_extract_epi8(__m128i, int);

_mm_extract_ps

int _mm_extract_ps(__m128 src, const int ndx);

_mm_extract_ps

int _mm_extract_ps(__m128, int);

_mm_extract_si64

__m128i _mm_extract_si64(__m128i, __m128i);

_mm_extracti_si64

__m128i _mm_extracti_si64(__m128i, int, int);

_mm_fmadd_pd

__m128d __cdecl _mm_fmadd_pd(__m128d, __m128d, __m128d);

_mm_fmadd_ps

__m128 __cdecl _mm_fmadd_ps(__m128, __m128, __m128);

_mm_fmadd_sd

__m128d __cdecl _mm_fmadd_sd(__m128d, __m128d, __m128d);

_mm_fmadd_ss

__m128 __cdecl _mm_fmadd_ss(__m128, __m128, __m128);

_mm_fmaddsub_pd

__m128d __cdecl _mm_fmaddsub_pd(__m128d, __m128d, __m128d);

_mm_fmaddsub_ps

__m128 __cdecl _mm_fmaddsub_ps(__m128, __m128, __m128);

_mm_fmsub_pd

__m128d __cdecl _mm_fmsub_pd(__m128d, __m128d, __m128d);

_mm_fmsub_ps

__m128 __cdecl _mm_fmsub_ps(__m128, __m128, __m128);

_mm_fmsub_sd

__m128d __cdecl _mm_fmsub_sd(__m128d, __m128d, __m128d);

_mm_fmsub_ss

__m128 __cdecl _mm_fmsub_ss(__m128, __m128, __m128);

_mm_fmsubadd_pd

__m128d __cdecl _mm_fmsubadd_pd(__m128d, __m128d, __m128d);

_mm_fmsubadd_ps

__m128 __cdecl _mm_fmsubadd_ps(__m128, __m128, __m128);

_mm_fnmadd_pd

__m128d __cdecl _mm_fnmadd_pd(__m128d, __m128d, __m128d);

_mm_fnmadd_ps

__m128 __cdecl _mm_fnmadd_ps(__m128, __m128, __m128);

_mm_fnmadd_sd

__m128d __cdecl _mm_fnmadd_sd(__m128d, __m128d, __m128d);

_mm_fnmadd_ss

__m128 __cdecl _mm_fnmadd_ss(__m128, __m128, __m128);

_mm_fnmsub_pd

__m128d __cdecl _mm_fnmsub_pd(__m128d, __m128d, __m128d);

_mm_fnmsub_ps

__m128 __cdecl _mm_fnmsub_ps(__m128, __m128, __m128);

_mm_fnmsub_sd

__m128d __cdecl _mm_fnmsub_sd(__m128d, __m128d, __m128d);

_mm_fnmsub_ss

__m128 __cdecl _mm_fnmsub_ss(__m128, __m128, __m128);

_mm_frcz_pd

__m128d _mm_frcz_pd(__m128d);

_mm_frcz_ps

__m128 _mm_frcz_ps(__m128);

_mm_frcz_sd

__m128d _mm_frcz_sd(__m128d, __m128d);

_mm_frcz_ss

__m128 _mm_frcz_ss(__m128, __m128);

_mm_getcsr

unsigned int _mm_getcsr(void);

_mm_getcsr

unsigned int _mm_getcsr(void);

_mm_hadd_epi16

__m128i _mm_hadd_epi16(__m128i a, __m128i b);

_mm_hadd_epi16

__m128i _mm_hadd_epi16(__m128i, __m128i);

_mm_hadd_epi32

__m128i _mm_hadd_epi32(__m128i a, __m128i b);

_mm_hadd_epi32

__m128i _mm_hadd_epi32(__m128i, __m128i);

_mm_hadd_pd

__m128d _mm_hadd_pd(__m128d a, __m128d b);

_mm_hadd_pd

__m128d _mm_hadd_pd(__m128d, __m128d);

_mm_hadd_pi16

__m64 _mm_hadd_pi16(__m64 a, __m64 b);

_mm_hadd_pi16

__m64 _mm_hadd_pi16(__m64, __m64);

_mm_hadd_pi32

__m64 _mm_hadd_pi32(__m64 a, __m64 b);

_mm_hadd_pi32

__m64 _mm_hadd_pi32(__m64, __m64);

_mm_hadd_ps

__m128 _mm_hadd_ps(__m128 a, __m128 b);

_mm_hadd_ps

__m128 _mm_hadd_ps(__m128, __m128);

_mm_haddd_epi16

__m128i _mm_haddd_epi16(__m128i);

_mm_haddd_epi8

__m128i _mm_haddd_epi8(__m128i);

_mm_haddd_epu16

__m128i _mm_haddd_epu16(__m128i);

_mm_haddd_epu8

__m128i _mm_haddd_epu8(__m128i);

_mm_haddq_epi16

__m128i _mm_haddq_epi16(__m128i);

_mm_haddq_epi32

__m128i _mm_haddq_epi32(__m128i);

_mm_haddq_epi8

__m128i _mm_haddq_epi8(__m128i);

_mm_haddq_epu16

__m128i _mm_haddq_epu16(__m128i);

_mm_haddq_epu32

__m128i _mm_haddq_epu32(__m128i);

_mm_haddq_epu8

__m128i _mm_haddq_epu8(__m128i);

_mm_hadds_epi16

__m128i _mm_hadds_epi16(__m128i a, __m128i b);

_mm_hadds_epi16

__m128i _mm_hadds_epi16(__m128i, __m128i);

_mm_hadds_pi16

__m64 _mm_hadds_pi16(__m64 a, __m64 b);

_mm_hadds_pi16

__m64 _mm_hadds_pi16(__m64, __m64);

_mm_haddw_epi8

__m128i _mm_haddw_epi8(__m128i);

_mm_haddw_epu8

__m128i _mm_haddw_epu8(__m128i);

_mm_hsub_epi16

__m128i _mm_hsub_epi16(__m128i a, __m128i b);

_mm_hsub_epi16

__m128i _mm_hsub_epi16(__m128i, __m128i);

_mm_hsub_epi32

__m128i _mm_hsub_epi32(__m128i a, __m128i b);

_mm_hsub_epi32

__m128i _mm_hsub_epi32(__m128i, __m128i);

_mm_hsub_pd

__m128d _mm_hsub_pd(__m128d a, __m128d b);

_mm_hsub_pd

__m128d _mm_hsub_pd(__m128d, __m128d);

_mm_hsub_pi16

__m64 _mm_hsub_pi16(__m64 a, __m64 b);

_mm_hsub_pi16

__m64 _mm_hsub_pi16(__m64, __m64);

_mm_hsub_pi32

__m64 _mm_hsub_pi32(__m64 a, __m64 b);

_mm_hsub_pi32

__m64 _mm_hsub_pi32(__m64, __m64);

_mm_hsub_ps

__m128 _mm_hsub_ps(__m128 a, __m128 b);

_mm_hsub_ps

__m128 _mm_hsub_ps(__m128, __m128);

_mm_hsubd_epi16

__m128i _mm_hsubd_epi16(__m128i);

_mm_hsubq_epi32

__m128i _mm_hsubq_epi32(__m128i);

_mm_hsubs_epi16

__m128i _mm_hsubs_epi16(__m128i a, __m128i b);

_mm_hsubs_epi16

__m128i _mm_hsubs_epi16(__m128i, __m128i);

_mm_hsubs_pi16

__m64 _mm_hsubs_pi16(__m64 a, __m64 b);

_mm_hsubs_pi16

__m64 _mm_hsubs_pi16(__m64, __m64);

_mm_hsubw_epi8

__m128i _mm_hsubw_epi8(__m128i);

_mm_i32gather_epi32

__m128i __cdecl _mm_i32gather_epi32(int const *, __m128i, const int );

_mm_i32gather_epi64

__m128i __cdecl _mm_i32gather_epi64(__int64 const *, __m128i, const int );

_mm_i32gather_pd

__m128d __cdecl _mm_i32gather_pd(double const *, __m128i, const int );

_mm_i32gather_ps

__m128 __cdecl _mm_i32gather_ps(float const *, __m128i, const int );

_mm_i64gather_epi32

__m128i __cdecl _mm_i64gather_epi32(int const *, __m128i, const int );

_mm_i64gather_epi64

__m128i __cdecl _mm_i64gather_epi64(__int64 const *, __m128i, const int );

_mm_i64gather_pd

__m128d __cdecl _mm_i64gather_pd(double const *, __m128i, const int );

_mm_i64gather_ps

__m128 __cdecl _mm_i64gather_ps(float const *, __m128i, const int );

_mm_insert_epi16

__m128i _mm_insert_epi16(__m128i _A, int _B, int _Imm);

_mm_insert_epi16

__m128i _mm_insert_epi16(__m128i, int, int);

_mm_insert_epi32

__m128i _mm_insert_epi32(__m128i dst, int s, const int ndx);

_mm_insert_epi32

__m128i _mm_insert_epi32(__m128i, int, int);

_mm_insert_epi8

__m128i _mm_insert_epi8(__m128i dst, int s, const int ndx);

_mm_insert_epi8

__m128i _mm_insert_epi8(__m128i, int, int);

_mm_insert_ps

__m128 _mm_insert_ps(__m128 dst, __m128 src, const int ndx);

_mm_insert_ps

__m128 _mm_insert_ps(__m128, __m128, int);

_mm_insert_si64

__m128i _mm_insert_si64(__m128i, __m128i);

_mm_inserti_si64

__m128i _mm_inserti_si64(__m128i, __m128i, int, int);

_mm_lddqu_si128

__m128i _mm_lddqu_si128(__m128i const *);

_mm_lddqu_si128

__m128i _mm_lddqu_si128(__m128i const *p);

_mm_lfence

void _mm_lfence(void);

_mm_lfence

void _mm_lfence(void);

_mm_load_pd

__m128d _mm_load_pd(double const *);

_mm_load_pd

__m128d _mm_load_pd(double const*_Dp);

_mm_load_ps

__m128 _mm_load_ps(float const *);

_mm_load_ps

__m128 _mm_load_ps(float const*_A);

_mm_load_ps1

__m128 _mm_load_ps1(float const *);

_mm_load_ps1

__m128 _mm_load_ps1(float const*_A);

_mm_load_sd

__m128d _mm_load_sd(double const *);

_mm_load_sd

__m128d _mm_load_sd(double const*_Dp);

_mm_load_si128

__m128i _mm_load_si128(__m128i const *);

_mm_load_si128

__m128i _mm_load_si128(__m128i const*_P);

_mm_load_ss

__m128 _mm_load_ss(float const *);

_mm_load_ss

__m128 _mm_load_ss(float const*_A);

_mm_load1_pd

__m128d _mm_load1_pd(double const *);

_mm_load1_pd

__m128d _mm_load1_pd(double const*_Dp);

_mm_loaddup_pd

__m128d _mm_loaddup_pd(double const * dp);

_mm_loaddup_pd

__m128d _mm_loaddup_pd(double const *);

_mm_loadh_pd

__m128d _mm_loadh_pd(__m128d _A, double const*_Dp);

_mm_loadh_pd

__m128d _mm_loadh_pd(__m128d, double const *);

_mm_loadh_pi

__m128 _mm_loadh_pi(__m128, __m64 const *);

_mm_loadh_pi

__m128 _mm_loadh_pi(__m128, __m64 const*);

_mm_loadl_epi64

__m128i _mm_loadl_epi64(__m128i const *);

_mm_loadl_epi64

__m128i _mm_loadl_epi64(__m128i const*_P);

_mm_loadl_pd

__m128d _mm_loadl_pd(__m128d _A, double const*_Dp);

_mm_loadl_pd

__m128d _mm_loadl_pd(__m128d, double const *);

_mm_loadl_pi

__m128 _mm_loadl_pi(__m128, __m64 const *);

_mm_loadl_pi

__m128 _mm_loadl_pi(__m128, __m64 const*);

_mm_loadr_pd

__m128d _mm_loadr_pd(double const *);

_mm_loadr_pd

__m128d _mm_loadr_pd(double const*_Dp);

_mm_loadr_ps

__m128 _mm_loadr_ps(float const *);

_mm_loadr_ps

__m128 _mm_loadr_ps(float const*_A);

_mm_loadu_pd

__m128d _mm_loadu_pd(double const *);

_mm_loadu_pd

__m128d _mm_loadu_pd(double const*_Dp);

_mm_loadu_ps

__m128 _mm_loadu_ps(float const *);

_mm_loadu_ps

__m128 _mm_loadu_ps(float const*_A);

_mm_loadu_si128

__m128i _mm_loadu_si128(__m128i const *);

_mm_loadu_si128

__m128i _mm_loadu_si128(__m128i const*_P);

_mm_macc_epi16

__m128i _mm_macc_epi16(__m128i, __m128i, __m128i);

_mm_macc_epi32

__m128i _mm_macc_epi32(__m128i, __m128i, __m128i);

_mm_macc_pd

__m128d _mm_macc_pd(__m128d, __m128d, __m128d);

_mm_macc_ps

__m128 _mm_macc_ps(__m128, __m128, __m128);

_mm_macc_sd

__m128d _mm_macc_sd(__m128d, __m128d, __m128d);

_mm_macc_ss

__m128 _mm_macc_ss(__m128, __m128, __m128);

_mm_maccd_epi16

__m128i _mm_maccd_epi16(__m128i, __m128i, __m128i);

_mm_macchi_epi32

__m128i _mm_macchi_epi32(__m128i, __m128i, __m128i);

_mm_macclo_epi32

__m128i _mm_macclo_epi32(__m128i, __m128i, __m128i);

_mm_maccs_epi16

__m128i _mm_maccs_epi16(__m128i, __m128i, __m128i);

_mm_maccs_epi32

__m128i _mm_maccs_epi32(__m128i, __m128i, __m128i);

_mm_maccsd_epi16

__m128i _mm_maccsd_epi16(__m128i, __m128i, __m128i);

_mm_maccshi_epi32

__m128i _mm_maccshi_epi32(__m128i, __m128i, __m128i);

_mm_maccslo_epi32

__m128i _mm_maccslo_epi32(__m128i, __m128i, __m128i);

_mm_madd_epi16

__m128i _mm_madd_epi16(__m128i _A, __m128i _B);

_mm_madd_epi16

__m128i _mm_madd_epi16(__m128i, __m128i);

_mm_maddd_epi16

__m128i _mm_maddd_epi16(__m128i, __m128i, __m128i);

_mm_maddsd_epi16

__m128i _mm_maddsd_epi16(__m128i, __m128i, __m128i);

_mm_maddsub_pd

__m128d _mm_maddsub_pd(__m128d, __m128d, __m128d);

_mm_maddsub_ps

__m128 _mm_maddsub_ps(__m128, __m128, __m128);

_mm_maddubs_epi16

__m128i _mm_maddubs_epi16(__m128i a, __m128i b);

_mm_maddubs_epi16

__m128i _mm_maddubs_epi16(__m128i, __m128i);

_mm_maddubs_pi16

__m64 _mm_maddubs_pi16(__m64 a, __m64 b);

_mm_maddubs_pi16

__m64 _mm_maddubs_pi16(__m64, __m64);

_mm_mask_i32gather_epi32

__m128i __cdecl _mm_mask_i32gather_epi32(__m128i, int const *, __m128i, __m128i, const int );

_mm_mask_i32gather_epi64

__m128i __cdecl _mm_mask_i32gather_epi64(__m128i, __int64 const *, __m128i, __m128i, const int );

_mm_mask_i32gather_pd

__m128d __cdecl _mm_mask_i32gather_pd(__m128d, double const *, __m128i, __m128d, const int );

_mm_mask_i32gather_ps

__m128 __cdecl _mm_mask_i32gather_ps(__m128, float const *, __m128i, __m128, const int );

_mm_mask_i64gather_epi32

__m128i __cdecl _mm_mask_i64gather_epi32(__m128i, int const *, __m128i, __m128i, const int );

_mm_mask_i64gather_epi64

__m128i __cdecl _mm_mask_i64gather_epi64(__m128i, __int64 const *, __m128i, __m128i, const int );

_mm_mask_i64gather_pd

__m128d __cdecl _mm_mask_i64gather_pd(__m128d, double const *, __m128i, __m128d, const int );

_mm_mask_i64gather_ps

__m128 __cdecl _mm_mask_i64gather_ps(__m128, float const *, __m128i, __m128, const int );

_mm_maskload_epi32

__m128i __cdecl _mm_maskload_epi32(int const *, __m128i );

_mm_maskload_epi64

__m128i __cdecl _mm_maskload_epi64(__int64 const *, __m128i );

_mm_maskload_pd

__m128d __cdecl _mm_maskload_pd(double const *, __m128i);

_mm_maskload_ps

__m128 __cdecl _mm_maskload_ps(float const *, __m128i);

_mm_maskmoveu_si128

void _mm_maskmoveu_si128(__m128i _D, __m128i _N, char *_P);

_mm_maskmoveu_si128

void _mm_maskmoveu_si128(__m128i, __m128i, char *);

_mm_maskstore_epi32

void __cdecl _mm_maskstore_epi32(int *, __m128i, __m128i );

_mm_maskstore_epi64

void __cdecl _mm_maskstore_epi64(__int64 *, __m128i, __m128i );

_mm_maskstore_pd

void __cdecl _mm_maskstore_pd(double *, __m128i, __m128d);

_mm_maskstore_ps

void __cdecl _mm_maskstore_ps(float *, __m128i, __m128);

_mm_max_epi16

__m128i _mm_max_epi16(__m128i _A, __m128i _B);

_mm_max_epi16

__m128i _mm_max_epi16(__m128i, __m128i);

_mm_max_epi32

__m128i _mm_max_epi32(__m128i val1, __m128i val2);

_mm_max_epi32

__m128i _mm_max_epi32(__m128i, __m128i);

_mm_max_epi8

__m128i _mm_max_epi8(__m128i val1, __m128i val2);

_mm_max_epi8

__m128i _mm_max_epi8(__m128i, __m128i);

_mm_max_epu16

__m128i _mm_max_epu16(__m128i val1, __m128i val2);

_mm_max_epu16

__m128i _mm_max_epu16(__m128i, __m128i);

_mm_max_epu32

__m128i _mm_max_epu32(__m128i val1, __m128i val2);

_mm_max_epu32

__m128i _mm_max_epu32(__m128i, __m128i);

_mm_max_epu8

__m128i _mm_max_epu8(__m128i _A, __m128i _B);

_mm_max_epu8

__m128i _mm_max_epu8(__m128i, __m128i);

_mm_max_pd

__m128d _mm_max_pd(__m128d _A, __m128d _B);

_mm_max_pd

__m128d _mm_max_pd(__m128d, __m128d);

_mm_max_ps

__m128 _mm_max_ps(__m128 _A, __m128 _B);

_mm_max_ps

__m128 _mm_max_ps(__m128, __m128);

_mm_max_sd

__m128d _mm_max_sd(__m128d _A, __m128d _B);

_mm_max_sd

__m128d _mm_max_sd(__m128d, __m128d);

_mm_max_ss

__m128 _mm_max_ss(__m128 _A, __m128 _B);

_mm_max_ss

__m128 _mm_max_ss(__m128, __m128);

_mm_mfence

void _mm_mfence(void);

_mm_mfence

void _mm_mfence(void);

_mm_min_epi16

__m128i _mm_min_epi16(__m128i _A, __m128i _B);

_mm_min_epi16

__m128i _mm_min_epi16(__m128i, __m128i);

_mm_min_epi32

__m128i _mm_min_epi32(__m128i val1, __m128i val2);

_mm_min_epi32

__m128i _mm_min_epi32(__m128i, __m128i);

_mm_min_epi8

__m128i _mm_min_epi8(__m128i val1, __m128i val2);

_mm_min_epi8

__m128i _mm_min_epi8(__m128i, __m128i);

_mm_min_epu16

__m128i _mm_min_epu16(__m128i val1, __m128i val2);

_mm_min_epu16

__m128i _mm_min_epu16(__m128i, __m128i);

_mm_min_epu32

__m128i _mm_min_epu32(__m128i val1, __m128i val2);

_mm_min_epu32

__m128i _mm_min_epu32(__m128i, __m128i);

_mm_min_epu8

__m128i _mm_min_epu8(__m128i _A, __m128i _B);

_mm_min_epu8

__m128i _mm_min_epu8(__m128i, __m128i);

_mm_min_pd

__m128d _mm_min_pd(__m128d _A, __m128d _B);

_mm_min_pd

__m128d _mm_min_pd(__m128d, __m128d);

_mm_min_ps

__m128 _mm_min_ps(__m128 _A, __m128 _B);

_mm_min_ps

__m128 _mm_min_ps(__m128, __m128);

_mm_min_sd

__m128d _mm_min_sd(__m128d _A, __m128d _B);

_mm_min_sd

__m128d _mm_min_sd(__m128d, __m128d);

_mm_min_ss

__m128 _mm_min_ss(__m128 _A, __m128 _B);

_mm_min_ss

__m128 _mm_min_ss(__m128, __m128);

_mm_minpos_epu16

__m128i _mm_minpos_epu16(__m128i shortValues);

_mm_minpos_epu16

__m128i _mm_minpos_epu16(__m128i);

_mm_monitor

void _mm_monitor(void const *, unsigned int, unsigned int);

_mm_monitor

void _mm_monitor(void const *p, unsigned extensions, unsigned hints);

_mm_move_epi64

__m128i _mm_move_epi64(__m128i _Q);

_mm_move_epi64

__m128i _mm_move_epi64(__m128i);

_mm_move_sd

__m128d _mm_move_sd(__m128d _A, __m128d _B);

_mm_move_sd

__m128d _mm_move_sd(__m128d, __m128d);

_mm_move_ss

__m128 _mm_move_ss(__m128 _A, __m128 _B);

_mm_move_ss

__m128 _mm_move_ss(__m128, __m128);

_mm_movedup_pd

__m128d _mm_movedup_pd(__m128d a);

_mm_movedup_pd

__m128d _mm_movedup_pd(__m128d);

_mm_movehdup_ps

__m128 _mm_movehdup_ps(__m128 a);

_mm_movehdup_ps

__m128 _mm_movehdup_ps(__m128);

_mm_movehl_ps

__m128 _mm_movehl_ps(__m128, __m128);

_mm_movehl_ps

__m128 _mm_movehl_ps(__m128, __m128);

_mm_moveldup_ps

__m128 _mm_moveldup_ps(__m128 a);

_mm_moveldup_ps

__m128 _mm_moveldup_ps(__m128);

_mm_movelh_ps

__m128 _mm_movelh_ps(__m128, __m128);

_mm_movelh_ps

__m128 _mm_movelh_ps(__m128, __m128);

_mm_movemask_epi8

int _mm_movemask_epi8(__m128i _A);

_mm_movemask_epi8

int _mm_movemask_epi8(__m128i);

_mm_movemask_pd

int _mm_movemask_pd(__m128d _A);

_mm_movemask_pd

int _mm_movemask_pd(__m128d);

_mm_movemask_ps

int _mm_movemask_ps(__m128 _A);

_mm_movemask_ps

int _mm_movemask_ps(__m128);

_mm_movepi64_pi64

__m64 _mm_movepi64_pi64(__m128i _Q);

_mm_movepi64_pi64

__m64 _mm_movepi64_pi64(__m128i);

_mm_movpi64_epi64

__m128i _mm_movpi64_epi64(__m64 _Q);

_mm_movpi64_epi64

__m128i _mm_movpi64_epi64(__m64);

_mm_mpsadbw_epu8

__m128i _mm_mpsadbw_epu8(__m128i s1, __m128i s2, const int msk);

_mm_mpsadbw_epu8

__m128i _mm_mpsadbw_epu8(__m128i, __m128i, int);

_mm_msub_pd

__m128d _mm_msub_pd(__m128d, __m128d, __m128d);

_mm_msub_ps

__m128 _mm_msub_ps(__m128, __m128, __m128);

_mm_msub_sd

__m128d _mm_msub_sd(__m128d, __m128d, __m128d);

_mm_msub_ss

__m128 _mm_msub_ss(__m128, __m128, __m128);

_mm_msubadd_pd

__m128d _mm_msubadd_pd(__m128d, __m128d, __m128d);

_mm_msubadd_ps

__m128 _mm_msubadd_ps(__m128, __m128, __m128);

_mm_mul_epi32

__m128i _mm_mul_epi32(__m128i a, __m128i b);

_mm_mul_epi32

__m128i _mm_mul_epi32(__m128i, __m128i);

_mm_mul_epu32

__m128i _mm_mul_epu32(__m128i _A, __m128i _B);

_mm_mul_epu32

__m128i _mm_mul_epu32(__m128i, __m128i);

_mm_mul_pd

__m128d _mm_mul_pd(__m128d _A, __m128d _B);

_mm_mul_pd

__m128d _mm_mul_pd(__m128d, __m128d);

_mm_mul_ps

__m128 _mm_mul_ps(__m128 _A, __m128 _B);

_mm_mul_ps

__m128 _mm_mul_ps(__m128, __m128);

_mm_mul_sd

__m128d _mm_mul_sd(__m128d _A, __m128d _B);

_mm_mul_sd

__m128d _mm_mul_sd(__m128d, __m128d);

_mm_mul_ss

__m128 _mm_mul_ss(__m128 _A, __m128 _B);

_mm_mul_ss

__m128 _mm_mul_ss(__m128, __m128);

_mm_mul_su32

__m64 _mm_mul_su32(__m64 _A, __m64 _B);

_mm_mul_su32

__m64 _mm_mul_su32(__m64, __m64);

_mm_mulhi_epi16

__m128i _mm_mulhi_epi16(__m128i _A, __m128i _B);

_mm_mulhi_epi16

__m128i _mm_mulhi_epi16(__m128i, __m128i);

_mm_mulhi_epu16

__m128i _mm_mulhi_epu16(__m128i _A, __m128i _B);

_mm_mulhi_epu16

__m128i _mm_mulhi_epu16(__m128i, __m128i);

_mm_mulhrs_epi16

__m128i _mm_mulhrs_epi16(__m128i a, __m128i b);

_mm_mulhrs_epi16

__m128i _mm_mulhrs_epi16(__m128i, __m128i);

_mm_mulhrs_pi16

__m64 _mm_mulhrs_pi16(__m64 a, __m64 b);

_mm_mulhrs_pi16

__m64 _mm_mulhrs_pi16(__m64, __m64);

_mm_mullo_epi16

__m128i _mm_mullo_epi16(__m128i _A, __m128i _B);

_mm_mullo_epi16

__m128i _mm_mullo_epi16(__m128i, __m128i);

_mm_mullo_epi32

__m128i _mm_mullo_epi32(__m128i a, __m128i b);

_mm_mullo_epi32

__m128i _mm_mullo_epi32(__m128i, __m128i);

_mm_mwait

void _mm_mwait(unsigned extensions, unsigned hints);

_mm_mwait

void _mm_mwait(unsigned int, unsigned int);

_mm_nmacc_pd

__m128d _mm_nmacc_pd(__m128d, __m128d, __m128d);

_mm_nmacc_ps

__m128 _mm_nmacc_ps(__m128, __m128, __m128);

_mm_nmacc_sd

__m128d _mm_nmacc_sd(__m128d, __m128d, __m128d);

_mm_nmacc_ss

__m128 _mm_nmacc_ss(__m128, __m128, __m128);

_mm_nmsub_pd

__m128d _mm_nmsub_pd(__m128d, __m128d, __m128d);

_mm_nmsub_ps

__m128 _mm_nmsub_ps(__m128, __m128, __m128);

_mm_nmsub_sd

__m128d _mm_nmsub_sd(__m128d, __m128d, __m128d);

_mm_nmsub_ss

__m128 _mm_nmsub_ss(__m128, __m128, __m128);

_mm_or_pd

__m128d _mm_or_pd(__m128d _A, __m128d _B);

_mm_or_pd

__m128d _mm_or_pd(__m128d, __m128d);

_mm_or_ps

__m128 _mm_or_ps(__m128 _A, __m128 _B);

_mm_or_ps

__m128 _mm_or_ps(__m128, __m128);

_mm_or_si128

__m128i _mm_or_si128(__m128i _A, __m128i _B);

_mm_or_si128

__m128i _mm_or_si128(__m128i, __m128i);

_mm_packs_epi16

__m128i _mm_packs_epi16(__m128i _A, __m128i _B);

_mm_packs_epi16

__m128i _mm_packs_epi16(__m128i, __m128i);

_mm_packs_epi32

__m128i _mm_packs_epi32(__m128i _A, __m128i _B);

_mm_packs_epi32

__m128i _mm_packs_epi32(__m128i, __m128i);

_mm_packus_epi16

__m128i _mm_packus_epi16(__m128i _A, __m128i _B);

_mm_packus_epi16

__m128i _mm_packus_epi16(__m128i, __m128i);

_mm_packus_epi32

__m128i _mm_packus_epi32(__m128i val1, __m128i val2);

_mm_packus_epi32

__m128i _mm_packus_epi32(__m128i, __m128i);

_mm_pause

void _mm_pause(void);

_mm_pause

void _mm_pause(void);

_mm_perm_epi8

__m128i _mm_perm_epi8(__m128i, __m128i, __m128i);

_mm_permute_pd

__m128d __cdecl _mm_permute_pd(__m128d, int);

_mm_permute_ps

__m128 __cdecl _mm_permute_ps(__m128, int);

_mm_permute2_pd

__m128d _mm_permute2_pd(__m128d, __m128d, __m128i, int);

_mm_permute2_ps

__m128 _mm_permute2_ps(__m128, __m128, __m128i, int);

_mm_permutevar_pd

__m128d __cdecl _mm_permutevar_pd(__m128d, __m128i);

_mm_permutevar_ps

__m128 __cdecl _mm_permutevar_ps(__m128, __m128i);

_mm_popcnt_u32

int _mm_popcnt_u32(unsigned int v);

_mm_popcnt_u32

int _mm_popcnt_u32(unsigned int);

_mm_prefetch

void _mm_prefetch(char const *, int);

_mm_prefetch

void _mm_prefetch(char const*_A, int _Sel);

_mm_rcp_ps

__m128 _mm_rcp_ps(__m128 _A);

_mm_rcp_ps

__m128 _mm_rcp_ps(__m128);

_mm_rcp_ss

__m128 _mm_rcp_ss(__m128 _A);

_mm_rcp_ss

__m128 _mm_rcp_ss(__m128);

_mm_rot_epi16

__m128i _mm_rot_epi16(__m128i, __m128i);

_mm_rot_epi32

__m128i _mm_rot_epi32(__m128i, __m128i);

_mm_rot_epi64

__m128i _mm_rot_epi64(__m128i, __m128i);

_mm_rot_epi8

__m128i _mm_rot_epi8(__m128i, __m128i);

_mm_roti_epi16

__m128i _mm_roti_epi16(__m128i, int);

_mm_roti_epi32

__m128i _mm_roti_epi32(__m128i, int);

_mm_roti_epi64

__m128i _mm_roti_epi64(__m128i, int);

_mm_roti_epi8

__m128i _mm_roti_epi8(__m128i, int);

_mm_round_pd

__m128d _mm_round_pd(__m128d val, int iRoundMode);

_mm_round_pd

__m128d _mm_round_pd(__m128d, int);

_mm_round_ps

__m128 _mm_round_ps(__m128 val, int iRoundMode);

_mm_round_ps

__m128 _mm_round_ps(__m128, int);

_mm_round_sd

__m128d _mm_round_sd(__m128d dst, __m128d val, int iRoundMode);

_mm_round_sd

__m128d _mm_round_sd(__m128d, __m128d, int);

_mm_round_ss

__m128 _mm_round_ss(__m128 dst, __m128 val, int iRoundMode);

_mm_round_ss

__m128 _mm_round_ss(__m128, __m128, int);

_mm_rsqrt_ps

__m128 _mm_rsqrt_ps(__m128 _A);

_mm_rsqrt_ps

__m128 _mm_rsqrt_ps(__m128);

_mm_rsqrt_ss

__m128 _mm_rsqrt_ss(__m128 _A);

_mm_rsqrt_ss

__m128 _mm_rsqrt_ss(__m128);

_mm_sad_epu8

__m128i _mm_sad_epu8(__m128i _A, __m128i _B);

_mm_sad_epu8

__m128i _mm_sad_epu8(__m128i, __m128i);

_mm_set_epi16

__m128i _mm_set_epi16(short _W7, short _W6, short _W5, short _W4, short _W3, short _W2, short _W1, short _W0);

_mm_set_epi16

__m128i _mm_set_epi16(short, short, short, short, short, short, short, short);

_mm_set_epi32

__m128i _mm_set_epi32(int _I3, int _I2, int _I1, int _I0);

_mm_set_epi32

__m128i _mm_set_epi32(int, int, int, int);

_mm_set_epi64

__m128i _mm_set_epi64(__m64 _Q1, __m64 _Q0);

_mm_set_epi64

__m128i _mm_set_epi64(__m64, __m64);

_mm_set_epi8

__m128i _mm_set_epi8(char _B15, char _B14, char _B13, char _B12, char _B11, char _B10, char _B9, char _B8, char _B7, char _B6, char _B5, char _B4, char _B3, char _B2, char _B1, char _B0);

_mm_set_epi8

__m128i _mm_set_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);

_mm_set_pd

__m128d _mm_set_pd(double _Z, double _Y);

_mm_set_pd

__m128d _mm_set_pd(double, double);

_mm_set_pi16

__m64 _mm_set_pi16(short _S3, short _S2, short _S1, short _S0);

_mm_set_pi16

__m64 _mm_set_pi16(short, short, short, short);

_mm_set_pi32

__m64 _mm_set_pi32(int _I1, int _I0);

_mm_set_pi32

__m64 _mm_set_pi32(int, int);

_mm_set_pi8

__m64 _mm_set_pi8(char _B7, char _B6, char _B5, char _B4, char _B3, char _B2, char _B1, char _B0);

_mm_set_pi8

__m64 _mm_set_pi8(char, char, char, char, char, char, char, char);

_mm_set_ps

__m128 _mm_set_ps(float _A, float _B, float _C, float _D);

_mm_set_ps

__m128 _mm_set_ps(float, float, float, float);

_mm_set_ps1

__m128 _mm_set_ps1(float _A);

_mm_set_ps1

__m128 _mm_set_ps1(float);

_mm_set_sd

__m128d _mm_set_sd(double _W);

_mm_set_sd

__m128d _mm_set_sd(double);

_mm_set_ss

__m128 _mm_set_ss(float _A);

_mm_set_ss

__m128 _mm_set_ss(float);

_mm_set1_epi16

__m128i _mm_set1_epi16(short _W);

_mm_set1_epi16

__m128i _mm_set1_epi16(short);

_mm_set1_epi32

__m128i _mm_set1_epi32(int _I);

_mm_set1_epi32

__m128i _mm_set1_epi32(int);

_mm_set1_epi64

__m128i _mm_set1_epi64(__m64 _Q);

_mm_set1_epi64

__m128i _mm_set1_epi64(__m64);

_mm_set1_epi8

__m128i _mm_set1_epi8(char _B);

_mm_set1_epi8

__m128i _mm_set1_epi8(char);

_mm_set1_pd

__m128d _mm_set1_pd(double _A);

_mm_set1_pd

__m128d _mm_set1_pd(double);

_mm_set1_pi16

__m64 _mm_set1_pi16(short _S);

_mm_set1_pi16

__m64 _mm_set1_pi16(short);

_mm_set1_pi32

__m64 _mm_set1_pi32(int _I);

_mm_set1_pi32

__m64 _mm_set1_pi32(int);

_mm_set1_pi8

__m64 _mm_set1_pi8(char _B);

_mm_set1_pi8

__m64 _mm_set1_pi8(char);

_mm_setcsr

void _mm_setcsr(unsigned int);

_mm_setcsr

void _mm_setcsr(unsigned int);

_mm_setl_epi64

__m128i _mm_setl_epi64(__m128i _Q);

_mm_setl_epi64

__m128i _mm_setl_epi64(__m128i);

_mm_setr_epi16

__m128i _mm_setr_epi16(short _W0, short _W1, short _W2, short _W3, short _W4, short _W5, short _W6, short _W7);

_mm_setr_epi16

__m128i _mm_setr_epi16(short, short, short, short, short, short, short, short);

_mm_setr_epi32

__m128i _mm_setr_epi32(int _I0, int _I1, int _I2, int _I3);

_mm_setr_epi32

__m128i _mm_setr_epi32(int, int, int, int);

_mm_setr_epi64

__m128i _mm_setr_epi64(__m64 _Q0, __m64 _Q1);

_mm_setr_epi64

__m128i _mm_setr_epi64(__m64, __m64);

_mm_setr_epi8

__m128i _mm_setr_epi8(char _B15, char _B14, char _B13, char _B12, char _B11, char _B10, char _B9, char _B8, char _B7, char _B6, char _B5, char _B4, char _B3, char _B2, char _B1, char _B0);

_mm_setr_epi8

__m128i _mm_setr_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);

_mm_setr_pd

__m128d _mm_setr_pd(double _Y, double _Z);

_mm_setr_pd

__m128d _mm_setr_pd(double, double);

_mm_setr_pi16

__m64 _mm_setr_pi16(short _S3, short _S2, short _S1, short _S0);

_mm_setr_pi16

__m64 _mm_setr_pi16(short, short, short, short);

_mm_setr_pi32

__m64 _mm_setr_pi32(int _I1, int _I0);

_mm_setr_pi32

__m64 _mm_setr_pi32(int, int);

_mm_setr_pi8

__m64 _mm_setr_pi8(char _B7, char _B6, char _B5, char _B4, char _B3, char _B2, char _B1, char _B0);

_mm_setr_pi8

__m64 _mm_setr_pi8(char, char, char, char, char, char, char, char);

_mm_setr_ps

__m128 _mm_setr_ps(float _A, float _B, float _C, float _D);

_mm_setr_ps

__m128 _mm_setr_ps(float, float, float, float);

_mm_setzero_pd

__m128d _mm_setzero_pd(void);

_mm_setzero_pd

__m128d _mm_setzero_pd(void);

_mm_setzero_ps

__m128 _mm_setzero_ps(void);

_mm_setzero_ps

__m128 _mm_setzero_ps(void);

_mm_setzero_si128

__m128i _mm_setzero_si128(void);

_mm_setzero_si128

__m128i _mm_setzero_si128(void);

_mm_setzero_si64

__m64 _mm_setzero_si64(void);

_mm_setzero_si64

__m64 _mm_setzero_si64(void);

_mm_sfence

void _mm_sfence(void);

_mm_sfence

void _mm_sfence(void);

_mm_sha_epi16

__m128i _mm_sha_epi16(__m128i, __m128i);

_mm_sha_epi32

__m128i _mm_sha_epi32(__m128i, __m128i);

_mm_sha_epi64

__m128i _mm_sha_epi64(__m128i, __m128i);

_mm_sha_epi8

__m128i _mm_sha_epi8(__m128i, __m128i);

_mm_shl_epi16

__m128i _mm_shl_epi16(__m128i, __m128i);

_mm_shl_epi32

__m128i _mm_shl_epi32(__m128i, __m128i);

_mm_shl_epi64

__m128i _mm_shl_epi64(__m128i, __m128i);

_mm_shl_epi8

__m128i _mm_shl_epi8(__m128i, __m128i);

_mm_shuffle_epi32

__m128i _mm_shuffle_epi32(__m128i _A, int _Imm);

_mm_shuffle_epi32

__m128i _mm_shuffle_epi32(__m128i, int);

_mm_shuffle_epi8

__m128i _mm_shuffle_epi8(__m128i a, __m128i b);

_mm_shuffle_epi8

__m128i _mm_shuffle_epi8(__m128i, __m128i);

_mm_shuffle_pd

__m128d _mm_shuffle_pd(__m128d _A, __m128d _B, int _I);

_mm_shuffle_pd

__m128d _mm_shuffle_pd(__m128d, __m128d, int);

_mm_shuffle_pi8

__m64 _mm_shuffle_pi8(__m64 a, __m64 b);

_mm_shuffle_pi8

__m64 _mm_shuffle_pi8(__m64, __m64);

_mm_shuffle_ps

__m128 _mm_shuffle_ps(__m128 _A, __m128 _B, unsigned int _Imm8);

_mm_shuffle_ps

__m128 _mm_shuffle_ps(__m128, __m128, unsigned int);

_mm_shufflehi_epi16

__m128i _mm_shufflehi_epi16(__m128i _A, int _Imm);

_mm_shufflehi_epi16

__m128i _mm_shufflehi_epi16(__m128i, int);

_mm_shufflelo_epi16

__m128i _mm_shufflelo_epi16(__m128i _A, int _Imm);

_mm_shufflelo_epi16

__m128i _mm_shufflelo_epi16(__m128i, int);

_mm_sign_epi16

__m128i _mm_sign_epi16(__m128i a, __m128i b);

_mm_sign_epi16

__m128i _mm_sign_epi16(__m128i, __m128i);

_mm_sign_epi32

__m128i _mm_sign_epi32(__m128i a, __m128i b);

_mm_sign_epi32

__m128i _mm_sign_epi32(__m128i, __m128i);

_mm_sign_epi8

__m128i _mm_sign_epi8(__m128i a, __m128i b);

_mm_sign_epi8

__m128i _mm_sign_epi8(__m128i, __m128i);

_mm_sign_pi16

__m64 _mm_sign_pi16(__m64 a, __m64 b);

_mm_sign_pi16

__m64 _mm_sign_pi16(__m64, __m64);

_mm_sign_pi32

__m64 _mm_sign_pi32(__m64 a, __m64 b);

_mm_sign_pi32

__m64 _mm_sign_pi32(__m64, __m64);

_mm_sign_pi8

__m64 _mm_sign_pi8(__m64 a, __m64 b);

_mm_sign_pi8

__m64 _mm_sign_pi8(__m64, __m64);

_mm_sll_epi16

__m128i _mm_sll_epi16(__m128i _A, __m128i _Count);

_mm_sll_epi16

__m128i _mm_sll_epi16(__m128i, __m128i);

_mm_sll_epi32

__m128i _mm_sll_epi32(__m128i _A, __m128i _Count);

_mm_sll_epi32

__m128i _mm_sll_epi32(__m128i, __m128i);

_mm_sll_epi64

__m128i _mm_sll_epi64(__m128i _A, __m128i _Count);

_mm_sll_epi64

__m128i _mm_sll_epi64(__m128i, __m128i);

_mm_slli_epi16

__m128i _mm_slli_epi16(__m128i _A, int _Count);

_mm_slli_epi16

__m128i _mm_slli_epi16(__m128i, int);

_mm_slli_epi32

__m128i _mm_slli_epi32(__m128i _A, int _Count);

_mm_slli_epi32

__m128i _mm_slli_epi32(__m128i, int);

_mm_slli_epi64

__m128i _mm_slli_epi64(__m128i _A, int _Count);

_mm_slli_epi64

__m128i _mm_slli_epi64(__m128i, int);

_mm_slli_si128

__m128i _mm_slli_si128(__m128i _A, int _Imm);

_mm_slli_si128

__m128i _mm_slli_si128(__m128i, int);

_mm_sllv_epi32

__m128i __cdecl _mm_sllv_epi32(__m128i, __m128i);

_mm_sllv_epi64

__m128i __cdecl _mm_sllv_epi64(__m128i, __m128i);

_mm_sqrt_pd

__m128d _mm_sqrt_pd(__m128d _A);

_mm_sqrt_pd

__m128d _mm_sqrt_pd(__m128d);

_mm_sqrt_ps

__m128 _mm_sqrt_ps(__m128 _A);

_mm_sqrt_ps

__m128 _mm_sqrt_ps(__m128);

_mm_sqrt_sd

__m128d _mm_sqrt_sd(__m128d _A, __m128d _B);

_mm_sqrt_sd

__m128d _mm_sqrt_sd(__m128d, __m128d);

_mm_sqrt_ss

__m128 _mm_sqrt_ss(__m128 _A);

_mm_sqrt_ss

__m128 _mm_sqrt_ss(__m128);

_mm_sra_epi16

__m128i _mm_sra_epi16(__m128i _A, __m128i _Count);

_mm_sra_epi16

__m128i _mm_sra_epi16(__m128i, __m128i);

_mm_sra_epi32

__m128i _mm_sra_epi32(__m128i _A, __m128i _Count);

_mm_sra_epi32

__m128i _mm_sra_epi32(__m128i, __m128i);

_mm_srai_epi16

__m128i _mm_srai_epi16(__m128i _A, int _Count);

_mm_srai_epi16

__m128i _mm_srai_epi16(__m128i, int);

_mm_srai_epi32

__m128i _mm_srai_epi32(__m128i _A, int _Count);

_mm_srai_epi32

__m128i _mm_srai_epi32(__m128i, int);

_mm_srav_epi32

__m128i __cdecl _mm_srav_epi32(__m128i, __m128i);

_mm_srl_epi16

__m128i _mm_srl_epi16(__m128i _A, __m128i _Count);

_mm_srl_epi16

__m128i _mm_srl_epi16(__m128i, __m128i);

_mm_srl_epi32

__m128i _mm_srl_epi32(__m128i _A, __m128i _Count);

_mm_srl_epi32

__m128i _mm_srl_epi32(__m128i, __m128i);

_mm_srl_epi64

__m128i _mm_srl_epi64(__m128i _A, __m128i _Count);

_mm_srl_epi64

__m128i _mm_srl_epi64(__m128i, __m128i);

_mm_srli_epi16

__m128i _mm_srli_epi16(__m128i _A, int _Count);

_mm_srli_epi16

__m128i _mm_srli_epi16(__m128i, int);

_mm_srli_epi32

__m128i _mm_srli_epi32(__m128i _A, int _Count);

_mm_srli_epi32

__m128i _mm_srli_epi32(__m128i, int);

_mm_srli_epi64

__m128i _mm_srli_epi64(__m128i _A, int _Count);

_mm_srli_epi64

__m128i _mm_srli_epi64(__m128i, int);

_mm_srli_si128

__m128i _mm_srli_si128(__m128i _A, int _Imm);

_mm_srli_si128

__m128i _mm_srli_si128(__m128i, int);

_mm_srlv_epi32

__m128i __cdecl _mm_srlv_epi32(__m128i, __m128i);

_mm_srlv_epi64

__m128i __cdecl _mm_srlv_epi64(__m128i, __m128i);

_mm_store_pd

void _mm_store_pd(double *, __m128d);

_mm_store_pd

void _mm_store_pd(double *_Dp, __m128d _A);

_mm_store_ps

void _mm_store_ps(float *, __m128);

_mm_store_ps

void _mm_store_ps(float *_V, __m128 _A);

_mm_store_ps1

void _mm_store_ps1(float *, __m128);

_mm_store_ps1

void _mm_store_ps1(float *_V, __m128 _A);

_mm_store_sd

void _mm_store_sd(double *, __m128d);

_mm_store_sd

void _mm_store_sd(double *_Dp, __m128d _A);

_mm_store_si128

void _mm_store_si128(__m128i *, __m128i);

_mm_store_si128

void _mm_store_si128(__m128i *_P, __m128i _B);

_mm_store_ss

void _mm_store_ss(float *, __m128);

_mm_store_ss

void _mm_store_ss(float *_V, __m128 _A);

_mm_store1_pd

void _mm_store1_pd(double *, __m128d);

_mm_store1_pd

void _mm_store1_pd(double *_Dp, __m128d _A);

_mm_storeh_pd

void _mm_storeh_pd(double *, __m128d);

_mm_storeh_pd

void _mm_storeh_pd(double *_Dp, __m128d _A);

_mm_storeh_pi

void _mm_storeh_pi(__m64 *, __m128);

_mm_storeh_pi

void _mm_storeh_pi(__m64 *, __m128);

_mm_storel_epi64

void _mm_storel_epi64(__m128i *, __m128i);

_mm_storel_epi64

void _mm_storel_epi64(__m128i *_P, __m128i _Q);

_mm_storel_pd

void _mm_storel_pd(double *, __m128d);

_mm_storel_pd

void _mm_storel_pd(double *_Dp, __m128d _A);

_mm_storel_pi

void _mm_storel_pi(__m64 *, __m128);

_mm_storel_pi

void _mm_storel_pi(__m64 *, __m128);

_mm_storer_pd

void _mm_storer_pd(double *, __m128d);

_mm_storer_pd

void _mm_storer_pd(double *_Dp, __m128d _A);

_mm_storer_ps

void _mm_storer_ps(float *, __m128);

_mm_storer_ps

void _mm_storer_ps(float *_V, __m128 _A);

_mm_storeu_pd

void _mm_storeu_pd(double *, __m128d);

_mm_storeu_pd

void _mm_storeu_pd(double *_Dp, __m128d _A);

_mm_storeu_ps

void _mm_storeu_ps(float *, __m128);

_mm_storeu_ps

void _mm_storeu_ps(float *_V, __m128 _A);

_mm_storeu_si128

void _mm_storeu_si128(__m128i *, __m128i);

_mm_storeu_si128

void _mm_storeu_si128(__m128i *_P, __m128i _B);

_mm_stream_load_si128

__m128i _mm_stream_load_si128(__m128i *);

_mm_stream_load_si128

__m128i _mm_stream_load_si128(__m128i* v1);

_mm_stream_pd

void _mm_stream_pd(double *, __m128d);

_mm_stream_pd

void _mm_stream_pd(double *_Dp, __m128d _A);

_mm_stream_pi

void _mm_stream_pi(__m64 *, __m64);

_mm_stream_pi

void _mm_stream_pi(__m64 *, __m64);

_mm_stream_ps

void _mm_stream_ps(float *, __m128);

_mm_stream_ps

void _mm_stream_ps(float *, __m128);

_mm_stream_sd

void _mm_stream_sd(double *, __m128d);

_mm_stream_si128

void _mm_stream_si128(__m128i *, __m128i);

_mm_stream_si128

void _mm_stream_si128(__m128i *_P, __m128i _A);

_mm_stream_si32

void _mm_stream_si32(int *, int);

_mm_stream_si32

void _mm_stream_si32(int *_P, int _I);

_mm_stream_ss

void _mm_stream_ss(float *, __m128);

_mm_sub_epi16

__m128i _mm_sub_epi16(__m128i _A, __m128i _B);

_mm_sub_epi16

__m128i _mm_sub_epi16(__m128i, __m128i);

_mm_sub_epi32

__m128i _mm_sub_epi32(__m128i _A, __m128i _B);

_mm_sub_epi32

__m128i _mm_sub_epi32(__m128i, __m128i);

_mm_sub_epi64

__m128i _mm_sub_epi64(__m128i _A, __m128i _B);

_mm_sub_epi64

__m128i _mm_sub_epi64(__m128i, __m128i);

_mm_sub_epi8

__m128i _mm_sub_epi8(__m128i _A, __m128i _B);

_mm_sub_epi8

__m128i _mm_sub_epi8(__m128i, __m128i);

_mm_sub_pd

__m128d _mm_sub_pd(__m128d _A, __m128d _B);

_mm_sub_pd

__m128d _mm_sub_pd(__m128d, __m128d);

_mm_sub_ps

__m128 _mm_sub_ps(__m128 _A, __m128 _B);

_mm_sub_ps

__m128 _mm_sub_ps(__m128, __m128);

_mm_sub_sd

__m128d _mm_sub_sd(__m128d _A, __m128d _B);

_mm_sub_sd

__m128d _mm_sub_sd(__m128d, __m128d);

_mm_sub_si64

__m64 _mm_sub_si64(__m64 _A, __m64 _B);

_mm_sub_si64

__m64 _mm_sub_si64(__m64, __m64);

_mm_sub_ss

__m128 _mm_sub_ss(__m128 _A, __m128 _B);

_mm_sub_ss

__m128 _mm_sub_ss(__m128, __m128);

_mm_subs_epi16

__m128i _mm_subs_epi16(__m128i _A, __m128i _B);

_mm_subs_epi16

__m128i _mm_subs_epi16(__m128i, __m128i);

_mm_subs_epi8

__m128i _mm_subs_epi8(__m128i _A, __m128i _B);

_mm_subs_epi8

__m128i _mm_subs_epi8(__m128i, __m128i);

_mm_subs_epu16

__m128i _mm_subs_epu16(__m128i _A, __m128i _B);

_mm_subs_epu16

__m128i _mm_subs_epu16(__m128i, __m128i);

_mm_subs_epu8

__m128i _mm_subs_epu8(__m128i _A, __m128i _B);

_mm_subs_epu8

__m128i _mm_subs_epu8(__m128i, __m128i);

_mm_testc_pd

int __cdecl _mm_testc_pd(__m128d, __m128d);

_mm_testc_ps

int __cdecl _mm_testc_ps(__m128, __m128);

_mm_testc_si128

int _mm_testc_si128(__m128i mask, __m128i val);

_mm_testc_si128

int _mm_testc_si128(__m128i, __m128i);

_mm_testnzc_pd

int __cdecl _mm_testnzc_pd(__m128d, __m128d);

_mm_testnzc_ps

int __cdecl _mm_testnzc_ps(__m128, __m128);

_mm_testnzc_si128

int _mm_testnzc_si128(__m128i mask, __m128i s2);

_mm_testnzc_si128

int _mm_testnzc_si128(__m128i, __m128i);

_mm_testz_pd

int __cdecl _mm_testz_pd(__m128d, __m128d);

_mm_testz_ps

int __cdecl _mm_testz_ps(__m128, __m128);

_mm_testz_si128

int _mm_testz_si128(__m128i mask, __m128i val);

_mm_testz_si128

int _mm_testz_si128(__m128i, __m128i);

_mm_ucomieq_sd

int _mm_ucomieq_sd(__m128d _A, __m128d _B);

_mm_ucomieq_sd

int _mm_ucomieq_sd(__m128d, __m128d);

_mm_ucomieq_ss

int _mm_ucomieq_ss(__m128 _A, __m128 _B);

_mm_ucomieq_ss

int _mm_ucomieq_ss(__m128, __m128);

_mm_ucomige_sd

int _mm_ucomige_sd(__m128d _A, __m128d _B);

_mm_ucomige_sd

int _mm_ucomige_sd(__m128d, __m128d);

_mm_ucomige_ss

int _mm_ucomige_ss(__m128 _A, __m128 _B);

_mm_ucomige_ss

int _mm_ucomige_ss(__m128, __m128);

_mm_ucomigt_sd

int _mm_ucomigt_sd(__m128d _A, __m128d _B);

_mm_ucomigt_sd

int _mm_ucomigt_sd(__m128d, __m128d);

_mm_ucomigt_ss

int _mm_ucomigt_ss(__m128 _A, __m128 _B);

_mm_ucomigt_ss

int _mm_ucomigt_ss(__m128, __m128);

_mm_ucomile_sd

int _mm_ucomile_sd(__m128d _A, __m128d _B);

_mm_ucomile_sd

int _mm_ucomile_sd(__m128d, __m128d);

_mm_ucomile_ss

int _mm_ucomile_ss(__m128 _A, __m128 _B);

_mm_ucomile_ss

int _mm_ucomile_ss(__m128, __m128);

_mm_ucomilt_sd

int _mm_ucomilt_sd(__m128d _A, __m128d _B);

_mm_ucomilt_sd

int _mm_ucomilt_sd(__m128d, __m128d);

_mm_ucomilt_ss

int _mm_ucomilt_ss(__m128 _A, __m128 _B);

_mm_ucomilt_ss

int _mm_ucomilt_ss(__m128, __m128);

_mm_ucomineq_sd

int _mm_ucomineq_sd(__m128d _A, __m128d _B);

_mm_ucomineq_sd

int _mm_ucomineq_sd(__m128d, __m128d);

_mm_ucomineq_ss

int _mm_ucomineq_ss(__m128 _A, __m128 _B);

_mm_ucomineq_ss

int _mm_ucomineq_ss(__m128, __m128);

_mm_unpackhi_epi16

__m128i _mm_unpackhi_epi16(__m128i _A, __m128i _B);

_mm_unpackhi_epi16

__m128i _mm_unpackhi_epi16(__m128i, __m128i);

_mm_unpackhi_epi32

__m128i _mm_unpackhi_epi32(__m128i _A, __m128i _B);

_mm_unpackhi_epi32

__m128i _mm_unpackhi_epi32(__m128i, __m128i);

_mm_unpackhi_epi64

__m128i _mm_unpackhi_epi64(__m128i _A, __m128i _B);

_mm_unpackhi_epi64

__m128i _mm_unpackhi_epi64(__m128i, __m128i);

_mm_unpackhi_epi8

__m128i _mm_unpackhi_epi8(__m128i _A, __m128i _B);

_mm_unpackhi_epi8

__m128i _mm_unpackhi_epi8(__m128i, __m128i);

_mm_unpackhi_pd

__m128d _mm_unpackhi_pd(__m128d _A, __m128d _B);

_mm_unpackhi_pd

__m128d _mm_unpackhi_pd(__m128d, __m128d);

_mm_unpackhi_ps

__m128 _mm_unpackhi_ps(__m128 _A, __m128 _B);

_mm_unpackhi_ps

__m128 _mm_unpackhi_ps(__m128, __m128);

_mm_unpacklo_epi16

__m128i _mm_unpacklo_epi16(__m128i _A, __m128i _B);

_mm_unpacklo_epi16

__m128i _mm_unpacklo_epi16(__m128i, __m128i);

_mm_unpacklo_epi32

__m128i _mm_unpacklo_epi32(__m128i _A, __m128i _B);

_mm_unpacklo_epi32

__m128i _mm_unpacklo_epi32(__m128i, __m128i);

_mm_unpacklo_epi64

__m128i _mm_unpacklo_epi64(__m128i _A, __m128i _B);

_mm_unpacklo_epi64

__m128i _mm_unpacklo_epi64(__m128i, __m128i);

_mm_unpacklo_epi8

__m128i _mm_unpacklo_epi8(__m128i _A, __m128i _B);

_mm_unpacklo_epi8

__m128i _mm_unpacklo_epi8(__m128i, __m128i);

_mm_unpacklo_pd

__m128d _mm_unpacklo_pd(__m128d _A, __m128d _B);

_mm_unpacklo_pd

__m128d _mm_unpacklo_pd(__m128d, __m128d);

_mm_unpacklo_ps

__m128 _mm_unpacklo_ps(__m128 _A, __m128 _B);

_mm_unpacklo_ps

__m128 _mm_unpacklo_ps(__m128, __m128);

_mm_xor_pd

__m128d _mm_xor_pd(__m128d _A, __m128d _B);

_mm_xor_pd

__m128d _mm_xor_pd(__m128d, __m128d);

_mm_xor_ps

__m128 _mm_xor_ps(__m128 _A, __m128 _B);

_mm_xor_ps

__m128 _mm_xor_ps(__m128, __m128);

_mm_xor_si128

__m128i _mm_xor_si128(__m128i _A, __m128i _B);

_mm_xor_si128

__m128i _mm_xor_si128(__m128i, __m128i);

_mm256_abs_epi16

__m256i __cdecl _mm256_abs_epi16(__m256i);

_mm256_abs_epi32

__m256i __cdecl _mm256_abs_epi32(__m256i);

_mm256_abs_epi8

__m256i __cdecl _mm256_abs_epi8(__m256i);

_mm256_add_epi16

__m256i __cdecl _mm256_add_epi16(__m256i, __m256i);

_mm256_add_epi32

__m256i __cdecl _mm256_add_epi32(__m256i, __m256i);

_mm256_add_epi64

__m256i __cdecl _mm256_add_epi64(__m256i, __m256i);

_mm256_add_epi8

__m256i __cdecl _mm256_add_epi8(__m256i, __m256i);

_mm256_add_pd

__m256d __cdecl _mm256_add_pd(__m256d, __m256d);

_mm256_add_ps

__m256 __cdecl _mm256_add_ps(__m256, __m256);

_mm256_adds_epi16

__m256i __cdecl _mm256_adds_epi16(__m256i, __m256i);

_mm256_adds_epi8

__m256i __cdecl _mm256_adds_epi8(__m256i, __m256i);

_mm256_adds_epu16

__m256i __cdecl _mm256_adds_epu16(__m256i, __m256i);

_mm256_adds_epu8

__m256i __cdecl _mm256_adds_epu8(__m256i, __m256i);

_mm256_addsub_pd

__m256d __cdecl _mm256_addsub_pd(__m256d, __m256d);

_mm256_addsub_ps

__m256 __cdecl _mm256_addsub_ps(__m256, __m256);

_mm256_alignr_epi8

__m256i __cdecl _mm256_alignr_epi8(__m256i, __m256i, const int);

_mm256_and_pd

__m256d __cdecl _mm256_and_pd(__m256d, __m256d);

_mm256_and_ps

__m256 __cdecl _mm256_and_ps(__m256, __m256);

_mm256_and_si256

__m256i __cdecl _mm256_and_si256(__m256i, __m256i);

_mm256_andnot_pd

__m256d __cdecl _mm256_andnot_pd(__m256d, __m256d);

_mm256_andnot_ps

__m256 __cdecl _mm256_andnot_ps(__m256, __m256);

_mm256_andnot_si256

__m256i __cdecl _mm256_andnot_si256(__m256i, __m256i);

_mm256_avg_epu16

__m256i __cdecl _mm256_avg_epu16(__m256i, __m256i);

_mm256_avg_epu8

__m256i __cdecl _mm256_avg_epu8(__m256i, __m256i);

_mm256_blend_epi16

__m256i __cdecl _mm256_blend_epi16(__m256i, __m256i, const int);

_mm256_blend_epi32

__m256i __cdecl _mm256_blend_epi32(__m256i,__m256i, const int);

_mm256_blend_pd

__m256d __cdecl _mm256_blend_pd(__m256d, __m256d, const int);

_mm256_blend_ps

__m256 __cdecl _mm256_blend_ps(__m256, __m256, const int);

_mm256_blendv_epi8

__m256i __cdecl _mm256_blendv_epi8(__m256i, __m256i, __m256i);

_mm256_blendv_pd

__m256d __cdecl _mm256_blendv_pd(__m256d, __m256d, __m256d);

_mm256_blendv_ps

__m256 __cdecl _mm256_blendv_ps(__m256, __m256, __m256);

_mm256_broadcast_pd

__m256d __cdecl _mm256_broadcast_pd(__m128d const *);

_mm256_broadcast_ps

__m256 __cdecl _mm256_broadcast_ps(__m128 const *);

_mm256_broadcast_sd

__m256d __cdecl _mm256_broadcast_sd(double const *);

_mm256_broadcast_ss

__m256 __cdecl _mm256_broadcast_ss(float const *);

_mm256_broadcastb_epi8

__m256i __cdecl _mm256_broadcastb_epi8(__m128i);

_mm256_broadcastd_epi32

__m256i __cdecl _mm256_broadcastd_epi32(__m128i);

_mm256_broadcastq_epi64

__m256i __cdecl _mm256_broadcastq_epi64(__m128i);

_mm256_broadcastsd_pd

__m256d __cdecl _mm256_broadcastsd_pd(__m128d);

_mm256_broadcastsi128_si256

__m256i __cdecl _mm256_broadcastsi128_si256(__m128i);

_mm256_broadcastss_ps

__m256 __cdecl _mm256_broadcastss_ps(__m128);

_mm256_broadcastw_epi16

__m256i __cdecl _mm256_broadcastw_epi16(__m128i);

_mm256_castpd_ps

__m256 __cdecl _mm256_castpd_ps(__m256d);

_mm256_castpd_si256

__m256i __cdecl _mm256_castpd_si256(__m256d);

_mm256_castpd128_pd256

__m256d __cdecl _mm256_castpd128_pd256(__m128d);

_mm256_castpd256_pd128

__m128d __cdecl _mm256_castpd256_pd128(__m256d);

_mm256_castps_pd

__m256d __cdecl _mm256_castps_pd(__m256);

_mm256_castps_si256

__m256i __cdecl _mm256_castps_si256(__m256);

_mm256_castps128_ps256

__m256 __cdecl _mm256_castps128_ps256(__m128);

_mm256_castps256_ps128

__m128 __cdecl _mm256_castps256_ps128(__m256);

_mm256_castsi128_si256

__m256i __cdecl _mm256_castsi128_si256(__m128i);

_mm256_castsi256_pd

__m256d __cdecl _mm256_castsi256_pd(__m256i);

_mm256_castsi256_ps

__m256 __cdecl _mm256_castsi256_ps(__m256i);

_mm256_castsi256_si128

__m128i __cdecl _mm256_castsi256_si128(__m256i);

_mm256_cmov_si256

__m256i _mm256_cmov_si256(__m256i, __m256i, __m256i);

_mm256_cmp_pd

__m256d __cdecl _mm256_cmp_pd(__m256d, __m256d, const int);

_mm256_cmp_ps

__m256 __cdecl _mm256_cmp_ps(__m256, __m256, const int);

_mm256_cmpeq_epi16

__m256i __cdecl _mm256_cmpeq_epi16(__m256i, __m256i);

_mm256_cmpeq_epi32

__m256i __cdecl _mm256_cmpeq_epi32(__m256i, __m256i);

_mm256_cmpeq_epi64

__m256i __cdecl _mm256_cmpeq_epi64(__m256i, __m256i);

_mm256_cmpeq_epi8

__m256i __cdecl _mm256_cmpeq_epi8(__m256i, __m256i);

_mm256_cmpgt_epi16

__m256i __cdecl _mm256_cmpgt_epi16(__m256i, __m256i);

_mm256_cmpgt_epi32

__m256i __cdecl _mm256_cmpgt_epi32(__m256i, __m256i);

_mm256_cmpgt_epi64

__m256i __cdecl _mm256_cmpgt_epi64(__m256i, __m256i);

_mm256_cmpgt_epi8

__m256i __cdecl _mm256_cmpgt_epi8(__m256i, __m256i);

_mm256_cvtepi16_epi32

__m256i __cdecl _mm256_cvtepi16_epi32(__m128i);

_mm256_cvtepi16_epi64

__m256i __cdecl _mm256_cvtepi16_epi64(__m128i);

_mm256_cvtepi32_epi64

__m256i __cdecl _mm256_cvtepi32_epi64(__m128i);

_mm256_cvtepi32_pd

__m256d __cdecl _mm256_cvtepi32_pd(__m128i);

_mm256_cvtepi32_ps

__m256 __cdecl _mm256_cvtepi32_ps(__m256i);

_mm256_cvtepi8_epi16

__m256i __cdecl _mm256_cvtepi8_epi16(__m128i);

_mm256_cvtepi8_epi32

__m256i __cdecl _mm256_cvtepi8_epi32(__m128i);

_mm256_cvtepi8_epi64

__m256i __cdecl _mm256_cvtepi8_epi64(__m128i);

_mm256_cvtepu16_epi32

__m256i __cdecl _mm256_cvtepu16_epi32(__m128i);

_mm256_cvtepu16_epi64

__m256i __cdecl _mm256_cvtepu16_epi64(__m128i);

_mm256_cvtepu32_epi64

__m256i __cdecl _mm256_cvtepu32_epi64(__m128i);

_mm256_cvtepu8_epi16

__m256i __cdecl _mm256_cvtepu8_epi16(__m128i);

_mm256_cvtepu8_epi32

__m256i __cdecl _mm256_cvtepu8_epi32(__m128i);

_mm256_cvtepu8_epi64

__m256i __cdecl _mm256_cvtepu8_epi64(__m128i);

_mm256_cvtpd_epi32

__m128i __cdecl _mm256_cvtpd_epi32(__m256d);

_mm256_cvtpd_ps

__m128 __cdecl _mm256_cvtpd_ps(__m256d);

_mm256_cvtph_ps

__m256 __cdecl _mm256_cvtph_ps(__m128i);

_mm256_cvtps_epi32

__m256i __cdecl _mm256_cvtps_epi32(__m256);

_mm256_cvtps_pd

__m256d __cdecl _mm256_cvtps_pd(__m128);

_mm256_cvtps_ph

__m128i __cdecl _mm256_cvtps_ph(__m256, int);

_mm256_cvttpd_epi32

__m128i __cdecl _mm256_cvttpd_epi32(__m256d);

_mm256_cvttps_epi32

__m256i __cdecl _mm256_cvttps_epi32(__m256);

_mm256_div_pd

__m256d __cdecl _mm256_div_pd(__m256d, __m256d);

_mm256_div_ps

__m256 __cdecl _mm256_div_ps(__m256, __m256);

_mm256_dp_ps

__m256 __cdecl _mm256_dp_ps(__m256, __m256, const int);

_mm256_extractf128_pd

__m128d __cdecl _mm256_extractf128_pd(__m256d, const int);

_mm256_extractf128_ps

__m128 __cdecl _mm256_extractf128_ps(__m256, const int);

_mm256_extractf128_si256

__m128i __cdecl _mm256_extractf128_si256(__m256i, const int);

_mm256_extracti128_si256

__m128i __cdecl _mm256_extracti128_si256(__m256i, const int);

_mm256_fmadd_pd

__m256d __cdecl _mm256_fmadd_pd(__m256d, __m256d, __m256d);

_mm256_fmadd_ps

__m256 __cdecl _mm256_fmadd_ps(__m256, __m256, __m256);

_mm256_fmaddsub_pd

__m256d __cdecl _mm256_fmaddsub_pd(__m256d, __m256d, __m256d);

_mm256_fmaddsub_ps

__m256 __cdecl _mm256_fmaddsub_ps(__m256, __m256, __m256);

_mm256_fmsub_pd

__m256d __cdecl _mm256_fmsub_pd(__m256d, __m256d, __m256d);

_mm256_fmsub_ps

__m256 __cdecl _mm256_fmsub_ps(__m256, __m256, __m256);

_mm256_fmsubadd_pd

__m256d __cdecl _mm256_fmsubadd_pd(__m256d, __m256d, __m256d);

_mm256_fmsubadd_ps

__m256 __cdecl _mm256_fmsubadd_ps(__m256, __m256, __m256);

_mm256_fnmadd_pd

__m256d __cdecl _mm256_fnmadd_pd(__m256d, __m256d, __m256d);

_mm256_fnmadd_ps

__m256 __cdecl _mm256_fnmadd_ps(__m256, __m256, __m256);

_mm256_fnmsub_pd

__m256d __cdecl _mm256_fnmsub_pd(__m256d, __m256d, __m256d);

_mm256_fnmsub_ps

__m256 __cdecl _mm256_fnmsub_ps(__m256, __m256, __m256);

_mm256_frcz_pd

__m256d _mm256_frcz_pd(__m256d);

_mm256_frcz_ps

__m256 _mm256_frcz_ps(__m256);

_mm256_hadd_epi16

__m256i __cdecl _mm256_hadd_epi16(__m256i, __m256i);

_mm256_hadd_epi32

__m256i __cdecl _mm256_hadd_epi32(__m256i, __m256i);

_mm256_hadd_pd

__m256d __cdecl _mm256_hadd_pd(__m256d, __m256d);

_mm256_hadd_ps

__m256 __cdecl _mm256_hadd_ps(__m256, __m256);

_mm256_hadds_epi16

__m256i __cdecl _mm256_hadds_epi16(__m256i, __m256i);

_mm256_hsub_epi16

__m256i __cdecl _mm256_hsub_epi16(__m256i, __m256i);

_mm256_hsub_epi32

__m256i __cdecl _mm256_hsub_epi32(__m256i, __m256i);

_mm256_hsub_pd

__m256d __cdecl _mm256_hsub_pd(__m256d, __m256d);

_mm256_hsub_ps

__m256 __cdecl _mm256_hsub_ps(__m256, __m256);

_mm256_hsubs_epi16

__m256i __cdecl _mm256_hsubs_epi16(__m256i, __m256i);

_mm256_i32gather_epi32

__m256i __cdecl _mm256_i32gather_epi32(int const *, __m256i, const int );

_mm256_i32gather_epi64

__m256i __cdecl _mm256_i32gather_epi64(__int64 const *, __m128i, const int );

_mm256_i32gather_pd

__m256d __cdecl _mm256_i32gather_pd(double const *, __m128i, const int );

_mm256_i32gather_ps

__m256 __cdecl _mm256_i32gather_ps(float const *, __m256i, const int );

_mm256_i64gather_epi32

__m128i __cdecl _mm256_i64gather_epi32(int const *, __m256i, const int );

_mm256_i64gather_epi64

__m256i __cdecl _mm256_i64gather_epi64(__int64 const *, __m256i, const int );

_mm256_i64gather_pd

__m256d __cdecl _mm256_i64gather_pd(double const *, __m256i, const int );

_mm256_i64gather_ps

__m128 __cdecl _mm256_i64gather_ps(float const *, __m256i, const int );

_mm256_insertf128_pd

__m256d __cdecl _mm256_insertf128_pd(__m256d, __m128d, int);

_mm256_insertf128_ps

__m256 __cdecl _mm256_insertf128_ps(__m256, __m128, int);

_mm256_insertf128_si256

__m256i __cdecl _mm256_insertf128_si256(__m256i, __m128i, int);

_mm256_inserti128_si256

__m256i __cdecl _mm256_inserti128_si256(__m256i, __m128i, const int);

_mm256_lddqu_si256

__m256i __cdecl _mm256_lddqu_si256(__m256i const *);

_mm256_load_pd

__m256d __cdecl _mm256_load_pd(double const *);

_mm256_load_ps

__m256 __cdecl _mm256_load_ps(float const *);

_mm256_load_si256

__m256i __cdecl _mm256_load_si256(__m256i const *);

_mm256_loadu_pd

__m256d __cdecl _mm256_loadu_pd(double const *);

_mm256_loadu_ps

__m256 __cdecl _mm256_loadu_ps(float const *);

_mm256_loadu_si256

__m256i __cdecl _mm256_loadu_si256(__m256i const *);

_mm256_macc_pd

__m256d _mm256_macc_pd(__m256d, __m256d, __m256d);

_mm256_macc_ps

__m256 _mm256_macc_ps(__m256, __m256, __m256);

_mm256_madd_epi16

__m256i __cdecl _mm256_madd_epi16(__m256i, __m256i);

_mm256_maddsub_pd

__m256d _mm256_maddsub_pd(__m256d, __m256d, __m256d);

_mm256_maddsub_ps

__m256 _mm256_maddsub_ps(__m256, __m256, __m256);

_mm256_maddubs_epi16

__m256i __cdecl _mm256_maddubs_epi16(__m256i, __m256i);

_mm256_mask_i32gather_epi32

__m256i __cdecl _mm256_mask_i32gather_epi32(__m256i, int const *, __m256i, __m256i, const int );

_mm256_mask_i32gather_epi64

__m256i __cdecl _mm256_mask_i32gather_epi64(__m256i, __int64 const *, __m128i, __m256i, const int );

_mm256_mask_i32gather_pd

__m256d __cdecl _mm256_mask_i32gather_pd(__m256d, double const *, __m128i, __m256d, const int );

_mm256_mask_i32gather_ps

__m256 __cdecl _mm256_mask_i32gather_ps(__m256, float const *, __m256i, __m256, const int );

_mm256_mask_i64gather_epi32

__m128i __cdecl _mm256_mask_i64gather_epi32(__m128i, int const *, __m256i, __m128i, const int );

_mm256_mask_i64gather_epi64

__m256i __cdecl _mm256_mask_i64gather_epi64(__m256i, __int64 const *, __m256i, __m256i, const int );

_mm256_mask_i64gather_pd

__m256d __cdecl _mm256_mask_i64gather_pd(__m256d, double const *, __m256i, __m256d, const int );

_mm256_mask_i64gather_ps

__m128 __cdecl _mm256_mask_i64gather_ps(__m128, float const *, __m256i, __m128, const int );

_mm256_maskload_epi32

__m256i __cdecl _mm256_maskload_epi32(int const *, __m256i );

_mm256_maskload_epi64

__m256i __cdecl _mm256_maskload_epi64(__int64 const *, __m256i );

_mm256_maskload_pd

__m256d __cdecl _mm256_maskload_pd(double const *, __m256i);

_mm256_maskload_ps

__m256 __cdecl _mm256_maskload_ps(float const *, __m256i);

_mm256_maskstore_epi32

void __cdecl _mm256_maskstore_epi32(int *, __m256i, __m256i );

_mm256_maskstore_epi64

void __cdecl _mm256_maskstore_epi64(__int64 *, __m256i, __m256i );

_mm256_maskstore_pd

void __cdecl _mm256_maskstore_pd(double *, __m256i, __m256d);

_mm256_maskstore_ps

void __cdecl _mm256_maskstore_ps(float *, __m256i, __m256);

_mm256_max_epi16

__m256i __cdecl _mm256_max_epi16(__m256i, __m256i);

_mm256_max_epi32

__m256i __cdecl _mm256_max_epi32(__m256i, __m256i);

_mm256_max_epi8

__m256i __cdecl _mm256_max_epi8(__m256i, __m256i);

_mm256_max_epu16

__m256i __cdecl _mm256_max_epu16(__m256i, __m256i);

_mm256_max_epu32

__m256i __cdecl _mm256_max_epu32(__m256i, __m256i);

_mm256_max_epu8

__m256i __cdecl _mm256_max_epu8(__m256i, __m256i);

_mm256_max_pd

__m256d __cdecl _mm256_max_pd(__m256d, __m256d);

_mm256_max_ps

__m256 __cdecl _mm256_max_ps(__m256, __m256);

_mm256_min_epi16

__m256i __cdecl _mm256_min_epi16(__m256i, __m256i);

_mm256_min_epi32

__m256i __cdecl _mm256_min_epi32(__m256i, __m256i);

_mm256_min_epi8

__m256i __cdecl _mm256_min_epi8(__m256i, __m256i);

_mm256_min_epu16

__m256i __cdecl _mm256_min_epu16(__m256i, __m256i);

_mm256_min_epu32

__m256i __cdecl _mm256_min_epu32(__m256i, __m256i);

_mm256_min_epu8

__m256i __cdecl _mm256_min_epu8(__m256i, __m256i);

_mm256_min_pd

__m256d __cdecl _mm256_min_pd(__m256d, __m256d);

_mm256_min_ps

__m256 __cdecl _mm256_min_ps(__m256, __m256);

_mm256_movedup_pd

__m256d __cdecl _mm256_movedup_pd(__m256d);

_mm256_movehdup_ps

__m256 __cdecl _mm256_movehdup_ps(__m256);

_mm256_moveldup_ps

__m256 __cdecl _mm256_moveldup_ps(__m256);

_mm256_movemask_epi8

int __cdecl _mm256_movemask_epi8(__m256i);

_mm256_movemask_pd

int __cdecl _mm256_movemask_pd(__m256d);

_mm256_movemask_ps

int __cdecl _mm256_movemask_ps(__m256);

_mm256_mpsadbw_epu8

__m256i __cdecl _mm256_mpsadbw_epu8(__m256i, __m256i, const int);

_mm256_msub_pd

__m256d _mm256_msub_pd(__m256d, __m256d, __m256d);

_mm256_msub_ps

__m256 _mm256_msub_ps(__m256, __m256, __m256);

_mm256_msubadd_pd

__m256d _mm256_msubadd_pd(__m256d, __m256d, __m256d);

_mm256_msubadd_ps

__m256 _mm256_msubadd_ps(__m256, __m256, __m256);

_mm256_mul_epi32

__m256i __cdecl _mm256_mul_epi32(__m256i, __m256i);

_mm256_mul_epu32

__m256i __cdecl _mm256_mul_epu32(__m256i, __m256i);

_mm256_mul_pd

__m256d __cdecl _mm256_mul_pd(__m256d, __m256d);

_mm256_mul_ps

__m256 __cdecl _mm256_mul_ps(__m256, __m256);

_mm256_mulhi_epi16

__m256i __cdecl _mm256_mulhi_epi16(__m256i, __m256i);

_mm256_mulhi_epu16

__m256i __cdecl _mm256_mulhi_epu16(__m256i, __m256i);

_mm256_mulhrs_epi16

__m256i __cdecl _mm256_mulhrs_epi16(__m256i, __m256i);

_mm256_mullo_epi16

__m256i __cdecl _mm256_mullo_epi16(__m256i, __m256i);

_mm256_mullo_epi32

__m256i __cdecl _mm256_mullo_epi32(__m256i, __m256i);

_mm256_nmacc_pd

__m256d _mm256_nmacc_pd(__m256d, __m256d, __m256d);

_mm256_nmacc_ps

__m256 _mm256_nmacc_ps(__m256, __m256, __m256);

_mm256_nmsub_pd

__m256d _mm256_nmsub_pd(__m256d, __m256d, __m256d);

_mm256_nmsub_ps

__m256 _mm256_nmsub_ps(__m256, __m256, __m256);

_mm256_or_pd

__m256d __cdecl _mm256_or_pd(__m256d, __m256d);

_mm256_or_ps

__m256 __cdecl _mm256_or_ps(__m256, __m256);

_mm256_or_si256

__m256i __cdecl _mm256_or_si256(__m256i, __m256i);

_mm256_packs_epi16

__m256i __cdecl _mm256_packs_epi16(__m256i, __m256i);

_mm256_packs_epi32

__m256i __cdecl _mm256_packs_epi32(__m256i, __m256i);

_mm256_packus_epi16

__m256i __cdecl _mm256_packus_epi16(__m256i, __m256i);

_mm256_packus_epi32

__m256i __cdecl _mm256_packus_epi32(__m256i, __m256i);

_mm256_permute_pd

__m256d __cdecl _mm256_permute_pd(__m256d, int);

_mm256_permute_ps

__m256 __cdecl _mm256_permute_ps(__m256, int);

_mm256_permute2_pd

__m256d _mm256_permute2_pd(__m256d, __m256d, __m256i, int);

_mm256_permute2_ps

__m256 _mm256_permute2_ps(__m256, __m256, __m256i, int);

_mm256_permute2f128_pd

__m256d __cdecl _mm256_permute2f128_pd(__m256d, __m256d, int);

_mm256_permute2f128_ps

__m256 __cdecl _mm256_permute2f128_ps(__m256, __m256, int);

_mm256_permute2f128_si256

__m256i __cdecl _mm256_permute2f128_si256(__m256i, __m256i, int);

_mm256_permute2x128_si256

__m256i __cdecl _mm256_permute2x128_si256(__m256i, __m256i, const int);

_mm256_permute4x64_epi64

__m256i __cdecl _mm256_permute4x64_epi64(__m256i, const int);

_mm256_permute4x64_pd

__m256d __cdecl _mm256_permute4x64_pd(__m256d, const int);

_mm256_permutevar_pd

__m256d __cdecl _mm256_permutevar_pd(__m256d, __m256i);

_mm256_permutevar_ps

__m256 __cdecl _mm256_permutevar_ps(__m256, __m256i);

_mm256_permutevar8x32_epi32

__m256i __cdecl _mm256_permutevar8x32_epi32(__m256i, __m256i);

_mm256_permutevar8x32_ps

__m256 __cdecl _mm256_permutevar8x32_ps(__m256, __m256i);

_mm256_rcp_ps

__m256 __cdecl _mm256_rcp_ps(__m256);

_mm256_round_pd

__m256d __cdecl _mm256_round_pd(__m256d, int);

_mm256_round_ps

__m256 __cdecl _mm256_round_ps(__m256, int);

_mm256_rsqrt_ps

__m256 __cdecl _mm256_rsqrt_ps(__m256);

_mm256_sad_epu8

__m256i __cdecl _mm256_sad_epu8(__m256i, __m256i);

_mm256_set_epi16

__m256i __cdecl _mm256_set_epi16(short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short);

_mm256_set_epi32

__m256i __cdecl _mm256_set_epi32(int, int, int, int, int, int, int, int);

_mm256_set_epi64x

__m256i __cdecl _mm256_set_epi64x(__int64, __int64, __int64, __int64);

_mm256_set_epi8

__m256i __cdecl _mm256_set_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);

_mm256_set_pd

__m256d __cdecl _mm256_set_pd(double, double, double, double);

_mm256_set_ps

__m256 __cdecl _mm256_set_ps(float, float, float, float, float, float, float, float);

_mm256_set1_epi16

__m256i __cdecl _mm256_set1_epi16(short);

_mm256_set1_epi32

__m256i __cdecl _mm256_set1_epi32(int);

_mm256_set1_epi64x

__m256i __cdecl _mm256_set1_epi64x(long long);

_mm256_set1_epi8

__m256i __cdecl _mm256_set1_epi8(char);

_mm256_set1_pd

__m256d __cdecl _mm256_set1_pd(double);

_mm256_set1_ps

__m256 __cdecl _mm256_set1_ps(float);

_mm256_setr_epi16

__m256i __cdecl _mm256_setr_epi16(short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short);

_mm256_setr_epi32

__m256i __cdecl _mm256_setr_epi32(int, int, int, int, int, int, int, int);

_mm256_setr_epi64x

__m256i __cdecl _mm256_setr_epi64x(__int64, __int64, __int64, __int64);

_mm256_setr_epi8

__m256i __cdecl _mm256_setr_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);

_mm256_setr_pd

__m256d __cdecl _mm256_setr_pd(double, double, double, double);

_mm256_setr_ps

__m256 __cdecl _mm256_setr_ps(float, float, float, float, float, float, float, float);

_mm256_setzero_pd

__m256d __cdecl _mm256_setzero_pd(void);

_mm256_setzero_ps

__m256 __cdecl _mm256_setzero_ps(void);

_mm256_setzero_si256

__m256i __cdecl _mm256_setzero_si256(void);

_mm256_shuffle_epi32

__m256i __cdecl _mm256_shuffle_epi32(__m256i, const int);

_mm256_shuffle_epi8

__m256i __cdecl _mm256_shuffle_epi8(__m256i, __m256i);

_mm256_shuffle_pd

__m256d __cdecl _mm256_shuffle_pd(__m256d, __m256d, const int);

_mm256_shuffle_ps

__m256 __cdecl _mm256_shuffle_ps(__m256, __m256, const int);

_mm256_shufflehi_epi16

__m256i __cdecl _mm256_shufflehi_epi16(__m256i, const int);

_mm256_shufflelo_epi16

__m256i __cdecl _mm256_shufflelo_epi16(__m256i, const int);

_mm256_sign_epi16

__m256i __cdecl _mm256_sign_epi16(__m256i, __m256i);

_mm256_sign_epi32

__m256i __cdecl _mm256_sign_epi32(__m256i, __m256i);

_mm256_sign_epi8

__m256i __cdecl _mm256_sign_epi8(__m256i, __m256i);

_mm256_sll_epi16

__m256i __cdecl _mm256_sll_epi16(__m256i, __m128i);

_mm256_sll_epi32

__m256i __cdecl _mm256_sll_epi32(__m256i, __m128i);

_mm256_sll_epi64

__m256i __cdecl _mm256_sll_epi64(__m256i, __m128i);

_mm256_slli_epi16

__m256i __cdecl _mm256_slli_epi16(__m256i, int);

_mm256_slli_epi32

__m256i __cdecl _mm256_slli_epi32(__m256i, int);

_mm256_slli_epi64

__m256i __cdecl _mm256_slli_epi64(__m256i, int);

_mm256_slli_si256

__m256i __cdecl _mm256_slli_si256(__m256i, const int);

_mm256_sllv_epi32

__m256i __cdecl _mm256_sllv_epi32(__m256i, __m256i);

_mm256_sllv_epi64

__m256i __cdecl _mm256_sllv_epi64(__m256i, __m256i);

_mm256_sqrt_pd

__m256d __cdecl _mm256_sqrt_pd(__m256d);

_mm256_sqrt_ps

__m256 __cdecl _mm256_sqrt_ps(__m256);

_mm256_sra_epi16

__m256i __cdecl _mm256_sra_epi16(__m256i, __m128i);

_mm256_sra_epi32

__m256i __cdecl _mm256_sra_epi32(__m256i, __m128i);

_mm256_srai_epi16

__m256i __cdecl _mm256_srai_epi16(__m256i, int);

_mm256_srai_epi32

__m256i __cdecl _mm256_srai_epi32(__m256i, int);

_mm256_srav_epi32

__m256i __cdecl _mm256_srav_epi32(__m256i, __m256i);

_mm256_srl_epi16

__m256i __cdecl _mm256_srl_epi16(__m256i, __m128i);

_mm256_srl_epi32

__m256i __cdecl _mm256_srl_epi32(__m256i, __m128i);

_mm256_srl_epi64

__m256i __cdecl _mm256_srl_epi64(__m256i, __m128i);

_mm256_srli_epi16

__m256i __cdecl _mm256_srli_epi16(__m256i, int);

_mm256_srli_epi32

__m256i __cdecl _mm256_srli_epi32(__m256i, int);

_mm256_srli_epi64

__m256i __cdecl _mm256_srli_epi64(__m256i, int);

_mm256_srli_si256

__m256i __cdecl _mm256_srli_si256(__m256i, const int);

_mm256_srlv_epi32

__m256i __cdecl _mm256_srlv_epi32(__m256i, __m256i);

_mm256_srlv_epi64

__m256i __cdecl _mm256_srlv_epi64(__m256i, __m256i);

_mm256_store_pd

void __cdecl _mm256_store_pd(double *, __m256d);

_mm256_store_ps

void __cdecl _mm256_store_ps(float *, __m256);

_mm256_store_si256

void __cdecl _mm256_store_si256(__m256i *, __m256i);

_mm256_storeu_pd

void __cdecl _mm256_storeu_pd(double *, __m256d);

_mm256_storeu_ps

void __cdecl _mm256_storeu_ps(float *, __m256);

_mm256_storeu_si256

void __cdecl _mm256_storeu_si256(__m256i *, __m256i);

_mm256_stream_load_si256

__m256i __cdecl _mm256_stream_load_si256(__m256i const *);

_mm256_stream_pd

void __cdecl _mm256_stream_pd(double *, __m256d);

_mm256_stream_ps

void __cdecl _mm256_stream_ps(float *, __m256);

_mm256_stream_si256

void __cdecl _mm256_stream_si256(__m256i *, __m256i);

_mm256_sub_epi16

__m256i __cdecl _mm256_sub_epi16(__m256i, __m256i);

_mm256_sub_epi32

__m256i __cdecl _mm256_sub_epi32(__m256i, __m256i);

_mm256_sub_epi64

__m256i __cdecl _mm256_sub_epi64(__m256i, __m256i);

_mm256_sub_epi8

__m256i __cdecl _mm256_sub_epi8(__m256i, __m256i);

_mm256_sub_pd

__m256d __cdecl _mm256_sub_pd(__m256d, __m256d);

_mm256_sub_ps

__m256 __cdecl _mm256_sub_ps(__m256, __m256);

_mm256_subs_epi16

__m256i __cdecl _mm256_subs_epi16(__m256i, __m256i);

_mm256_subs_epi8

__m256i __cdecl _mm256_subs_epi8(__m256i, __m256i);

_mm256_subs_epu16

__m256i __cdecl _mm256_subs_epu16(__m256i, __m256i);

_mm256_subs_epu8

__m256i __cdecl _mm256_subs_epu8(__m256i, __m256i);

_mm256_testc_pd

int __cdecl _mm256_testc_pd(__m256d, __m256d);

_mm256_testc_ps

int __cdecl _mm256_testc_ps(__m256, __m256);

_mm256_testc_si256

int __cdecl _mm256_testc_si256(__m256i, __m256i);

_mm256_testnzc_pd

int __cdecl _mm256_testnzc_pd(__m256d, __m256d);

_mm256_testnzc_ps

int __cdecl _mm256_testnzc_ps(__m256, __m256);

_mm256_testnzc_si256

int __cdecl _mm256_testnzc_si256(__m256i, __m256i);

_mm256_testz_pd

int __cdecl _mm256_testz_pd(__m256d, __m256d);

_mm256_testz_ps

int __cdecl _mm256_testz_ps(__m256, __m256);

_mm256_testz_si256

int __cdecl _mm256_testz_si256(__m256i, __m256i);

_mm256_unpackhi_epi16

__m256i __cdecl _mm256_unpackhi_epi16(__m256i, __m256i);

_mm256_unpackhi_epi32

__m256i __cdecl _mm256_unpackhi_epi32(__m256i, __m256i);

_mm256_unpackhi_epi64

__m256i __cdecl _mm256_unpackhi_epi64(__m256i, __m256i);

_mm256_unpackhi_epi8

__m256i __cdecl _mm256_unpackhi_epi8(__m256i, __m256i);

_mm256_unpackhi_pd

__m256d __cdecl _mm256_unpackhi_pd(__m256d, __m256d);

_mm256_unpackhi_ps

__m256 __cdecl _mm256_unpackhi_ps(__m256, __m256);

_mm256_unpacklo_epi16

__m256i __cdecl _mm256_unpacklo_epi16(__m256i, __m256i);

_mm256_unpacklo_epi32

__m256i __cdecl _mm256_unpacklo_epi32(__m256i, __m256i);

_mm256_unpacklo_epi64

__m256i __cdecl _mm256_unpacklo_epi64(__m256i, __m256i);

_mm256_unpacklo_epi8

__m256i __cdecl _mm256_unpacklo_epi8(__m256i, __m256i);

_mm256_unpacklo_pd

__m256d __cdecl _mm256_unpacklo_pd(__m256d, __m256d);

_mm256_unpacklo_ps

__m256 __cdecl _mm256_unpacklo_ps(__m256, __m256);

_mm256_xor_pd

__m256d __cdecl _mm256_xor_pd(__m256d, __m256d);

_mm256_xor_ps

__m256 __cdecl _mm256_xor_ps(__m256, __m256);

_mm256_xor_si256

__m256i __cdecl _mm256_xor_si256(__m256i, __m256i);

_mm256_zeroall

void __cdecl _mm256_zeroall(void);

_mm256_zeroupper

void __cdecl _mm256_zeroupper(void);

_mulx_u32

unsigned int _mulx_u32(unsigned int, unsigned int, unsigned int * );

_pdep_u32

unsigned int _pdep_u32(unsigned int, unsigned int );

_pext_u32

unsigned int _pext_u32(unsigned int, unsigned int );

_rdrand16_step

int __cdecl _rdrand16_step(unsigned short *);

_rdrand32_step

int __cdecl _rdrand32_step(unsigned int *);

_ReadBarrier

void _ReadBarrier(void);

_ReadWriteBarrier

void _ReadWriteBarrier(void);

_ReturnAddress

void * _ReturnAddress(void);

_rorx_u32

unsigned int _rorx_u32(unsigned int, const unsigned int );

_rotl

unsigned int __cdecl _rotl(unsigned int _Value, int _Shift);

_rotl16

unsigned short _rotl16(unsigned short _Value, unsigned char _Shift);

_rotl64

unsigned __int64 __cdecl _rotl64(unsigned __int64 _Value, int _Shift);

_rotl8

unsigned char _rotl8(unsigned char _Value, unsigned char _Shift);

_rotr

unsigned int __cdecl _rotr(unsigned int _Value, int _Shift);

_rotr16

unsigned short _rotr16(unsigned short _Value, unsigned char _Shift);

_rotr64

unsigned __int64 __cdecl _rotr64(unsigned __int64 _Value, int _Shift);

_rotr8

unsigned char _rotr8(unsigned char _Value, unsigned char _Shift);

_sarx_i32

int _sarx_i32(int, unsigned int );

_setjmp

int __cdecl _setjmp(jmp_buf);

_shlx_u32

unsigned int _shlx_u32(unsigned int, unsigned int );

_shrx_u32

unsigned int _shrx_u32(unsigned int, unsigned int );

_Store_HLERelease

void _Store_HLERelease(long volatile *,long);

_Store64_HLERelease

void _Store64_HLERelease(__int64 volatile *,__int64);

_StorePointer_HLERelease

void _StorePointer_HLERelease(void * volatile *,void *);

_t1mskc_u32

unsigned int _t1mskc_u32(unsigned int);

_tzcnt_u32

unsigned int _tzcnt_u32(unsigned int);

_tzcnt_u32

unsigned int _tzcnt_u32(unsigned int);

_tzmsk_u32

unsigned int _tzmsk_u32(unsigned int);

_WriteBarrier

void _WriteBarrier(void);

_xabort

void _xabort(const unsigned int imm);

_xbegin

unsigned __int32 _xbegin(void);

_xend

void _xend(void);

_xgetbv

unsigned __int64 __cdecl _xgetbv(unsigned int);

_xrstor

void __cdecl _xrstor(void const *, unsigned __int64);

_xsave

void __cdecl _xsave(void *, unsigned __int64);

_xsaveopt

void __cdecl _xsaveopt(void *, unsigned __int64);

_xsetbv

void __cdecl _xsetbv(unsigned int, unsigned __int64);

_xtest

unsigned char _xtest(void);

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.