diff --git a/examples/intrinsics/generic-16.h b/examples/intrinsics/generic-16.h
index 438b4d5f..e4123cc5 100644
--- a/examples/intrinsics/generic-16.h
+++ b/examples/intrinsics/generic-16.h
@@ -212,7 +212,7 @@ static FORCEINLINE void __insert_element(VTYPE *v, int index, STYPE val) { \
 
 #define LOAD_STORE(VTYPE, STYPE)                       \
 template <int ALIGN>                                   \
-static FORCEINLINE VTYPE __load(VTYPE *p) {            \
+static FORCEINLINE VTYPE __load(const VTYPE *p) {      \
     STYPE *ptr = (STYPE *)p;                           \
     VTYPE ret;                                         \
     for (int i = 0; i < 16; ++i)                       \
@@ -395,7 +395,7 @@ static FORCEINLINE void __insert_element(__vec16_i1 *vec, int index,
         vec->v |= (1 << index);
 }
 
-template <int ALIGN> static FORCEINLINE __vec16_i1 __load(__vec16_i1 *p) {
+template <int ALIGN> static FORCEINLINE __vec16_i1 __load(const __vec16_i1 *p) {
     uint16_t *ptr = (uint16_t *)p;
     __vec16_i1 r;
     r.v = *ptr;
diff --git a/examples/intrinsics/generic-32.h b/examples/intrinsics/generic-32.h
index dc55fb00..271f4f52 100644
--- a/examples/intrinsics/generic-32.h
+++ b/examples/intrinsics/generic-32.h
@@ -277,7 +277,7 @@ static FORCEINLINE void __insert_element(VTYPE *v, int index, STYPE val) { \
 
 #define LOAD_STORE(VTYPE, STYPE)                       \
 template <int ALIGN>                                   \
-static FORCEINLINE VTYPE __load(VTYPE *p) {            \
+static FORCEINLINE VTYPE __load(const VTYPE *p) {      \
     STYPE *ptr = (STYPE *)p;                           \
     VTYPE ret;                                         \
     for (int i = 0; i < 32; ++i)                       \
@@ -460,7 +460,7 @@ static FORCEINLINE void __insert_element(__vec32_i1 *vec, int index,
         vec->v |= (1 << index);
 }
 
-template <int ALIGN> static FORCEINLINE __vec32_i1 __load(__vec32_i1 *p) {
+template <int ALIGN> static FORCEINLINE __vec32_i1 __load(const __vec32_i1 *p) {
     uint16_t *ptr = (uint16_t *)p;
     __vec32_i1 r;
     r.v = *ptr;
diff --git a/examples/intrinsics/generic-64.h b/examples/intrinsics/generic-64.h
index f1eb22ae..d1703e38 100644
--- a/examples/intrinsics/generic-64.h
+++ b/examples/intrinsics/generic-64.h
@@ -402,7 +402,7 @@ static FORCEINLINE void __insert_element(VTYPE *v, int index, STYPE val) { \
 
 #define LOAD_STORE(VTYPE, STYPE)                       \
 template <int ALIGN>                                   \
-static FORCEINLINE VTYPE __load(VTYPE *p) {            \
+static FORCEINLINE VTYPE __load(const VTYPE *p) {      \
     STYPE *ptr = (STYPE *)p;                           \
     VTYPE ret;                                         \
     for (int i = 0; i < 64; ++i)                       \
@@ -585,7 +585,7 @@ static FORCEINLINE void __insert_element(__vec64_i1 *vec, int index,
         vec->v |= (1ull << index);
 }
 
-template <int ALIGN> static FORCEINLINE __vec64_i1 __load(__vec64_i1 *p) {
+template <int ALIGN> static FORCEINLINE __vec64_i1 __load(const __vec64_i1 *p) {
     uint16_t *ptr = (uint16_t *)p;
     __vec64_i1 r;
     r.v = *ptr;
diff --git a/examples/intrinsics/knc.h b/examples/intrinsics/knc.h
index bcc89bf4..8eda5224 100644
--- a/examples/intrinsics/knc.h
+++ b/examples/intrinsics/knc.h
@@ -465,8 +465,8 @@ static FORCEINLINE void __insert_element(__vec16_i1 *vec, int index,
 }
 */
 
-template <int ALIGN> static FORCEINLINE __vec16_i1 __load(__vec16_i1 *p) {
-    uint16_t *ptr = (uint16_t *)p;
+template <int ALIGN> static FORCEINLINE __vec16_i1 __load(const __vec16_i1 *p) {
+    const uint16_t *ptr = (const uint16_t *)p;
     __vec16_i1 r;
     r.m = *ptr;
     return r;
@@ -729,14 +729,14 @@ static FORCEINLINE __vec16_i32 __shuffle2_i32(__vec16_i32 v0, __vec16_i32 v1, __
 }
 */
 
-template <int ALIGN> static FORCEINLINE __vec16_i32 __load(__vec16_i32 *p) {
+template <int ALIGN> static FORCEINLINE __vec16_i32 __load(const __vec16_i32 *p) {
     __vec16_i32 v;
     v = _mm512_extloadunpackhi_epi32(v, p, _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE);
     v = _mm512_extloadunpacklo_epi32(v, p, _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE);
     return v;
 }
 
-template <> static FORCEINLINE __vec16_i32 __load<64>(__vec16_i32 *p) {
+template <> static FORCEINLINE __vec16_i32 __load<64>(const __vec16_i32 *p) {
     return _mm512_load_epi32(p);
 }
 
@@ -827,7 +827,7 @@ SHUFFLES(__vec16_i64, i64, int64_t)
 LOAD_STORE(__vec16_i64, int64_t)
 
 
-template <int ALIGN> static FORCEINLINE __vec16_i64 __load(__vec16_i64 *p) {
+template <int ALIGN> static FORCEINLINE __vec16_i64 __load(const __vec16_i64 *p) {
     __m512i v1;
     __m512i v2;
     v2 = _mm512_extloadunpackhi_epi32(v1, p, _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE);
@@ -851,7 +851,7 @@ template <int ALIGN> static FORCEINLINE __vec16_i64 __load(__vec16_i64 *p) {
     return ret;    
 }
 
-template <> static FORCEINLINE __vec16_i64 __load<64>(__vec16_i64 *p) {
+template <> static FORCEINLINE __vec16_i64 __load<64>(const __vec16_i64 *p) {
     __m512i v2 = _mm512_load_epi32(p);
     __m512i v1 = _mm512_load_epi32(((uint8_t*)p)+64);
     __vec16_i64 ret;
@@ -1015,14 +1015,14 @@ static FORCEINLINE __vec16_f __shuffle2_float(__vec16_f v0, __vec16_f v1, __vec1
 }
 */
 
-template <int ALIGN> static FORCEINLINE __vec16_f __load(__vec16_f *p) {
+template <int ALIGN> static FORCEINLINE __vec16_f __load(const __vec16_f *p) {
     __vec16_f v;
     v = _mm512_extloadunpackhi_ps(v, p, _MM_UPCONV_PS_NONE, _MM_HINT_NONE);
     v = _mm512_extloadunpacklo_ps(v, p, _MM_UPCONV_PS_NONE, _MM_HINT_NONE);
     return v;
 }
 
-template <> static FORCEINLINE __vec16_f __load<64>(__vec16_f *p) {
+template <> static FORCEINLINE __vec16_f __load<64>(const __vec16_f *p) {
     return _mm512_load_ps(p);
 }
 
@@ -1184,7 +1184,7 @@ static FORCEINLINE __vec16_f __shuffle2_float(__vec16_d v0, __vec16_d v1, __vec1
 }
 */
 
-template <int ALIGN> static FORCEINLINE __vec16_d __load(__vec16_d *p) {
+template <int ALIGN> static FORCEINLINE __vec16_d __load(const __vec16_d *p) {
     __vec16_d ret;
     ret.v1 = _mm512_extloadunpackhi_pd(ret.v1, p, _MM_UPCONV_PD_NONE, _MM_HINT_NONE);
     ret.v1 = _mm512_extloadunpacklo_pd(ret.v1, p, _MM_UPCONV_PD_NONE, _MM_HINT_NONE);
@@ -1193,7 +1193,7 @@ template <int ALIGN> static FORCEINLINE __vec16_d __load(__vec16_d *p) {
     return ret;
 }
 
-template <> static FORCEINLINE __vec16_d __load<64>(__vec16_d *p) {
+template <> static FORCEINLINE __vec16_d __load<64>(const __vec16_d *p) {
     __vec16_d ret;
     ret.v1 = _mm512_load_pd(p);
     ret.v2 = _mm512_load_pd(((uint8_t*)p)+64);
diff --git a/examples/intrinsics/sse4.h b/examples/intrinsics/sse4.h
index 57a483c6..54eb8bc6 100644
--- a/examples/intrinsics/sse4.h
+++ b/examples/intrinsics/sse4.h
@@ -287,7 +287,7 @@ static FORCEINLINE void __insert_element(__vec4_i1 *v, int index, bool val) {
     ((int32_t *)v)[index] = val ? -1 : 0;
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_i1 __load(__vec4_i1 *v) {
+template <int ALIGN> static FORCEINLINE __vec4_i1 __load(const __vec4_i1 *v) {
     // FIXME: handle align of 16...
     return _mm_loadu_ps((float *)(&v->v));
 }
@@ -572,7 +572,7 @@ static FORCEINLINE __vec4_i8 __shuffle2_i8(__vec4_i8 v0, __vec4_i8 v1,
     return __vec4_i8(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_i8 __load(__vec4_i8 *v) {
+template <int ALIGN> static FORCEINLINE __vec4_i8 __load(const __vec4_i8 *v) {
     uint8_t *ptr = (uint8_t *)(&v->v);
     return __vec4_i8(ptr[0], ptr[1], ptr[2], ptr[3]);
 }
@@ -839,7 +839,7 @@ static FORCEINLINE __vec4_i16 __shuffle2_i16(__vec4_i16 v0, __vec4_i16 v1,
     return __vec4_i16(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_i16 __load(__vec4_i16 *v) {
+template <int ALIGN> static FORCEINLINE __vec4_i16 __load(const __vec4_i16 *v) {
     uint16_t *ptr = (uint16_t *)(&v->v);
     return __vec4_i16(ptr[0], ptr[1], ptr[2], ptr[3]);
 }
@@ -1092,7 +1092,7 @@ static FORCEINLINE __vec4_i32 __shuffle2_i32(__vec4_i32 v0, __vec4_i32 v1,
     return __vec4_i32(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_i32 __load(__vec4_i32 *v) {
+template <int ALIGN> static FORCEINLINE __vec4_i32 __load(const __vec4_i32 *v) {
     // FIXME: handle align of 16...
     return _mm_loadu_si128((__m128i *)(&v->v));
 }
@@ -1362,7 +1362,7 @@ static FORCEINLINE __vec4_i64 __shuffle2_i64(__vec4_i64 v0, __vec4_i64 v1,
     return __vec4_i64(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_i64 __load(__vec4_i64 *v) {
+template <int ALIGN> static FORCEINLINE __vec4_i64 __load(const __vec4_i64 *v) {
     // FIXME: handle align of 16...
     return __vec4_i64(_mm_loadu_si128((__m128i *)(&v->v[0])),
                       _mm_loadu_si128((__m128i *)(&v->v[1])));
@@ -1473,7 +1473,7 @@ static FORCEINLINE __vec4_f __shuffle2_float(__vec4_f v0, __vec4_f v1,
     return __vec4_f(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_f __load(__vec4_f *v) {
+template <int ALIGN> static FORCEINLINE __vec4_f __load(const __vec4_f *v) {
     // FIXME: handle align of 16...
     return _mm_loadu_ps((float *)(&v->v));
 }
@@ -1614,7 +1614,7 @@ static FORCEINLINE __vec4_d __shuffle2_double(__vec4_d v0, __vec4_d v1,
     return __vec4_d(r[0], r[1], r[2], r[3]);
 }
 
-template <int ALIGN> static FORCEINLINE __vec4_d __load(__vec4_d *v) {
+template <int ALIGN> static FORCEINLINE __vec4_d __load(const __vec4_d *v) {
     // FIXME: handle align of 16...
     return __vec4_d(_mm_loadu_pd((double *)(&v->v[0])),
                     _mm_loadu_pd((double *)(&v->v[1])));