diff -Nru vc-0.7.4/.appveyor.yml vc-1.3.0/.appveyor.yml
--- vc-0.7.4/.appveyor.yml	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/.appveyor.yml	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,19 @@
+version: 1.0.{build}
+os: Visual Studio 2015
+configuration: Release
+platform:
+   - x64
+   #- x86
+
+clone_depth: 50
+
+environment:
+  matrix:
+    - subset: sse
+    - subset: avx
+
+build_script:
+- cmd: >-
+    CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %PLATFORM%
+
+    ctest -VV -S C:\projects\vc\test.cmake
diff -Nru vc-0.7.4/avx/casts.h vc-1.3.0/avx/casts.h
--- vc-0.7.4/avx/casts.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/casts.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,60 +1,62 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef AVX_CASTS_H
-#define AVX_CASTS_H
+#ifndef VC_AVX_CASTS_H_
+#define VC_AVX_CASTS_H_
 
 #include "intrinsics.h"
 #include "types.h"
+#include "../sse/casts.h"
+#include "shuffle.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param128  v) Vc_INTRINSIC_R;
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param128i v) Vc_INTRINSIC_R;
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param128d v) Vc_INTRINSIC_R;
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param256  v) Vc_INTRINSIC_R;
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param256i v) Vc_INTRINSIC_R;
-    template<typename T> static Vc_INTRINSIC_L T avx_cast(param256d v) Vc_INTRINSIC_R;
-
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m128  v) { return avx_cast<T>(param128 (v)); }
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m128i v) { return avx_cast<T>(param128i(v)); }
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m128d v) { return avx_cast<T>(param128d(v)); }
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m256  v) { return avx_cast<T>(param256 (v)); }
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m256i v) { return avx_cast<T>(param256i(v)); }
-    template<typename T> static Vc_INTRINSIC T avx_cast(__m256d v) { return avx_cast<T>(param256d(v)); }
-#endif
+namespace Casts
+{
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m128  v) Vc_INTRINSIC_R;
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m128i v) Vc_INTRINSIC_R;
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m128d v) Vc_INTRINSIC_R;
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m256  v) Vc_INTRINSIC_R;
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m256i v) Vc_INTRINSIC_R;
+    template<typename T> Vc_INTRINSIC_L T avx_cast(__m256d v) Vc_INTRINSIC_R;
 
     // 128 -> 128
-    template<> Vc_INTRINSIC m128  avx_cast(param128  v) { return v; }
-    template<> Vc_INTRINSIC m128  avx_cast(param128i v) { return _mm_castsi128_ps(v); }
-    template<> Vc_INTRINSIC m128  avx_cast(param128d v) { return _mm_castpd_ps(v); }
-    template<> Vc_INTRINSIC m128i avx_cast(param128  v) { return _mm_castps_si128(v); }
-    template<> Vc_INTRINSIC m128i avx_cast(param128i v) { return v; }
-    template<> Vc_INTRINSIC m128i avx_cast(param128d v) { return _mm_castpd_si128(v); }
-    template<> Vc_INTRINSIC m128d avx_cast(param128  v) { return _mm_castps_pd(v); }
-    template<> Vc_INTRINSIC m128d avx_cast(param128i v) { return _mm_castsi128_pd(v); }
-    template<> Vc_INTRINSIC m128d avx_cast(param128d v) { return v; }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m128  v) { return v; }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m128i v) { return _mm_castsi128_ps(v); }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m128d v) { return _mm_castpd_ps(v); }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m128  v) { return _mm_castps_si128(v); }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m128i v) { return v; }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m128d v) { return _mm_castpd_si128(v); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m128  v) { return _mm_castps_pd(v); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m128i v) { return _mm_castsi128_pd(v); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m128d v) { return v; }
 
     // 128 -> 256
     // FIXME: the following casts leave the upper 128bits undefined. With GCC and ICC I've never
@@ -64,127 +66,238 @@
     // + 256bit load. Thus the upper 128bits are really undefined. But there is no intrinsic to do
     // what I want (i.e. alias the register, disallowing the move to memory in-between). I'm stuck,
     // do we really want to rely on specific compiler behavior here?
-    template<> Vc_INTRINSIC m256  avx_cast(param128  v) { return _mm256_castps128_ps256(v); }
-    template<> Vc_INTRINSIC m256  avx_cast(param128i v) { return _mm256_castps128_ps256(_mm_castsi128_ps(v)); }
-    template<> Vc_INTRINSIC m256  avx_cast(param128d v) { return _mm256_castps128_ps256(_mm_castpd_ps(v)); }
-    template<> Vc_INTRINSIC m256i avx_cast(param128  v) { return _mm256_castsi128_si256(_mm_castps_si128(v)); }
-    template<> Vc_INTRINSIC m256i avx_cast(param128i v) { return _mm256_castsi128_si256(v); }
-    template<> Vc_INTRINSIC m256i avx_cast(param128d v) { return _mm256_castsi128_si256(_mm_castpd_si128(v)); }
-    template<> Vc_INTRINSIC m256d avx_cast(param128  v) { return _mm256_castpd128_pd256(_mm_castps_pd(v)); }
-    template<> Vc_INTRINSIC m256d avx_cast(param128i v) { return _mm256_castpd128_pd256(_mm_castsi128_pd(v)); }
-    template<> Vc_INTRINSIC m256d avx_cast(param128d v) { return _mm256_castpd128_pd256(v); }
-
-#ifdef VC_MSVC
-    static Vc_INTRINSIC Vc_CONST m256  zeroExtend(param128  v) { return _mm256_permute2f128_ps   (_mm256_castps128_ps256(v), _mm256_castps128_ps256(v), 0x80); }
-    static Vc_INTRINSIC Vc_CONST m256i zeroExtend(param128i v) { return _mm256_permute2f128_si256(_mm256_castsi128_si256(v), _mm256_castsi128_si256(v), 0x80); }
-    static Vc_INTRINSIC Vc_CONST m256d zeroExtend(param128d v) { return _mm256_permute2f128_pd   (_mm256_castpd128_pd256(v), _mm256_castpd128_pd256(v), 0x80); }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m128  v) { return _mm256_castps128_ps256(v); }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m128i v) { return _mm256_castps128_ps256(_mm_castsi128_ps(v)); }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m128d v) { return _mm256_castps128_ps256(_mm_castpd_ps(v)); }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m128  v) { return _mm256_castsi128_si256(_mm_castps_si128(v)); }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m128i v) { return _mm256_castsi128_si256(v); }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m128d v) { return _mm256_castsi128_si256(_mm_castpd_si128(v)); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m128  v) { return _mm256_castpd128_pd256(_mm_castps_pd(v)); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m128i v) { return _mm256_castpd128_pd256(_mm_castsi128_pd(v)); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m128d v) { return _mm256_castpd128_pd256(v); }
+
+#if defined Vc_MSVC || defined Vc_CLANG || defined Vc_APPLECLANG
+    static Vc_INTRINSIC Vc_CONST __m256  zeroExtend(__m128  v) { return _mm256_permute2f128_ps   (_mm256_castps128_ps256(v), _mm256_castps128_ps256(v), 0x80); }
+    static Vc_INTRINSIC Vc_CONST __m256i zeroExtend(__m128i v) { return _mm256_permute2f128_si256(_mm256_castsi128_si256(v), _mm256_castsi128_si256(v), 0x80); }
+    static Vc_INTRINSIC Vc_CONST __m256d zeroExtend(__m128d v) { return _mm256_permute2f128_pd   (_mm256_castpd128_pd256(v), _mm256_castpd128_pd256(v), 0x80); }
 #else
-    static Vc_INTRINSIC Vc_CONST m256  zeroExtend(param128  v) { return _mm256_castps128_ps256(v); }
-    static Vc_INTRINSIC Vc_CONST m256i zeroExtend(param128i v) { return _mm256_castsi128_si256(v); }
-    static Vc_INTRINSIC Vc_CONST m256d zeroExtend(param128d v) { return _mm256_castpd128_pd256(v); }
-#ifdef VC_ICC
-    static Vc_INTRINSIC Vc_CONST m256  zeroExtend(__m128  v) { return _mm256_castps128_ps256(v); }
-    static Vc_INTRINSIC Vc_CONST m256i zeroExtend(__m128i v) { return _mm256_castsi128_si256(v); }
-    static Vc_INTRINSIC Vc_CONST m256d zeroExtend(__m128d v) { return _mm256_castpd128_pd256(v); }
-#endif
+    static Vc_INTRINSIC Vc_CONST __m256  zeroExtend(__m128  v) { return _mm256_castps128_ps256(v); }
+    static Vc_INTRINSIC Vc_CONST __m256i zeroExtend(__m128i v) { return _mm256_castsi128_si256(v); }
+    static Vc_INTRINSIC Vc_CONST __m256d zeroExtend(__m128d v) { return _mm256_castpd128_pd256(v); }
 #endif
 
     // 256 -> 128
-    template<> Vc_INTRINSIC m128  avx_cast(param256  v) { return _mm256_castps256_ps128(v); }
-    template<> Vc_INTRINSIC m128  avx_cast(param256i v) { return _mm256_castps256_ps128(_mm256_castsi256_ps(v)); }
-    template<> Vc_INTRINSIC m128  avx_cast(param256d v) { return _mm256_castps256_ps128(_mm256_castpd_ps(v)); }
-    template<> Vc_INTRINSIC m128i avx_cast(param256  v) { return _mm256_castsi256_si128(_mm256_castps_si256(v)); }
-    template<> Vc_INTRINSIC m128i avx_cast(param256i v) { return _mm256_castsi256_si128(v); }
-    template<> Vc_INTRINSIC m128i avx_cast(param256d v) { return _mm256_castsi256_si128(_mm256_castpd_si256(v)); }
-    template<> Vc_INTRINSIC m128d avx_cast(param256  v) { return _mm256_castpd256_pd128(_mm256_castps_pd(v)); }
-    template<> Vc_INTRINSIC m128d avx_cast(param256i v) { return _mm256_castpd256_pd128(_mm256_castsi256_pd(v)); }
-    template<> Vc_INTRINSIC m128d avx_cast(param256d v) { return _mm256_castpd256_pd128(v); }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m256  v) { return _mm256_castps256_ps128(v); }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m256i v) { return _mm256_castps256_ps128(_mm256_castsi256_ps(v)); }
+    template<> Vc_INTRINSIC __m128  avx_cast(__m256d v) { return _mm256_castps256_ps128(_mm256_castpd_ps(v)); }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m256  v) { return _mm256_castsi256_si128(_mm256_castps_si256(v)); }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m256i v) { return _mm256_castsi256_si128(v); }
+    template<> Vc_INTRINSIC __m128i avx_cast(__m256d v) { return _mm256_castsi256_si128(_mm256_castpd_si256(v)); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m256  v) { return _mm256_castpd256_pd128(_mm256_castps_pd(v)); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m256i v) { return _mm256_castpd256_pd128(_mm256_castsi256_pd(v)); }
+    template<> Vc_INTRINSIC __m128d avx_cast(__m256d v) { return _mm256_castpd256_pd128(v); }
 
     // 256 -> 256
-    template<> Vc_INTRINSIC m256  avx_cast(param256  v) { return v; }
-    template<> Vc_INTRINSIC m256  avx_cast(param256i v) { return _mm256_castsi256_ps(v); }
-    template<> Vc_INTRINSIC m256  avx_cast(param256d v) { return _mm256_castpd_ps(v); }
-    template<> Vc_INTRINSIC m256i avx_cast(param256  v) { return _mm256_castps_si256(v); }
-    template<> Vc_INTRINSIC m256i avx_cast(param256i v) { return v; }
-    template<> Vc_INTRINSIC m256i avx_cast(param256d v) { return _mm256_castpd_si256(v); }
-    template<> Vc_INTRINSIC m256d avx_cast(param256  v) { return _mm256_castps_pd(v); }
-    template<> Vc_INTRINSIC m256d avx_cast(param256i v) { return _mm256_castsi256_pd(v); }
-    template<> Vc_INTRINSIC m256d avx_cast(param256d v) { return v; }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m256  v) { return v; }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m256i v) { return _mm256_castsi256_ps(v); }
+    template<> Vc_INTRINSIC __m256  avx_cast(__m256d v) { return _mm256_castpd_ps(v); }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m256  v) { return _mm256_castps_si256(v); }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m256i v) { return v; }
+    template<> Vc_INTRINSIC __m256i avx_cast(__m256d v) { return _mm256_castpd_si256(v); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m256  v) { return _mm256_castps_pd(v); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m256i v) { return _mm256_castsi256_pd(v); }
+    template<> Vc_INTRINSIC __m256d avx_cast(__m256d v) { return v; }
 
     // simplify splitting 256-bit registers in 128-bit registers
-    Vc_INTRINSIC Vc_CONST m128  lo128(param256  v) { return avx_cast<m128>(v); }
-    Vc_INTRINSIC Vc_CONST m128d lo128(param256d v) { return avx_cast<m128d>(v); }
-    Vc_INTRINSIC Vc_CONST m128i lo128(param256i v) { return avx_cast<m128i>(v); }
-    Vc_INTRINSIC Vc_CONST m128  hi128(param256  v) { return _mm256_extractf128_ps(v, 1); }
-    Vc_INTRINSIC Vc_CONST m128d hi128(param256d v) { return _mm256_extractf128_pd(v, 1); }
-    Vc_INTRINSIC Vc_CONST m128i hi128(param256i v) { return _mm256_extractf128_si256(v, 1); }
+    Vc_INTRINSIC Vc_CONST __m128  lo128(__m256  v) { return avx_cast<__m128>(v); }
+    Vc_INTRINSIC Vc_CONST __m128d lo128(__m256d v) { return avx_cast<__m128d>(v); }
+    Vc_INTRINSIC Vc_CONST __m128i lo128(__m256i v) { return avx_cast<__m128i>(v); }
+    Vc_INTRINSIC Vc_CONST __m128  hi128(__m256  v) { return extract128<1>(v); }
+    Vc_INTRINSIC Vc_CONST __m128d hi128(__m256d v) { return extract128<1>(v); }
+    Vc_INTRINSIC Vc_CONST __m128i hi128(__m256i v) { return extract128<1>(v); }
 
     // simplify combining 128-bit registers in 256-bit registers
-    Vc_INTRINSIC Vc_CONST m256  concat(param128  a, param128  b) { return _mm256_insertf128_ps   (avx_cast<m256 >(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256d concat(param128d a, param128d b) { return _mm256_insertf128_pd   (avx_cast<m256d>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256i concat(param128i a, param128i b) { return _mm256_insertf128_si256(avx_cast<m256i>(a), b, 1); }
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-    Vc_INTRINSIC Vc_CONST m256  concat(__m128  a, param128  b) { return _mm256_insertf128_ps   (avx_cast<m256 >(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256d concat(__m128d a, param128d b) { return _mm256_insertf128_pd   (avx_cast<m256d>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256i concat(__m128i a, param128i b) { return _mm256_insertf128_si256(avx_cast<m256i>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256  concat(param128  a, __m128  b) { return _mm256_insertf128_ps   (avx_cast<m256 >(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256d concat(param128d a, __m128d b) { return _mm256_insertf128_pd   (avx_cast<m256d>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256i concat(param128i a, __m128i b) { return _mm256_insertf128_si256(avx_cast<m256i>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256  concat(__m128  a, __m128  b) { return _mm256_insertf128_ps   (avx_cast<m256 >(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256d concat(__m128d a, __m128d b) { return _mm256_insertf128_pd   (avx_cast<m256d>(a), b, 1); }
-    Vc_INTRINSIC Vc_CONST m256i concat(__m128i a, __m128i b) { return _mm256_insertf128_si256(avx_cast<m256i>(a), b, 1); }
+    Vc_INTRINSIC Vc_CONST __m256  concat(__m128  a, __m128  b) { return insert128<1>(avx_cast<__m256 >(a), b); }
+    Vc_INTRINSIC Vc_CONST __m256d concat(__m128d a, __m128d b) { return insert128<1>(avx_cast<__m256d>(a), b); }
+    Vc_INTRINSIC Vc_CONST __m256i concat(__m128i a, __m128i b) { return insert128<1>(avx_cast<__m256i>(a), b); }
+
+}  // namespace Casts
+using namespace Casts;
+}  // namespace AVX
+
+namespace AVX2
+{
+using namespace AVX::Casts;
+}  // namespace AVX2
+
+namespace AVX
+{
+template <typename From, typename To> struct ConvertTag {};
+
+Vc_INTRINSIC __m256i convert(__m256  v, ConvertTag<float , int>) { return _mm256_cvttps_epi32(v); }
+Vc_INTRINSIC __m128i convert(__m256d v, ConvertTag<double, int>) { return _mm256_cvttpd_epi32(v); }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<int   , int>) { return v; }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<uint  , int>) { return v; }
+Vc_INTRINSIC __m256i convert(__m128i v, ConvertTag<short , int>) {
+#ifdef Vc_IMPL_AVX2
+    return _mm256_cvtepi16_epi32(v);
+#else
+    return AVX::srai_epi32<16>(
+        concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));
+#endif
+}
+Vc_INTRINSIC __m256i convert(__m128i v, ConvertTag<ushort, int>) {
+#ifdef Vc_IMPL_AVX2
+    return _mm256_cvtepu16_epi32(v);
+#else
+    return AVX::srli_epi32<16>(
+        concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));
 #endif
+}
 
-    template<typename From, typename To> struct StaticCastHelper {};
-    template<> struct StaticCastHelper<float         , int           > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256  v) { return _mm256_cvttps_epi32(v); } };
-    template<> struct StaticCastHelper<double        , int           > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256d v) { return avx_cast<m256i>(_mm256_cvttpd_epi32(v)); } };
-    template<> struct StaticCastHelper<int           , int           > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned int  , int           > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256i v) { return v; } };
-    template<> struct StaticCastHelper<short         , int           > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param128i   v) { return concat(_mm_srai_epi32(_mm_unpacklo_epi16(v, v), 16), _mm_srai_epi32(_mm_unpackhi_epi16(v, v), 16)); } };
-    template<> struct StaticCastHelper<float         , unsigned int  > { static inline Vc_CONST m256i  cast(param256  v) {
-        return _mm256_castps_si256(_mm256_blendv_ps(
-                _mm256_castsi256_ps(_mm256_cvttps_epi32(v)),
-                _mm256_castsi256_ps(_mm256_add_epi32(m256i(_mm256_cvttps_epi32(_mm256_sub_ps(v, _mm256_set2power31_ps()))), _mm256_set2power31_epu32())),
-                _mm256_cmpge_ps(v, _mm256_set2power31_ps())
-                ));
-
-    } };
-    template<> struct StaticCastHelper<double        , unsigned int  > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256d v) { return avx_cast<m256i>(_mm256_cvttpd_epi32(v)); } };
-    template<> struct StaticCastHelper<int           , unsigned int  > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned int  , unsigned int  > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param256i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned short, unsigned int  > { static Vc_ALWAYS_INLINE Vc_CONST m256i  cast(param128i   v) { return concat(_mm_srli_epi32(_mm_unpacklo_epi16(v, v), 16), _mm_srli_epi32(_mm_unpackhi_epi16(v, v), 16)); } };
-    template<> struct StaticCastHelper<float         , float         > { static Vc_ALWAYS_INLINE Vc_CONST m256   cast(param256  v) { return v; } };
-    template<> struct StaticCastHelper<double        , float         > { static Vc_ALWAYS_INLINE Vc_CONST m256   cast(param256d v) { return avx_cast<m256>(_mm256_cvtpd_ps(v)); } };
-    template<> struct StaticCastHelper<int           , float         > { static Vc_ALWAYS_INLINE Vc_CONST m256   cast(param256i v) { return _mm256_cvtepi32_ps(v); } };
-    template<> struct StaticCastHelper<unsigned int  , float         > { static inline Vc_CONST m256   cast(param256i v) {
-        return _mm256_blendv_ps(
-                _mm256_cvtepi32_ps(v),
-                _mm256_add_ps(_mm256_cvtepi32_ps(_mm256_sub_epi32(v, _mm256_set2power31_epu32())), _mm256_set2power31_ps()),
-                _mm256_castsi256_ps(_mm256_cmplt_epi32(v, _mm256_setzero_si256()))
-                );
-    } };
-    template<> struct StaticCastHelper<short         , float         > { static Vc_ALWAYS_INLINE Vc_CONST m256  cast(param128i v) { return _mm256_cvtepi32_ps(StaticCastHelper<short, int>::cast(v)); } };
-    template<> struct StaticCastHelper<unsigned short, float         > { static Vc_ALWAYS_INLINE Vc_CONST m256  cast(param128i v) { return _mm256_cvtepi32_ps(StaticCastHelper<unsigned short, unsigned int>::cast(v)); } };
-    template<> struct StaticCastHelper<float         , double        > { static Vc_ALWAYS_INLINE Vc_CONST m256d cast(param256  v) { return _mm256_cvtps_pd(avx_cast<m128>(v)); } };
-    template<> struct StaticCastHelper<double        , double        > { static Vc_ALWAYS_INLINE Vc_CONST m256d cast(param256d v) { return v; } };
-    template<> struct StaticCastHelper<int           , double        > { static Vc_ALWAYS_INLINE Vc_CONST m256d cast(param256i v) { return _mm256_cvtepi32_pd(avx_cast<m128i>(v)); } };
-    template<> struct StaticCastHelper<unsigned int  , double        > { static Vc_ALWAYS_INLINE Vc_CONST m256d cast(param256i v) { return _mm256_cvtepi32_pd(avx_cast<m128i>(v)); } };
-    template<> struct StaticCastHelper<int           , short         > { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256i v) { return _mm_packs_epi32(lo128(v), hi128(v)); } };
-    template<> struct StaticCastHelper<float         , short         > { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256  v) { return StaticCastHelper<int, short>::cast(StaticCastHelper<float, int>::cast(v)); } };
-    template<> struct StaticCastHelper<short         , short         > { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param128i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned short, short         > { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param128i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned int  , unsigned short> { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256i v) { return _mm_packus_epi32(lo128(v), hi128(v)); } };
-    template<> struct StaticCastHelper<float         , unsigned short> { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256  v) { return StaticCastHelper<unsigned int, unsigned short>::cast(StaticCastHelper<float, unsigned int>::cast(v)); } };
-    template<> struct StaticCastHelper<short         , unsigned short> { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param128i v) { return v; } };
-    template<> struct StaticCastHelper<unsigned short, unsigned short> { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param128i v) { return v; } };
-    template<> struct StaticCastHelper<sfloat        , short         > { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256  v) { return StaticCastHelper<int, short>::cast(StaticCastHelper<float, int>::cast(v)); } };
-    template<> struct StaticCastHelper<sfloat        , unsigned short> { static Vc_ALWAYS_INLINE Vc_CONST m128i cast(param256  v) { return StaticCastHelper<unsigned int, unsigned short>::cast(StaticCastHelper<float, unsigned int>::cast(v)); } };
-    template<> struct StaticCastHelper<short         , sfloat        > { static Vc_ALWAYS_INLINE Vc_CONST m256  cast(param128i v) { return _mm256_cvtepi32_ps(StaticCastHelper<short, int>::cast(v)); } };
-    template<> struct StaticCastHelper<unsigned short, sfloat        > { static Vc_ALWAYS_INLINE Vc_CONST m256  cast(param128i v) { return _mm256_cvtepi32_ps(StaticCastHelper<unsigned short, unsigned int>::cast(v)); } };
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+Vc_INTRINSIC __m256i convert(__m256  v, ConvertTag<float , uint>) {
+    using namespace AVX;
+    return _mm256_castps_si256(_mm256_blendv_ps(
+        _mm256_castsi256_ps(_mm256_cvttps_epi32(v)),
+        _mm256_castsi256_ps(add_epi32(_mm256_cvttps_epi32(_mm256_sub_ps(v, set2power31_ps())),
+                                      set2power31_epu32())),
+        cmpge_ps(v, set2power31_ps())));
+}
+Vc_INTRINSIC __m128i convert(__m256d v, ConvertTag<double, uint>) {
+    using namespace AVX;
+    return _mm_xor_si128(
+        _mm256_cvttpd_epi32(_mm256_sub_pd(_mm256_floor_pd(v), set1_pd(0x80000000u))),
+        _mm_set2power31_epu32());
+}
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<int   , uint>) { return v; }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<uint  , uint>) { return v; }
+Vc_INTRINSIC __m256i convert(__m128i v, ConvertTag<short , uint>) {
+#ifdef Vc_IMPL_AVX2
+    return _mm256_cvtepi16_epi32(v);
+#else
+    return AVX::srai_epi32<16>(
+        concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));
+#endif
+}
+Vc_INTRINSIC __m256i convert(__m128i v, ConvertTag<ushort, uint>) {
+#ifdef Vc_IMPL_AVX2
+    return _mm256_cvtepu16_epi32(v);
+#else
+    return AVX::srli_epi32<16>(
+        concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));
+#endif
+}
 
-#include "undomacros.h"
+Vc_INTRINSIC __m256  convert(__m256  v, ConvertTag<float , float>) { return v; }
+Vc_INTRINSIC __m128  convert(__m256d v, ConvertTag<double, float>) { return _mm256_cvtpd_ps(v); }
+Vc_INTRINSIC __m256  convert(__m256i v, ConvertTag<int   , float>) { return _mm256_cvtepi32_ps(v); }
+Vc_INTRINSIC __m256  convert(__m256i v, ConvertTag<uint  , float>) {
+    // this is complicated because cvtepi32_ps only supports signed input. Thus, all
+    // input values with the MSB set would produce a negative result. We can reuse the
+    // cvtepi32_ps instruction if we unset the MSB. But then the rounding results can be
+    // different. Since float uses 24 bits for the mantissa (effectively), the 9-bit LSB
+    // determines the rounding direction. (Consider the bits ...8'7654'3210. The bits [0:7]
+    // need to be dropped and if > 0x80 round up, if < 0x80 round down. If [0:7] == 0x80
+    // then the rounding direction is determined by bit [8] for round to even. That's why
+    // the 9th bit is relevant for the rounding decision.)
+    // If the MSB of the input is set to 0, the cvtepi32_ps instruction makes its rounding
+    // decision on the lowest 8 bits instead. A second rounding decision is made when
+    // float(0x8000'0000) is added. This will rarely fix the rounding issue.
+    //
+    // Here's what the standard rounding mode expects:
+    // 0xc0000080 should cvt to 0xc0000000
+    // 0xc0000081 should cvt to 0xc0000100
+    //     --     should cvt to 0xc0000100
+    // 0xc000017f should cvt to 0xc0000100
+    // 0xc0000180 should cvt to 0xc0000200
+    //
+    // However: using float(input ^ 0x8000'0000) + float(0x8000'0000) we get:
+    // 0xc0000081 would cvt to 0xc0000000
+    // 0xc00000c0 would cvt to 0xc0000000
+    // 0xc00000c1 would cvt to 0xc0000100
+    // 0xc000013f would cvt to 0xc0000100
+    // 0xc0000140 would cvt to 0xc0000200
+    //
+    // Solution: float(input & 0x7fff'fe00) + (float(0x8000'0000) + float(input & 0x1ff))
+    // This ensures the rounding decision is made on the 9-bit LSB when 0x8000'0000 is
+    // added to the float value of the low 8 bits of the input.
+    using namespace AVX;
+    return _mm256_blendv_ps(
+        _mm256_cvtepi32_ps(v),
+        _mm256_add_ps(_mm256_cvtepi32_ps(and_si256(v, set1_epi32(0x7ffffe00))),
+                      _mm256_add_ps(set2power31_ps(), _mm256_cvtepi32_ps(and_si256(
+                                                          v, set1_epi32(0x000001ff))))),
+        _mm256_castsi256_ps(cmplt_epi32(v, _mm256_setzero_si256())));
+}
+Vc_INTRINSIC __m256  convert(__m128i v, ConvertTag<short , float>) { return _mm256_cvtepi32_ps(convert(v, ConvertTag< short, int>())); }
+Vc_INTRINSIC __m256  convert(__m128i v, ConvertTag<ushort, float>) { return _mm256_cvtepi32_ps(convert(v, ConvertTag<ushort, int>())); }
+
+Vc_INTRINSIC __m256d convert(__m128  v, ConvertTag<float , double>) { return _mm256_cvtps_pd(v); }
+Vc_INTRINSIC __m256d convert(__m256d v, ConvertTag<double, double>) { return v; }
+Vc_INTRINSIC __m256d convert(__m128i v, ConvertTag<int   , double>) { return _mm256_cvtepi32_pd(v); }
+Vc_INTRINSIC __m256d convert(__m128i v, ConvertTag<uint  , double>) {
+    using namespace AVX;
+    return _mm256_add_pd(
+        _mm256_cvtepi32_pd(_mm_xor_si128(v, _mm_setmin_epi32())),
+        set1_pd(1u << 31)); }
+Vc_INTRINSIC __m256d convert(__m128i v, ConvertTag<short , double>) { return convert(convert(v, SSE::ConvertTag< short, int>()), ConvertTag<int, double>()); }
+Vc_INTRINSIC __m256d convert(__m128i v, ConvertTag<ushort, double>) { return convert(convert(v, SSE::ConvertTag<ushort, int>()), ConvertTag<int, double>()); }
+
+Vc_INTRINSIC __m128i convert(__m256i v, ConvertTag<int   , short>) {
+    const auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));
+    const auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));
+    const auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);
+    const auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);
+    return _mm_unpacklo_epi16(tmp2, tmp3);
+}
+Vc_INTRINSIC __m128i convert(__m256i v, ConvertTag<uint  , short>) {
+    const auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));
+    const auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));
+    const auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);
+    const auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);
+    return _mm_unpacklo_epi16(tmp2, tmp3);
+}
+Vc_INTRINSIC __m128i convert(__m256  v, ConvertTag<float , short>) { return convert(convert(v, ConvertTag<float, int>()), ConvertTag<int, short>()); }
+Vc_INTRINSIC __m128i convert(__m256d v, ConvertTag<double, short>) { return convert(convert(v, ConvertTag<double, int>()), SSE::ConvertTag<int, short>()); }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<short , short>) { return v; }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<ushort, short>) { return v; }
+
+Vc_INTRINSIC __m128i convert(__m256i v, ConvertTag<int   , ushort>) {
+    auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));
+    auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));
+    auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);
+    return _mm_unpacklo_epi16(tmp2, tmp3);
+}
+Vc_INTRINSIC __m128i convert(__m256i v, ConvertTag<uint  , ushort>) {
+    auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));
+    auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));
+    auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);
+    return _mm_unpacklo_epi16(tmp2, tmp3);
+}
+Vc_INTRINSIC __m128i convert(__m256  v, ConvertTag<float , ushort>) { return convert(convert(v, ConvertTag<float, uint>()), ConvertTag<uint, ushort>()); }
+Vc_INTRINSIC __m128i convert(__m256d v, ConvertTag<double, ushort>) { return convert(convert(v, ConvertTag<double, uint>()), SSE::ConvertTag<uint, ushort>()); }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<short , ushort>) { return v; }
+Vc_INTRINSIC __m256i convert(__m256i v, ConvertTag<ushort, ushort>) { return v; }
+
+template <typename From, typename To>
+Vc_INTRINSIC auto convert(
+    typename std::conditional<(sizeof(From) < sizeof(To)),
+                              typename SSE::VectorTraits<From>::VectorType,
+                              typename AVX::VectorTypeHelper<From>::Type>::type v)
+    -> decltype(convert(v, ConvertTag<From, To>()))
+{
+    return convert(v, ConvertTag<From, To>());
+}
+
+template <typename From, typename To, typename = enable_if<(sizeof(From) < sizeof(To))>>
+Vc_INTRINSIC auto convert(typename AVX::VectorTypeHelper<From>::Type v)
+    -> decltype(convert(lo128(v), ConvertTag<From, To>()))
+{
+    return convert(lo128(v), ConvertTag<From, To>());
+}
+}  // namespace AVX
+}  // namespace Vc
 
-#endif // AVX_CASTS_H
+#endif // VC_AVX_CASTS_H_
diff -Nru vc-0.7.4/avx/const_data.h vc-1.3.0/avx/const_data.h
--- vc-0.7.4/avx/const_data.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/const_data.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,37 +1,46 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_AVX_CONST_DATA_H
-#define VC_AVX_CONST_DATA_H
+#ifndef VC_AVX_CONST_DATA_H_
+#define VC_AVX_CONST_DATA_H_
 
+#include "../common/data.h"
 #include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
 
-ALIGN(64) extern const unsigned int   _IndexesFromZero32[8];
-ALIGN(16) extern const unsigned short _IndexesFromZero16[8];
-ALIGN(16) extern const unsigned char  _IndexesFromZero8[16];
+alignas(64) extern const unsigned int   _IndexesFromZero32[ 8];
+alignas(16) extern const unsigned short _IndexesFromZero16[16];
+alignas(16) extern const unsigned char  _IndexesFromZero8 [32];
 
-struct STRUCT_ALIGN1(64) c_general
+struct alignas(64) c_general
 {
     static const float oneFloat;
     static const unsigned int absMaskFloat[2];
@@ -43,18 +52,18 @@
     static const double oneDouble;
     static const unsigned long long frexpMask;
     static const unsigned long long highMaskDouble;
-} STRUCT_ALIGN2(64);
+};
 
 template<typename T> struct c_trig
 {
-    ALIGN(64) static const T data[];
+    alignas(64) static const T data[];
 };
 
 template<typename T> struct c_log
 {
     typedef float floatAlias Vc_MAY_ALIAS;
     static Vc_ALWAYS_INLINE float d(int i) { return *reinterpret_cast<const floatAlias *>(&data[i]); }
-    ALIGN(64) static const unsigned int data[];
+    alignas(64) static const unsigned int data[];
 };
 
 template<> struct c_log<double>
@@ -62,13 +71,23 @@
     enum VectorSize { Size = 16 / sizeof(double) };
     typedef double doubleAlias Vc_MAY_ALIAS;
     static Vc_ALWAYS_INLINE double d(int i) { return *reinterpret_cast<const doubleAlias *>(&data[i]); }
-    ALIGN(64) static const unsigned long long data[];
+    alignas(64) static const unsigned long long data[];
 };
 
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace AVX
+}  // namespace Vc
 
-#include "undomacros.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace AVX2
+{
+    using AVX::_IndexesFromZero8;
+    using AVX::_IndexesFromZero16;
+    using AVX::_IndexesFromZero32;
+    using AVX::c_general;
+    using AVX::c_trig;
+    using AVX::c_log;
+}  // namespace AVX2
+}  // namespace Vc
 
-#endif // VC_AVX_CONST_DATA_H
+#endif // VC_AVX_CONST_DATA_H_
diff -Nru vc-0.7.4/avx/const.h vc-1.3.0/avx/const.h
--- vc-0.7.4/avx/const.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/const.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,36 +1,42 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_CONST_H
-#define VC_AVX_CONST_H
+#ifndef VC_AVX_CONST_H_
+#define VC_AVX_CONST_H_
 
 #include <cstddef>
+#include "types.h"
 #include "const_data.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
-    template<typename T> class Vector;
-
     template<typename T> struct IndexesFromZeroData;
     template<> struct IndexesFromZeroData<int> {
         static Vc_ALWAYS_INLINE Vc_CONST const int *address() { return reinterpret_cast<const int *>(&_IndexesFromZero32[0]); }
@@ -102,11 +108,13 @@
 
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float>  Const<float>::highMask() { return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::highMaskFloat)); }
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<double> Const<double>::highMask() { return _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::highMaskDouble)); }
-    template<> Vc_ALWAYS_INLINE Vc_CONST Vector<sfloat> Const<sfloat>::highMask() { return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::highMaskFloat)); }
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace AVX
 
-#include "undomacros.h"
+namespace AVX2
+{
+using AVX::IndexesFromZeroData;
+using AVX::Const;
+}  // namespace AVX2
+}  // namespace Vc
 
-#endif // VC_AVX_CONST_H
+#endif // VC_AVX_CONST_H_
diff -Nru vc-0.7.4/avx/debug.h vc-1.3.0/avx/debug.h
--- vc-0.7.4/avx/debug.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/debug.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,36 +1,47 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_DEBUG_H
-#define VC_AVX_DEBUG_H
+#ifndef VC_AVX_DEBUG_H_
+#define VC_AVX_DEBUG_H_
 
 #ifndef NDEBUG
-#include "vectorbase.h"
+#include "vector.h"
 #include <iostream>
 #include <iomanip>
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
+template <typename T, typename U> struct AddType {
+    const U &d;
+};
+template <typename T, typename U> AddType<T, U> addType(const U &x) { return {x}; }
 
 #ifdef NDEBUG
 class DebugStream
@@ -61,6 +72,11 @@
 
         template<typename T> DebugStream &operator<<(const T &x) { std::cerr << x; return *this; }
 
+        template <typename T, typename U> DebugStream &operator<<(AddType<T, U> &&x)
+        {
+            printVector<T, U>(x.d);
+            return *this;
+        }
         DebugStream &operator<<(__m128 x) {
             printVector<float, __m128>(x);
             return *this;
@@ -93,10 +109,16 @@
 };
 #endif
 
-#define VC_DEBUG ::Vc::AVX::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)
+#ifdef Vc_DEBUG
+#undef Vc_DEBUG
+#endif
+#ifdef Vc_MSVC
+#define Vc_DEBUG Vc::AVX::DebugStream(__FUNCSIG__, __FILE__, __LINE__)
+#else
+#define Vc_DEBUG Vc::AVX::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)
+#endif
 
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace AVX
+}  // namespace Vc
 
-#endif // VC_AVX_DEBUG_H
+#endif // VC_AVX_DEBUG_H_
diff -Nru vc-0.7.4/avx/deinterleave.tcc vc-1.3.0/avx/deinterleave.tcc
--- vc-0.7.4/avx/deinterleave.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/deinterleave.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,29 +1,36 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace AVX
+namespace AVX2
 {
 
-inline void deinterleave(double_v &VC_RESTRICT a, double_v &VC_RESTRICT b, double_v &VC_RESTRICT c)
+inline void deinterleave(double_v &Vc_RESTRICT a, double_v &Vc_RESTRICT b, double_v &Vc_RESTRICT c)
 {   // estimated latency (AVX): 4.5 cycles
     const m256d tmp0 = Mem::shuffle128<X0, Y1>(a.data(), b.data());
     const m256d tmp1 = Mem::shuffle128<X1, Y0>(a.data(), c.data());
@@ -33,7 +40,7 @@
     c.data() = Mem::shuffle<X0, Y1, X2, Y3>(tmp1, tmp2);
 }
 
-inline void deinterleave(float_v &VC_RESTRICT a, float_v &VC_RESTRICT b, float_v &VC_RESTRICT c)
+inline void deinterleave(float_v &Vc_RESTRICT a, float_v &Vc_RESTRICT b, float_v &Vc_RESTRICT c)
 {
     //                               abc   abc abc
     // a = [a0 b0 c0 a1 b1 c1 a2 b2] 332 = 211+121
@@ -54,21 +61,23 @@
     c.data() = Mem::permute<X2, X1, X0, X3>(tmp2);
 }
 
-inline void deinterleave(int_v &VC_RESTRICT a, int_v &VC_RESTRICT b, int_v &VC_RESTRICT c)
+inline void deinterleave(int_v &Vc_RESTRICT a, int_v &Vc_RESTRICT b, int_v &Vc_RESTRICT c)
 {
     deinterleave(reinterpret_cast<float_v &>(a), reinterpret_cast<float_v &>(b),
             reinterpret_cast<float_v &>(c));
 }
 
-inline void deinterleave(uint_v &VC_RESTRICT a, uint_v &VC_RESTRICT b, uint_v &VC_RESTRICT c)
+inline void deinterleave(uint_v &Vc_RESTRICT a, uint_v &Vc_RESTRICT b, uint_v &Vc_RESTRICT c)
 {
     deinterleave(reinterpret_cast<float_v &>(a), reinterpret_cast<float_v &>(b),
             reinterpret_cast<float_v &>(c));
 }
 
-inline void deinterleave(Vector<short> &VC_RESTRICT a, Vector<short> &VC_RESTRICT b,
-        Vector<short> &VC_RESTRICT c)
+inline void deinterleave(Vector<short> &Vc_RESTRICT , Vector<short> &Vc_RESTRICT ,
+        Vector<short> &Vc_RESTRICT )
 {
+    return;
+    /* TODO:
     //                               abc   abc abc
     // a = [a0 b0 c0 a1 b1 c1 a2 b2] 332 = 211+121
     // b = [c2 a3 b3 c3 a4 b4 c4 a5] 323 = 112+211
@@ -86,10 +95,11 @@
     a.data() = Mem::permuteHi<X4, X7, X6, X5>(Mem::permuteLo<X0, X3, X2, X1>(tmp0));
     b.data() = Mem::permuteHi<X5, X4, X7, X6>(Mem::permuteLo<X1, X0, X3, X2>(tmp1));
     c.data() = Mem::permuteHi<X6, X5, X4, X7>(Mem::permuteLo<X2, X1, X0, X3>(tmp2));
+    */
 }
 
-inline void deinterleave(Vector<unsigned short> &VC_RESTRICT a, Vector<unsigned short> &VC_RESTRICT b,
-        Vector<unsigned short> &VC_RESTRICT c)
+inline void deinterleave(Vector<unsigned short> &Vc_RESTRICT a, Vector<unsigned short> &Vc_RESTRICT b,
+        Vector<unsigned short> &Vc_RESTRICT c)
 {
     deinterleave(reinterpret_cast<Vector<short> &>(a), reinterpret_cast<Vector<short> &>(b),
             reinterpret_cast<Vector<short> &>(c));
@@ -109,174 +119,172 @@
     b.data() = _mm256_unpackhi_ps(tmp2, tmp3); // b7 b5 b3 b1 a7 a5 a3 a1
 }
 
-inline void deinterleave(Vector<short> &a, Vector<short> &b)
+inline void deinterleave(Vector<short> &a, // a0 b0 a1 b1 a2 b2 a3 b3 | a4 b4 a5 ...
+                         Vector<short> &b) // a8 b8 a9 ...
 {
-    m128i tmp0 = _mm_unpacklo_epi16(a.data(), b.data()); // a0 a4 b0 b4 a1 a5 b1 b5
-    m128i tmp1 = _mm_unpackhi_epi16(a.data(), b.data()); // a2 a6 b2 b6 a3 a7 b3 b7
-    m128i tmp2 = _mm_unpacklo_epi16(tmp0, tmp1); // a0 a2 a4 a6 b0 b2 b4 b6
-    m128i tmp3 = _mm_unpackhi_epi16(tmp0, tmp1); // a1 a3 a5 a7 b1 b3 b5 b7
-    a.data() = _mm_unpacklo_epi16(tmp2, tmp3);
-    b.data() = _mm_unpackhi_epi16(tmp2, tmp3);
+    auto v0 = Mem::shuffle128<X0, Y0>(a.data(), b.data());
+    auto v1 = Mem::shuffle128<X1, Y1>(a.data(), b.data());
+    auto v2 = AVX::unpacklo_epi16(v0, v1); // a0 a4 ...
+    auto v3 = AVX::unpackhi_epi16(v0, v1); // a2 a6 ...
+    v0 = AVX::unpacklo_epi16(v2, v3); // a0 a2 ...
+    v1 = AVX::unpackhi_epi16(v2, v3); // a1 a3 ...
+    a.data() = AVX::unpacklo_epi16(v0, v1); // a0 a1 ...
+    b.data() = AVX::unpackhi_epi16(v0, v1); // b0 b1 ...
+}
+
+inline void deinterleave(Vector<ushort> &a, Vector<ushort> &b)
+{
+    auto v0 = Mem::shuffle128<X0, Y0>(a.data(), b.data());
+    auto v1 = Mem::shuffle128<X1, Y1>(a.data(), b.data());
+    auto v2 = AVX::unpacklo_epi16(v0, v1); // a0 a4 ...
+    auto v3 = AVX::unpackhi_epi16(v0, v1); // a2 a6 ...
+    v0 = AVX::unpacklo_epi16(v2, v3); // a0 a2 ...
+    v1 = AVX::unpackhi_epi16(v2, v3); // a1 a3 ...
+    a.data() = AVX::unpacklo_epi16(v0, v1); // a0 a1 ...
+    b.data() = AVX::unpackhi_epi16(v0, v1); // b0 b1 ...
 }
 
-inline void deinterleave(Vector<unsigned short> &a, Vector<unsigned short> &b)
+}  // namespace AVX2
+namespace Detail
 {
-    m128i tmp0 = _mm_unpacklo_epi16(a.data(), b.data()); // a0 a4 b0 b4 a1 a5 b1 b5
-    m128i tmp1 = _mm_unpackhi_epi16(a.data(), b.data()); // a2 a6 b2 b6 a3 a7 b3 b7
-    m128i tmp2 = _mm_unpacklo_epi16(tmp0, tmp1); // a0 a2 a4 a6 b0 b2 b4 b6
-    m128i tmp3 = _mm_unpackhi_epi16(tmp0, tmp1); // a1 a3 a5 a7 b1 b3 b5 b7
-    a.data() = _mm_unpacklo_epi16(tmp2, tmp3);
-    b.data() = _mm_unpackhi_epi16(tmp2, tmp3);
-}
-
-} // namespace AVX
-
-
-namespace Internal
-{
-
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        float_v &a, float_v &b, const float *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const float *m, Flags align)
 {
     a.load(m, align);
-    b.load(m + float_v::Size, align);
-    Vc::AVX::deinterleave(a, b);
+    b.load(m + AVX2::float_v::Size, align);
+    Vc::AVX2::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        float_v &a, float_v &b, const short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const short *m, Flags f)
 {
-    using Vc::AVX::m256i;
-    const m256i tmp = Vc::AVX::VectorHelper<m256i>::load(m, align);
-    a.data() = _mm256_cvtepi32_ps(Vc::AVX::concat(
-                _mm_srai_epi32(_mm_slli_epi32(AVX::lo128(tmp), 16), 16),
-                _mm_srai_epi32(_mm_slli_epi32(AVX::hi128(tmp), 16), 16)));
-    b.data() = _mm256_cvtepi32_ps(Vc::AVX::concat(
-                _mm_srai_epi32(AVX::lo128(tmp), 16),
-                _mm_srai_epi32(AVX::hi128(tmp), 16)));
+    using namespace Vc::AVX2;
+    const auto tmp = Detail::load32(m, f);
+    a.data() =
+        _mm256_cvtepi32_ps(concat(_mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),
+                                  _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16)));
+    b.data() = _mm256_cvtepi32_ps(
+        concat(_mm_srai_epi32(lo128(tmp), 16), _mm_srai_epi32(hi128(tmp), 16)));
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        float_v &a, float_v &b, const unsigned short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const unsigned short *m, Flags f)
 {
-    using Vc::AVX::m256i;
-    const m256i tmp = Vc::AVX::VectorHelper<m256i>::load(m, align);
-    a.data() = _mm256_cvtepi32_ps(Vc::AVX::concat(
-                _mm_blend_epi16(AVX::lo128(tmp), _mm_setzero_si128(), 0xaa),
-                _mm_blend_epi16(AVX::hi128(tmp), _mm_setzero_si128(), 0xaa)));
-    b.data() = _mm256_cvtepi32_ps(Vc::AVX::concat(
-                _mm_srli_epi32(AVX::lo128(tmp), 16),
-                _mm_srli_epi32(AVX::hi128(tmp), 16)));
+    using namespace Vc::AVX2;
+    const auto tmp = Detail::load32(m, f);
+    a.data() = _mm256_cvtepi32_ps(
+        concat(_mm_blend_epi16(lo128(tmp), _mm_setzero_si128(), 0xaa),
+               _mm_blend_epi16(hi128(tmp), _mm_setzero_si128(), 0xaa)));
+    b.data() = _mm256_cvtepi32_ps(
+        concat(_mm_srli_epi32(lo128(tmp), 16), _mm_srli_epi32(hi128(tmp), 16)));
 }
 
-template<typename A, typename MemT> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        sfloat_v &_a, sfloat_v &_b, const MemT *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::double_v &a, AVX2::double_v &b, const double *m, Flags align)
 {
-    float_v &a = reinterpret_cast<float_v &>(_a);
-    float_v &b = reinterpret_cast<float_v &>(_b);
-    HelperImpl<Vc::AVXImpl>::deinterleave(a, b, m, align);
-}
+    using namespace Vc::AVX2;
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        double_v &a, double_v &b, const double *m, A align)
-{
     a.load(m, align);
-    b.load(m + double_v::Size, align);
+    b.load(m + AVX2::double_v::Size, align);
 
-    m256d tmp0 = Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data()); // b1 b0 a1 a0
-    m256d tmp1 = Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data()); // b3 b2 a3 a2
+    m256d tmp0 = Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data());  // b1 b0 a1 a0
+    m256d tmp1 = Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data());  // b3 b2 a3 a2
 
-    a.data() = _mm256_unpacklo_pd(tmp0, tmp1); // b2 b0 a2 a0
-    b.data() = _mm256_unpackhi_pd(tmp0, tmp1); // b3 b1 a3 a1
+    a.data() = _mm256_unpacklo_pd(tmp0, tmp1);  // b2 b0 a2 a0
+    b.data() = _mm256_unpackhi_pd(tmp0, tmp1);  // b3 b1 a3 a1
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        int_v &a, int_v &b, const int *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::int_v &a, AVX2::int_v &b, const int *m, Flags align)
 {
-    using Vc::AVX::m256;
+    using namespace AVX;
     a.load(m, align);
-    b.load(m + int_v::Size, align);
+    b.load(m + AVX2::int_v::Size, align);
 
-    const m256 tmp0 = AVX::avx_cast<m256>(Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data()));
-    const m256 tmp1 = AVX::avx_cast<m256>(Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data()));
+    const m256 tmp0 = avx_cast<m256>(Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data()));
+    const m256 tmp1 = avx_cast<m256>(Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data()));
 
     const m256 tmp2 = _mm256_unpacklo_ps(tmp0, tmp1); // b5 b1 b4 b0 a5 a1 a4 a0
     const m256 tmp3 = _mm256_unpackhi_ps(tmp0, tmp1); // b7 b3 b6 b2 a7 a3 a6 a2
 
-    a.data() = AVX::avx_cast<m256i>(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0
-    b.data() = AVX::avx_cast<m256i>(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1
+    a.data() = avx_cast<m256i>(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0
+    b.data() = avx_cast<m256i>(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        int_v &a, int_v &b, const short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::int_v &a, AVX2::int_v &b, const short *m, Flags f)
 {
-    using Vc::AVX::m256i;
-    const m256i tmp = Vc::AVX::VectorHelper<m256i>::load(m, align);
-    a.data() = Vc::AVX::concat(
-                _mm_srai_epi32(_mm_slli_epi32(AVX::lo128(tmp), 16), 16),
-                _mm_srai_epi32(_mm_slli_epi32(AVX::hi128(tmp), 16), 16));
-    b.data() = Vc::AVX::concat(
-                _mm_srai_epi32(AVX::lo128(tmp), 16),
-                _mm_srai_epi32(AVX::hi128(tmp), 16));
+    using namespace Vc::AVX;
+    const AVX2::short_v tmp0(m, f);
+    const m256i tmp = tmp0.data();
+    a.data() = concat(
+                _mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),
+                _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16));
+    b.data() = concat(
+                _mm_srai_epi32(lo128(tmp), 16),
+                _mm_srai_epi32(hi128(tmp), 16));
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        uint_v &a, uint_v &b, const unsigned int *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::uint_v &a, AVX2::uint_v &b, const unsigned int *m, Flags align)
 {
-    using Vc::AVX::m256;
+    using namespace AVX;
     a.load(m, align);
-    b.load(m + uint_v::Size, align);
+    b.load(m + AVX2::uint_v::Size, align);
 
-    const m256 tmp0 = AVX::avx_cast<m256>(Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data()));
-    const m256 tmp1 = AVX::avx_cast<m256>(Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data()));
+    const m256 tmp0 = avx_cast<m256>(Mem::shuffle128<Vc::X0, Vc::Y0>(a.data(), b.data()));
+    const m256 tmp1 = avx_cast<m256>(Mem::shuffle128<Vc::X1, Vc::Y1>(a.data(), b.data()));
 
     const m256 tmp2 = _mm256_unpacklo_ps(tmp0, tmp1); // b5 b1 b4 b0 a5 a1 a4 a0
     const m256 tmp3 = _mm256_unpackhi_ps(tmp0, tmp1); // b7 b3 b6 b2 a7 a3 a6 a2
 
-    a.data() = AVX::avx_cast<m256i>(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0
-    b.data() = AVX::avx_cast<m256i>(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1
+    a.data() = avx_cast<m256i>(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0
+    b.data() = avx_cast<m256i>(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        uint_v &a, uint_v &b, const unsigned short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::uint_v &a, AVX2::uint_v &b, const unsigned short *m, Flags f)
 {
-    using Vc::AVX::m256i;
-    const m256i tmp = Vc::AVX::VectorHelper<m256i>::load(m, align);
-    a.data() = Vc::AVX::concat(
-                _mm_srli_epi32(_mm_slli_epi32(AVX::lo128(tmp), 16), 16),
-                _mm_srli_epi32(_mm_slli_epi32(AVX::hi128(tmp), 16), 16));
-    b.data() = Vc::AVX::concat(
-                _mm_srli_epi32(AVX::lo128(tmp), 16),
-                _mm_srli_epi32(AVX::hi128(tmp), 16));
+    using namespace Vc::AVX;
+    const AVX2::ushort_v tmp0(m, f);
+    const m256i tmp = tmp0.data();
+    a.data() = concat(
+                _mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),
+                _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16));
+    b.data() = concat(
+                _mm_srai_epi32(lo128(tmp), 16),
+                _mm_srai_epi32(hi128(tmp), 16));
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        short_v &a, short_v &b, const short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::short_v &a, AVX2::short_v &b, const short *m, Flags align)
 {
     a.load(m, align);
-    b.load(m + short_v::Size, align);
-    Vc::AVX::deinterleave(a, b);
+    b.load(m + AVX2::short_v::Size, align);
+    Vc::AVX2::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::AVXImpl>::deinterleave(
-        ushort_v &a, ushort_v &b, const unsigned short *m, A align)
+template <typename Flags>
+inline void deinterleave(AVX2::ushort_v &a, AVX2::ushort_v &b, const unsigned short *m, Flags align)
 {
     a.load(m, align);
-    b.load(m + ushort_v::Size, align);
-    Vc::AVX::deinterleave(a, b);
+    b.load(m + AVX2::ushort_v::Size, align);
+    Vc::AVX2::deinterleave(a, b);
 }
 
 // only support M == V::EntryType -> no specialization
-template<typename V, typename M, typename A>
-inline Vc_FLATTEN void HelperImpl<Vc::AVXImpl>::deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-        V &VC_RESTRICT c, const M *VC_RESTRICT memory, A align)
+template <typename T, typename M, typename Flags>
+Vc_ALWAYS_INLINE void deinterleave(AVX2::Vector<T> &Vc_RESTRICT a,
+                                   AVX2::Vector<T> &Vc_RESTRICT b,
+                                   AVX2::Vector<T> &Vc_RESTRICT c,
+                                   const M *Vc_RESTRICT memory, Flags align)
 {
+    using V = AVX2::Vector<T>;
     a.load(&memory[0 * V::Size], align);
     b.load(&memory[1 * V::Size], align);
     c.load(&memory[2 * V::Size], align);
-    Vc::AVX::deinterleave(a, b, c);
+    Vc::AVX2::deinterleave(a, b, c);
 }
 
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Detail
+}  // namespace Vc
diff -Nru vc-0.7.4/avx/detail.h vc-1.3.0/avx/detail.h
--- vc-0.7.4/avx/detail.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/avx/detail.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,2171 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_AVX_DETAIL_H_
+#define VC_AVX_DETAIL_H_
+
+#include "../sse/detail.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+// (converting) load functions {{{1
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,
+                                 typename Flags::EnableIfAligned = nullptr)
+{
+    return _mm256_load_ps(x);
+}
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,
+                                 typename Flags::EnableIfUnaligned = nullptr)
+{
+    return _mm256_loadu_ps(x);
+}
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,
+                                 typename Flags::EnableIfStreaming = nullptr)
+{
+    return AvxIntrinsics::stream_load<__m256>(x);
+}
+
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,
+                                  typename Flags::EnableIfAligned = nullptr)
+{
+    return _mm256_load_pd(x);
+}
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,
+                                  typename Flags::EnableIfUnaligned = nullptr)
+{
+    return _mm256_loadu_pd(x);
+}
+template <typename Flags>
+Vc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,
+                                  typename Flags::EnableIfStreaming = nullptr)
+{
+    return AvxIntrinsics::stream_load<__m256d>(x);
+}
+
+template <typename Flags, typename T, typename = enable_if<std::is_integral<T>::value>>
+Vc_INTRINSIC Vc_PURE __m256i
+load(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfAligned = nullptr)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(x));
+}
+template <typename Flags, typename T, typename = enable_if<std::is_integral<T>::value>>
+Vc_INTRINSIC Vc_PURE __m256i
+load(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfUnaligned = nullptr)
+{
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(x));
+}
+template <typename Flags, typename T, typename = enable_if<std::is_integral<T>::value>>
+Vc_INTRINSIC Vc_PURE __m256i
+load(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfStreaming = nullptr)
+{
+    return AvxIntrinsics::stream_load<__m256i>(x);
+}
+
+// load32{{{2
+Vc_INTRINSIC __m256 load32(const float *mem, when_aligned)
+{
+    return _mm256_load_ps(mem);
+}
+Vc_INTRINSIC __m256 load32(const float *mem, when_unaligned)
+{
+    return _mm256_loadu_ps(mem);
+}
+Vc_INTRINSIC __m256 load32(const float *mem, when_streaming)
+{
+    return AvxIntrinsics::stream_load<__m256>(mem);
+}
+Vc_INTRINSIC __m256d load32(const double *mem, when_aligned)
+{
+    return _mm256_load_pd(mem);
+}
+Vc_INTRINSIC __m256d load32(const double *mem, when_unaligned)
+{
+    return _mm256_loadu_pd(mem);
+}
+Vc_INTRINSIC __m256d load32(const double *mem, when_streaming)
+{
+    return AvxIntrinsics::stream_load<__m256d>(mem);
+}
+template <class T> Vc_INTRINSIC __m256i load32(const T *mem, when_aligned)
+{
+    static_assert(std::is_integral<T>::value, "load32<T> is only intended for integral T");
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+template <class T> Vc_INTRINSIC __m256i load32(const T *mem, when_unaligned)
+{
+    static_assert(std::is_integral<T>::value, "load32<T> is only intended for integral T");
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(mem));
+}
+template <class T> Vc_INTRINSIC __m256i load32(const T *mem, when_streaming)
+{
+    static_assert(std::is_integral<T>::value, "load32<T> is only intended for integral T");
+    return AvxIntrinsics::stream_load<__m256i>(mem);
+}
+
+// MSVC workarounds{{{2
+#ifdef Vc_MSVC
+// work around: "fatal error C1001: An internal error has occurred in the compiler."
+Vc_INTRINSIC __m256i load(const uint *mem, when_aligned, LoadTag<__m256i, int>)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+Vc_INTRINSIC __m256d load(const double *mem, when_unaligned, LoadTag<__m256d, double>)
+{
+    return _mm256_loadu_pd(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256 load(const float *mem, when_aligned,
+                         enable_if<(std::is_same<DstT, float>::value &&
+                                    std::is_same<V, __m256>::value)> = nullarg)
+{
+    return _mm256_load_ps(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256 load(const float *mem, when_unaligned,
+                         enable_if<(std::is_same<DstT, float>::value &&
+                                    std::is_same<V, __m256>::value)> = nullarg)
+{
+    return _mm256_loadu_ps(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256 load(const float *mem, when_streaming,
+                         enable_if<(std::is_same<DstT, float>::value &&
+                                    std::is_same<V, __m256>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256>(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256d load(const double *mem, when_aligned,
+                          enable_if<(std::is_same<DstT, double>::value &&
+                                     std::is_same<V, __m256d>::value)> = nullarg)
+{
+    return _mm256_load_pd(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256d load(const double *mem, when_unaligned,
+                          enable_if<(std::is_same<DstT, double>::value &&
+                                     std::is_same<V, __m256d>::value)> = nullarg)
+{
+    return _mm256_loadu_pd(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256d load(const double *mem, when_streaming,
+                          enable_if<(std::is_same<DstT, double>::value &&
+                                     std::is_same<V, __m256d>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256d>(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const uint *mem, when_aligned,
+                          enable_if<(std::is_same<DstT, uint>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const uint *mem, when_unaligned,
+                          enable_if<(std::is_same<DstT, uint>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const uint *mem, when_streaming,
+                          enable_if<(std::is_same<DstT, uint>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256i>(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const int *mem, when_unaligned,
+                          enable_if<(std::is_same<DstT, int>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const int *mem, when_aligned,
+                          enable_if<(std::is_same<DstT, int>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const int *mem, when_streaming,
+                          enable_if<(std::is_same<DstT, int>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256i>(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const short *mem, when_unaligned,
+                          enable_if<(std::is_same<DstT, short>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const short *mem, when_aligned,
+                          enable_if<(std::is_same<DstT, short>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const short *mem, when_streaming,
+                          enable_if<(std::is_same<DstT, short>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256i>(mem);
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const ushort *mem, when_unaligned,
+                          enable_if<(std::is_same<DstT, ushort>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const ushort *mem, when_aligned,
+                          enable_if<(std::is_same<DstT, ushort>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return _mm256_load_si256(reinterpret_cast<const __m256i *>(mem));
+}
+
+template <typename V, typename DstT>
+Vc_INTRINSIC __m256i load(const ushort *mem, when_streaming,
+                          enable_if<(std::is_same<DstT, ushort>::value &&
+                                     std::is_same<V, __m256i>::value)> = nullarg)
+{
+    return AvxIntrinsics::stream_load<__m256i>(mem);
+}
+
+#endif  // Vc_MSVC
+
+// short {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, short>)
+{
+    return load32(mem, f);
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const uchar *mem, Flags f, LoadTag<__m256i, short>)
+{
+    return AVX::cvtepu8_epi16(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const schar *mem, Flags f, LoadTag<__m256i, short>)
+{
+    return AVX::cvtepi8_epi16(load16(mem, f));
+}
+
+// ushort {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const uchar *mem, Flags f, LoadTag<__m256i, ushort>)
+{
+    return AVX::cvtepu8_epi16(load16(mem, f));
+}
+
+// int {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const uint *mem, Flags f, LoadTag<__m256i, int>)
+{
+    return load32(mem, f);
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, int>)
+{
+    return AVX::cvtepu16_epi32(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const short *mem, Flags f, LoadTag<__m256i, int>)
+{
+    return AVX::cvtepi16_epi32(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const uchar *mem, Flags, LoadTag<__m256i, int>)
+{
+    return AVX::cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const schar *mem, Flags, LoadTag<__m256i, int>)
+{
+    return AVX::cvtepi8_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+
+// uint {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, uint>)
+{
+    return AVX::cvtepu16_epi32(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256i load(const uchar *mem, Flags, LoadTag<__m256i, uint>)
+{
+    return AVX::cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+
+// double {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const float *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<float, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const uint *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<uint, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const int *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<int, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const ushort *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<int, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const short *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<int, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const uchar *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<int, double>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256d load(const schar *mem, Flags f, LoadTag<__m256d, double>)
+{
+    return AVX::convert<int, double>(load16(mem, f));
+}
+
+// float {{{2
+template <typename Flags>
+Vc_INTRINSIC __m256 load(const double *mem, Flags f, LoadTag<__m256, float>)
+{
+    return AVX::concat(_mm256_cvtpd_ps(load32(&mem[0], f)),
+                       _mm256_cvtpd_ps(load32(&mem[4], f)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256 load(const uint *mem, Flags f, LoadTag<__m256, float>)
+{
+    const auto v = load32(mem, f);
+    return _mm256_blendv_ps(
+        _mm256_cvtepi32_ps(v),
+        _mm256_add_ps(_mm256_cvtepi32_ps(AVX::sub_epi32(v, AVX::set2power31_epu32())),
+                      AVX::set2power31_ps()),
+        _mm256_castsi256_ps(AVX::cmplt_epi32(v, _mm256_setzero_si256())));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256 load(const int *mem, Flags f, LoadTag<__m256, float>)
+{
+    return AVX::convert<int, float>(load32(mem, f));
+}
+template <typename T, typename Flags,
+          typename = enable_if<!std::is_same<T, float>::value>>
+Vc_INTRINSIC __m256 load(const T *mem, Flags f, LoadTag<__m256, float>)
+{
+    return _mm256_cvtepi32_ps(load<__m256i, int>(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256 load(const ushort *mem, Flags f, LoadTag<__m256, float>)
+{
+    return AVX::convert<ushort, float>(load16(mem, f));
+}
+template <typename Flags>
+Vc_INTRINSIC __m256 load(const short *mem, Flags f, LoadTag<__m256, float>)
+{
+    return AVX::convert<short, float>(load16(mem, f));
+}
+/*
+template<typename Flags> struct LoadHelper<float, unsigned char, Flags> {
+    static __m256 load(const unsigned char *mem, Flags)
+    {
+        return _mm256_cvtepi32_ps(
+            cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem))));
+    }
+};
+template<typename Flags> struct LoadHelper<float, signed char, Flags> {
+    static __m256 load(const signed char *mem, Flags)
+    {
+        return _mm256_cvtepi32_ps(
+            cvtepi8_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem))));
+    }
+};
+*/
+
+// shifted{{{1
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount >= 16), T> shifted(T k)
+{
+    return AVX::avx_cast<T>(AVX::zeroExtend(
+        _mm_srli_si128(AVX::hi128(AVX::avx_cast<__m256i>(k)), amount - 16)));
+}
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount > 0 && amount < 16), T>
+shifted(T k)
+{
+    return AVX::avx_cast<T>(
+        AVX::alignr<amount>(Mem::permute128<X1, Const0>(AVX::avx_cast<__m256i>(k)),
+                            Mem::permute128<X0, X1>(AVX::avx_cast<__m256i>(k))));
+}
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount <= -16), T> shifted(T k)
+{
+    return AVX::avx_cast<T>(Mem::permute128<Const0, X0>(AVX::avx_cast<__m256i>(
+        _mm_slli_si128(AVX::lo128(AVX::avx_cast<__m256i>(k)), -16 - amount))));
+}
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount > -16 && amount < 0), T>
+shifted(T k)
+{
+    return AVX::avx_cast<T>(
+        AVX::alignr<16 + amount>(AVX::avx_cast<__m256i>(k),
+                                 Mem::permute128<Const0, X0>(AVX::avx_cast<__m256i>(k))));
+}
+// mask_cast{{{1
+template<size_t From, size_t To, typename R> Vc_INTRINSIC Vc_CONST R mask_cast(__m256i k)
+{
+    static_assert(From == To, "Incorrect mask cast.");
+    static_assert(std::is_same<R, __m256>::value, "Incorrect mask cast.");
+    return AVX::avx_cast<__m256>(k);
+}
+
+// 4 -> 4
+template <> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 4, __m128>(__m256i k)
+{
+    return AVX::avx_cast<__m128>(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)));
+}
+
+template <> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 4, __m256>(__m128i k)
+{
+    const auto kk = _mm_castsi128_ps(k);
+    return AVX::concat(_mm_unpacklo_ps(kk, kk), _mm_unpackhi_ps(kk, kk));
+}
+
+// 4 -> 8
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 8, __m256>(__m256i k)
+{
+    // aabb ccdd -> abcd 0000
+    return AVX::avx_cast<__m256>(AVX::concat(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)),
+                                 _mm_setzero_si128()));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 8, __m128>(__m256i k)
+{
+    // aaaa bbbb cccc dddd -> abcd 0000
+    return AVX::avx_cast<__m128>(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)), _mm_setzero_si128()));
+}
+
+template <> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 8, __m256>(__m128i k)
+{
+    return AVX::zeroExtend(AVX::avx_cast<__m128>(k));
+}
+
+// 4 -> 16
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 16, __m256>(__m256i k)
+{
+    // aaaa bbbb cccc dddd -> abcd 0000 0000 0000
+    return AVX::zeroExtend(mask_cast<4, 8, __m128>(k));
+}
+
+// 8 -> 4
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 4, __m256>(__m256i k)
+{
+    // aabb ccdd eeff gghh -> aaaa bbbb cccc dddd
+    const auto lo = AVX::lo128(AVX::avx_cast<__m256>(k));
+    return AVX::concat(_mm_unpacklo_ps(lo, lo),
+                  _mm_unpackhi_ps(lo, lo));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 4, __m128>(__m256i k)
+{
+    return AVX::avx_cast<__m128>(AVX::lo128(k));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 4, __m256>(__m128i k)
+{
+    // abcd efgh -> aaaa bbbb cccc dddd
+    const auto tmp = _mm_unpacklo_epi16(k, k); // aa bb cc dd
+    return AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi32(tmp, tmp), // aaaa bbbb
+                                 _mm_unpackhi_epi32(tmp, tmp))); // cccc dddd
+}
+
+// 8 -> 8
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 8, __m128>(__m256i k)
+{
+    // aabb ccdd eeff gghh -> abcd efgh
+    return AVX::avx_cast<__m128>(_mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 8, __m256>(__m128i k)
+{
+    return AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi16(k, k),
+                                 _mm_unpackhi_epi16(k, k)));
+}
+
+// 8 -> 16
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 16, __m256>(__m256i k)
+{
+    // aabb ccdd eeff gghh -> abcd efgh 0000 0000
+    return AVX::zeroExtend(mask_cast<8, 8, __m128>(k));
+}
+
+// 16 -> 8
+#ifdef Vc_IMPL_AVX2
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<16, 8, __m256>(__m256i k)
+{
+    // abcd efgh ijkl mnop -> aabb ccdd eeff gghh
+    const auto flipped = Mem::permute4x64<X0, X2, X1, X3>(k);
+    return _mm256_castsi256_ps(AVX::unpacklo_epi16(flipped, flipped));
+}
+#endif
+
+// 16 -> 4
+template<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<16, 4, __m256>(__m256i k)
+{
+    // abcd efgh ijkl mnop -> aaaa bbbb cccc dddd
+    const auto tmp = _mm_unpacklo_epi16(AVX::lo128(k), AVX::lo128(k)); // aabb ccdd
+    return _mm256_castsi256_ps(AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)));
+}
+
+// allone{{{1
+template<> Vc_INTRINSIC Vc_CONST __m256  allone<__m256 >() { return AVX::setallone_ps(); }
+template<> Vc_INTRINSIC Vc_CONST __m256i allone<__m256i>() { return AVX::setallone_si256(); }
+template<> Vc_INTRINSIC Vc_CONST __m256d allone<__m256d>() { return AVX::setallone_pd(); }
+
+// zero{{{1
+template<> Vc_INTRINSIC Vc_CONST __m256  zero<__m256 >() { return _mm256_setzero_ps(); }
+template<> Vc_INTRINSIC Vc_CONST __m256i zero<__m256i>() { return _mm256_setzero_si256(); }
+template<> Vc_INTRINSIC Vc_CONST __m256d zero<__m256d>() { return _mm256_setzero_pd(); }
+
+// one{{{1
+Vc_INTRINSIC Vc_CONST __m256  one( float) { return AVX::setone_ps   (); }
+Vc_INTRINSIC Vc_CONST __m256d one(double) { return AVX::setone_pd   (); }
+Vc_INTRINSIC Vc_CONST __m256i one(   int) { return AVX::setone_epi32(); }
+Vc_INTRINSIC Vc_CONST __m256i one(  uint) { return AVX::setone_epu32(); }
+Vc_INTRINSIC Vc_CONST __m256i one( short) { return AVX::setone_epi16(); }
+Vc_INTRINSIC Vc_CONST __m256i one(ushort) { return AVX::setone_epu16(); }
+Vc_INTRINSIC Vc_CONST __m256i one( schar) { return AVX::setone_epi8 (); }
+Vc_INTRINSIC Vc_CONST __m256i one( uchar) { return AVX::setone_epu8 (); }
+
+// negate{{{1
+Vc_ALWAYS_INLINE Vc_CONST __m256 negate(__m256 v, std::integral_constant<std::size_t, 4>)
+{
+    return _mm256_xor_ps(v, AVX::setsignmask_ps());
+}
+Vc_ALWAYS_INLINE Vc_CONST __m256d negate(__m256d v, std::integral_constant<std::size_t, 8>)
+{
+    return _mm256_xor_pd(v, AVX::setsignmask_pd());
+}
+Vc_ALWAYS_INLINE Vc_CONST __m256i negate(__m256i v, std::integral_constant<std::size_t, 4>)
+{
+    return AVX::sign_epi32(v, Detail::allone<__m256i>());
+}
+Vc_ALWAYS_INLINE Vc_CONST __m256i negate(__m256i v, std::integral_constant<std::size_t, 2>)
+{
+    return AVX::sign_epi16(v, Detail::allone<__m256i>());
+}
+
+// xor_{{{1
+Vc_INTRINSIC __m256 xor_(__m256 a, __m256 b) { return _mm256_xor_ps(a, b); }
+Vc_INTRINSIC __m256d xor_(__m256d a, __m256d b) { return _mm256_xor_pd(a, b); }
+Vc_INTRINSIC __m256i xor_(__m256i a, __m256i b)
+{
+#ifdef Vc_IMPL_AVX2
+    return _mm256_xor_si256(a, b);
+#else
+    return _mm256_castps_si256(
+        _mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
+#endif
+}
+
+// or_{{{1
+Vc_INTRINSIC __m256 or_(__m256 a, __m256 b) { return _mm256_or_ps(a, b); }
+Vc_INTRINSIC __m256d or_(__m256d a, __m256d b) { return _mm256_or_pd(a, b); }
+Vc_INTRINSIC __m256i or_(__m256i a, __m256i b)
+{
+#ifdef Vc_IMPL_AVX2
+    return _mm256_or_si256(a, b);
+#else
+    return _mm256_castps_si256(
+        _mm256_or_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
+#endif
+}
+
+// and_{{{1
+Vc_INTRINSIC __m256 and_(__m256 a, __m256 b) { return _mm256_and_ps(a, b); }
+Vc_INTRINSIC __m256d and_(__m256d a, __m256d b) { return _mm256_and_pd(a, b); }
+Vc_INTRINSIC __m256i and_(__m256i a, __m256i b) {
+#ifdef Vc_IMPL_AVX2
+    return _mm256_and_si256(a, b);
+#else
+    return _mm256_castps_si256(
+        _mm256_and_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
+#endif
+}
+
+// andnot_{{{1
+Vc_INTRINSIC __m256 andnot_(__m256 a, __m256 b) { return _mm256_andnot_ps(a, b); }
+Vc_INTRINSIC __m256d andnot_(__m256d a, __m256d b) { return _mm256_andnot_pd(a, b); }
+Vc_INTRINSIC __m256i andnot_(__m256i a, __m256i b)
+{
+#ifdef Vc_IMPL_AVX2
+    return _mm256_andnot_si256(a, b);
+#else
+    return _mm256_castps_si256(
+        _mm256_andnot_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
+#endif
+}
+
+// not_{{{1
+Vc_INTRINSIC __m256  not_(__m256  a) { return andnot_(a, allone<__m256 >()); }
+Vc_INTRINSIC __m256d not_(__m256d a) { return andnot_(a, allone<__m256d>()); }
+Vc_INTRINSIC __m256i not_(__m256i a) { return andnot_(a, allone<__m256i>()); }
+
+// blend{{{1
+Vc_INTRINSIC __m256  blend(__m256  a, __m256  b, __m256  c) { return _mm256_blendv_ps(a, b, c); }
+Vc_INTRINSIC __m256d blend(__m256d a, __m256d b, __m256d c) { return _mm256_blendv_pd(a, b, c); }
+Vc_INTRINSIC __m256i blend(__m256i a, __m256i b, __m256i c) { return AVX::blendv_epi8(a, b, c); }
+
+// abs{{{1
+Vc_INTRINSIC __m256  abs(__m256  a,  float) { return and_(a, AVX::setabsmask_ps()); }
+Vc_INTRINSIC __m256d abs(__m256d a, double) { return and_(a, AVX::setabsmask_pd()); }
+Vc_INTRINSIC __m256i abs(__m256i a,    int) { return AVX::abs_epi32(a); }
+Vc_INTRINSIC __m256i abs(__m256i a,   uint) { return a; }
+Vc_INTRINSIC __m256i abs(__m256i a,  short) { return AVX::abs_epi16(a); }
+Vc_INTRINSIC __m256i abs(__m256i a, ushort) { return a; }
+Vc_INTRINSIC __m256i abs(__m256i a,  schar) { return AVX::abs_epi8 (a); }
+Vc_INTRINSIC __m256i abs(__m256i a,  uchar) { return a; }
+
+// add{{{1
+Vc_INTRINSIC __m256  add(__m256  a, __m256  b,  float) { return _mm256_add_ps(a, b); }
+Vc_INTRINSIC __m256d add(__m256d a, __m256d b, double) { return _mm256_add_pd(a, b); }
+Vc_INTRINSIC __m256i add(__m256i a, __m256i b,    int) { return AVX::add_epi32(a, b); }
+Vc_INTRINSIC __m256i add(__m256i a, __m256i b,   uint) { return AVX::add_epi32(a, b); }
+Vc_INTRINSIC __m256i add(__m256i a, __m256i b,  short) { return AVX::add_epi16(a, b); }
+Vc_INTRINSIC __m256i add(__m256i a, __m256i b, ushort) { return AVX::add_epi16(a, b); }
+
+// sub{{{1
+Vc_INTRINSIC __m256  sub(__m256  a, __m256  b,  float) { return _mm256_sub_ps(a, b); }
+Vc_INTRINSIC __m256d sub(__m256d a, __m256d b, double) { return _mm256_sub_pd(a, b); }
+Vc_INTRINSIC __m256i sub(__m256i a, __m256i b,    int) { return AVX::sub_epi32(a, b); }
+Vc_INTRINSIC __m256i sub(__m256i a, __m256i b,   uint) { return AVX::sub_epi32(a, b); }
+Vc_INTRINSIC __m256i sub(__m256i a, __m256i b,  short) { return AVX::sub_epi16(a, b); }
+Vc_INTRINSIC __m256i sub(__m256i a, __m256i b, ushort) { return AVX::sub_epi16(a, b); }
+
+// mul{{{1
+Vc_INTRINSIC __m256  mul(__m256  a, __m256  b,  float) { return _mm256_mul_ps(a, b); }
+Vc_INTRINSIC __m256d mul(__m256d a, __m256d b, double) { return _mm256_mul_pd(a, b); }
+Vc_INTRINSIC __m256i mul(__m256i a, __m256i b,    int) { return AVX::mullo_epi32(a, b); }
+Vc_INTRINSIC __m256i mul(__m256i a, __m256i b,   uint) { return AVX::mullo_epi32(a, b); }
+Vc_INTRINSIC __m256i mul(__m256i a, __m256i b,  short) { return AVX::mullo_epi16(a, b); }
+Vc_INTRINSIC __m256i mul(__m256i a, __m256i b, ushort) { return AVX::mullo_epi16(a, b); }
+
+// mul{{{1
+Vc_INTRINSIC __m256  div(__m256  a, __m256  b,  float) { return _mm256_div_ps(a, b); }
+Vc_INTRINSIC __m256d div(__m256d a, __m256d b, double) { return _mm256_div_pd(a, b); }
+Vc_INTRINSIC __m256i div(__m256i a, __m256i b,    int) {
+    using namespace AVX;
+    const __m256d lo1 = _mm256_cvtepi32_pd(lo128(a));
+    const __m256d lo2 = _mm256_cvtepi32_pd(lo128(b));
+    const __m256d hi1 = _mm256_cvtepi32_pd(hi128(a));
+    const __m256d hi2 = _mm256_cvtepi32_pd(hi128(b));
+    return concat(_mm256_cvttpd_epi32(_mm256_div_pd(lo1, lo2)),
+                  _mm256_cvttpd_epi32(_mm256_div_pd(hi1, hi2)));
+}
+Vc_INTRINSIC __m256i div(__m256i a, __m256i b,   uint) {
+    // SSE/AVX only has signed int conversion to doubles. Therefore we first adjust the input before
+    // conversion and take the adjustment back after the conversion.
+    // It could be argued that for b this is not really important because division by a b >= 2^31 is
+    // useless. But for full correctness it cannot be ignored.
+    using namespace AVX;
+    const __m256i aa = add_epi32(a, set1_epi32(-2147483648));
+    const __m256i bb = add_epi32(b, set1_epi32(-2147483648));
+    const __m256d loa = _mm256_add_pd(_mm256_cvtepi32_pd(lo128(aa)), set1_pd(2147483648.));
+    const __m256d hia = _mm256_add_pd(_mm256_cvtepi32_pd(hi128(aa)), set1_pd(2147483648.));
+    const __m256d lob = _mm256_add_pd(_mm256_cvtepi32_pd(lo128(bb)), set1_pd(2147483648.));
+    const __m256d hib = _mm256_add_pd(_mm256_cvtepi32_pd(hi128(bb)), set1_pd(2147483648.));
+    // there is one remaining problem: a >= 2^31 and b == 1
+    // in that case the return value would be 2^31
+    return avx_cast<__m256i>(_mm256_blendv_ps(
+        avx_cast<__m256>(concat(_mm256_cvttpd_epi32(_mm256_div_pd(loa, lob)),
+                                          _mm256_cvttpd_epi32(_mm256_div_pd(hia, hib)))),
+        avx_cast<__m256>(a),
+        avx_cast<__m256>(cmpeq_epi32(b, setone_epi32()))));
+}
+Vc_INTRINSIC __m256i div(__m256i a, __m256i b,  short) {
+    using namespace AVX;
+    const __m256 lo =
+        _mm256_div_ps(convert<short, float>(lo128(a)), convert<short, float>(lo128(b)));
+    const __m256 hi =
+        _mm256_div_ps(convert<short, float>(hi128(a)), convert<short, float>(hi128(b)));
+    return concat(convert<float, short>(lo), convert<float, short>(hi));
+}
+
+// horizontal add{{{1
+template <typename T> Vc_INTRINSIC T add(Common::IntrinsicType<T, 32 / sizeof(T)> a, T)
+{
+    return {add(add(AVX::lo128(a), AVX::hi128(a), T()), T())};
+}
+
+// horizontal mul{{{1
+template <typename T> Vc_INTRINSIC T mul(Common::IntrinsicType<T, 32 / sizeof(T)> a, T)
+{
+    return {mul(mul(AVX::lo128(a), AVX::hi128(a), T()), T())};
+}
+
+// horizontal min{{{1
+template <typename T> Vc_INTRINSIC T min(Common::IntrinsicType<T, 32 / sizeof(T)> a, T)
+{
+    return {min(min(AVX::lo128(a), AVX::hi128(a), T()), T())};
+}
+
+// horizontal max{{{1
+template <typename T> Vc_INTRINSIC T max(Common::IntrinsicType<T, 32 / sizeof(T)> a, T)
+{
+    return {max(max(AVX::lo128(a), AVX::hi128(a), T()), T())};
+}
+// cmpeq{{{1
+Vc_INTRINSIC __m256  cmpeq(__m256  a, __m256  b,  float) { return AvxIntrinsics::cmpeq_ps(a, b); }
+Vc_INTRINSIC __m256d cmpeq(__m256d a, __m256d b, double) { return AvxIntrinsics::cmpeq_pd(a, b); }
+Vc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b,    int) { return AvxIntrinsics::cmpeq_epi32(a, b); }
+Vc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b,   uint) { return AvxIntrinsics::cmpeq_epi32(a, b); }
+Vc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b,  short) { return AvxIntrinsics::cmpeq_epi16(a, b); }
+Vc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b, ushort) { return AvxIntrinsics::cmpeq_epi16(a, b); }
+
+// cmpneq{{{1
+Vc_INTRINSIC __m256  cmpneq(__m256  a, __m256  b,  float) { return AvxIntrinsics::cmpneq_ps(a, b); }
+Vc_INTRINSIC __m256d cmpneq(__m256d a, __m256d b, double) { return AvxIntrinsics::cmpneq_pd(a, b); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b,    int) { return not_(AvxIntrinsics::cmpeq_epi32(a, b)); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b,   uint) { return not_(AvxIntrinsics::cmpeq_epi32(a, b)); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b,  short) { return not_(AvxIntrinsics::cmpeq_epi16(a, b)); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, ushort) { return not_(AvxIntrinsics::cmpeq_epi16(a, b)); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b,  schar) { return not_(AvxIntrinsics::cmpeq_epi8 (a, b)); }
+Vc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b,  uchar) { return not_(AvxIntrinsics::cmpeq_epi8 (a, b)); }
+
+// cmpgt{{{1
+Vc_INTRINSIC __m256  cmpgt(__m256  a, __m256  b,  float) { return AVX::cmpgt_ps(a, b); }
+Vc_INTRINSIC __m256d cmpgt(__m256d a, __m256d b, double) { return AVX::cmpgt_pd(a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b,    int) { return AVX::cmpgt_epi32(a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b,   uint) { return AVX::cmpgt_epu32(a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b,  short) { return AVX::cmpgt_epi16(a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, ushort) { return AVX::cmpgt_epu16(a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b,  schar) { return AVX::cmpgt_epi8 (a, b); }
+Vc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b,  uchar) { return AVX::cmpgt_epu8 (a, b); }
+
+// cmpge{{{1
+Vc_INTRINSIC __m256  cmpge(__m256  a, __m256  b,  float) { return AVX::cmpge_ps(a, b); }
+Vc_INTRINSIC __m256d cmpge(__m256d a, __m256d b, double) { return AVX::cmpge_pd(a, b); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b,    int) { return not_(AVX::cmpgt_epi32(b, a)); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b,   uint) { return not_(AVX::cmpgt_epu32(b, a)); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b,  short) { return not_(AVX::cmpgt_epi16(b, a)); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, ushort) { return not_(AVX::cmpgt_epu16(b, a)); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b,  schar) { return not_(AVX::cmpgt_epi8 (b, a)); }
+Vc_INTRINSIC __m256i cmpge(__m256i a, __m256i b,  uchar) { return not_(AVX::cmpgt_epu8 (b, a)); }
+
+// cmple{{{1
+Vc_INTRINSIC __m256  cmple(__m256  a, __m256  b,  float) { return AVX::cmple_ps(a, b); }
+Vc_INTRINSIC __m256d cmple(__m256d a, __m256d b, double) { return AVX::cmple_pd(a, b); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b,    int) { return not_(AVX::cmpgt_epi32(a, b)); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b,   uint) { return not_(AVX::cmpgt_epu32(a, b)); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b,  short) { return not_(AVX::cmpgt_epi16(a, b)); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b, ushort) { return not_(AVX::cmpgt_epu16(a, b)); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b,  schar) { return not_(AVX::cmpgt_epi8 (a, b)); }
+Vc_INTRINSIC __m256i cmple(__m256i a, __m256i b,  uchar) { return not_(AVX::cmpgt_epu8 (a, b)); }
+
+// cmplt{{{1
+Vc_INTRINSIC __m256  cmplt(__m256  a, __m256  b,  float) { return AVX::cmplt_ps(a, b); }
+Vc_INTRINSIC __m256d cmplt(__m256d a, __m256d b, double) { return AVX::cmplt_pd(a, b); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b,    int) { return AVX::cmpgt_epi32(b, a); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b,   uint) { return AVX::cmpgt_epu32(b, a); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b,  short) { return AVX::cmpgt_epi16(b, a); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, ushort) { return AVX::cmpgt_epu16(b, a); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b,  schar) { return AVX::cmpgt_epi8 (b, a); }
+Vc_INTRINSIC __m256i cmplt(__m256i a, __m256i b,  uchar) { return AVX::cmpgt_epu8 (b, a); }
+
+// fma{{{1
+Vc_INTRINSIC __m256 fma(__m256  a, __m256  b, __m256  c,  float) {
+#ifdef Vc_IMPL_FMA4
+    return _mm256_macc_ps(a, b, c);
+#elif defined Vc_IMPL_FMA
+    return _mm256_fmadd_ps(a, b, c);
+#else
+    using namespace AVX;
+    __m256d v1_0 = _mm256_cvtps_pd(lo128(a));
+    __m256d v1_1 = _mm256_cvtps_pd(hi128(a));
+    __m256d v2_0 = _mm256_cvtps_pd(lo128(b));
+    __m256d v2_1 = _mm256_cvtps_pd(hi128(b));
+    __m256d v3_0 = _mm256_cvtps_pd(lo128(c));
+    __m256d v3_1 = _mm256_cvtps_pd(hi128(c));
+    return concat(_mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_0, v2_0), v3_0)),
+                  _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_1, v2_1), v3_1)));
+#endif
+}
+Vc_INTRINSIC __m256d fma(__m256d a, __m256d b, __m256d c, double)
+{
+#ifdef Vc_IMPL_FMA4
+    return _mm256_macc_pd(a, b, c);
+#elif defined Vc_IMPL_FMA
+    return _mm256_fmadd_pd(a, b, c);
+#else
+    using namespace AVX;
+    __m256d h1 = and_(a, _mm256_broadcast_sd(reinterpret_cast<const double *>(
+                             &c_general::highMaskDouble)));
+    __m256d h2 = and_(b, _mm256_broadcast_sd(reinterpret_cast<const double *>(
+                             &c_general::highMaskDouble)));
+    const __m256d l1 = _mm256_sub_pd(a, h1);
+    const __m256d l2 = _mm256_sub_pd(b, h2);
+    const __m256d ll = mul(l1, l2, double());
+    const __m256d lh = add(mul(l1, h2, double()), mul(h1, l2, double()), double());
+    const __m256d hh = mul(h1, h2, double());
+    // ll < lh < hh for all entries is certain
+    const __m256d lh_lt_v3 = cmplt(abs(lh, double()), abs(c, double()), double());  // |lh| < |c|
+    const __m256d x = _mm256_blendv_pd(c, lh, lh_lt_v3);
+    const __m256d y = _mm256_blendv_pd(lh, c, lh_lt_v3);
+    return add(add(ll, x, double()), add(y, hh, double()), double());
+#endif
+}
+template <typename T> Vc_INTRINSIC __m256i fma(__m256i a, __m256i b, __m256i c, T)
+{
+    return add(mul(a, b, T()), c, T());
+}
+
+// shiftRight{{{1
+template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a,    int) { return AVX::srai_epi32<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a,   uint) { return AVX::srli_epi32<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a,  short) { return AVX::srai_epi16<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a, ushort) { return AVX::srli_epi16<shift>(a); }
+//template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a,  schar) { return AVX::srai_epi8 <shift>(a); }
+//template <int shift> Vc_INTRINSIC __m256i shiftRight(__m256i a,  uchar) { return AVX::srli_epi8 <shift>(a); }
+
+Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift,    int) { return AVX::sra_epi32(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift,   uint) { return AVX::srl_epi32(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift,  short) { return AVX::sra_epi16(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift, ushort) { return AVX::srl_epi16(a, _mm_cvtsi32_si128(shift)); }
+//Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift,  schar) { return AVX::sra_epi8 (a, _mm_cvtsi32_si128(shift)); }
+//Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift,  uchar) { return AVX::srl_epi8 (a, _mm_cvtsi32_si128(shift)); }
+
+// shiftLeft{{{1
+template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a,    int) { return AVX::slli_epi32<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a,   uint) { return AVX::slli_epi32<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a,  short) { return AVX::slli_epi16<shift>(a); }
+template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a, ushort) { return AVX::slli_epi16<shift>(a); }
+//template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a,  schar) { return AVX::slli_epi8 <shift>(a); }
+//template <int shift> Vc_INTRINSIC __m256i shiftLeft(__m256i a,  uchar) { return AVX::slli_epi8 <shift>(a); }
+
+Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift,    int) { return AVX::sll_epi32(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift,   uint) { return AVX::sll_epi32(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift,  short) { return AVX::sll_epi16(a, _mm_cvtsi32_si128(shift)); }
+Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, ushort) { return AVX::sll_epi16(a, _mm_cvtsi32_si128(shift)); }
+//Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift,  schar) { return AVX::sll_epi8 (a, _mm_cvtsi32_si128(shift)); }
+//Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift,  uchar) { return AVX::sll_epi8 (a, _mm_cvtsi32_si128(shift)); }
+
+// zeroExtendIfNeeded{{{1
+Vc_INTRINSIC __m256  zeroExtendIfNeeded(__m256  x) { return x; }
+Vc_INTRINSIC __m256d zeroExtendIfNeeded(__m256d x) { return x; }
+Vc_INTRINSIC __m256i zeroExtendIfNeeded(__m256i x) { return x; }
+Vc_INTRINSIC __m256  zeroExtendIfNeeded(__m128  x) { return AVX::zeroExtend(x); }
+Vc_INTRINSIC __m256d zeroExtendIfNeeded(__m128d x) { return AVX::zeroExtend(x); }
+Vc_INTRINSIC __m256i zeroExtendIfNeeded(__m128i x) { return AVX::zeroExtend(x); }
+
+// broadcast{{{1
+Vc_INTRINSIC __m256  avx_broadcast( float x) { return _mm256_set1_ps(x); }
+Vc_INTRINSIC __m256d avx_broadcast(double x) { return _mm256_set1_pd(x); }
+Vc_INTRINSIC __m256i avx_broadcast(   int x) { return _mm256_set1_epi32(x); }
+Vc_INTRINSIC __m256i avx_broadcast(  uint x) { return _mm256_set1_epi32(x); }
+Vc_INTRINSIC __m256i avx_broadcast( short x) { return _mm256_set1_epi16(x); }
+Vc_INTRINSIC __m256i avx_broadcast(ushort x) { return _mm256_set1_epi16(x); }
+Vc_INTRINSIC __m256i avx_broadcast(  char x) { return _mm256_set1_epi8(x); }
+Vc_INTRINSIC __m256i avx_broadcast( schar x) { return _mm256_set1_epi8(x); }
+Vc_INTRINSIC __m256i avx_broadcast( uchar x) { return _mm256_set1_epi8(x); }
+
+// sorted{{{1
+template <Vc::Implementation Impl, typename T,
+          typename = enable_if<(Impl >= AVXImpl && Impl <= AVX2Impl)>>
+Vc_CONST_L AVX2::Vector<T> sorted(AVX2::Vector<T> x) Vc_CONST_R;
+template <typename T> Vc_INTRINSIC Vc_CONST AVX2::Vector<T> sorted(AVX2::Vector<T> x)
+{
+    return sorted<CurrentImplementation::current()>(x);
+}
+
+// shifted{{{1
+template <typename T, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32), V> shifted(V v, int amount)
+{
+    using namespace AVX;
+    constexpr int S = sizeof(T);
+    switch (amount) {
+    case  0: return v;
+    case  1: return shifted<sanitize<V>( 1 * S)>(v);
+    case  2: return shifted<sanitize<V>( 2 * S)>(v);
+    case  3: return shifted<sanitize<V>( 3 * S)>(v);
+    case -1: return shifted<sanitize<V>(-1 * S)>(v);
+    case -2: return shifted<sanitize<V>(-2 * S)>(v);
+    case -3: return shifted<sanitize<V>(-3 * S)>(v);
+    }
+    if (sizeof(T) <= 4) {
+        switch (amount) {
+        case  4: return shifted<sanitize<V>( 4 * S)>(v);
+        case  5: return shifted<sanitize<V>( 5 * S)>(v);
+        case  6: return shifted<sanitize<V>( 6 * S)>(v);
+        case  7: return shifted<sanitize<V>( 7 * S)>(v);
+        case -4: return shifted<sanitize<V>(-4 * S)>(v);
+        case -5: return shifted<sanitize<V>(-5 * S)>(v);
+        case -6: return shifted<sanitize<V>(-6 * S)>(v);
+        case -7: return shifted<sanitize<V>(-7 * S)>(v);
+        }
+        if (sizeof(T) <= 2) {
+            switch (amount) {
+            case   8: return shifted<sanitize<V>(  8 * S)>(v);
+            case   9: return shifted<sanitize<V>(  9 * S)>(v);
+            case  10: return shifted<sanitize<V>( 10 * S)>(v);
+            case  11: return shifted<sanitize<V>( 11 * S)>(v);
+            case  12: return shifted<sanitize<V>( 12 * S)>(v);
+            case  13: return shifted<sanitize<V>( 13 * S)>(v);
+            case  14: return shifted<sanitize<V>( 14 * S)>(v);
+            case  15: return shifted<sanitize<V>( 15 * S)>(v);
+            case  -8: return shifted<sanitize<V>(- 8 * S)>(v);
+            case  -9: return shifted<sanitize<V>(- 9 * S)>(v);
+            case -10: return shifted<sanitize<V>(-10 * S)>(v);
+            case -11: return shifted<sanitize<V>(-11 * S)>(v);
+            case -12: return shifted<sanitize<V>(-12 * S)>(v);
+            case -13: return shifted<sanitize<V>(-13 * S)>(v);
+            case -14: return shifted<sanitize<V>(-14 * S)>(v);
+            case -15: return shifted<sanitize<V>(-15 * S)>(v);
+            }
+            if (sizeof(T) == 1) {
+                switch (amount) {
+                case  16: return shifted<sanitize<V>( 16)>(v);
+                case  17: return shifted<sanitize<V>( 17)>(v);
+                case  18: return shifted<sanitize<V>( 18)>(v);
+                case  19: return shifted<sanitize<V>( 19)>(v);
+                case  20: return shifted<sanitize<V>( 20)>(v);
+                case  21: return shifted<sanitize<V>( 21)>(v);
+                case  22: return shifted<sanitize<V>( 22)>(v);
+                case  23: return shifted<sanitize<V>( 23)>(v);
+                case  24: return shifted<sanitize<V>( 24)>(v);
+                case  25: return shifted<sanitize<V>( 25)>(v);
+                case  26: return shifted<sanitize<V>( 26)>(v);
+                case  27: return shifted<sanitize<V>( 27)>(v);
+                case  28: return shifted<sanitize<V>( 28)>(v);
+                case  29: return shifted<sanitize<V>( 29)>(v);
+                case  30: return shifted<sanitize<V>( 30)>(v);
+                case  31: return shifted<sanitize<V>( 31)>(v);
+                case -16: return shifted<sanitize<V>(-16)>(v);
+                case -17: return shifted<sanitize<V>(-17)>(v);
+                case -18: return shifted<sanitize<V>(-18)>(v);
+                case -19: return shifted<sanitize<V>(-19)>(v);
+                case -20: return shifted<sanitize<V>(-20)>(v);
+                case -21: return shifted<sanitize<V>(-21)>(v);
+                case -22: return shifted<sanitize<V>(-22)>(v);
+                case -23: return shifted<sanitize<V>(-23)>(v);
+                case -24: return shifted<sanitize<V>(-24)>(v);
+                case -25: return shifted<sanitize<V>(-25)>(v);
+                case -26: return shifted<sanitize<V>(-26)>(v);
+                case -27: return shifted<sanitize<V>(-27)>(v);
+                case -28: return shifted<sanitize<V>(-28)>(v);
+                case -29: return shifted<sanitize<V>(-29)>(v);
+                case -30: return shifted<sanitize<V>(-30)>(v);
+                case -31: return shifted<sanitize<V>(-31)>(v);
+                }
+            }
+        }
+    }
+    return avx_cast<V>(_mm256_setzero_ps());
+}
+
+template <typename T, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 16), V> shifted(V v, int amount)
+{
+    using namespace AVX;
+    switch (amount) {
+    case  0: return v;
+    case  1: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(1 * sizeof(T))));
+    case  2: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(2 * sizeof(T))));
+    case  3: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(3 * sizeof(T))));
+    case -1: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(1 * sizeof(T))));
+    case -2: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(2 * sizeof(T))));
+    case -3: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(3 * sizeof(T))));
+    }
+    if (sizeof(T) <= 2) {
+        switch (amount) {
+        case  4: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(4 * sizeof(T))));
+        case  5: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(5 * sizeof(T))));
+        case  6: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(6 * sizeof(T))));
+        case  7: return avx_cast<V>(_mm_srli_si128(avx_cast<__m128i>(v), sanitize<V>(7 * sizeof(T))));
+        case -4: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(4 * sizeof(T))));
+        case -5: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(5 * sizeof(T))));
+        case -6: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(6 * sizeof(T))));
+        case -7: return avx_cast<V>(_mm_slli_si128(avx_cast<__m128i>(v), sanitize<V>(7 * sizeof(T))));
+        }
+    }
+    return avx_cast<V>(_mm_setzero_ps());
+}
+// rotated{{{1
+template <typename T, size_t N, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 4), V> rotated(V v,
+                                                                               int amount)
+{
+    using namespace AVX;
+    const __m128i vLo = avx_cast<__m128i>(lo128(v));
+    const __m128i vHi = avx_cast<__m128i>(hi128(v));
+    switch (static_cast<unsigned int>(amount) % N) {
+    case 0:
+        return v;
+    case 1:
+        return avx_cast<V>(concat(SSE::alignr_epi8<sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<sizeof(T)>(vLo, vHi)));
+    case 2:
+        return Mem::permute128<X1, X0>(v);
+    case 3:
+        return avx_cast<V>(concat(SSE::alignr_epi8<sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<sizeof(T)>(vHi, vLo)));
+    }
+    return avx_cast<V>(_mm256_setzero_ps());
+}
+
+template <typename T, size_t N, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 8), V> rotated(V v,
+                                                                               int amount)
+{
+    using namespace AVX;
+    const __m128i vLo = avx_cast<__m128i>(lo128(v));
+    const __m128i vHi = avx_cast<__m128i>(hi128(v));
+    switch (static_cast<unsigned int>(amount) % N) {
+    case 0:
+        return v;
+    case 1:
+        return avx_cast<V>(concat(SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi)));
+    case 2:
+        return avx_cast<V>(concat(SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi)));
+    case 3:
+        return avx_cast<V>(concat(SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi)));
+    case 4:
+        return Mem::permute128<X1, X0>(v);
+    case 5:
+        return avx_cast<V>(concat(SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo)));
+    case 6:
+        return avx_cast<V>(concat(SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo)));
+    case 7:
+        return avx_cast<V>(concat(SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo)));
+    }
+    return avx_cast<V>(_mm256_setzero_ps());
+}
+
+#ifdef Vc_IMPL_AVX2
+template <typename T, size_t N, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 16), V> rotated(
+    V v, int amount)
+{
+    using namespace AVX;
+    const __m128i vLo = avx_cast<__m128i>(lo128(v));
+    const __m128i vHi = avx_cast<__m128i>(hi128(v));
+    switch (static_cast<unsigned int>(amount) % N) {
+    case 0:
+        return v;
+    case 1:
+        return avx_cast<V>(concat(SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi)));
+    case 2:
+        return avx_cast<V>(concat(SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi)));
+    case 3:
+        return avx_cast<V>(concat(SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi)));
+    case 4:
+        return Mem::permute4x64<X1, X2, X3, X0>(v);
+    case 5:
+        return avx_cast<V>(concat(SSE::alignr_epi8<5 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<5 * sizeof(T)>(vLo, vHi)));
+    case 6:
+        return avx_cast<V>(concat(SSE::alignr_epi8<6 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<6 * sizeof(T)>(vLo, vHi)));
+    case 7:
+        return avx_cast<V>(concat(SSE::alignr_epi8<7 * sizeof(T)>(vHi, vLo),
+                                  SSE::alignr_epi8<7 * sizeof(T)>(vLo, vHi)));
+    case 8:
+        return Mem::permute128<X1, X0>(v);
+    case 9:
+        return avx_cast<V>(concat(SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo)));
+    case 10:
+        return avx_cast<V>(concat(SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo)));
+    case 11:
+        return avx_cast<V>(concat(SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo)));
+    case 12:
+        return Mem::permute4x64<X3, X0, X1, X2>(v);
+    case 13:
+        return avx_cast<V>(concat(SSE::alignr_epi8<5 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<5 * sizeof(T)>(vHi, vLo)));
+    case 14:
+        return avx_cast<V>(concat(SSE::alignr_epi8<6 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<6 * sizeof(T)>(vHi, vLo)));
+    case 15:
+        return avx_cast<V>(concat(SSE::alignr_epi8<7 * sizeof(T)>(vLo, vHi),
+                                  SSE::alignr_epi8<7 * sizeof(T)>(vHi, vLo)));
+    }
+    return avx_cast<V>(_mm256_setzero_ps());
+}
+#endif  // Vc_IMPL_AVX2
+
+// testc{{{1
+Vc_INTRINSIC Vc_CONST int testc(__m128  a, __m128  b) { return _mm_testc_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }
+Vc_INTRINSIC Vc_CONST int testc(__m256  a, __m256  b) { return _mm256_testc_ps(a, b); }
+Vc_INTRINSIC Vc_CONST int testc(__m256d a, __m256d b) { return _mm256_testc_pd(a, b); }
+Vc_INTRINSIC Vc_CONST int testc(__m256i a, __m256i b) { return _mm256_testc_si256(a, b); }
+
+// testz{{{1
+Vc_INTRINSIC Vc_CONST int testz(__m128  a, __m128  b) { return _mm_testz_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }
+Vc_INTRINSIC Vc_CONST int testz(__m256  a, __m256  b) { return _mm256_testz_ps(a, b); }
+Vc_INTRINSIC Vc_CONST int testz(__m256d a, __m256d b) { return _mm256_testz_pd(a, b); }
+Vc_INTRINSIC Vc_CONST int testz(__m256i a, __m256i b) { return _mm256_testz_si256(a, b); }
+
+// testnzc{{{1
+Vc_INTRINSIC Vc_CONST int testnzc(__m128 a, __m128 b) { return _mm_testnzc_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }
+Vc_INTRINSIC Vc_CONST int testnzc(__m256  a, __m256  b) { return _mm256_testnzc_ps(a, b); }
+Vc_INTRINSIC Vc_CONST int testnzc(__m256d a, __m256d b) { return _mm256_testnzc_pd(a, b); }
+Vc_INTRINSIC Vc_CONST int testnzc(__m256i a, __m256i b) { return _mm256_testnzc_si256(a, b); }
+
+// movemask{{{1
+Vc_INTRINSIC Vc_CONST int movemask(__m256i a) { return AVX::movemask_epi8(a); }
+Vc_INTRINSIC Vc_CONST int movemask(__m128i a) { return _mm_movemask_epi8(a); }
+Vc_INTRINSIC Vc_CONST int movemask(__m256d a) { return _mm256_movemask_pd(a); }
+Vc_INTRINSIC Vc_CONST int movemask(__m128d a) { return _mm_movemask_pd(a); }
+Vc_INTRINSIC Vc_CONST int movemask(__m256  a) { return _mm256_movemask_ps(a); }
+Vc_INTRINSIC Vc_CONST int movemask(__m128  a) { return _mm_movemask_ps(a); }
+
+// mask_store{{{1
+template <size_t N, typename Flags>
+Vc_INTRINSIC void mask_store(__m256i k, bool *mem, Flags)
+{
+    static_assert(
+        N == 4 || N == 8 || N == 16,
+        "mask_store(__m256i, bool *) is only implemented for 4, 8, and 16 entries");
+    switch (N) {
+    case 4:
+        *reinterpret_cast<MayAlias<int32_t> *>(mem) =
+            (_mm_movemask_epi8(AVX::lo128(k)) |
+             (_mm_movemask_epi8(AVX::hi128(k)) << 16)) &
+            0x01010101;
+        break;
+    case 8: {
+        const auto k2 = _mm_srli_epi16(_mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)), 15);
+        const auto k3 = _mm_packs_epi16(k2, _mm_setzero_si128());
+#ifdef __x86_64__
+        *reinterpret_cast<MayAlias<int64_t> *>(mem) = _mm_cvtsi128_si64(k3);
+#else
+        *reinterpret_cast<MayAlias<int32_t> *>(mem) = _mm_cvtsi128_si32(k3);
+        *reinterpret_cast<MayAlias<int32_t> *>(mem + 4) = _mm_extract_epi32(k3, 1);
+#endif
+    } break;
+    case 16: {
+        const auto bools = Detail::and_(AVX::_mm_setone_epu8(),
+                                        _mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)));
+        if (Flags::IsAligned) {
+            _mm_store_si128(reinterpret_cast<__m128i *>(mem), bools);
+        } else {
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(mem), bools);
+        }
+    } break;
+    default:
+        Vc_UNREACHABLE();
+    }
+}
+
+// mask_load{{{1
+template <typename R, size_t N, typename Flags>
+Vc_INTRINSIC R mask_load(const bool *mem, Flags,
+                         enable_if<std::is_same<R, __m128>::value> = nullarg)
+{
+    static_assert(N == 4 || N == 8,
+                  "mask_load<__m128>(const bool *) is only implemented for 4, 8 entries");
+    switch (N) {
+    case 4: {
+        __m128i k = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int32_t> *>(mem));
+        k = _mm_unpacklo_epi8(k, k);
+        k = _mm_unpacklo_epi16(k, k);
+        k = _mm_cmpgt_epi32(k, _mm_setzero_si128());
+        return AVX::avx_cast<__m128>(k);
+    }
+    case 8: {
+#ifdef __x86_64__
+        __m128i k = _mm_cvtsi64_si128(*reinterpret_cast<const MayAlias<int64_t> *>(mem));
+#else
+        __m128i k = _mm_castpd_si128(
+            _mm_load_sd(reinterpret_cast<const MayAlias<double> *>(mem)));
+#endif
+        return AVX::avx_cast<__m128>(
+            _mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128()));
+    }
+    default:
+        Vc_UNREACHABLE();
+    }
+}
+
+template <typename R, size_t N, typename Flags>
+Vc_INTRINSIC R mask_load(const bool *mem, Flags,
+                         enable_if<std::is_same<R, __m256>::value> = nullarg)
+{
+    static_assert(
+        N == 4 || N == 8 || N == 16,
+        "mask_load<__m256>(const bool *) is only implemented for 4, 8, and 16 entries");
+    switch (N) {
+    case 4: {
+        __m128i k = AVX::avx_cast<__m128i>(_mm_and_ps(
+            _mm_set1_ps(*reinterpret_cast<const MayAlias<float> *>(mem)),
+            AVX::avx_cast<__m128>(_mm_setr_epi32(0x1, 0x100, 0x10000, 0x1000000))));
+        k = _mm_cmpgt_epi32(k, _mm_setzero_si128());
+        return AVX::avx_cast<__m256>(
+            AVX::concat(_mm_unpacklo_epi32(k, k), _mm_unpackhi_epi32(k, k)));
+    }
+    case 8: {
+#ifdef __x86_64__
+        __m128i k = _mm_cvtsi64_si128(*reinterpret_cast<const MayAlias<int64_t> *>(mem));
+#else
+        __m128i k = _mm_castpd_si128(
+            _mm_load_sd(reinterpret_cast<const MayAlias<double> *>(mem)));
+#endif
+        k = _mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128());
+        return AVX::avx_cast<__m256>(
+            AVX::concat(_mm_unpacklo_epi16(k, k), _mm_unpackhi_epi16(k, k)));
+    }
+    case 16: {
+        const auto k128 = _mm_cmpgt_epi8(
+            Flags::IsAligned ? _mm_load_si128(reinterpret_cast<const __m128i *>(mem))
+                             : _mm_loadu_si128(reinterpret_cast<const __m128i *>(mem)),
+            _mm_setzero_si128());
+        return AVX::avx_cast<__m256>(
+            AVX::concat(_mm_unpacklo_epi8(k128, k128), _mm_unpackhi_epi8(k128, k128)));
+    }
+    default:
+        Vc_UNREACHABLE();
+    }
+}
+
+// mask_to_int{{{1
+template <size_t Size>
+Vc_INTRINSIC_L Vc_CONST_L int mask_to_int(__m256i x) Vc_INTRINSIC_R Vc_CONST_R;
+template <> Vc_INTRINSIC Vc_CONST int mask_to_int<4>(__m256i k)
+{
+    return movemask(AVX::avx_cast<__m256d>(k));
+}
+template <> Vc_INTRINSIC Vc_CONST int mask_to_int<8>(__m256i k)
+{
+    return movemask(AVX::avx_cast<__m256>(k));
+}
+#ifdef Vc_IMPL_BMI2
+template <> Vc_INTRINSIC Vc_CONST int mask_to_int<16>(__m256i k)
+{
+    return _pext_u32(movemask(k), 0x55555555u);
+}
+#endif
+template <> Vc_INTRINSIC Vc_CONST int mask_to_int<32>(__m256i k)
+{
+    return movemask(k);
+}
+
+//InterleaveImpl{{{1
+template<typename V> struct InterleaveImpl<V, 16, 32> {
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, // a0 a1 a2 a3 a4 a5 a6 a7 | a8 a9 ...
+            const typename V::AsArg v1) // b0 b1 b2 b3 b4 b5 b6 b7 | b8 b9 ...
+    {
+        const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v1.data()); // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 ...
+        const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v1.data()); // a4 b4 a5 ...
+        using namespace AVX;
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 0]]) = _mm_cvtsi128_si32(lo128(tmp0));
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 1]]) = _mm_extract_epi32(lo128(tmp0), 1);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 2]]) = _mm_extract_epi32(lo128(tmp0), 2);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 3]]) = _mm_extract_epi32(lo128(tmp0), 3);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 4]]) = _mm_cvtsi128_si32(lo128(tmp1));
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 5]]) = _mm_extract_epi32(lo128(tmp1), 1);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 6]]) = _mm_extract_epi32(lo128(tmp1), 2);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 7]]) = _mm_extract_epi32(lo128(tmp1), 3);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 8]]) = _mm_cvtsi128_si32(hi128(tmp0));
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[ 9]]) = _mm_extract_epi32(hi128(tmp0), 1);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[10]]) = _mm_extract_epi32(hi128(tmp0), 2);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[11]]) = _mm_extract_epi32(hi128(tmp0), 3);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[12]]) = _mm_cvtsi128_si32(hi128(tmp1));
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[13]]) = _mm_extract_epi32(hi128(tmp1), 1);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[14]]) = _mm_extract_epi32(hi128(tmp1), 2);
+        *reinterpret_cast<MayAlias<uint32_t> *>(&data[i[15]]) = _mm_extract_epi32(hi128(tmp1), 3);
+    }/*}}}*/
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v1.data()); // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 ...
+        const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v1.data()); // a4 b4 a5 ...
+        V(Mem::shuffle128<X0, Y0>(tmp0, tmp1)).store(&data[i[0]], Vc::Unaligned);
+        V(Mem::shuffle128<X1, Y1>(tmp0, tmp1)).store(&data[i[8]], Vc::Unaligned);
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
+    {
+        interleave(data, i, v0, v1);
+        v2.scatter(data + 2, i);
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1,
+            const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v2.data()); // a0 c0 a1 c1 a2 c2 a3 c3 | a8 c8 a9 c9 ...
+        const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v2.data()); // a4 c4 a5 c5 a6 c6 a7 c7 | a12 c12 ...
+        const __m256i tmp2 = AVX::unpacklo_epi16(v1.data(), v3.data()); // b0 d0 b1 d1 b2 d2 b3 d3 | b8 d8 b9 d9 ...
+        const __m256i tmp3 = AVX::unpackhi_epi16(v1.data(), v3.data()); // b4 d4 b5 ...
+
+        const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 b0 c0 d0 a1 b1 c1 d1 | a8 b8 c8 d8 a9 b9 ...
+        const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // [abcd]2 [abcd]3 | [abcd]10 [abcd]11
+        const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // [abcd]4 [abcd]5 | [abcd]12 [abcd]13
+        const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // [abcd]6 [abcd]7 | [abcd]14 [abcd]15
+
+        using namespace AVX;
+        auto &&store = [&](__m256i x, int offset) {
+            _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[offset + 0]]), lo128(x));
+            _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[offset + 8]]), hi128(x));
+            _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[offset + 1]]), avx_cast<__m128>(x));
+            _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[offset + 9]]), avx_cast<__m128>(hi128(x)));
+        };
+        store(tmp4, 0);
+        store(tmp5, 2);
+        store(tmp6, 4);
+        store(tmp7, 6);
+    }/*}}}*/
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<4> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1,
+            const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v2.data()); // a0 c0 a1 c1 a2 c2 a3 c3 | a8 c8 a9 c9 ...
+        const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v2.data()); // a4 c4 a5 c5 a6 c6 a7 c7 | a12 c12 ...
+        const __m256i tmp2 = AVX::unpacklo_epi16(v1.data(), v3.data()); // b0 d0 b1 d1 b2 d2 b3 d3 | b8 d8 b9 d9 ...
+        const __m256i tmp3 = AVX::unpackhi_epi16(v1.data(), v3.data()); // b4 d4 b5 ...
+
+        const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 b0 c0 d0 a1 b1 c1 d1 | a8 b8 c8 d8 a9 b9 ...
+        const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // [abcd]2 [abcd]3 | [abcd]10 [abcd]11
+        const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // [abcd]4 [abcd]5 | [abcd]12 [abcd]13
+        const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // [abcd]6 [abcd]7 | [abcd]14 [abcd]15
+
+        V(Mem::shuffle128<X0, Y0>(tmp4, tmp5)).store(&data[i[0]], ::Vc::Unaligned);
+        V(Mem::shuffle128<X0, Y0>(tmp6, tmp7)).store(&data[i[4]], ::Vc::Unaligned);
+        V(Mem::shuffle128<X1, Y1>(tmp4, tmp5)).store(&data[i[8]], ::Vc::Unaligned);
+        V(Mem::shuffle128<X1, Y1>(tmp6, tmp7)).store(&data[i[12]], ::Vc::Unaligned);
+    }/*}}}*/
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        const __m256i tmp4 =  // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 b9 a10 b10 a11 b11
+            _mm256_setr_epi32(*reinterpret_cast<const MayAlias<int> *>(&data[i[0]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[1]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[2]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[3]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[8]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[9]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[10]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[11]]));
+        const __m256i tmp5 = // a4 b4 a5 b5 a6 b6 a7 b7 | a12 b12 a13 b13 a14 b14 a15 b15
+            _mm256_setr_epi32(*reinterpret_cast<const MayAlias<int> *>(&data[i[4]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[5]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[6]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[7]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[12]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[13]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[14]]),
+                              *reinterpret_cast<const MayAlias<int> *>(&data[i[15]]));
+
+        const __m256i tmp2 = AVX::unpacklo_epi16(tmp4, tmp5);  // a0 a4 b0 b4 a1 a5 b1 b5 | a8 a12 b8 b12 a9 a13 b9 b13
+        const __m256i tmp3 = AVX::unpackhi_epi16(tmp4, tmp5);  // a2 a6 b2 b6 a3 a7 b3 b7 | a10 a14 b10 b14 a11 a15 b11 b15
+
+        const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3);  // a0 a2 a4 a6 b0 b2 b4 b6 | a8 a10 a12 a14 b8 ...
+        const __m256i tmp1 = AVX::unpackhi_epi16(tmp2, tmp3);  // a1 a3 a5 a7 b1 b3 b5 b7 | a9 a11 a13 a15 b9 ...
+
+        v0.data() = AVX::unpacklo_epi16(tmp0, tmp1); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 a9 ...
+        v1.data() = AVX::unpackhi_epi16(tmp0, tmp1); // b0 b1 b2 b3 b4 b5 b6 b7 | b8 b9 ...
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        using namespace AVX;
+        const __m256i tmp0 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[0]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[1]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[8]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[9]])));
+        const __m256i tmp1 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[2]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[3]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[10]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[11]])));
+        const __m256i tmp2 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[4]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[5]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[12]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[13]])));
+        const __m256i tmp3 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[6]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[7]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[14]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[15]])));
+        const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 a4 b0 b4 c0 c4 XX XX | a8 a12 b8 ...
+        const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // a1 a5 ...
+        const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // a2 a6 ...
+        const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // a3 a7 ...
+
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp4, tmp6); // a0 a2 a4 a6 b0 ...
+        const __m256i tmp9  = AVX::unpackhi_epi16(tmp4, tmp6); // c0 c2 c4 c6 XX ...
+        const __m256i tmp10 = AVX::unpacklo_epi16(tmp5, tmp7); // a1 a3 a5 a7 b1 ...
+        const __m256i tmp11 = AVX::unpackhi_epi16(tmp5, tmp7); // c1 c3 c5 c7 XX ...
+
+        v0.data() = AVX::unpacklo_epi16(tmp8, tmp10); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 ...
+        v1.data() = AVX::unpackhi_epi16(tmp8, tmp10);
+        v2.data() = AVX::unpacklo_epi16(tmp9, tmp11);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        using namespace AVX;
+        const __m256i tmp0 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[0]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[1]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[8]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[9]])));
+        const __m256i tmp1 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[2]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[3]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[10]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[11]])));
+        const __m256i tmp2 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[4]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[5]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[12]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[13]])));
+        const __m256i tmp3 = avx_cast<__m256i>(_mm256_setr_pd(*reinterpret_cast<const MayAlias<double> *>(&data[i[6]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[7]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[14]]),
+                                                              *reinterpret_cast<const MayAlias<double> *>(&data[i[15]])));
+        const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 a12 b8 ...
+        const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // a1 a5 ...
+        const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // a2 a6 ...
+        const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // a3 a7 ...
+
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp4, tmp6); // a0 a2 a4 a6 b0 ...
+        const __m256i tmp9  = AVX::unpackhi_epi16(tmp4, tmp6); // c0 c2 c4 c6 d0 ...
+        const __m256i tmp10 = AVX::unpacklo_epi16(tmp5, tmp7); // a1 a3 a5 a7 b1 ...
+        const __m256i tmp11 = AVX::unpackhi_epi16(tmp5, tmp7); // c1 c3 c5 c7 d1 ...
+
+        v0.data() = AVX::unpacklo_epi16(tmp8, tmp10); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 ...
+        v1.data() = AVX::unpackhi_epi16(tmp8, tmp10);
+        v2.data() = AVX::unpacklo_epi16(tmp9, tmp11);
+        v3.data() = AVX::unpackhi_epi16(tmp9, tmp11);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        using namespace AVX;
+        const __m256i a = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[8]])));
+        const __m256i b = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[9]])));
+        const __m256i c = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[10]])));
+        const __m256i d = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[11]])));
+        const __m256i e = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[12]])));
+        const __m256i f = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[13]])));
+        const __m256i g = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[14]])));
+        const __m256i h = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[15]])));
+
+        const __m256i tmp2  = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...
+        const __m256i tmp4  = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m256i tmp3  = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m256i tmp5  = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m256i tmp0  = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...
+        const __m256i tmp1  = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m256i tmp6  = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m256i tmp7  = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m256i tmp9  = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+
+        v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);
+        v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);
+        v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);
+        v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);
+        v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        using namespace AVX;
+        const __m256i a = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[8]])));
+        const __m256i b = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[9]])));
+        const __m256i c = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[10]])));
+        const __m256i d = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[11]])));
+        const __m256i e = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[12]])));
+        const __m256i f = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[13]])));
+        const __m256i g = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[14]])));
+        const __m256i h = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[15]])));
+
+        const __m256i tmp2  = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...
+        const __m256i tmp4  = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m256i tmp3  = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m256i tmp5  = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m256i tmp0  = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...
+        const __m256i tmp1  = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m256i tmp6  = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m256i tmp7  = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m256i tmp9  = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+
+        v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);
+        v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);
+        v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);
+        v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);
+        v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);
+        v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        using namespace AVX;
+        const __m256i a = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[8]])));
+        const __m256i b = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[9]])));
+        const __m256i c = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[10]])));
+        const __m256i d = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[11]])));
+        const __m256i e = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[12]])));
+        const __m256i f = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[13]])));
+        const __m256i g = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[14]])));
+        const __m256i h = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[15]])));
+
+        const __m256i tmp2  = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...
+        const __m256i tmp4  = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m256i tmp3  = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m256i tmp5  = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m256i tmp0  = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...
+        const __m256i tmp1  = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m256i tmp6  = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m256i tmp7  = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m256i tmp9  = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+        const __m256i tmp14 = AVX::unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
+        const __m256i tmp15 = AVX::unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
+
+        v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);
+        v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);
+        v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);
+        v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);
+        v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);
+        v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);
+        v6.data() = AVX::unpacklo_epi16(tmp14, tmp15);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        using namespace AVX;
+        const __m256i a = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[8]])));
+        const __m256i b = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[9]])));
+        const __m256i c = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[10]])));
+        const __m256i d = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[11]])));
+        const __m256i e = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[12]])));
+        const __m256i f = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[13]])));
+        const __m256i g = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[14]])));
+        const __m256i h = concat(_mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]])),
+                                 _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[15]])));
+
+        const __m256i tmp2  = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...
+        const __m256i tmp4  = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m256i tmp3  = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m256i tmp5  = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m256i tmp0  = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...
+        const __m256i tmp1  = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m256i tmp6  = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m256i tmp7  = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m256i tmp8  = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m256i tmp9  = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+        const __m256i tmp14 = AVX::unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
+        const __m256i tmp15 = AVX::unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
+
+        v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);
+        v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);
+        v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);
+        v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);
+        v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);
+        v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);
+        v6.data() = AVX::unpacklo_epi16(tmp14, tmp15);
+        v7.data() = AVX::unpackhi_epi16(tmp14, tmp15);
+    }/*}}}*/
+};
+template<typename V> struct InterleaveImpl<V, 8, 32> {
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        using namespace AVX;
+        // [0a 1a 0b 1b 0e 1e 0f 1f]:
+        const m256 tmp0 = _mm256_unpacklo_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v1.data()));
+        // [0c 1c 0d 1d 0g 1g 0h 1h]:
+        const m256 tmp1 = _mm256_unpackhi_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v1.data()));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), lo128(tmp0));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), lo128(tmp0));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), lo128(tmp1));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), lo128(tmp1));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[4]]), hi128(tmp0));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), hi128(tmp0));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[6]]), hi128(tmp1));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), hi128(tmp1));
+    }/*}}}*/
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        using namespace AVX;
+        // [0a 1a 0b 1b 0e 1e 0f 1f]:
+        const m256 tmp0 = _mm256_unpacklo_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v1.data()));
+        // [0c 1c 0d 1d 0g 1g 0h 1h]:
+        const m256 tmp1 = _mm256_unpackhi_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v1.data()));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[0]]), lo128(tmp0));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[2]]), lo128(tmp1));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[4]]), hi128(tmp0));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[6]]), hi128(tmp1));
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
+    {
+        using namespace AVX;
+#ifdef Vc_USE_MASKMOV_SCATTER
+        // [0a 2a 0b 2b 0e 2e 0f 2f]:
+        const m256 tmp0 = _mm256_unpacklo_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v2.data()));
+        // [0c 2c 0d 2d 0g 2g 0h 2h]:
+        const m256 tmp1 = _mm256_unpackhi_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v2.data()));
+        // [1a __ 1b __ 1e __ 1f __]:
+        const m256 tmp2 = _mm256_unpacklo_ps(avx_cast<m256>(v1.data()), avx_cast<m256>(v1.data()));
+        // [1c __ 1d __ 1g __ 1h __]:
+        const m256 tmp3 = _mm256_unpackhi_ps(avx_cast<m256>(v1.data()), avx_cast<m256>(v1.data()));
+        const m256 tmp4 = _mm256_unpacklo_ps(tmp0, tmp2);
+        const m256 tmp5 = _mm256_unpackhi_ps(tmp0, tmp2);
+        const m256 tmp6 = _mm256_unpacklo_ps(tmp1, tmp3);
+        const m256 tmp7 = _mm256_unpackhi_ps(tmp1, tmp3);
+        const m128i mask = _mm_set_epi32(0, -1, -1, -1);
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[0]]), mask, lo128(tmp4));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[1]]), mask, lo128(tmp5));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[2]]), mask, lo128(tmp6));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[3]]), mask, lo128(tmp7));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[4]]), mask, hi128(tmp4));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[5]]), mask, hi128(tmp5));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[6]]), mask, hi128(tmp6));
+        _mm_maskstore_ps(reinterpret_cast<MayAlias<float> *>(&data[i[7]]), mask, hi128(tmp7));
+#else
+        interleave(data, i, v0, v1);
+        v2.scatter(data + 2, i);
+#endif
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1,
+            const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        using namespace AVX;
+        const m256 tmp0 = _mm256_unpacklo_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v2.data()));
+        const m256 tmp1 = _mm256_unpackhi_ps(avx_cast<m256>(v0.data()), avx_cast<m256>(v2.data()));
+        const m256 tmp2 = _mm256_unpacklo_ps(avx_cast<m256>(v1.data()), avx_cast<m256>(v3.data()));
+        const m256 tmp3 = _mm256_unpackhi_ps(avx_cast<m256>(v1.data()), avx_cast<m256>(v3.data()));
+        const m256 tmp4 = _mm256_unpacklo_ps(tmp0, tmp2);
+        const m256 tmp5 = _mm256_unpackhi_ps(tmp0, tmp2);
+        const m256 tmp6 = _mm256_unpacklo_ps(tmp1, tmp3);
+        const m256 tmp7 = _mm256_unpackhi_ps(tmp1, tmp3);
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[0]]), lo128(tmp4));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[1]]), lo128(tmp5));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[2]]), lo128(tmp6));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[3]]), lo128(tmp7));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[4]]), hi128(tmp4));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[5]]), hi128(tmp5));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[6]]), hi128(tmp6));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[7]]), hi128(tmp7));
+    }/*}}}*/
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        using namespace AVX;
+        const m128  il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[0]])); // a0 b0
+        const m128  il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[2]])); // a2 b2
+        const m128  il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[4]])); // a4 b4
+        const m128  il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[6]])); // a6 b6
+        const m128 il01 = _mm_loadh_pi(             il0, reinterpret_cast<__m64 const *>(&data[i[1]])); // a0 b0 a1 b1
+        const m128 il23 = _mm_loadh_pi(             il2, reinterpret_cast<__m64 const *>(&data[i[3]])); // a2 b2 a3 b3
+        const m128 il45 = _mm_loadh_pi(             il4, reinterpret_cast<__m64 const *>(&data[i[5]])); // a4 b4 a5 b5
+        const m128 il67 = _mm_loadh_pi(             il6, reinterpret_cast<__m64 const *>(&data[i[7]])); // a6 b6 a7 b7
+
+        const m256 tmp2 = concat(il01, il45);
+        const m256 tmp3 = concat(il23, il67);
+
+        const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
+        const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
+
+        v0.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(tmp0, tmp1));
+        v1.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(tmp0, tmp1));
+    }/*}}}*/
+    static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const Common::SuccessiveEntries<2> &i, V &v0, V &v1)
+    {
+        using namespace AVX;
+        const m256 il0123 = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]])); // a0 b0 a1 b1 a2 b2 a3 b3
+        const m256 il4567 = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[4]])); // a4 b4 a5 b5 a6 b6 a7 b7
+
+        const m256 tmp2 = Mem::shuffle128<X0, Y0>(il0123, il4567);
+        const m256 tmp3 = Mem::shuffle128<X1, Y1>(il0123, il4567);
+
+        const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
+        const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
+
+        v0.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(tmp0, tmp1));
+        v1.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(tmp0, tmp1));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        using namespace AVX;
+        const m128  il0 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]])); // a0 b0 c0 d0
+        const m128  il1 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[1]])); // a1 b1 c1 d1
+        const m128  il2 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[2]])); // a2 b2 c2 d2
+        const m128  il3 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[3]])); // a3 b3 c3 d3
+        const m128  il4 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[4]])); // a4 b4 c4 d4
+        const m128  il5 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[5]])); // a5 b5 c5 d5
+        const m128  il6 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[6]])); // a6 b6 c6 d6
+        const m128  il7 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[7]])); // a7 b7 c7 d7
+
+        const m256 il04 = concat(il0, il4);
+        const m256 il15 = concat(il1, il5);
+        const m256 il26 = concat(il2, il6);
+        const m256 il37 = concat(il3, il7);
+        const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
+        const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
+        const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
+        const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
+        v0.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(ab0246, ab1357));
+        v1.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(ab0246, ab1357));
+        v2.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(cd0246, cd1357));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        using namespace AVX;
+        const m128  il0 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]])); // a0 b0 c0 d0
+        const m128  il1 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[1]])); // a1 b1 c1 d1
+        const m128  il2 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[2]])); // a2 b2 c2 d2
+        const m128  il3 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[3]])); // a3 b3 c3 d3
+        const m128  il4 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[4]])); // a4 b4 c4 d4
+        const m128  il5 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[5]])); // a5 b5 c5 d5
+        const m128  il6 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[6]])); // a6 b6 c6 d6
+        const m128  il7 = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[7]])); // a7 b7 c7 d7
+
+        const m256 il04 = concat(il0, il4);
+        const m256 il15 = concat(il1, il5);
+        const m256 il26 = concat(il2, il6);
+        const m256 il37 = concat(il3, il7);
+        const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
+        const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
+        const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
+        const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
+        v0.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(ab0246, ab1357));
+        v1.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(ab0246, ab1357));
+        v2.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(cd0246, cd1357));
+        v3.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(cd0246, cd1357));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        v4.gather(data + 4, i);
+        deinterleave(data, i, v0, v1, v2, v3);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }/*}}}*/
+    static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const Common::SuccessiveEntries<6> &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        using namespace AVX;
+        const m256 a = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]]));
+        const m256 b = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0] + 1 * V::Size]));
+        const m256 c = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0] + 2 * V::Size]));
+        const m256 d = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0] + 3 * V::Size]));
+        const m256 e = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0] + 4 * V::Size]));
+        const m256 f = _mm256_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0] + 5 * V::Size]));
+        const __m256 tmp2 = Mem::shuffle128<X0, Y0>(a, d);
+        const __m256 tmp3 = Mem::shuffle128<X1, Y1>(b, e);
+        const __m256 tmp4 = Mem::shuffle128<X1, Y1>(a, d);
+        const __m256 tmp5 = Mem::shuffle128<X0, Y0>(c, f);
+        const __m256 tmp8 = Mem::shuffle128<X0, Y0>(b, e);
+        const __m256 tmp9 = Mem::shuffle128<X1, Y1>(c, f);
+        const __m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
+        const __m256 tmp1 = _mm256_unpackhi_ps(tmp4, tmp5);
+        const __m256 tmp6 = _mm256_unpackhi_ps(tmp2, tmp3);
+        const __m256 tmp7 = _mm256_unpacklo_ps(tmp8, tmp9);
+        const __m256 tmp10 = _mm256_unpacklo_ps(tmp4, tmp5);
+        const __m256 tmp11 = _mm256_unpackhi_ps(tmp8, tmp9);
+        v0.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(tmp0, tmp1));
+        v1.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(tmp0, tmp1));
+        v2.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(tmp6, tmp7));
+        v3.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(tmp6, tmp7));
+        v4.data() = avx_cast<typename V::VectorType>(_mm256_unpacklo_ps(tmp10, tmp11));
+        v5.data() = avx_cast<typename V::VectorType>(_mm256_unpackhi_ps(tmp10, tmp11));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6, v7);
+    }/*}}}*/
+};
+template<typename V> struct InterleaveImpl<V, 4, 32> {
+    template <typename I>  // interleave 2 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        using namespace AVX;
+        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
+        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
+        _mm_storeu_pd(&data[i[0]], lo128(tmp0));
+        _mm_storeu_pd(&data[i[1]], lo128(tmp1));
+        _mm_storeu_pd(&data[i[2]], hi128(tmp0));
+        _mm_storeu_pd(&data[i[3]], hi128(tmp1));
+    }
+    template <typename I>  // interleave 3 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2)
+    {
+        using namespace AVX;
+#ifdef Vc_USE_MASKMOV_SCATTER
+        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
+        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
+        const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v2.data());
+        const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v2.data());
+
+#if defined(Vc_MSVC) && (Vc_MSVC < 170000000 || !defined(_WIN64))
+        // MSVC needs to be at Version 2012 before _mm256_set_epi64x works
+        const m256i mask = concat(_mm_setallone_si128(), _mm_set_epi32(0, 0, -1, -1));
+#else
+        const m256i mask = _mm256_set_epi64x(0, -1, -1, -1);
+#endif
+        _mm256_maskstore_pd(&data[i[0]], mask, Mem::shuffle128<X0, Y0>(tmp0, tmp2));
+        _mm256_maskstore_pd(&data[i[1]], mask, Mem::shuffle128<X0, Y0>(tmp1, tmp3));
+        _mm256_maskstore_pd(&data[i[2]], mask, Mem::shuffle128<X1, Y1>(tmp0, tmp2));
+        _mm256_maskstore_pd(&data[i[3]], mask, Mem::shuffle128<X1, Y1>(tmp1, tmp3));
+#else
+        interleave(data, i, v0, v1);
+        v2.scatter(data + 2, i);
+#endif
+    }
+    template <typename I>  // interleave 4 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        using namespace AVX;
+        // 0a 1a 0c 1c:
+        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
+        // 0b 1b 0b 1b:
+        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
+        // 2a 3a 2c 3c:
+        const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v3.data());
+        // 2b 3b 2b 3b:
+        const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v3.data());
+        /* The following might be more efficient once 256-bit stores are not split internally into 2
+         * 128-bit stores.
+        _mm256_storeu_pd(&data[i[0]], Mem::shuffle128<X0, Y0>(tmp0, tmp2));
+        _mm256_storeu_pd(&data[i[1]], Mem::shuffle128<X0, Y0>(tmp1, tmp3));
+        _mm256_storeu_pd(&data[i[2]], Mem::shuffle128<X1, Y1>(tmp0, tmp2));
+        _mm256_storeu_pd(&data[i[3]], Mem::shuffle128<X1, Y1>(tmp1, tmp3));
+        */
+        _mm_storeu_pd(&data[i[0]  ], lo128(tmp0));
+        _mm_storeu_pd(&data[i[0]+2], lo128(tmp2));
+        _mm_storeu_pd(&data[i[1]  ], lo128(tmp1));
+        _mm_storeu_pd(&data[i[1]+2], lo128(tmp3));
+        _mm_storeu_pd(&data[i[2]  ], hi128(tmp0));
+        _mm_storeu_pd(&data[i[2]+2], hi128(tmp2));
+        _mm_storeu_pd(&data[i[3]  ], hi128(tmp1));
+        _mm_storeu_pd(&data[i[3]+2], hi128(tmp3));
+    }
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        using namespace Vc::AVX;
+        const m256d ab02 = concat(_mm_loadu_pd(&data[i[0]]), _mm_loadu_pd(&data[i[2]]));
+        const m256d ab13 = concat(_mm_loadu_pd(&data[i[1]]), _mm_loadu_pd(&data[i[3]]));
+
+        v0.data() = _mm256_unpacklo_pd(ab02, ab13);
+        v1.data() = _mm256_unpackhi_pd(ab02, ab13);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        v2.gather(data + 2, i);
+        deinterleave(data, i, v0, v1);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        v4.gather(data + 4, i);
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        v6.gather(data + 6, i);
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+        deinterleave(data + 6, i, v6, v7);
+    }/*}}}*/
+};
+//}}}1
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_AVX_DETAIL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/forceToRegisters.tcc vc-1.3.0/avx/forceToRegisters.tcc
--- vc-0.7.4/avx/forceToRegisters.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/forceToRegisters.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,141 +0,0 @@
-#ifdef __GNUC__
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x1.data()));
-}
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x1.data()));
-}
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x2.data()), "x"(x1.data()));
-}
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T7> &x7, const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x7.data()), "x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T7> &x7, Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x7.data()), "+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T8> &x8, const Vector<T7> &x7, const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x8.data()), "x"(x7.data()), "x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T8> &x8, Vector<T7> &x7, Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x8.data()), "+x"(x7.data()), "+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-#elif defined(VC_MSVC)
-#pragma optimize("g", off)
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T7> &/*x7*/, const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T7> &/*x7*/, Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T8> &/*x8*/, const Vector<T7> &/*x7*/, const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T8> &/*x8*/, Vector<T7> &/*x7*/, Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#else
-#error "forceToRegisters unsupported on this compiler"
-#endif
diff -Nru vc-0.7.4/avx/helperimpl.h vc-1.3.0/avx/helperimpl.h
--- vc-0.7.4/avx/helperimpl.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/helperimpl.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,104 +1,119 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_HELPERIMPL_H
-#define VC_AVX_HELPERIMPL_H
+#ifndef VC_AVX_HELPERIMPL_H_
+#define VC_AVX_HELPERIMPL_H_
 
+#include "../sse/helperimpl.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Internal
+namespace Detail
 {
+template <typename A>
+inline void deinterleave(AVX2::float_v &, AVX2::float_v &, const float *, A);
+template <typename A>
+inline void deinterleave(AVX2::float_v &, AVX2::float_v &, const short *, A);
+template <typename A>
+inline void deinterleave(AVX2::float_v &, AVX2::float_v &, const ushort *, A);
+template <typename A>
+inline void deinterleave(AVX2::double_v &, AVX2::double_v &, const double *, A);
+template <typename A>
+inline void deinterleave(AVX2::int_v &, AVX2::int_v &, const int *, A);
+template <typename A>
+inline void deinterleave(AVX2::int_v &, AVX2::int_v &, const short *, A);
+template <typename A>
+inline void deinterleave(AVX2::uint_v &, AVX2::uint_v &, const uint *, A);
+template <typename A>
+inline void deinterleave(AVX2::uint_v &, AVX2::uint_v &, const ushort *, A);
+template <typename A>
+inline void deinterleave(AVX2::short_v &, AVX2::short_v &, const short *, A);
+template <typename A>
+inline void deinterleave(AVX2::ushort_v &, AVX2::ushort_v &, const ushort *, A);
+
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector<T> &Vc_RESTRICT a,
+                                     AVX2::Vector<T> &Vc_RESTRICT b,
+                                     AVX2::Vector<T> &Vc_RESTRICT c,
+                                     const M *Vc_RESTRICT memory,
+                                     A align) Vc_ALWAYS_INLINE_R;
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector<T> &Vc_RESTRICT a,
+                                     AVX2::Vector<T> &Vc_RESTRICT b,
+                                     AVX2::Vector<T> &Vc_RESTRICT c,
+                                     AVX2::Vector<T> &Vc_RESTRICT d,
+                                     const M *Vc_RESTRICT memory,
+                                     A align) Vc_ALWAYS_INLINE_R;
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector<T> &Vc_RESTRICT a,
+                                     AVX2::Vector<T> &Vc_RESTRICT b,
+                                     AVX2::Vector<T> &Vc_RESTRICT c,
+                                     AVX2::Vector<T> &Vc_RESTRICT d,
+                                     AVX2::Vector<T> &Vc_RESTRICT e,
+                                     const M *Vc_RESTRICT memory,
+                                     A align) Vc_ALWAYS_INLINE_R;
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE_L void deinterleave(
+    AVX2::Vector<T> &Vc_RESTRICT a, AVX2::Vector<T> &Vc_RESTRICT b,
+    AVX2::Vector<T> &Vc_RESTRICT c, AVX2::Vector<T> &Vc_RESTRICT d,
+    AVX2::Vector<T> &Vc_RESTRICT e, AVX2::Vector<T> &Vc_RESTRICT f,
+    const M *Vc_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE_L void deinterleave(
+    AVX2::Vector<T> &Vc_RESTRICT a, AVX2::Vector<T> &Vc_RESTRICT b,
+    AVX2::Vector<T> &Vc_RESTRICT c, AVX2::Vector<T> &Vc_RESTRICT d,
+    AVX2::Vector<T> &Vc_RESTRICT e, AVX2::Vector<T> &Vc_RESTRICT f,
+    AVX2::Vector<T> &Vc_RESTRICT g, AVX2::Vector<T> &Vc_RESTRICT h,
+    const M *Vc_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
 
-template<> struct HelperImpl<Vc::AVXImpl>
+Vc_ALWAYS_INLINE void prefetchForOneRead(const void *addr, VectorAbi::Avx)
 {
-    typedef AVX::Vector<float> float_v;
-    typedef AVX::Vector<sfloat> sfloat_v;
-    typedef AVX::Vector<double> double_v;
-    typedef AVX::Vector<int> int_v;
-    typedef AVX::Vector<unsigned int> uint_v;
-    typedef AVX::Vector<short> short_v;
-    typedef AVX::Vector<unsigned short> ushort_v;
-
-    template<typename A> static void deinterleave(float_v &, float_v &, const float *, A);
-    template<typename A> static void deinterleave(float_v &, float_v &, const short *, A);
-    template<typename A> static void deinterleave(float_v &, float_v &, const unsigned short *, A);
-
-    template<typename A, typename MemT> static void deinterleave(sfloat_v &, sfloat_v &, const MemT *, A);
-
-    template<typename A> static void deinterleave(double_v &, double_v &, const double *, A);
-
-    template<typename A> static void deinterleave(int_v &, int_v &, const int *, A);
-    template<typename A> static void deinterleave(int_v &, int_v &, const short *, A);
-
-    template<typename A> static void deinterleave(uint_v &, uint_v &, const unsigned int *, A);
-    template<typename A> static void deinterleave(uint_v &, uint_v &, const unsigned short *, A);
-
-    template<typename A> static void deinterleave(short_v &, short_v &, const short *, A);
-
-    template<typename A> static void deinterleave(ushort_v &, ushort_v &, const unsigned short *, A);
-
-    template<typename V, typename M, typename A>
-        static Vc_ALWAYS_INLINE_L void deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-                V &VC_RESTRICT c, const M *VC_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
-
-    template<typename V, typename M, typename A>
-        static Vc_ALWAYS_INLINE_L void deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-                V &VC_RESTRICT c, V &VC_RESTRICT d,
-                const M *VC_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
-
-    template<typename V, typename M, typename A>
-        static Vc_ALWAYS_INLINE_L void deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-                V &VC_RESTRICT c, V &VC_RESTRICT d, V &VC_RESTRICT e,
-                const M *VC_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
-
-    template<typename V, typename M, typename A>
-        static Vc_ALWAYS_INLINE_L void deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-                V &VC_RESTRICT c, V &VC_RESTRICT d, V &VC_RESTRICT e,
-                V &VC_RESTRICT f, const M *VC_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
-
-    template<typename V, typename M, typename A>
-        static Vc_ALWAYS_INLINE_L void deinterleave(V &VC_RESTRICT a, V &VC_RESTRICT b,
-                V &VC_RESTRICT c, V &VC_RESTRICT d, V &VC_RESTRICT e,
-                V &VC_RESTRICT f, V &VC_RESTRICT g, V &VC_RESTRICT h,
-                const M *VC_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;
-
-    static Vc_ALWAYS_INLINE_L void prefetchForOneRead(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchForModify(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchClose(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchMid(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchFar(const void *addr) Vc_ALWAYS_INLINE_R;
-
-    template<Vc::MallocAlignment A>
-    static Vc_ALWAYS_INLINE_L void *malloc(size_t n) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void free(void *p) Vc_ALWAYS_INLINE_R;
-};
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+    prefetchForOneRead(addr, VectorAbi::Sse());
+}
+Vc_ALWAYS_INLINE void prefetchForModify(const void *addr, VectorAbi::Avx)
+{
+    prefetchForModify(addr, VectorAbi::Sse());
+}
+Vc_ALWAYS_INLINE void prefetchClose(const void *addr, VectorAbi::Avx)
+{
+    prefetchClose(addr, VectorAbi::Sse());
+}
+Vc_ALWAYS_INLINE void prefetchMid(const void *addr, VectorAbi::Avx)
+{
+    prefetchMid(addr, VectorAbi::Sse());
+}
+Vc_ALWAYS_INLINE void prefetchFar(const void *addr, VectorAbi::Avx)
+{
+    prefetchFar(addr, VectorAbi::Sse());
+}
+}  // namespace Detail
+}  // namespace Vc
 
 #include "deinterleave.tcc"
-#include "prefetches.tcc"
-#include "helperimpl.tcc"
-#include "undomacros.h"
 
-#endif // VC_AVX_HELPERIMPL_H
+#endif // VC_AVX_HELPERIMPL_H_
diff -Nru vc-0.7.4/avx/helperimpl.tcc vc-1.3.0/avx/helperimpl.tcc
--- vc-0.7.4/avx/helperimpl.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/helperimpl.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,64 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_HELPERIMPL_TCC
-#define VC_AVX_HELPERIMPL_TCC
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Internal
-{
-
-template<size_t X>
-static _VC_CONSTEXPR size_t nextMultipleOf(size_t value)
-{
-    return (value % X) > 0 ? value + X - (value % X) : value;
-}
-
-template<Vc::MallocAlignment A>
-Vc_ALWAYS_INLINE void *HelperImpl<AVXImpl>::malloc(size_t n)
-{
-    switch (A) {
-        case Vc::AlignOnVector:
-            return _mm_malloc(nextMultipleOf<Vc::AVX::VectorAlignment>(n), Vc::AVX::VectorAlignment);
-        case Vc::AlignOnCacheline:
-            // TODO: hardcoding 64 is not such a great idea
-            return _mm_malloc(nextMultipleOf<64>(n), 64);
-        case Vc::AlignOnPage:
-            // TODO: hardcoding 4096 is not such a great idea
-            return _mm_malloc(nextMultipleOf<4096>(n), 4096);
-        default:
-#ifndef NDEBUG
-            abort();
-#endif
-            return _mm_malloc(n, 8);
-    }
-}
-
-Vc_ALWAYS_INLINE void HelperImpl<AVXImpl>::free(void *p)
-{
-    _mm_free(p);
-}
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_AVX_HELPERIMPL_TCC
diff -Nru vc-0.7.4/avx/interleavedmemory.tcc vc-1.3.0/avx/interleavedmemory.tcc
--- vc-0.7.4/avx/interleavedmemory.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/interleavedmemory.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,890 +0,0 @@
-/*  This file is part of the Vc library. {{{
-
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-}}}*/
-
-#ifndef VC_AVX_INTERLEAVEDMEMORY_TCC
-#define VC_AVX_INTERLEAVEDMEMORY_TCC
-
-#include "macros.h"
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Common
-{
-
-namespace
-{
-template<typename V, int Size, size_t VSize> struct InterleaveImpl;
-template<typename V> struct InterleaveImpl<V, 8, 16> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        const m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v1.data());
-        const m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v1.data());
-#ifdef __x86_64__
-        const long long tmp00 = _mm_cvtsi128_si64(tmp0);
-        const long long tmp01 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp0, tmp0));
-        const long long tmp10 = _mm_cvtsi128_si64(tmp1);
-        const long long tmp11 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp1, tmp1));
-        *reinterpret_cast<int *>(&data[i[0]]) = tmp00;
-        *reinterpret_cast<int *>(&data[i[1]]) = tmp00 >> 32;
-        *reinterpret_cast<int *>(&data[i[2]]) = tmp01;
-        *reinterpret_cast<int *>(&data[i[3]]) = tmp01 >> 32;
-        *reinterpret_cast<int *>(&data[i[4]]) = tmp10;
-        *reinterpret_cast<int *>(&data[i[5]]) = tmp10 >> 32;
-        *reinterpret_cast<int *>(&data[i[6]]) = tmp11;
-        *reinterpret_cast<int *>(&data[i[7]]) = tmp11 >> 32;
-#else
-        *reinterpret_cast<int *>(&data[i[0]]) = _mm_cvtsi128_si32(tmp0);
-        *reinterpret_cast<int *>(&data[i[1]]) = _mm_extract_epi32(tmp0, 1);
-        *reinterpret_cast<int *>(&data[i[2]]) = _mm_extract_epi32(tmp0, 2);
-        *reinterpret_cast<int *>(&data[i[3]]) = _mm_extract_epi32(tmp0, 3);
-        *reinterpret_cast<int *>(&data[i[4]]) = _mm_cvtsi128_si32(tmp1);
-        *reinterpret_cast<int *>(&data[i[5]]) = _mm_extract_epi32(tmp1, 1);
-        *reinterpret_cast<int *>(&data[i[6]]) = _mm_extract_epi32(tmp1, 2);
-        *reinterpret_cast<int *>(&data[i[7]]) = _mm_extract_epi32(tmp1, 3);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-#ifdef VC_USE_MASKMOV_SCATTER
-        const m128i maskLo = _mm_set_epi16(0, 0, 0, 0, 0, -1, -1, -1);
-        const m128i maskHi = _mm_set_epi16(0, -1, -1, -1, 0, 0, 0, 0);
-        typename V::EntryType *const dataHi = data - 4;
-        const m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
-        const m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
-        const m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v1.data());
-        const m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v1.data());
-
-        const m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
-        const m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
-        const m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
-        const m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
-        _mm_maskmoveu_si128(tmp4, maskLo, reinterpret_cast<char *>(&data[i[0]]));
-        _mm_maskmoveu_si128(tmp4, maskHi, reinterpret_cast<char *>(&dataHi[i[1]]));
-        _mm_maskmoveu_si128(tmp5, maskLo, reinterpret_cast<char *>(&data[i[2]]));
-        _mm_maskmoveu_si128(tmp5, maskHi, reinterpret_cast<char *>(&dataHi[i[3]]));
-        _mm_maskmoveu_si128(tmp6, maskLo, reinterpret_cast<char *>(&data[i[4]]));
-        _mm_maskmoveu_si128(tmp6, maskHi, reinterpret_cast<char *>(&dataHi[i[5]]));
-        _mm_maskmoveu_si128(tmp7, maskLo, reinterpret_cast<char *>(&data[i[6]]));
-        _mm_maskmoveu_si128(tmp7, maskHi, reinterpret_cast<char *>(&dataHi[i[7]]));
-#else
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        const m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
-        const m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
-        const m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v3.data());
-        const m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v3.data());
-
-        const m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
-        const m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
-        const m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
-        const m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
-
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[0]]), tmp4);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[2]]), tmp5);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[4]]), tmp6);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[6]]), tmp7);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), _mm_castsi128_ps(tmp4));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), _mm_castsi128_ps(tmp5));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), _mm_castsi128_ps(tmp6));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), _mm_castsi128_ps(tmp7));
-    }/*}}}*/
-};
-template<typename V> struct InterleaveImpl<V, 8, 32> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        using namespace Vc::AVX;
-        // [0a 1a 0b 1b 0e 1e 0f 1f]:
-        const m256 tmp0 = _mm256_unpacklo_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v1.data()));
-        // [0c 1c 0d 1d 0g 1g 0h 1h]:
-        const m256 tmp1 = _mm256_unpackhi_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v1.data()));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), lo128(tmp0));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), lo128(tmp0));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), lo128(tmp1));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), lo128(tmp1));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[4]]), hi128(tmp0));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), hi128(tmp0));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[6]]), hi128(tmp1));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), hi128(tmp1));
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-        using namespace Vc::AVX;
-#ifdef VC_USE_MASKMOV_SCATTER
-        // [0a 2a 0b 2b 0e 2e 0f 2f]:
-        const m256 tmp0 = _mm256_unpacklo_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v2.data()));
-        // [0c 2c 0d 2d 0g 2g 0h 2h]:
-        const m256 tmp1 = _mm256_unpackhi_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v2.data()));
-        // [1a __ 1b __ 1e __ 1f __]:
-        const m256 tmp2 = _mm256_unpacklo_ps(AVX::avx_cast<m256>(v1.data()), AVX::avx_cast<m256>(v1.data()));
-        // [1c __ 1d __ 1g __ 1h __]:
-        const m256 tmp3 = _mm256_unpackhi_ps(AVX::avx_cast<m256>(v1.data()), AVX::avx_cast<m256>(v1.data()));
-        const m256 tmp4 = _mm256_unpacklo_ps(tmp0, tmp2);
-        const m256 tmp5 = _mm256_unpackhi_ps(tmp0, tmp2);
-        const m256 tmp6 = _mm256_unpacklo_ps(tmp1, tmp3);
-        const m256 tmp7 = _mm256_unpackhi_ps(tmp1, tmp3);
-        const m128i mask = _mm_set_epi32(0, -1, -1, -1);
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[0]]), mask, lo128(tmp4));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[1]]), mask, lo128(tmp5));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[2]]), mask, lo128(tmp6));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[3]]), mask, lo128(tmp7));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[4]]), mask, hi128(tmp4));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[5]]), mask, hi128(tmp5));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[6]]), mask, hi128(tmp6));
-        _mm_maskstore_ps(reinterpret_cast<float *>(&data[i[7]]), mask, hi128(tmp7));
-#else
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        using namespace Vc::AVX;
-        const m256 tmp0 = _mm256_unpacklo_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v2.data()));
-        const m256 tmp1 = _mm256_unpackhi_ps(AVX::avx_cast<m256>(v0.data()), AVX::avx_cast<m256>(v2.data()));
-        const m256 tmp2 = _mm256_unpacklo_ps(AVX::avx_cast<m256>(v1.data()), AVX::avx_cast<m256>(v3.data()));
-        const m256 tmp3 = _mm256_unpackhi_ps(AVX::avx_cast<m256>(v1.data()), AVX::avx_cast<m256>(v3.data()));
-        const m256 tmp4 = _mm256_unpacklo_ps(tmp0, tmp2);
-        const m256 tmp5 = _mm256_unpackhi_ps(tmp0, tmp2);
-        const m256 tmp6 = _mm256_unpacklo_ps(tmp1, tmp3);
-        const m256 tmp7 = _mm256_unpackhi_ps(tmp1, tmp3);
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[0]]), lo128(tmp4));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[1]]), lo128(tmp5));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[2]]), lo128(tmp6));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[3]]), lo128(tmp7));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[4]]), hi128(tmp4));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[5]]), hi128(tmp5));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[6]]), hi128(tmp6));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[7]]), hi128(tmp7));
-    }/*}}}*/
-};
-template<typename V> struct InterleaveImpl<V, 4, 32> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        using namespace Vc::AVX;
-        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
-        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
-        _mm_storeu_pd(&data[i[0]], lo128(tmp0));
-        _mm_storeu_pd(&data[i[1]], lo128(tmp1));
-        _mm_storeu_pd(&data[i[2]], hi128(tmp0));
-        _mm_storeu_pd(&data[i[3]], hi128(tmp1));
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-        using namespace Vc::AVX;
-#ifdef VC_USE_MASKMOV_SCATTER
-        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
-        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
-        const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v2.data());
-        const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v2.data());
-
-#if defined(VC_MSVC) && (VC_MSVC < 170000000 || !defined(_WIN64))
-        // MSVC needs to be at Version 2012 before _mm256_set_epi64x works
-        const m256i mask = AVX::concat(_mm_setallone_si128(), _mm_set_epi32(0, 0, -1, -1));
-#else
-        const m256i mask = _mm256_set_epi64x(0, -1, -1, -1);
-#endif
-        _mm256_maskstore_pd(&data[i[0]], mask, Mem::shuffle128<X0, Y0>(tmp0, tmp2));
-        _mm256_maskstore_pd(&data[i[1]], mask, Mem::shuffle128<X0, Y0>(tmp1, tmp3));
-        _mm256_maskstore_pd(&data[i[2]], mask, Mem::shuffle128<X1, Y1>(tmp0, tmp2));
-        _mm256_maskstore_pd(&data[i[3]], mask, Mem::shuffle128<X1, Y1>(tmp1, tmp3));
-#else
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        using namespace Vc::AVX;
-        // 0a 1a 0c 1c:
-        const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());
-        // 0b 1b 0b 1b:
-        const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());
-        // 2a 3a 2c 3c:
-        const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v3.data());
-        // 2b 3b 2b 3b:
-        const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v3.data());
-        _mm256_storeu_pd(&data[i[0]], Mem::shuffle128<X0, Y0>(tmp0, tmp2));
-        _mm256_storeu_pd(&data[i[1]], Mem::shuffle128<X0, Y0>(tmp1, tmp3));
-        _mm256_storeu_pd(&data[i[2]], Mem::shuffle128<X1, Y1>(tmp0, tmp2));
-        _mm256_storeu_pd(&data[i[3]], Mem::shuffle128<X1, Y1>(tmp1, tmp3));
-    }/*}}}*/
-};
-} // anonymous namespace
-
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data, m_indexes, v0, v1);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data, m_indexes, v0, v1, v2);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data, m_indexes, v0, v1, v2, v3);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data, m_indexes, v0, v1, v2, v3);
-    v4.scatter(m_data + 4, m_indexes);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data    , m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data + 4, m_indexes, v4, v5);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data + 0, m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data + 4, m_indexes, v4, v5, v6);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6, const typename V::AsArg v7)
-{
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data + 0, m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size, sizeof(V)>::interleave(m_data + 4, m_indexes, v4, v5, v6, v7);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1) const/*{{{*/
-{
-    const m128  il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[0]])); // a0 b0
-    const m128  il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[2]])); // a2 b2
-    const m128  il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[4]])); // a4 b4
-    const m128  il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[6]])); // a6 b6
-    const m128 il01 = _mm_loadh_pi(             il0, reinterpret_cast<__m64 const *>(&m_data[m_indexes[1]])); // a0 b0 a1 b1
-    const m128 il23 = _mm_loadh_pi(             il2, reinterpret_cast<__m64 const *>(&m_data[m_indexes[3]])); // a2 b2 a3 b3
-    const m128 il45 = _mm_loadh_pi(             il4, reinterpret_cast<__m64 const *>(&m_data[m_indexes[5]])); // a4 b4 a5 b5
-    const m128 il67 = _mm_loadh_pi(             il6, reinterpret_cast<__m64 const *>(&m_data[m_indexes[7]])); // a6 b6 a7 b7
-
-    const m256 tmp2 = AVX::concat(il01, il45);
-    const m256 tmp3 = AVX::concat(il23, il67);
-
-    const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
-    const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
-
-    v0.data() = _mm256_unpacklo_ps(tmp0, tmp1);
-    v1.data() = _mm256_unpackhi_ps(tmp0, tmp1);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2) const/*{{{*/
-{
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0]]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1]]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2]]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3]]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4]]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5]]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6]]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7]]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v0.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v1.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v2.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3) const/*{{{*/
-{
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0]]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1]]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2]]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3]]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4]]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5]]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6]]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7]]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v0.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v1.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v2.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-    v3.data() = _mm256_unpackhi_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4) const/*{{{*/
-{
-    v4.gather(m_data, m_indexes + I(4));
-    deinterleave(v0, v1, v2, v3);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[0] + 4])); // a0 b0
-    const m128  il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[2] + 4])); // a2 b2
-    const m128  il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[4] + 4])); // a4 b4
-    const m128  il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[6] + 4])); // a6 b6
-    const m128 il01 = _mm_loadh_pi(             il0, reinterpret_cast<__m64 const *>(&m_data[m_indexes[1] + 4])); // a0 b0 a1 b1
-    const m128 il23 = _mm_loadh_pi(             il2, reinterpret_cast<__m64 const *>(&m_data[m_indexes[3] + 4])); // a2 b2 a3 b3
-    const m128 il45 = _mm_loadh_pi(             il4, reinterpret_cast<__m64 const *>(&m_data[m_indexes[5] + 4])); // a4 b4 a5 b5
-    const m128 il67 = _mm_loadh_pi(             il6, reinterpret_cast<__m64 const *>(&m_data[m_indexes[7] + 4])); // a6 b6 a7 b7
-
-    const m256 tmp2 = AVX::concat(il01, il45);
-    const m256 tmp3 = AVX::concat(il23, il67);
-
-    const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
-    const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
-
-    v4.data() = _mm256_unpacklo_ps(tmp0, tmp1);
-    v5.data() = _mm256_unpackhi_ps(tmp0, tmp1);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5, float_v &v6) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0] + 4]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1] + 4]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2] + 4]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3] + 4]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4] + 4]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5] + 4]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6] + 4]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7] + 4]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v4.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v5.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v6.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5, float_v &v6, float_v &v7) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0] + 4]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1] + 4]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2] + 4]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3] + 4]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4] + 4]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5] + 4]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6] + 4]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7] + 4]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v4.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v5.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v6.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-    v7.data() = _mm256_unpackhi_ps(cd0246, cd1357);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1) const/*{{{*/
-{
-    const m128  il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[0]])); // a0 b0
-    const m128  il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[2]])); // a2 b2
-    const m128  il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[4]])); // a4 b4
-    const m128  il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[6]])); // a6 b6
-    const m128 il01 = _mm_loadh_pi(             il0, reinterpret_cast<__m64 const *>(&m_data[m_indexes[1]])); // a0 b0 a1 b1
-    const m128 il23 = _mm_loadh_pi(             il2, reinterpret_cast<__m64 const *>(&m_data[m_indexes[3]])); // a2 b2 a3 b3
-    const m128 il45 = _mm_loadh_pi(             il4, reinterpret_cast<__m64 const *>(&m_data[m_indexes[5]])); // a4 b4 a5 b5
-    const m128 il67 = _mm_loadh_pi(             il6, reinterpret_cast<__m64 const *>(&m_data[m_indexes[7]])); // a6 b6 a7 b7
-
-    const m256 tmp2 = AVX::concat(il01, il45);
-    const m256 tmp3 = AVX::concat(il23, il67);
-
-    const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
-    const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
-
-    v0.data() = _mm256_unpacklo_ps(tmp0, tmp1);
-    v1.data() = _mm256_unpackhi_ps(tmp0, tmp1);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2) const/*{{{*/
-{
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0]]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1]]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2]]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3]]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4]]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5]]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6]]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7]]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v0.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v1.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v2.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3) const/*{{{*/
-{
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0]]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1]]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2]]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3]]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4]]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5]]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6]]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7]]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v0.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v1.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v2.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-    v3.data() = _mm256_unpackhi_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4) const/*{{{*/
-{
-    v4.gather(m_data, m_indexes + I(4));
-    deinterleave(v0, v1, v2, v3);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[0] + 4])); // a0 b0
-    const m128  il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[2] + 4])); // a2 b2
-    const m128  il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[4] + 4])); // a4 b4
-    const m128  il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&m_data[m_indexes[6] + 4])); // a6 b6
-    const m128 il01 = _mm_loadh_pi(             il0, reinterpret_cast<__m64 const *>(&m_data[m_indexes[1] + 4])); // a0 b0 a1 b1
-    const m128 il23 = _mm_loadh_pi(             il2, reinterpret_cast<__m64 const *>(&m_data[m_indexes[3] + 4])); // a2 b2 a3 b3
-    const m128 il45 = _mm_loadh_pi(             il4, reinterpret_cast<__m64 const *>(&m_data[m_indexes[5] + 4])); // a4 b4 a5 b5
-    const m128 il67 = _mm_loadh_pi(             il6, reinterpret_cast<__m64 const *>(&m_data[m_indexes[7] + 4])); // a6 b6 a7 b7
-
-    const m256 tmp2 = AVX::concat(il01, il45);
-    const m256 tmp3 = AVX::concat(il23, il67);
-
-    const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);
-    const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);
-
-    v4.data() = _mm256_unpacklo_ps(tmp0, tmp1);
-    v5.data() = _mm256_unpackhi_ps(tmp0, tmp1);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5, sfloat_v &v6) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0] + 4]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1] + 4]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2] + 4]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3] + 4]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4] + 4]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5] + 4]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6] + 4]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7] + 4]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v4.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v5.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v6.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5, sfloat_v &v6, sfloat_v &v7) const/*{{{*/
-{
-    deinterleave(v0, v1, v2, v3);
-    const m128  il0 = _mm_loadu_ps(&m_data[m_indexes[0] + 4]); // a0 b0 c0 d0
-    const m128  il1 = _mm_loadu_ps(&m_data[m_indexes[1] + 4]); // a1 b1 c1 d1
-    const m128  il2 = _mm_loadu_ps(&m_data[m_indexes[2] + 4]); // a2 b2 c2 d2
-    const m128  il3 = _mm_loadu_ps(&m_data[m_indexes[3] + 4]); // a3 b3 c3 d3
-    const m128  il4 = _mm_loadu_ps(&m_data[m_indexes[4] + 4]); // a4 b4 c4 d4
-    const m128  il5 = _mm_loadu_ps(&m_data[m_indexes[5] + 4]); // a5 b5 c5 d5
-    const m128  il6 = _mm_loadu_ps(&m_data[m_indexes[6] + 4]); // a6 b6 c6 d6
-    const m128  il7 = _mm_loadu_ps(&m_data[m_indexes[7] + 4]); // a7 b7 c7 d7
-
-    const m256 il04 = AVX::concat(il0, il4);
-    const m256 il15 = AVX::concat(il1, il5);
-    const m256 il26 = AVX::concat(il2, il6);
-    const m256 il37 = AVX::concat(il3, il7);
-    const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);
-    const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);
-    const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);
-    const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);
-    v4.data() = _mm256_unpacklo_ps(ab0246, ab1357);
-    v5.data() = _mm256_unpackhi_ps(ab0246, ab1357);
-    v6.data() = _mm256_unpacklo_ps(cd0246, cd1357);
-    v7.data() = _mm256_unpackhi_ps(cd0246, cd1357);
-}/*}}}*/
-
-static Vc_ALWAYS_INLINE void _avx_deinterleave_double(const double *VC_RESTRICT data, const uint_v &indexes, double_v &v0, double_v &v1)/*{{{*/
-{
-    const m256d ab02 = AVX::concat(_mm_loadu_pd(&data[indexes[0]]), _mm_loadu_pd(&data[indexes[2]]));
-    const m256d ab13 = AVX::concat(_mm_loadu_pd(&data[indexes[1]]), _mm_loadu_pd(&data[indexes[3]]));
-
-    v0.data() = _mm256_unpacklo_pd(ab02, ab13);
-    v1.data() = _mm256_unpackhi_pd(ab02, ab13);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    v2.gather(m_data + 2, m_indexes);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2, double_v &v3) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _avx_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2, double_v &v3, double_v &v4) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _avx_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    v4.gather(m_data + 4, m_indexes);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2, double_v &v3, double_v &v4, double_v &v5) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _avx_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _avx_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2, double_v &v3, double_v &v4, double_v &v5, double_v &v6) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _avx_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _avx_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-    v6.gather(m_data + 6, m_indexes);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1, double_v &v2, double_v &v3, double_v &v4, double_v &v5, double_v &v6, double_v &v7) const/*{{{*/
-{
-    _avx_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _avx_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _avx_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-    _avx_deinterleave_double(m_data + 6, m_indexes, v6, v7);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1) const {/*{{{*/
-    const m128i a = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2) const {
-    const m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3) const {
-    const m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4) const {
-    const m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5) const {
-    const m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5, short_v &v6) const {
-    const m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-    const m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
-    const m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-    v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5, short_v &v6, short_v &v7) const {
-    const m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-    const m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
-    const m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-    v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
-    v7.data() = _mm_unpackhi_epi16(tmp14, tmp15);
-}/*}}}*/
-
-// forward types of equal size - ugly, but it works/*{{{*/
-#define _forward(V, V2) \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5, V &v6) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5), reinterpret_cast<V2 &>(v6)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5, V &v6, V &v7) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5), reinterpret_cast<V2 &>(v6), reinterpret_cast<V2 &>(v7)); \
-}
-_forward( int_v, float_v)
-_forward(uint_v, float_v)
-_forward(ushort_v, short_v)
-#undef _forward/*}}}*/
-
-} // namespace Common
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
-
-#endif // VC_AVX_INTERLEAVEDMEMORY_TCC
-
-// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/intrinsics.h vc-1.3.0/avx/intrinsics.h
--- vc-0.7.4/avx/intrinsics.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/intrinsics.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,147 +1,77 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_INTRINSICS_H
-#define VC_AVX_INTRINSICS_H
-
-#include "../common/windows_fix_intrin.h"
+#ifndef VC_AVX_INTRINSICS_H_
+#define VC_AVX_INTRINSICS_H_
 
 #include <Vc/global.h>
+#include "../traits/type_traits.h"
 
 // see comment in sse/intrinsics.h
 extern "C" {
 // AVX
 #include <immintrin.h>
 
-#if (defined(VC_IMPL_XOP) || defined(VC_IMPL_FMA4)) && !defined(VC_MSVC)
+#if (defined(Vc_IMPL_XOP) || defined(Vc_IMPL_FMA4)) && !defined(Vc_MSVC)
 #include <x86intrin.h>
 #endif
 }
 
 #include "../common/fix_clang_emmintrin.h"
 
-#if defined(VC_CLANG) && VC_CLANG < 0x30100
-// _mm_permute_ps is broken: http://llvm.org/bugs/show_bug.cgi?id=12401
-#undef _mm_permute_ps
-#define _mm_permute_ps(A, C) __extension__ ({ \
-  m128 __A = (A); \
-  (m128)__builtin_shufflevector((__v4sf)__A, (__v4sf) _mm_setzero_ps(), \
-                                   (C) & 0x3, ((C) & 0xc) >> 2, \
-                                   ((C) & 0x30) >> 4, ((C) & 0xc0) >> 6); })
-#endif
-
 #include "const_data.h"
+#include "../common/types.h"
 #include "macros.h"
 #include <cstdlib>
 
-#if defined(VC_CLANG) || defined(VC_MSVC) || (defined(VC_GCC) && !defined(__OPTIMIZE__))
-#define VC_REQUIRES_MACRO_FOR_IMMEDIATE_ARGUMENT
-#endif
-
-#if defined(VC_CLANG) && VC_CLANG <= 0x30000
-// _mm_alignr_epi8 doesn't specify its return type, thus breaking overload resolution
-#undef _mm_alignr_epi8
-#define _mm_alignr_epi8(a, b, n) ((m128i)__builtin_ia32_palignr128((a), (b), (n)))
-#endif
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace AVX
+namespace AvxIntrinsics
 {
-    /* super evil hacking around C++ features:
-     * consider
-     * void fun(int);
-     * namespace X { void fun(int); }
-     * namespace X { void bar() { fun(0); } } // this will be a call to X::fun(int)
-     *
-     * void fun(m256);
-     * namespace X { void fun(m256); }
-     * namespace X { void bar() { fun(0); } } // this will be ambiguous because m256 is a
-     *                                           non-fundamental type in the global namespace, thus
-     *                                           adding ::fun(m256) to the candidates
-     *
-     * To make my own overloads of the intrinsics distinct I have to use a type that is inside the
-     * Vc::AVX namespace. To reduce porting effort and increase generality I want to use the same
-     * function names as used in the global namespace. The type name may not be the same, though
-     * because identifiers starting with two underscores are reserved by the standard. Thus using
-     * those would mean to depend on undefined behavior.
-     * Sadly a typedef is not enough.
-     * Public inheritance also does not work, because at least ICC considers the __m??? types to be
-     * some sort of fundamental types.
-     * Thus composition is the only solution.
-     */
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-    template<typename T> struct Alias
-    {
-        typedef T Base;
-        T _d;
-        Vc_ALWAYS_INLINE operator T &() { return _d; }
-        Vc_ALWAYS_INLINE operator const T &() const { return _d; }
-        Vc_ALWAYS_INLINE Alias() {}
-        Vc_ALWAYS_INLINE Alias(T x) : _d(x) {}
-        Vc_ALWAYS_INLINE Alias(const Alias &x) : _d(x._d) {}
-        Vc_ALWAYS_INLINE Alias &operator=(T x) { _d = x; return *this; }
-        Vc_ALWAYS_INLINE Alias &operator=(const Alias &x) { _d = x._d; return *this; }
-    };
-    typedef Alias<__m128 > m128 ;
-    typedef Alias<__m128d> m128d;
-    typedef Alias<__m128i> m128i;
-    typedef Alias<__m256 > m256 ;
-    typedef Alias<__m256d> m256d;
-    typedef Alias<__m256i> m256i;
-#else
+    using AVX::c_general;
+    using AVX::_IndexesFromZero32;
+    using AVX::_IndexesFromZero16;
+    using AVX::_IndexesFromZero8;
+
     typedef __m128  m128 ;
     typedef __m128d m128d;
     typedef __m128i m128i;
     typedef __m256  m256 ;
     typedef __m256d m256d;
     typedef __m256i m256i;
-#endif
-#if defined(VC_UNCONDITIONAL_AVX2_INTRINSICS) && defined(VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN)
-    typedef const m128  & param128 ;
-    typedef const m128d & param128d;
-    typedef const m128i & param128i;
-    typedef const m256  & param256 ;
-    typedef const m256d & param256d;
-    typedef const m256i & param256i;
-#else
+
     typedef const m128  param128 ;
     typedef const m128d param128d;
     typedef const m128i param128i;
     typedef const m256  param256 ;
     typedef const m256d param256d;
     typedef const m256i param256i;
-#endif
-
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-    // Make use of cast intrinsics easier. But if param256 == const __m256 then these would lead to
-    // ambiguities.
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_castps_si256(param256  a) { return ::_mm256_castps_si256(a); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_castps_pd   (param256  a) { return ::_mm256_castps_pd   (a); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_castpd_si256(param256d a) { return ::_mm256_castpd_si256(a); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_castpd_ps   (param256d a) { return ::_mm256_castpd_ps   (a); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_castsi256_ps(param256i a) { return ::_mm256_castsi256_ps(a); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_castsi256_pd(param256i a) { return ::_mm256_castsi256_pd(a); }
-#endif
 
-#ifdef VC_GCC
+#ifdef Vc_GCC
     // Redefine the mul/add/sub intrinsics to use GCC-specific operators instead of builtin
     // functions. This way the fp-contraction optimization step kicks in and creates FMAs! :)
     static Vc_INTRINSIC Vc_CONST m256d _mm256_mul_pd(m256d a, m256d b) { return static_cast<m256d>(static_cast<__v4df>(a) * static_cast<__v4df>(b)); }
@@ -152,460 +82,627 @@
     static Vc_INTRINSIC Vc_CONST m256 _mm256_sub_ps(m256 a, m256 b) { return static_cast<m256>(static_cast<__v8sf>(a) - static_cast<__v8sf>(b)); }
 #endif
 
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_set1_ps   (float  a) { return ::_mm256_set1_ps   (a); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_set1_pd   (double a) { return ::_mm256_set1_pd   (a); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_set1_epi32(int    a) { return ::_mm256_set1_epi32(a); }
+    static Vc_INTRINSIC m256  Vc_CONST set1_ps   (float  a) { return _mm256_set1_ps   (a); }
+    static Vc_INTRINSIC m256d Vc_CONST set1_pd   (double a) { return _mm256_set1_pd   (a); }
+    static Vc_INTRINSIC m256i Vc_CONST set1_epi32(int    a) { return _mm256_set1_epi32(a); }
     //static Vc_INTRINSIC m256i Vc_CONST _mm256_set1_epu32(unsigned int a) { return ::_mm256_set1_epu32(a); }
 
-#if defined(VC_GNU_ASM) && !defined(NVALGRIND)
-    static Vc_INTRINSIC m128i Vc_CONST _mm_setallone() { m128i r; __asm__("pcmpeqb %0,%0":"=x"(r)); return r; }
-#else
-    static Vc_INTRINSIC m128i Vc_CONST _mm_setallone() { m128i r = _mm_setzero_si128(); return _mm_cmpeq_epi8(r, r); }
-#endif
-    static Vc_INTRINSIC m128i Vc_CONST _mm_setallone_si128() { return _mm_setallone(); }
-    static Vc_INTRINSIC m128d Vc_CONST _mm_setallone_pd() { return _mm_castsi128_pd(_mm_setallone()); }
-    static Vc_INTRINSIC m128  Vc_CONST _mm_setallone_ps() { return _mm_castsi128_ps(_mm_setallone()); }
+    static Vc_INTRINSIC Vc_CONST m128i _mm_setallone_si128() { return _mm_load_si128(reinterpret_cast<const __m128i *>(Common::AllBitsSet)); }
+    static Vc_INTRINSIC Vc_CONST m128  _mm_setallone_ps() { return _mm_load_ps(reinterpret_cast<const float *>(Common::AllBitsSet)); }
+    static Vc_INTRINSIC Vc_CONST m128d _mm_setallone_pd() { return _mm_load_pd(reinterpret_cast<const double *>(Common::AllBitsSet)); }
+
+    static Vc_INTRINSIC Vc_CONST m256i setallone_si256() { return _mm256_castps_si256(_mm256_load_ps(reinterpret_cast<const float *>(Common::AllBitsSet))); }
+    static Vc_INTRINSIC Vc_CONST m256d setallone_pd() { return _mm256_load_pd(reinterpret_cast<const double *>(Common::AllBitsSet)); }
+    static Vc_INTRINSIC Vc_CONST m256  setallone_ps() { return _mm256_load_ps(reinterpret_cast<const float *>(Common::AllBitsSet)); }
 
     static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epi8 ()  { return _mm_set1_epi8(1); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epu8 ()  { return _mm_setone_epi8(); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epi16()  { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast<const float *>(c_general::one16))); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epu16()  { return _mm_setone_epi16(); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epi32()  { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast<const float *>(&_IndexesFromZero32[1]))); }
+    static Vc_INTRINSIC m128i Vc_CONST _mm_setone_epu32()  { return _mm_setone_epi32(); }
 
-#if defined(VC_GNU_ASM) && !defined(NVALGRIND)
-    static Vc_INTRINSIC m256 Vc_CONST _mm256_setallone() { __m256 r; __asm__("vcmpps $8,%0,%0,%0":"=x"(r)); return r; }
-#elif defined(VC_MSVC)
-    // MSVC puts temporaries of this value on the stack, but sometimes at misaligned addresses, try
-    // some other generator instead...
-    static Vc_INTRINSIC m256 Vc_CONST _mm256_setallone() { return _mm256_castsi256_ps(_mm256_set1_epi32(-1)); }
-#else
-    static Vc_INTRINSIC m256 Vc_CONST _mm256_setallone() { m256 r = _mm256_setzero_ps(); return _mm256_cmp_ps(r, r, _CMP_EQ_UQ); }
-#endif
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setallone_si256() { return _mm256_castps_si256(_mm256_setallone()); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_setallone_pd() { return _mm256_castps_pd(_mm256_setallone()); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_setallone_ps() { return _mm256_setallone(); }
-
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epi8 ()  { return _mm256_set1_epi8(1); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epu8 ()  { return _mm256_setone_epi8(); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epi16()  { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(c_general::one16))); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epu16()  { return _mm256_setone_epi16(); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epi32()  { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&_IndexesFromZero32[1]))); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setone_epu32()  { return _mm256_setone_epi32(); }
-
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_setone_ps()     { return _mm256_broadcast_ss(&c_general::oneFloat); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_setone_pd()     { return _mm256_broadcast_sd(&c_general::oneDouble); }
-
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_setabsmask_pd() { return _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::absMaskFloat[0])); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_setabsmask_ps() { return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::absMaskFloat[1])); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_setsignmask_pd(){ return _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::signMaskFloat[0])); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_setsignmask_ps(){ return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1])); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epi8 ()  { return _mm256_set1_epi8(1); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epu8 ()  { return setone_epi8(); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epi16()  { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(c_general::one16))); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epu16()  { return setone_epi16(); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epi32()  { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&_IndexesFromZero32[1]))); }
+    static Vc_INTRINSIC m256i Vc_CONST setone_epu32()  { return setone_epi32(); }
+
+    static Vc_INTRINSIC m256  Vc_CONST setone_ps()     { return _mm256_broadcast_ss(&c_general::oneFloat); }
+    static Vc_INTRINSIC m256d Vc_CONST setone_pd()     { return _mm256_broadcast_sd(&c_general::oneDouble); }
+
+    static Vc_INTRINSIC m256d Vc_CONST setabsmask_pd() { return _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::absMaskFloat[0])); }
+    static Vc_INTRINSIC m256  Vc_CONST setabsmask_ps() { return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::absMaskFloat[1])); }
+    static Vc_INTRINSIC m256d Vc_CONST setsignmask_pd(){ return _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::signMaskFloat[0])); }
+    static Vc_INTRINSIC m256  Vc_CONST setsignmask_ps(){ return _mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1])); }
+
+    static Vc_INTRINSIC m256  Vc_CONST set2power31_ps()    { return _mm256_broadcast_ss(&c_general::_2power31); }
+    static Vc_INTRINSIC m128  Vc_CONST _mm_set2power31_ps()    { return _mm_broadcast_ss(&c_general::_2power31); }
+    static Vc_INTRINSIC m256i Vc_CONST set2power31_epu32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
+    static Vc_INTRINSIC m128i Vc_CONST _mm_set2power31_epu32() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
 
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_set2power31_ps()    { return _mm256_broadcast_ss(&c_general::_2power31); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_set2power31_epu32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
-
-    //X         static Vc_INTRINSIC m256i Vc_CONST _mm256_setmin_epi8 () { return _mm256_slli_epi8 (_mm256_setallone_si256(),  7); }
+    static Vc_INTRINSIC m256i Vc_CONST setmin_epi8 () { return _mm256_set1_epi8(-0x80); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setmin_epi16() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast<const float *>(c_general::minShort))); }
     static Vc_INTRINSIC m128i Vc_CONST _mm_setmin_epi32() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setmin_epi16() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(c_general::minShort))); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_setmin_epi32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
+    static Vc_INTRINSIC m256i Vc_CONST setmin_epi16() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(c_general::minShort))); }
+    static Vc_INTRINSIC m256i Vc_CONST setmin_epi32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast<const float *>(&c_general::signMaskFloat[1]))); }
 
-#ifdef VC_REQUIRES_MACRO_FOR_IMMEDIATE_ARGUMENT
-#define _mm_extract_epu8 (x, i) (static_cast<unsigned char> (_mm_extract_epi8 ((x), (i))))
-#define _mm_extract_epu16(x, i) (static_cast<unsigned short>(_mm_extract_epi16((x), (i))))
-#define _mm_extract_epu32(x, i) (static_cast<unsigned int>  (_mm_extract_epi32((x), (i))))
+    template <int i>
+    static Vc_INTRINSIC Vc_CONST unsigned char extract_epu8(__m128i x)
+    {
+        return _mm_extract_epi8(x, i);
+    }
+    template <int i>
+    static Vc_INTRINSIC Vc_CONST unsigned short extract_epu16(__m128i x)
+    {
+        return _mm_extract_epi16(x, i);
+    }
+    template <int i>
+    static Vc_INTRINSIC Vc_CONST unsigned int extract_epu32(__m128i x)
+    {
+        return _mm_extract_epi32(x, i);
+    }
+
+    template <int offset> Vc_INTRINSIC __m256  insert128(__m256  a, __m128  b) { return _mm256_insertf128_ps(a, b, offset); }
+    template <int offset> Vc_INTRINSIC __m256d insert128(__m256d a, __m128d b) { return _mm256_insertf128_pd(a, b, offset); }
+    template <int offset> Vc_INTRINSIC __m256i insert128(__m256i a, __m128i b) {
+#ifdef Vc_IMPL_AVX2
+        return _mm256_inserti128_si256(a, b, offset);
 #else
-    static Vc_INTRINSIC unsigned char Vc_CONST _mm_extract_epu8(param128i x, const int i) { return _mm_extract_epi8(x, i); }
-    static Vc_INTRINSIC unsigned short Vc_CONST _mm_extract_epu16(param128i x, const int i) { return _mm_extract_epi16(x, i); }
-    static Vc_INTRINSIC unsigned int Vc_CONST _mm_extract_epu32(param128i x, const int i) { return _mm_extract_epi32(x, i); }
+        return _mm256_insertf128_si256(a, b, offset);
 #endif
+    }
 
-    /////////////////////// COMPARE OPS ///////////////////////
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpeq_pd   (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_EQ_OQ); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpneq_pd  (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmplt_pd   (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_LT_OS); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpnlt_pd  (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_NLT_US); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmple_pd   (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_LE_OS); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpnle_pd  (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_NLE_US); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpord_pd  (param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_ORD_Q); }
-    static Vc_INTRINSIC m256d Vc_CONST _mm256_cmpunord_pd(param256d a, param256d b) { return _mm256_cmp_pd(a, b, _CMP_UNORD_Q); }
-
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpeq_ps   (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_EQ_OQ); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpneq_ps  (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmplt_ps   (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_LT_OS); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpnlt_ps  (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_NLT_US); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpge_ps   (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_NLT_US); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmple_ps   (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_LE_OS); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpnle_ps  (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_NLE_US); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpgt_ps   (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_NLE_US); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpord_ps  (param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_ORD_Q); }
-    static Vc_INTRINSIC m256  Vc_CONST _mm256_cmpunord_ps(param256  a, param256  b) { return _mm256_cmp_ps(a, b, _CMP_UNORD_Q); }
+    template <int offset> Vc_INTRINSIC __m128  extract128(__m256  a) { return _mm256_extractf128_ps(a, offset); }
+    template <int offset> Vc_INTRINSIC __m128d extract128(__m256d a) { return _mm256_extractf128_pd(a, offset); }
+    template <int offset> Vc_INTRINSIC __m128i extract128(__m256i a) {
+#ifdef Vc_IMPL_AVX2
+        return _mm256_extracti128_si256(a, offset);
+#else
+        return _mm256_extractf128_si256(a, offset);
+#endif
+    }
 
-    static Vc_INTRINSIC m128i _mm_cmplt_epu16(param128i a, param128i b) {
+    /////////////////////// COMPARE OPS ///////////////////////
+    static Vc_INTRINSIC m256d Vc_CONST cmpeq_pd   (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_EQ_OQ); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpneq_pd  (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ); }
+    static Vc_INTRINSIC m256d Vc_CONST cmplt_pd   (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_LT_OS); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpnlt_pd  (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLT_US); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpge_pd   (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLT_US); }
+    static Vc_INTRINSIC m256d Vc_CONST cmple_pd   (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_LE_OS); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpnle_pd  (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLE_US); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpgt_pd   (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLE_US); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpord_pd  (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_ORD_Q); }
+    static Vc_INTRINSIC m256d Vc_CONST cmpunord_pd(__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_UNORD_Q); }
+
+    static Vc_INTRINSIC m256  Vc_CONST cmpeq_ps   (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_EQ_OQ); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpneq_ps  (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ); }
+    static Vc_INTRINSIC m256  Vc_CONST cmplt_ps   (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_LT_OS); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpnlt_ps  (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_NLT_US); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpge_ps   (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_NLT_US); }
+    static Vc_INTRINSIC m256  Vc_CONST cmple_ps   (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_LE_OS); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpnle_ps  (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_NLE_US); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpgt_ps   (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_NLE_US); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpord_ps  (__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_ORD_Q); }
+    static Vc_INTRINSIC m256  Vc_CONST cmpunord_ps(__m256  a, __m256  b) { return _mm256_cmp_ps(a, b, _CMP_UNORD_Q); }
+
+#if defined(Vc_IMPL_XOP)
+    static Vc_INTRINSIC m128i cmplt_epu16(__m128i a, __m128i b) {
+        return _mm_comlt_epu16(a, b);
+    }
+    static Vc_INTRINSIC m128i cmpgt_epu16(__m128i a, __m128i b) {
+        return _mm_comgt_epu16(a, b);
+    }
+#else
+    static Vc_INTRINSIC m128i cmplt_epu16(__m128i a, __m128i b) {
         return _mm_cmplt_epi16(_mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16()));
     }
-    static Vc_INTRINSIC m128i _mm_cmpgt_epu16(param128i a, param128i b) {
+    static Vc_INTRINSIC m128i cmpgt_epu16(__m128i a, __m128i b) {
         return _mm_cmpgt_epi16(_mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16()));
     }
-
-    /////////////////////// INTEGER OPS ///////////////////////
-#define AVX_TO_SSE_2(name) \
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_##name(param256i a0, param256i b0) { \
-        m128i a1 = _mm256_extractf128_si256(a0, 1); \
-        m128i b1 = _mm256_extractf128_si256(b0, 1); \
-        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0)); \
-        m128i r1 = _mm_##name(a1, b1); \
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1); \
-    }
-#define AVX_TO_SSE_2_si128_si256(name) \
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_##name##_si256(param256i a0, param256i b0) { \
-        m128i a1 = _mm256_extractf128_si256(a0, 1); \
-        m128i b1 = _mm256_extractf128_si256(b0, 1); \
-        m128i r0 = _mm_##name##_si128(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0)); \
-        m128i r1 = _mm_##name##_si128(a1, b1); \
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1); \
-    }
-#define AVX_TO_SSE_1(name) \
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_##name(param256i a0) { \
-        m128i a1 = _mm256_extractf128_si256(a0, 1); \
-        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0)); \
-        m128i r1 = _mm_##name(a1); \
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1); \
-    }
-#define AVX_TO_SSE_1i(name) \
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_##name(param256i a0, const int i) { \
-        m128i a1 = _mm256_extractf128_si256(a0, 1); \
-        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), i); \
-        m128i r1 = _mm_##name(a1, i); \
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1); \
-    }
-
-    AVX_TO_SSE_2(cmplt_epi8)
-    AVX_TO_SSE_2(cmplt_epi16)
-    AVX_TO_SSE_2(cmplt_epi32)
-    AVX_TO_SSE_2(cmpeq_epi8)
-    AVX_TO_SSE_2(cmpeq_epi16)
-    AVX_TO_SSE_2(cmpeq_epi32)
-    AVX_TO_SSE_2(cmpgt_epi8)
-    AVX_TO_SSE_2(cmpgt_epi16)
-    AVX_TO_SSE_2(cmpgt_epi32)
-
-    // This code is AVX only (without AVX2). We never asked for AVX2 intrinsics. So go away... :)
-#if defined _mm256_srli_si256
-#undef _mm256_srli_si256
-#endif
-#if defined _mm256_slli_si256
-#undef _mm256_slli_si256
 #endif
-#if defined _mm256_blend_epi16
-#undef _mm256_blend_epi16
+
+#ifdef Vc_IMPL_AVX2
+    template <int shift> Vc_INTRINSIC Vc_CONST m256i alignr(__m256i s1, __m256i s2)
+    {
+        return _mm256_alignr_epi8(s1, s2, shift);
+    }
+#else
+    template <int shift> Vc_INTRINSIC Vc_CONST m256i alignr(__m256i s1, __m256i s2)
+    {
+        return insert128<1>(
+            _mm256_castsi128_si256(_mm_alignr_epi8(_mm256_castsi256_si128(s1),
+                                                   _mm256_castsi256_si128(s2), shift)),
+            _mm_alignr_epi8(extract128<1>(s1), extract128<1>(s2), shift));
+    }
 #endif
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_srli_si256(param256i a0, const int i) {
-        const m128i vLo = _mm256_castsi256_si128(a0);
-        const m128i vHi = _mm256_extractf128_si256(a0, 1);
-        switch (i) {
-        case  0: return a0;
-        case  1: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  1)), _mm_srli_si128(vHi,  1), 1);
-        case  2: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  2)), _mm_srli_si128(vHi,  2), 1);
-        case  3: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  3)), _mm_srli_si128(vHi,  3), 1);
-        case  4: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  4)), _mm_srli_si128(vHi,  4), 1);
-        case  5: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  5)), _mm_srli_si128(vHi,  5), 1);
-        case  6: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  6)), _mm_srli_si128(vHi,  6), 1);
-        case  7: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  7)), _mm_srli_si128(vHi,  7), 1);
-        case  8: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  8)), _mm_srli_si128(vHi,  8), 1);
-        case  9: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo,  9)), _mm_srli_si128(vHi,  9), 1);
-        case 10: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 10)), _mm_srli_si128(vHi, 10), 1);
-        case 11: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 11)), _mm_srli_si128(vHi, 11), 1);
-        case 12: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 12)), _mm_srli_si128(vHi, 12), 1);
-        case 13: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 13)), _mm_srli_si128(vHi, 13), 1);
-        case 14: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 14)), _mm_srli_si128(vHi, 14), 1);
-        case 15: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_alignr_epi8(vHi, vLo, 15)), _mm_srli_si128(vHi, 15), 1);
-        case 16: return _mm256_permute2f128_si256(a0, a0, 0x81);
-        case 17: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  1)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  1)), 0x80);
-        case 18: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  2)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  2)), 0x80);
-        case 19: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  3)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  3)), 0x80);
-        case 20: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  4)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  4)), 0x80);
-        case 21: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  5)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  5)), 0x80);
-        case 22: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  6)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  6)), 0x80);
-        case 23: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  7)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  7)), 0x80);
-        case 24: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  8)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  8)), 0x80);
-        case 25: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi,  9)), _mm256_castsi128_si256(_mm_srli_si128(vHi,  9)), 0x80);
-        case 26: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 10)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 10)), 0x80);
-        case 27: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 11)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 11)), 0x80);
-        case 28: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 12)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 12)), 0x80);
-        case 29: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 13)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 13)), 0x80);
-        case 30: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 14)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 14)), 0x80);
-        case 31: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_srli_si128(vHi, 15)), _mm256_castsi128_si256(_mm_srli_si128(vHi, 15)), 0x80);
-        }
-        return _mm256_setzero_si256();
-    }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_slli_si256(param256i a0, const int i) {
-        const m128i vLo = _mm256_castsi256_si128(a0);
-        const m128i vHi = _mm256_extractf128_si256(a0, 1);
-        switch (i) {
-        case  0: return a0;
-        case  1: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  1)), _mm_alignr_epi8(vHi, vLo, 15), 1);
-        case  2: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  2)), _mm_alignr_epi8(vHi, vLo, 14), 1);
-        case  3: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  3)), _mm_alignr_epi8(vHi, vLo, 13), 1);
-        case  4: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  4)), _mm_alignr_epi8(vHi, vLo, 12), 1);
-        case  5: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  5)), _mm_alignr_epi8(vHi, vLo, 11), 1);
-        case  6: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  6)), _mm_alignr_epi8(vHi, vLo, 10), 1);
-        case  7: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  7)), _mm_alignr_epi8(vHi, vLo,  9), 1);
-        case  8: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  8)), _mm_alignr_epi8(vHi, vLo,  8), 1);
-        case  9: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  9)), _mm_alignr_epi8(vHi, vLo,  7), 1);
-        case 10: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 10)), _mm_alignr_epi8(vHi, vLo,  6), 1);
-        case 11: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 11)), _mm_alignr_epi8(vHi, vLo,  5), 1);
-        case 12: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 12)), _mm_alignr_epi8(vHi, vLo,  4), 1);
-        case 13: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 13)), _mm_alignr_epi8(vHi, vLo,  3), 1);
-        case 14: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 14)), _mm_alignr_epi8(vHi, vLo,  2), 1);
-        case 15: return _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 15)), _mm_alignr_epi8(vHi, vLo,  1), 1);
-        case 16: return _mm256_permute2f128_si256(a0, a0, 0x8);
-        case 17: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  1)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  1)), 0x8);
-        case 18: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  2)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  2)), 0x8);
-        case 19: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  3)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  3)), 0x8);
-        case 20: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  4)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  4)), 0x8);
-        case 21: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  5)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  5)), 0x8);
-        case 22: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  6)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  6)), 0x8);
-        case 23: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  7)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  7)), 0x8);
-        case 24: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  8)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  8)), 0x8);
-        case 25: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo,  9)), _mm256_castsi128_si256(_mm_slli_si128(vLo,  9)), 0x8);
-        case 26: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 10)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 10)), 0x8);
-        case 27: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 11)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 11)), 0x8);
-        case 28: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 12)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 12)), 0x8);
-        case 29: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 13)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 13)), 0x8);
-        case 30: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 14)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 14)), 0x8);
-        case 31: return _mm256_permute2f128_si256(_mm256_castsi128_si256(_mm_slli_si128(vLo, 15)), _mm256_castsi128_si256(_mm_slli_si128(vLo, 15)), 0x8);
-        }
-        return _mm256_setzero_si256();
+
+#ifdef Vc_IMPL_AVX2
+#define Vc_AVX_TO_SSE_2_NEW(name)                                                        \
+    Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m256i b0)                             \
+    {                                                                                    \
+        return _mm256_##name(a0, b0);                                                    \
+    }
+#define Vc_AVX_TO_SSE_256_128(name)                                                      \
+    Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m128i b0)                             \
+    {                                                                                    \
+        return _mm256_##name(a0, b0);                                                    \
+    }
+#define Vc_AVX_TO_SSE_1i(name)                                                           \
+    template <int i> Vc_INTRINSIC Vc_CONST m256i name(__m256i a0)                        \
+    {                                                                                    \
+        return _mm256_##name(a0, i);                                                     \
+    }
+#define Vc_AVX_TO_SSE_1(name)                                                            \
+    Vc_INTRINSIC Vc_CONST __m256i name(__m256i a0) { return _mm256_##name(a0); }
+#define Vc_AVX_TO_SSE_1_128(name, shift__)                                               \
+    Vc_INTRINSIC Vc_CONST __m256i name(__m128i a0) { return _mm256_##name(a0); }
+#else
+/**\internal
+ * Defines the function \p name, which takes to __m256i arguments and calls `_mm_##name` on the low
+ * and high 128 bit halfs of the arguments.
+ *
+ * In case the AVX2 intrinsics are enabled, the arguments are directly passed to a single
+ * `_mm256_##name` call.
+ */
+#define Vc_AVX_TO_SSE_1(name)                                                            \
+    Vc_INTRINSIC Vc_CONST __m256i name(__m256i a0)                                       \
+    {                                                                                    \
+        __m128i a1 = extract128<1>(a0);                                                  \
+        __m128i r0 = _mm_##name(_mm256_castsi256_si128(a0));                             \
+        __m128i r1 = _mm_##name(a1);                                                     \
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);                             \
+    }
+#define Vc_AVX_TO_SSE_1_128(name, shift__)                                               \
+    Vc_INTRINSIC Vc_CONST __m256i name(__m128i a0)                                       \
+    {                                                                                    \
+        __m128i r0 = _mm_##name(a0);                                                     \
+        __m128i r1 = _mm_##name(_mm_srli_si128(a0, shift__));                            \
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);                             \
+    }
+#define Vc_AVX_TO_SSE_2_NEW(name)                                                        \
+    Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m256i b0)                             \
+    {                                                                                    \
+        m128i a1 = extract128<1>(a0);                                                    \
+        m128i b1 = extract128<1>(b0);                                                    \
+        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0));   \
+        m128i r1 = _mm_##name(a1, b1);                                                   \
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);                             \
+    }
+#define Vc_AVX_TO_SSE_256_128(name)                                                      \
+    Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m128i b0)                             \
+    {                                                                                    \
+        m128i a1 = extract128<1>(a0);                                                    \
+        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), b0);                           \
+        m128i r1 = _mm_##name(a1, b0);                                                   \
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);                             \
+    }
+#define Vc_AVX_TO_SSE_1i(name)                                                           \
+    template <int i> Vc_INTRINSIC Vc_CONST m256i name(__m256i a0)                        \
+    {                                                                                    \
+        m128i a1 = extract128<1>(a0);                                                    \
+        m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), i);                            \
+        m128i r1 = _mm_##name(a1, i);                                                    \
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);                             \
+    }
+#endif
+    Vc_INTRINSIC Vc_CONST __m128i sll_epi16(__m128i a, __m128i b) { return _mm_sll_epi16(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i sll_epi32(__m128i a, __m128i b) { return _mm_sll_epi32(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i sll_epi64(__m128i a, __m128i b) { return _mm_sll_epi64(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i srl_epi16(__m128i a, __m128i b) { return _mm_srl_epi16(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i srl_epi32(__m128i a, __m128i b) { return _mm_srl_epi32(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i srl_epi64(__m128i a, __m128i b) { return _mm_srl_epi64(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i sra_epi16(__m128i a, __m128i b) { return _mm_sra_epi16(a, b); }
+    Vc_INTRINSIC Vc_CONST __m128i sra_epi32(__m128i a, __m128i b) { return _mm_sra_epi32(a, b); }
+
+    Vc_AVX_TO_SSE_1i(slli_epi16)
+    Vc_AVX_TO_SSE_1i(slli_epi32)
+    Vc_AVX_TO_SSE_1i(slli_epi64)
+    Vc_AVX_TO_SSE_1i(srai_epi16)
+    Vc_AVX_TO_SSE_1i(srai_epi32)
+    Vc_AVX_TO_SSE_1i(srli_epi16)
+    Vc_AVX_TO_SSE_1i(srli_epi32)
+    Vc_AVX_TO_SSE_1i(srli_epi64)
+
+    Vc_AVX_TO_SSE_256_128(sll_epi16)
+    Vc_AVX_TO_SSE_256_128(sll_epi32)
+    Vc_AVX_TO_SSE_256_128(sll_epi64)
+    Vc_AVX_TO_SSE_256_128(srl_epi16)
+    Vc_AVX_TO_SSE_256_128(srl_epi32)
+    Vc_AVX_TO_SSE_256_128(srl_epi64)
+    Vc_AVX_TO_SSE_256_128(sra_epi16)
+    Vc_AVX_TO_SSE_256_128(sra_epi32)
+
+    Vc_AVX_TO_SSE_2_NEW(cmpeq_epi8)
+    Vc_AVX_TO_SSE_2_NEW(cmpeq_epi16)
+    Vc_AVX_TO_SSE_2_NEW(cmpeq_epi32)
+    Vc_AVX_TO_SSE_2_NEW(cmpeq_epi64)
+    Vc_AVX_TO_SSE_2_NEW(cmpgt_epi8)
+    Vc_AVX_TO_SSE_2_NEW(cmpgt_epi16)
+    Vc_AVX_TO_SSE_2_NEW(cmpgt_epi32)
+    Vc_AVX_TO_SSE_2_NEW(cmpgt_epi64)
+    Vc_AVX_TO_SSE_2_NEW(packs_epi16)
+    Vc_AVX_TO_SSE_2_NEW(packs_epi32)
+    Vc_AVX_TO_SSE_2_NEW(packus_epi16)
+    Vc_AVX_TO_SSE_2_NEW(unpackhi_epi8)
+    Vc_AVX_TO_SSE_2_NEW(unpackhi_epi16)
+    Vc_AVX_TO_SSE_2_NEW(unpackhi_epi32)
+    Vc_AVX_TO_SSE_2_NEW(unpackhi_epi64)
+    Vc_AVX_TO_SSE_2_NEW(unpacklo_epi8)
+    Vc_AVX_TO_SSE_2_NEW(unpacklo_epi16)
+    Vc_AVX_TO_SSE_2_NEW(unpacklo_epi32)
+    Vc_AVX_TO_SSE_2_NEW(unpacklo_epi64)
+    Vc_AVX_TO_SSE_2_NEW(add_epi8)
+    Vc_AVX_TO_SSE_2_NEW(add_epi16)
+    Vc_AVX_TO_SSE_2_NEW(add_epi32)
+    Vc_AVX_TO_SSE_2_NEW(add_epi64)
+    Vc_AVX_TO_SSE_2_NEW(adds_epi8)
+    Vc_AVX_TO_SSE_2_NEW(adds_epi16)
+    Vc_AVX_TO_SSE_2_NEW(adds_epu8)
+    Vc_AVX_TO_SSE_2_NEW(adds_epu16)
+    Vc_AVX_TO_SSE_2_NEW(sub_epi8)
+    Vc_AVX_TO_SSE_2_NEW(sub_epi16)
+    Vc_AVX_TO_SSE_2_NEW(sub_epi32)
+    Vc_AVX_TO_SSE_2_NEW(sub_epi64)
+    Vc_AVX_TO_SSE_2_NEW(subs_epi8)
+    Vc_AVX_TO_SSE_2_NEW(subs_epi16)
+    Vc_AVX_TO_SSE_2_NEW(subs_epu8)
+    Vc_AVX_TO_SSE_2_NEW(subs_epu16)
+    Vc_AVX_TO_SSE_2_NEW(madd_epi16)
+    Vc_AVX_TO_SSE_2_NEW(mulhi_epi16)
+    Vc_AVX_TO_SSE_2_NEW(mullo_epi16)
+    Vc_AVX_TO_SSE_2_NEW(mul_epu32)
+    Vc_AVX_TO_SSE_2_NEW(max_epi16)
+    Vc_AVX_TO_SSE_2_NEW(max_epu8)
+    Vc_AVX_TO_SSE_2_NEW(min_epi16)
+    Vc_AVX_TO_SSE_2_NEW(min_epu8)
+    Vc_AVX_TO_SSE_2_NEW(mulhi_epu16)
+    // shufflehi_epi16
+    // shufflelo_epi16 (__m128i __A, const int __mask)
+    // shuffle_epi32 (__m128i __A, const int __mask)
+    // maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
+    Vc_AVX_TO_SSE_2_NEW(avg_epu8)
+    Vc_AVX_TO_SSE_2_NEW(avg_epu16)
+    Vc_AVX_TO_SSE_2_NEW(sad_epu8)
+    // stream_si32 (int *__A, int __B)
+    // stream_si128 (__m128i *__A, __m128i __B)
+    // cvtsi32_si128 (int __A)
+    // cvtsi64_si128 (long long __A)
+    // cvtsi64x_si128 (long long __A)
+    Vc_AVX_TO_SSE_2_NEW(hadd_epi16)
+    Vc_AVX_TO_SSE_2_NEW(hadd_epi32)
+    Vc_AVX_TO_SSE_2_NEW(hadds_epi16)
+    Vc_AVX_TO_SSE_2_NEW(hsub_epi16)
+    Vc_AVX_TO_SSE_2_NEW(hsub_epi32)
+    Vc_AVX_TO_SSE_2_NEW(hsubs_epi16)
+    Vc_AVX_TO_SSE_2_NEW(maddubs_epi16)
+    Vc_AVX_TO_SSE_2_NEW(mulhrs_epi16)
+    Vc_AVX_TO_SSE_2_NEW(shuffle_epi8)
+    Vc_AVX_TO_SSE_2_NEW(sign_epi8)
+    Vc_AVX_TO_SSE_2_NEW(sign_epi16)
+    Vc_AVX_TO_SSE_2_NEW(sign_epi32)
+    Vc_AVX_TO_SSE_2_NEW(min_epi8)
+    Vc_AVX_TO_SSE_2_NEW(max_epi8)
+    Vc_AVX_TO_SSE_2_NEW(min_epu16)
+    Vc_AVX_TO_SSE_2_NEW(max_epu16)
+    Vc_AVX_TO_SSE_2_NEW(min_epi32)
+    Vc_AVX_TO_SSE_2_NEW(max_epi32)
+    Vc_AVX_TO_SSE_2_NEW(min_epu32)
+    Vc_AVX_TO_SSE_2_NEW(max_epu32)
+    Vc_AVX_TO_SSE_2_NEW(mullo_epi32)
+    Vc_AVX_TO_SSE_2_NEW(mul_epi32)
+
+    Vc_AVX_TO_SSE_1(abs_epi8)
+    Vc_AVX_TO_SSE_1(abs_epi16)
+    Vc_AVX_TO_SSE_1(abs_epi32)
+    Vc_AVX_TO_SSE_1_128(cvtepi8_epi16, 8)
+    Vc_AVX_TO_SSE_1_128(cvtepi8_epi32, 4)
+    Vc_AVX_TO_SSE_1_128(cvtepi8_epi64, 2)
+    Vc_AVX_TO_SSE_1_128(cvtepi16_epi32, 8)
+    Vc_AVX_TO_SSE_1_128(cvtepi16_epi64, 4)
+    Vc_AVX_TO_SSE_1_128(cvtepi32_epi64, 8)
+    Vc_AVX_TO_SSE_1_128(cvtepu8_epi16, 8)
+    Vc_AVX_TO_SSE_1_128(cvtepu8_epi32, 4)
+    Vc_AVX_TO_SSE_1_128(cvtepu8_epi64, 2)
+    Vc_AVX_TO_SSE_1_128(cvtepu16_epi32, 8)
+    Vc_AVX_TO_SSE_1_128(cvtepu16_epi64, 4)
+    Vc_AVX_TO_SSE_1_128(cvtepu32_epi64, 8)
+
+    Vc_AVX_TO_SSE_2_NEW(packus_epi32)
+
+#ifndef Vc_IMPL_AVX2
+
+/////////////////////////////////////////////////////////////////////////
+// implementation of the intrinsics missing in AVX
+/////////////////////////////////////////////////////////////////////////
+
+    template <int i> Vc_INTRINSIC Vc_CONST __m256i srli_si256(__m256i a0) {
+        const __m128i vLo = _mm256_castsi256_si128(a0);
+        const __m128i vHi = extract128<1>(a0);
+        return insert128<1>(_mm256_castsi128_si256(_mm_srli_si128(vLo,  i)), _mm_srli_si128(vHi, i));
+    }
+    template <int i> Vc_INTRINSIC Vc_CONST __m256i slli_si256(__m256i a0) {
+        const __m128i vLo = _mm256_castsi256_si128(a0);
+        const __m128i vHi = extract128<1>(a0);
+        return insert128<1>(_mm256_castsi128_si256(_mm_slli_si128(vLo,  i)), _mm_slli_si128(vHi, i));
     }
 
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_and_si256(param256i x, param256i y) {
+    static Vc_INTRINSIC m256i Vc_CONST and_si256(__m256i x, __m256i y) {
         return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));
     }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_andnot_si256(param256i x, param256i y) {
+    static Vc_INTRINSIC m256i Vc_CONST andnot_si256(__m256i x, __m256i y) {
         return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));
     }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_or_si256(param256i x, param256i y) {
+    static Vc_INTRINSIC m256i Vc_CONST or_si256(__m256i x, __m256i y) {
         return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));
     }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_xor_si256(param256i x, param256i y) {
+    static Vc_INTRINSIC m256i Vc_CONST xor_si256(__m256i x, __m256i y) {
         return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));
     }
 
-    AVX_TO_SSE_2(packs_epi16)
-    AVX_TO_SSE_2(packs_epi32)
-    AVX_TO_SSE_2(packus_epi16)
-    AVX_TO_SSE_2(unpackhi_epi8)
-    AVX_TO_SSE_2(unpackhi_epi16)
-    AVX_TO_SSE_2(unpackhi_epi32)
-    AVX_TO_SSE_2(unpackhi_epi64)
-    AVX_TO_SSE_2(unpacklo_epi8)
-    AVX_TO_SSE_2(unpacklo_epi16)
-    AVX_TO_SSE_2(unpacklo_epi32)
-    AVX_TO_SSE_2(unpacklo_epi64)
-    AVX_TO_SSE_2(add_epi8)
-    AVX_TO_SSE_2(add_epi16)
-    AVX_TO_SSE_2(add_epi32)
-    AVX_TO_SSE_2(add_epi64)
-    AVX_TO_SSE_2(adds_epi8)
-    AVX_TO_SSE_2(adds_epi16)
-    AVX_TO_SSE_2(adds_epu8)
-    AVX_TO_SSE_2(adds_epu16)
-    AVX_TO_SSE_2(sub_epi8)
-    AVX_TO_SSE_2(sub_epi16)
-    AVX_TO_SSE_2(sub_epi32)
-    AVX_TO_SSE_2(sub_epi64)
-    AVX_TO_SSE_2(subs_epi8)
-    AVX_TO_SSE_2(subs_epi16)
-    AVX_TO_SSE_2(subs_epu8)
-    AVX_TO_SSE_2(subs_epu16)
-    AVX_TO_SSE_2(madd_epi16)
-    AVX_TO_SSE_2(mulhi_epi16)
-    AVX_TO_SSE_2(mullo_epi16)
-    AVX_TO_SSE_2(mul_epu32)
-    AVX_TO_SSE_1i(slli_epi16)
-    AVX_TO_SSE_1i(slli_epi32)
-    AVX_TO_SSE_1i(slli_epi64)
-    AVX_TO_SSE_1i(srai_epi16)
-    AVX_TO_SSE_1i(srai_epi32)
-    AVX_TO_SSE_1i(srli_epi16)
-    AVX_TO_SSE_1i(srli_epi32)
-    AVX_TO_SSE_1i(srli_epi64)
-    AVX_TO_SSE_2(sll_epi16)
-    AVX_TO_SSE_2(sll_epi32)
-    AVX_TO_SSE_2(sll_epi64)
-    AVX_TO_SSE_2(sra_epi16)
-    AVX_TO_SSE_2(sra_epi32)
-    AVX_TO_SSE_2(srl_epi16)
-    AVX_TO_SSE_2(srl_epi32)
-    AVX_TO_SSE_2(srl_epi64)
-    AVX_TO_SSE_2(max_epi16)
-    AVX_TO_SSE_2(max_epu8)
-    AVX_TO_SSE_2(min_epi16)
-    AVX_TO_SSE_2(min_epu8)
-    Vc_INTRINSIC int Vc_CONST _mm256_movemask_epi8(param256i a0)
+    Vc_INTRINSIC Vc_CONST int movemask_epi8(__m256i a0)
     {
-        m128i a1 = _mm256_extractf128_si256(a0, 1);
+        m128i a1 = extract128<1>(a0);
         return (_mm_movemask_epi8(a1) << 16) | _mm_movemask_epi8(_mm256_castsi256_si128(a0));
     }
-    AVX_TO_SSE_2(mulhi_epu16)
-    // shufflehi_epi16
-    // shufflelo_epi16 (param128i __A, const int __mask)
-    // shuffle_epi32 (param128i __A, const int __mask)
-    // maskmoveu_si128 (param128i __A, param128i __B, char *__C)
-    AVX_TO_SSE_2(avg_epu8)
-    AVX_TO_SSE_2(avg_epu16)
-    AVX_TO_SSE_2(sad_epu8)
-    // stream_si32 (int *__A, int __B)
-    // stream_si128 (param128i *__A, param128i __B)
-    // cvtsi32_si128 (int __A)
-    // cvtsi64_si128 (long long __A)
-    // cvtsi64x_si128 (long long __A)
-    AVX_TO_SSE_2(hadd_epi16)
-    AVX_TO_SSE_2(hadd_epi32)
-    AVX_TO_SSE_2(hadds_epi16)
-    AVX_TO_SSE_2(hsub_epi16)
-    AVX_TO_SSE_2(hsub_epi32)
-    AVX_TO_SSE_2(hsubs_epi16)
-    AVX_TO_SSE_2(maddubs_epi16)
-    AVX_TO_SSE_2(mulhrs_epi16)
-    AVX_TO_SSE_2(shuffle_epi8)
-    AVX_TO_SSE_2(sign_epi8)
-    AVX_TO_SSE_2(sign_epi16)
-    AVX_TO_SSE_2(sign_epi32)
-    // alignr_epi8(param128i __X, param128i __Y, const int __N)
-    AVX_TO_SSE_1(abs_epi8)
-    AVX_TO_SSE_1(abs_epi16)
-    AVX_TO_SSE_1(abs_epi32)
-#if !defined(VC_REQUIRES_MACRO_FOR_IMMEDIATE_ARGUMENT)
-    m256i Vc_INTRINSIC Vc_CONST _mm256_blend_epi16(param256i a0, param256i b0, const int m) {
-        m128i a1 = _mm256_extractf128_si256(a0, 1);
-        m128i b1 = _mm256_extractf128_si256(b0, 1);
+    template <int m> Vc_INTRINSIC Vc_CONST m256i blend_epi16(param256i a0, param256i b0)
+    {
+        m128i a1 = extract128<1>(a0);
+        m128i b1 = extract128<1>(b0);
         m128i r0 = _mm_blend_epi16(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0), m & 0xff);
         m128i r1 = _mm_blend_epi16(a1, b1, m >> 8);
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1);
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);
     }
-#else
-#   define _mm256_blend_epi16(a0, b0, m) \
-    _mm256_insertf128_si256( \
-            _mm256_castsi128_si256( \
-                _mm_blend_epi16( \
-                    _mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0), m & 0xff)), \
-            _mm_blend_epi16(_mm256_extractf128_si256(a0, 1), _mm256_extractf128_si256(b0, 1), m >> 8);, 1)
-#endif
-    Vc_INTRINSIC m256i Vc_CONST _mm256_blendv_epi8(param256i a0, param256i b0, param256i m0) {
-        m128i a1 = _mm256_extractf128_si256(a0, 1);
-        m128i b1 = _mm256_extractf128_si256(b0, 1);
-        m128i m1 = _mm256_extractf128_si256(m0, 1);
+    Vc_INTRINSIC Vc_CONST m256i blendv_epi8(param256i a0, param256i b0, param256i m0) {
+        m128i a1 = extract128<1>(a0);
+        m128i b1 = extract128<1>(b0);
+        m128i m1 = extract128<1>(m0);
         m128i r0 = _mm_blendv_epi8(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0), _mm256_castsi256_si128(m0));
         m128i r1 = _mm_blendv_epi8(a1, b1, m1);
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(r0), r1, 1);
+        return insert128<1>(_mm256_castsi128_si256(r0), r1);
     }
-    AVX_TO_SSE_2(cmpeq_epi64)
-    AVX_TO_SSE_2(min_epi8)
-    AVX_TO_SSE_2(max_epi8)
-    AVX_TO_SSE_2(min_epu16)
-    AVX_TO_SSE_2(max_epu16)
-    AVX_TO_SSE_2(min_epi32)
-    AVX_TO_SSE_2(max_epi32)
-    AVX_TO_SSE_2(min_epu32)
-    AVX_TO_SSE_2(max_epu32)
-    AVX_TO_SSE_2(mullo_epi32)
-    AVX_TO_SSE_2(mul_epi32)
-#if !defined(VC_CLANG) || VC_CLANG > 0x30100
-    // clang is missing _mm_minpos_epu16 from smmintrin.h
-    // http://llvm.org/bugs/show_bug.cgi?id=12399
-    AVX_TO_SSE_1(minpos_epu16)
-#endif
-    AVX_TO_SSE_1(cvtepi8_epi32)
-    AVX_TO_SSE_1(cvtepi16_epi32)
-    AVX_TO_SSE_1(cvtepi8_epi64)
-    AVX_TO_SSE_1(cvtepi32_epi64)
-    AVX_TO_SSE_1(cvtepi16_epi64)
-    AVX_TO_SSE_1(cvtepi8_epi16)
-    AVX_TO_SSE_1(cvtepu8_epi32)
-    AVX_TO_SSE_1(cvtepu16_epi32)
-    AVX_TO_SSE_1(cvtepu8_epi64)
-    AVX_TO_SSE_1(cvtepu32_epi64)
-    AVX_TO_SSE_1(cvtepu16_epi64)
-    AVX_TO_SSE_1(cvtepu8_epi16)
-    AVX_TO_SSE_2(packus_epi32)
-    // mpsadbw_epu8 (param128i __X, param128i __Y, const int __M)
-    // stream_load_si128 (param128i *__X)
-    AVX_TO_SSE_2(cmpgt_epi64)
-
-//X     static Vc_INTRINSIC m256i _mm256_cmplt_epu8 (param256i a, param256i b) { return _mm256_cmplt_epi8 (
-//X             _mm256_xor_si256(a, _mm256_setmin_epi8 ()), _mm256_xor_si256(b, _mm256_setmin_epi8 ())); }
-//X     static Vc_INTRINSIC m256i _mm256_cmpgt_epu8 (param256i a, param256i b) { return _mm256_cmpgt_epi8 (
-//X             _mm256_xor_si256(a, _mm256_setmin_epi8 ()), _mm256_xor_si256(b, _mm256_setmin_epi8 ())); }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_cmplt_epu32(param256i _a, param256i _b) {
-        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(_mm256_setmin_epi32())));
-        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(_mm256_setmin_epi32())));
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(
-                    _mm_cmplt_epi32(_mm256_castsi256_si128(a), _mm256_castsi256_si128(b))),
-                _mm_cmplt_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1)), 1);
-    }
-    static Vc_INTRINSIC m256i Vc_CONST _mm256_cmpgt_epu32(param256i _a, param256i _b) {
-        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(_mm256_setmin_epi32())));
-        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(_mm256_setmin_epi32())));
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(
-                    _mm_cmpgt_epi32(_mm256_castsi256_si128(a), _mm256_castsi256_si128(b))),
-                _mm_cmpgt_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1)), 1);
-    }
-
-        static Vc_INTRINSIC void _mm256_maskstore(float *mem, const param256 mask, const param256 v) {
-#ifndef VC_MM256_MASKSTORE_WRONG_MASK_TYPE
-            _mm256_maskstore_ps(mem, _mm256_castps_si256(mask), v);
-#else
-            _mm256_maskstore_ps(mem, mask, v);
-#endif
-        }
-        static Vc_INTRINSIC void _mm256_maskstore(double *mem, const param256d mask, const param256d v) {
-#ifndef VC_MM256_MASKSTORE_WRONG_MASK_TYPE
-            _mm256_maskstore_pd(mem, _mm256_castpd_si256(mask), v);
+    // mpsadbw_epu8 (__m128i __X, __m128i __Y, const int __M)
+    // stream_load_si128 (__m128i *__X)
+
+#else // Vc_IMPL_AVX2
+
+static Vc_INTRINSIC Vc_CONST m256i xor_si256(__m256i x, __m256i y) { return _mm256_xor_si256(x, y); }
+static Vc_INTRINSIC Vc_CONST m256i or_si256(__m256i x, __m256i y) { return _mm256_or_si256(x, y); }
+static Vc_INTRINSIC Vc_CONST m256i and_si256(__m256i x, __m256i y) { return _mm256_and_si256(x, y); }
+static Vc_INTRINSIC Vc_CONST m256i andnot_si256(__m256i x, __m256i y) { return _mm256_andnot_si256(x, y); }
+
+template <int i> Vc_INTRINSIC Vc_CONST __m256i srli_si256(__m256i a0)
+{
+    return _mm256_srli_si256(a0, i);
+}
+template <int i> Vc_INTRINSIC Vc_CONST __m256i slli_si256(__m256i a0)
+{
+    return _mm256_slli_si256(a0, i);
+}
+
+/////////////////////////////////////////////////////////////////////////
+// implementation of the intrinsics missing in AVX2
+/////////////////////////////////////////////////////////////////////////
+Vc_INTRINSIC Vc_CONST m256i blendv_epi8(__m256i a0, __m256i b0, __m256i m0)
+{
+    return _mm256_blendv_epi8(a0, b0, m0);
+}
+Vc_INTRINSIC Vc_CONST int movemask_epi8(__m256i a0)
+{
+    return _mm256_movemask_epi8(a0);
+}
+
+#endif // Vc_IMPL_AVX2
+
+/////////////////////////////////////////////////////////////////////////
+// implementation of intrinsics missing in AVX and AVX2
+/////////////////////////////////////////////////////////////////////////
+
+static Vc_INTRINSIC m256i cmplt_epi64(__m256i a, __m256i b) {
+    return cmpgt_epi64(b, a);
+}
+static Vc_INTRINSIC m256i cmplt_epi32(__m256i a, __m256i b) {
+    return cmpgt_epi32(b, a);
+}
+static Vc_INTRINSIC m256i cmplt_epi16(__m256i a, __m256i b) {
+    return cmpgt_epi16(b, a);
+}
+static Vc_INTRINSIC m256i cmplt_epi8(__m256i a, __m256i b) {
+    return cmpgt_epi8(b, a);
+}
+
+static Vc_INTRINSIC m256i cmplt_epu8(__m256i a, __m256i b) {
+    return cmplt_epi8(xor_si256(a, setmin_epi8()), xor_si256(b, setmin_epi8()));
+}
+static Vc_INTRINSIC m256i cmpgt_epu8(__m256i a, __m256i b) {
+    return cmpgt_epi8(xor_si256(a, setmin_epi8()), xor_si256(b, setmin_epi8()));
+}
+#if defined(Vc_IMPL_XOP)
+    Vc_AVX_TO_SSE_2_NEW(comlt_epu32)
+    Vc_AVX_TO_SSE_2_NEW(comgt_epu32)
+    Vc_AVX_TO_SSE_2_NEW(comlt_epu16)
+    Vc_AVX_TO_SSE_2_NEW(comgt_epu16)
+    static Vc_INTRINSIC m256i Vc_CONST cmplt_epu32(__m256i a, __m256i b) { return comlt_epu32(a, b); }
+    static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu32(__m256i a, __m256i b) { return comgt_epu32(a, b); }
+    static Vc_INTRINSIC m256i Vc_CONST cmplt_epu16(__m256i a, __m256i b) { return comlt_epu16(a, b); }
+    static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu16(__m256i a, __m256i b) { return comgt_epu16(a, b); }
 #else
-            _mm256_maskstore_pd(mem, mask, v);
+    static Vc_INTRINSIC m256i Vc_CONST cmplt_epu32(__m256i _a, __m256i _b) {
+        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi32())));
+        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi32())));
+        return cmplt_epi32(a, b);
+    }
+    static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu32(__m256i _a, __m256i _b) {
+        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi32())));
+        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi32())));
+        return cmpgt_epi32(a, b);
+    }
+    static Vc_INTRINSIC m256i Vc_CONST cmplt_epu16(__m256i _a, __m256i _b) {
+        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi16())));
+        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi16())));
+        return cmplt_epi16(a, b);
+    }
+    static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu16(__m256i _a, __m256i _b) {
+        m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi16())));
+        m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi16())));
+        return cmpgt_epi16(a, b);
+    }
 #endif
-        }
-        static Vc_INTRINSIC void _mm256_maskstore(int *mem, const param256i mask, const param256i v) {
-#ifndef VC_MM256_MASKSTORE_WRONG_MASK_TYPE
-            _mm256_maskstore_ps(reinterpret_cast<float *>(mem), mask, _mm256_castsi256_ps(v));
+
+static Vc_INTRINSIC void _mm256_maskstore(float *mem, const __m256 mask, const __m256 v) {
+    _mm256_maskstore_ps(mem, _mm256_castps_si256(mask), v);
+}
+static Vc_INTRINSIC void _mm256_maskstore(double *mem, const __m256d mask, const __m256d v) {
+    _mm256_maskstore_pd(mem, _mm256_castpd_si256(mask), v);
+}
+static Vc_INTRINSIC void _mm256_maskstore(int *mem, const __m256i mask, const __m256i v) {
+#ifdef Vc_IMPL_AVX2
+    _mm256_maskstore_epi32(mem, mask, v);
 #else
-            _mm256_maskstore_ps(reinterpret_cast<float *>(mem), _mm256_castsi256_ps(mask), _mm256_castsi256_ps(v));
-#endif
-        }
-        static Vc_INTRINSIC void _mm256_maskstore(unsigned int *mem, const param256i mask, const param256i v) {
-            _mm256_maskstore(reinterpret_cast<int *>(mem), mask, v);
-        }
-
-#if defined(VC_IMPL_FMA4) && defined(VC_CLANG) && VC_CLANG < 0x30300
-        // clang miscompiles _mm256_macc_ps: http://llvm.org/bugs/show_bug.cgi?id=15040
-        static Vc_INTRINSIC __m256 my256_macc_ps(__m256 a, __m256 b, __m256 c) {
-            __m256 r;
-            // avoid loading c from memory as that would trigger the bug
-            asm("vfmaddps %[c], %[b], %[a], %[r]" : [r]"=x"(r) : [a]"x"(a), [b]"x"(b), [c]"x"(c));
-            return r;
-        }
-#ifdef _mm256_macc_ps
-#undef _mm256_macc_ps
+    _mm256_maskstore_ps(reinterpret_cast<float *>(mem), mask, _mm256_castsi256_ps(v));
 #endif
-#define _mm256_macc_ps(a, b, c) Vc::AVX::my256_macc_ps(a, b, c)
+}
+static Vc_INTRINSIC void _mm256_maskstore(unsigned int *mem, const __m256i mask, const __m256i v) {
+    _mm256_maskstore(reinterpret_cast<int *>(mem), mask, v);
+}
+static Vc_INTRINSIC void _mm256_maskstore(short *mem, const __m256i mask, const __m256i v) {
+    using namespace AVX;
+    _mm_maskmoveu_si128(_mm256_castsi256_si128(v), _mm256_castsi256_si128(mask), reinterpret_cast<char *>(&mem[0]));
+    _mm_maskmoveu_si128(extract128<1>(v), extract128<1>(mask), reinterpret_cast<char *>(&mem[8]));
+}
+static Vc_INTRINSIC void _mm256_maskstore(unsigned short *mem, const __m256i mask, const __m256i v) {
+    _mm256_maskstore(reinterpret_cast<short *>(mem), mask, v);
+}
 
-        static Vc_INTRINSIC __m256d my256_macc_pd(__m256d a, __m256d b, __m256d c) {
-            __m256d r;
-            // avoid loading c from memory as that would trigger the bug
-            asm("vfmaddpd %[c], %[b], %[a], %[r]" : [r]"=x"(r) : [a]"x"(a), [b]"x"(b), [c]"x"(c));
-            return r;
-        }
-#ifdef _mm256_macc_pd
-#undef _mm256_macc_pd
-#endif
-#define _mm256_macc_pd(a, b, c) Vc::AVX::my256_macc_pd(a, b, c)
+#undef Vc_AVX_TO_SSE_1
+#undef Vc_AVX_TO_SSE_1_128
+#undef Vc_AVX_TO_SSE_2_NEW
+#undef Vc_AVX_TO_SSE_256_128
+#undef Vc_AVX_TO_SSE_1i
+
+template<typename R> Vc_INTRINSIC_L R stream_load(const float *mem) Vc_INTRINSIC_R;
+template<> Vc_INTRINSIC m128 stream_load<m128>(const float *mem)
+{
+    return _mm_castsi128_ps(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<float *>(mem))));
+}
+template<> Vc_INTRINSIC m256 stream_load<m256>(const float *mem)
+{
+    return insert128<1>(_mm256_castps128_ps256(stream_load<m128>(mem)),
+                                stream_load<m128>(mem + 4));
+}
+
+template<typename R> Vc_INTRINSIC_L R stream_load(const double *mem) Vc_INTRINSIC_R;
+template<> Vc_INTRINSIC m128d stream_load<m128d>(const double *mem)
+{
+    return _mm_castsi128_pd(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<double *>(mem))));
+}
+template<> Vc_INTRINSIC m256d stream_load<m256d>(const double *mem)
+{
+    return insert128<1>(_mm256_castpd128_pd256(stream_load<m128d>(mem)),
+                                stream_load<m128d>(mem + 2));
+}
+
+template<typename R> Vc_INTRINSIC_L R stream_load(const void *mem) Vc_INTRINSIC_R;
+template<> Vc_INTRINSIC m128i stream_load<m128i>(const void *mem)
+{
+    return _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<void *>(mem)));
+}
+template<> Vc_INTRINSIC m256i stream_load<m256i>(const void *mem)
+{
+    return insert128<1>(_mm256_castsi128_si256(stream_load<m128i>(mem)),
+                                stream_load<m128i>(static_cast<const __m128i *>(mem) + 1));
+}
+
+Vc_INTRINSIC void stream_store(float *mem, __m128 value, __m128 mask)
+{
+    _mm_maskmoveu_si128(_mm_castps_si128(value), _mm_castps_si128(mask), reinterpret_cast<char *>(mem));
+}
+Vc_INTRINSIC void stream_store(float *mem, __m256 value, __m256 mask)
+{
+    stream_store(mem, _mm256_castps256_ps128(value), _mm256_castps256_ps128(mask));
+    stream_store(mem + 4, extract128<1>(value), extract128<1>(mask));
+}
+Vc_INTRINSIC void stream_store(double *mem, __m128d value, __m128d mask)
+{
+    _mm_maskmoveu_si128(_mm_castpd_si128(value), _mm_castpd_si128(mask), reinterpret_cast<char *>(mem));
+}
+Vc_INTRINSIC void stream_store(double *mem, __m256d value, __m256d mask)
+{
+    stream_store(mem, _mm256_castpd256_pd128(value), _mm256_castpd256_pd128(mask));
+    stream_store(mem + 2, extract128<1>(value), extract128<1>(mask));
+}
+Vc_INTRINSIC void stream_store(void *mem, __m128i value, __m128i mask)
+{
+    _mm_maskmoveu_si128(value, mask, reinterpret_cast<char *>(mem));
+}
+Vc_INTRINSIC void stream_store(void *mem, __m256i value, __m256i mask)
+{
+    stream_store(mem, _mm256_castsi256_si128(value), _mm256_castsi256_si128(mask));
+    stream_store(static_cast<__m128i *>(mem) + 1, extract128<1>(value), extract128<1>(mask));
+}
+
+#ifndef __x86_64__
+Vc_INTRINSIC Vc_PURE __m128i _mm_cvtsi64_si128(int64_t x) {
+    return _mm_castpd_si128(_mm_load_sd(reinterpret_cast<const double *>(&x)));
+}
 #endif
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
 
-#include "shuffle.h"
+}  // namespace AvxIntrinsics
+}  // namespace Vc
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace AVX
+{
+    using namespace AvxIntrinsics;
+}  // namespace AVX
+namespace AVX2
+{
+    using namespace AvxIntrinsics;
+}  // namespace AVX2
+namespace AVX
+{
+    template<typename T> struct VectorTypeHelper;
+    template<> struct VectorTypeHelper<         char > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<  signed char > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<unsigned char > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<         short> { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<unsigned short> { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<         int  > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<unsigned int  > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<         long > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<unsigned long > { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<         long long> { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<unsigned long long> { typedef __m256i Type; };
+    template<> struct VectorTypeHelper<         float> { typedef __m256  Type; };
+    template<> struct VectorTypeHelper<        double> { typedef __m256d Type; };
+
+    template<typename T> struct SseVectorType;
+    template<> struct SseVectorType<__m256 > { typedef __m128  Type; };
+    template<> struct SseVectorType<__m256i> { typedef __m128i Type; };
+    template<> struct SseVectorType<__m256d> { typedef __m128d Type; };
+    template<> struct SseVectorType<__m128 > { typedef __m128  Type; };
+    template<> struct SseVectorType<__m128i> { typedef __m128i Type; };
+    template<> struct SseVectorType<__m128d> { typedef __m128d Type; };
+
+    template <typename T>
+    using IntegerVectorType =
+        typename std::conditional<sizeof(T) == 16, __m128i, __m256i>::type;
+    template <typename T>
+    using DoubleVectorType =
+        typename std::conditional<sizeof(T) == 16, __m128d, __m256d>::type;
+    template <typename T>
+    using FloatVectorType =
+        typename std::conditional<sizeof(T) == 16, __m128, __m256>::type;
+
+    template<typename T> struct VectorHelper {};
+    template<typename T> struct GatherHelper;
+    template<typename T> struct ScatterHelper;
+
+    template<typename T> struct HasVectorDivisionHelper { enum { Value = 1 }; };
+    template<typename T> struct VectorHelperSize;
+}  // namespace AVX
+}  // namespace Vc
 
-#endif // VC_AVX_INTRINSICS_H
+#endif // VC_AVX_INTRINSICS_H_
diff -Nru vc-0.7.4/avx/limits.h vc-1.3.0/avx/limits.h
--- vc-0.7.4/avx/limits.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/limits.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,55 +1,87 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_LIMITS_H
-#define VC_AVX_LIMITS_H
+#ifndef VC_AVX_LIMITS_H_
+#define VC_AVX_LIMITS_H_
 
 #include "intrinsics.h"
 #include "types.h"
+#include "macros.h"
 
 namespace std
 {
-#define _VC_NUM_LIM(T, _max, _min) \
-template<> struct numeric_limits< ::Vc::AVX::Vector<T> > : public numeric_limits<T> \
-{ \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> max()           _VC_NOEXCEPT { return _max; } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> min()           _VC_NOEXCEPT { return _min; } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> lowest()        _VC_NOEXCEPT { return min(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> epsilon()       _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> round_error()   _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> infinity()      _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> quiet_NaN()     _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> signaling_NaN() _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-    static Vc_INTRINSIC Vc_CONST ::Vc::AVX::Vector<T> denorm_min()    _VC_NOEXCEPT { return ::Vc::AVX::Vector<T>::Zero(); } \
-}
-
-#ifndef VC_IMPL_AVX2
-namespace {
-    using ::Vc::AVX::_mm256_srli_epi32;
-}
+#define Vc_NUM_LIM(T, _max, _min)                                                        \
+    template <> struct numeric_limits<Vc::AVX2::Vector<T>> : public numeric_limits<T> {  \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> max() Vc_NOEXCEPT               \
+        {                                                                                \
+            return _max;                                                                 \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> min() Vc_NOEXCEPT               \
+        {                                                                                \
+            return _min;                                                                 \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> lowest() Vc_NOEXCEPT            \
+        {                                                                                \
+            return min();                                                                \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> epsilon() Vc_NOEXCEPT           \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> round_error() Vc_NOEXCEPT       \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> infinity() Vc_NOEXCEPT          \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> quiet_NaN() Vc_NOEXCEPT         \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> signaling_NaN() Vc_NOEXCEPT     \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+        static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector<T> denorm_min() Vc_NOEXCEPT        \
+        {                                                                                \
+            return Vc::AVX2::Vector<T>::Zero();                                          \
+        }                                                                                \
+    }
+
+#ifdef Vc_IMPL_AVX2
+Vc_NUM_LIM(unsigned short, Vc::Detail::allone<__m256i>(), Vc::Detail::zero<__m256i>());
+Vc_NUM_LIM(         short, _mm256_srli_epi16(Vc::Detail::allone<__m256i>(), 1), Vc::AVX::setmin_epi16());
+Vc_NUM_LIM(  unsigned int, Vc::Detail::allone<__m256i>(), Vc::Detail::zero<__m256i>());
+Vc_NUM_LIM(           int, _mm256_srli_epi32(Vc::Detail::allone<__m256i>(), 1), Vc::AVX::setmin_epi32());
 #endif
-_VC_NUM_LIM(unsigned short, ::Vc::AVX::_mm_setallone_si128(), _mm_setzero_si128());
-_VC_NUM_LIM(         short, _mm_srli_epi16(::Vc::AVX::_mm_setallone_si128(), 1), ::Vc::AVX::_mm_setmin_epi16());
-_VC_NUM_LIM(  unsigned int, ::Vc::AVX::_mm256_setallone_si256(), _mm256_setzero_si256());
-_VC_NUM_LIM(           int, _mm256_srli_epi32(::Vc::AVX::_mm256_setallone_si256(), 1), ::Vc::AVX::_mm256_setmin_epi32());
-#undef _VC_NUM_LIM
+#undef Vc_NUM_LIM
 
 } // namespace std
 
-#endif // VC_AVX_LIMITS_H
+#endif // VC_AVX_LIMITS_H_
diff -Nru vc-0.7.4/avx/macros.h vc-1.3.0/avx/macros.h
--- vc-0.7.4/avx/macros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/macros.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,26 +1,33 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "../common/macros.h"
 
-#ifndef VC_AVX_MACROS_H
-#define VC_AVX_MACROS_H
-#undef VC_AVX_UNDOMACROS_H
+#ifndef VC_AVX_MACROS_H_
+#define VC_AVX_MACROS_H_
 
-#endif // VC_AVX_MACROS_H
+#endif // VC_AVX_MACROS_H_
diff -Nru vc-0.7.4/avx/mask.h vc-1.3.0/avx/mask.h
--- vc-0.7.4/avx/mask.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/mask.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,246 +1,221 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_AVX_MASK_H_
+#define VC_AVX_MASK_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_MASK_H
-#define VC_AVX_MASK_H
+#include <array>
 
 #include "intrinsics.h"
+#include "../common/storage.h"
 #include "../common/bitscanintrinsics.h"
+#include "../common/maskbool.h"
+#include "detail.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace AVX
+namespace Vc_VERSIONED_NAMESPACE
 {
-
-template<unsigned int VectorSize> class Mask<VectorSize, 32u>
+template <typename T> class Mask<T, VectorAbi::Avx>
 {
-    friend class Mask<4u, 32u>; // double_v
-    friend class Mask<8u, 32u>; // float_v, (u)int_v
-    friend class Mask<8u, 16u>; // (u)short_v
-    friend class Mask<16u, 16u>; // (u)char_v
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(32)
-
-        // abstracts the way Masks are passed to functions, it can easily be changed to const ref here
-#if defined VC_MSVC && defined _WIN32
-        typedef const Mask<VectorSize, 32u> &AsArg;
-#else
-        typedef Mask<VectorSize, 32u> AsArg;
-#endif
-
-        Vc_ALWAYS_INLINE Mask() {}
-        Vc_ALWAYS_INLINE Mask(param256  x) : k(x) {}
-        Vc_ALWAYS_INLINE Mask(param256d x) : k(_mm256_castpd_ps(x)) {}
-        Vc_ALWAYS_INLINE Mask(param256i x) : k(_mm256_castsi256_ps(x)) {}
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-        Vc_ALWAYS_INLINE Mask(__m256  x) : k(x) {}
-        Vc_ALWAYS_INLINE Mask(__m256d x) : k(_mm256_castpd_ps(x)) {}
-        Vc_ALWAYS_INLINE Mask(__m256i x) : k(_mm256_castsi256_ps(x)) {}
-#endif
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerZero::ZEnum) : k(_mm256_setzero_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerOne::OEnum) : k(_mm256_setallone_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(bool b) : k(b ? _mm256_setallone_ps() : m256(_mm256_setzero_ps())) {}
-        Vc_ALWAYS_INLINE Mask(const Mask &rhs) : k(rhs.k) {}
-        Vc_ALWAYS_INLINE Mask(const Mask<VectorSize, 16u> &rhs) : k(avx_cast<m256>(concat(
-                        _mm_unpacklo_epi16(rhs.dataI(), rhs.dataI()),
-                        _mm_unpackhi_epi16(rhs.dataI(), rhs.dataI())))) {}
-        Vc_ALWAYS_INLINE_L Mask(const Mask<VectorSize * 2, 32u> &m) Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L Mask(const Mask<VectorSize / 2, 32u> &m) Vc_ALWAYS_INLINE_R;
-
-        Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return 0 != _mm256_testc_ps(k, rhs.k); }
-        Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return 0 == _mm256_testc_ps(k, rhs.k); }
-
-        Vc_ALWAYS_INLINE Mask operator!() const { return _mm256_andnot_ps(data(), _mm256_setallone_ps()); }
-
-        Vc_ALWAYS_INLINE Mask &operator&=(const Mask &rhs) { k = _mm256_and_ps(k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator|=(const Mask &rhs) { k = _mm256_or_ps (k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator^=(const Mask &rhs) { k = _mm256_xor_ps(k, rhs.k); return *this; }
+public:
+    using abi = VectorAbi::Avx;
 
-        // no need for expression template optimizations because cmp(n)eq for floats are not bitwise
-        // compares
-        Vc_ALWAYS_INLINE bool isFull () const { return 0 != _mm256_testc_ps(k, _mm256_setallone_ps()); }
-        Vc_ALWAYS_INLINE bool isEmpty() const { return 0 != _mm256_testz_ps(k, k); }
-        Vc_ALWAYS_INLINE bool isMix  () const { return 0 != _mm256_testnzc_ps(k, _mm256_setallone_ps()); }
-
-#ifndef VC_NO_AUTOMATIC_BOOL_FROM_MASK
-        Vc_ALWAYS_INLINE operator bool() const { return isFull(); }
-#endif
-
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int shiftMask() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int toInt() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-        Vc_ALWAYS_INLINE m256  data () const { return k; }
-        Vc_ALWAYS_INLINE m256i dataI() const { return _mm256_castps_si256(k); }
-        Vc_ALWAYS_INLINE m256d dataD() const { return _mm256_castps_pd(k); }
+    /**
+     * The \c EntryType of masks is always bool, independent of \c T.
+     */
+    typedef bool EntryType;
+    using value_type = EntryType;
+
+    using MaskBool = Common::MaskBool<sizeof(T)>;
+    /**
+     * The \c VectorEntryType, in contrast to \c EntryType, reveals information about the SIMD
+     * implementation. This type is useful for the \c sizeof operator in generic functions.
+     */
+    using VectorEntryType = MaskBool;
+
+    /**
+     * The associated Vector<T> type.
+     */
+    using Vector = AVX2::Vector<T>;
+
+    ///\internal
+    using VectorTypeF = AVX::FloatVectorType<typename AVX::VectorTypeHelper<T>::Type>;
+    ///\internal
+    using VectorTypeD = AVX::DoubleVectorType<VectorTypeF>;
+    ///\internal
+    using VectorTypeI = AVX::IntegerVectorType<VectorTypeF>;
+
+private:
+    typedef const VectorTypeF VArg;
+    typedef const VectorTypeD VdArg;
+    typedef const VectorTypeI ViArg;
+
+public:
+    static constexpr size_t Size = sizeof(VectorTypeF) / sizeof(T);
+    static constexpr size_t MemoryAlignment = Size;
+    static constexpr std::size_t size() { return Size; }
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(VectorType));
+
+private:
+    typedef Common::Storage<T, Size> Storage;
+
+public:
+    /**
+     * The \c VectorType reveals the implementation-specific internal type used for the
+     * SIMD type.
+     */
+    using VectorType = typename Storage::VectorType;
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L bool operator[](int index) const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int count() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int firstOne() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-    private:
-#ifdef VC_COMPILE_BENCHMARKS
-    public:
-#endif
-        m256 k;
-};
-
-template<unsigned int VectorSize> class Mask<VectorSize, 16u>
-{
-    friend class Mask<4u, 32u>; // double_v
-    friend class Mask<8u, 32u>; // float_v, (u)int_v
-    friend class Mask<8u, 16u>; // (u)short_v
-    friend class Mask<16u, 16u>; // (u)char_v
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(16)
+    using EntryReference = Vc::Detail::ElementReference<Mask>;
+    using reference = EntryReference;
 
         // abstracts the way Masks are passed to functions, it can easily be changed to const ref here
-#if defined VC_MSVC && defined _WIN32
-        typedef const Mask<VectorSize, 16u> &AsArg;
+#if defined Vc_MSVC && defined _WIN32
+        typedef const Mask &AsArg;
 #else
-        typedef Mask<VectorSize, 16u> AsArg;
+        typedef const Mask AsArg;
 #endif
 
-        Vc_ALWAYS_INLINE Mask() {}
-        Vc_ALWAYS_INLINE Mask(param128  x) : k(x) {}
-        Vc_ALWAYS_INLINE Mask(param128d x) : k(_mm_castpd_ps(x)) {}
-        Vc_ALWAYS_INLINE Mask(param128i x) : k(_mm_castsi128_ps(x)) {}
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-        Vc_ALWAYS_INLINE Mask(__m128  x) : k(x) {}
-        Vc_ALWAYS_INLINE Mask(__m128d x) : k(_mm_castpd_ps(x)) {}
-        Vc_ALWAYS_INLINE Mask(__m128i x) : k(_mm_castsi128_ps(x)) {}
-#endif
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerZero::ZEnum) : k(_mm_setzero_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerOne::OEnum) : k(_mm_setallone_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(bool b) : k(b ? _mm_setallone_ps() : m128(_mm_setzero_ps())) {}
-        Vc_ALWAYS_INLINE Mask(const Mask &rhs) : k(rhs.k) {}
-        Vc_ALWAYS_INLINE Mask(const Mask<VectorSize, 32u> &rhs) : k(avx_cast<m128>(
-                _mm_packs_epi32(avx_cast<m128i>(rhs.data()), _mm256_extractf128_si256(rhs.dataI(), 1)))) {}
-        Vc_ALWAYS_INLINE Mask(const Mask<VectorSize / 2, 16u> *a) : k(avx_cast<m128>(
-                _mm_packs_epi16(a[0].dataI(), a[1].dataI()))) {}
-
-        Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return 0 != _mm_testc_si128(dataI(), rhs.dataI()); }
-        Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return 0 == _mm_testc_si128(dataI(), rhs.dataI()); }
-
-        Vc_ALWAYS_INLINE Mask operator!() const { return _mm_andnot_ps(data(), _mm_setallone_ps()); }
-
-        Vc_ALWAYS_INLINE Mask &operator&=(const Mask &rhs) { k = _mm_and_ps(k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator|=(const Mask &rhs) { k = _mm_or_ps (k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator^=(const Mask &rhs) { k = _mm_xor_ps(k, rhs.k); return *this; }
-
-        // TODO: use expression templates to optimize (v1 == v2).isFull() and friends
-        Vc_ALWAYS_INLINE bool isFull () const { return 0 != _mm_testc_si128(dataI(), _mm_setallone_si128()); }
-        Vc_ALWAYS_INLINE bool isEmpty() const { return 0 != _mm_testz_si128(dataI(), dataI()); }
-        Vc_ALWAYS_INLINE bool isMix  () const { return 0 != _mm_testnzc_si128(dataI(), _mm_setallone_si128()); }
+        Vc_INTRINSIC Mask() {}
+        Vc_INTRINSIC Mask(VArg  x) : d(AVX::avx_cast<VectorType>(x)) {}
+        Vc_INTRINSIC Mask(VdArg x) : d(AVX::avx_cast<VectorType>(x)) {}
+        Vc_INTRINSIC Mask(ViArg x) : d(AVX::avx_cast<VectorType>(x)) {}
+        Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero) : d(Detail::zero<VectorType>()) {}
+        Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne) : d(Detail::allone<VectorType>()) {}
+        Vc_INTRINSIC explicit Mask(bool b)
+            : d(b ? Detail::allone<VectorType>() : Detail::zero<VectorType>())
+        {
+        }
+        Vc_INTRINSIC static Mask Zero() { return Mask{Vc::Zero}; }
+        Vc_INTRINSIC static Mask One() { return Mask{Vc::One}; }
+
+        // implicit cast
+        template <typename U>
+        Vc_INTRINSIC Mask(U &&rhs,
+                          Common::enable_if_mask_converts_implicitly<T, U> = nullarg)
+            : d(AVX::avx_cast<VectorType>(
+                  Detail::mask_cast<Traits::decay<U>::Size, Size, VectorTypeF>(
+                      rhs.dataI())))
+        {
+        }
+
+#if Vc_IS_VERSION_1
+        // explicit cast, implemented via simd_cast (in avx/simd_cast_caller.h)
+        template <typename U>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "mask types") Vc_INTRINSIC
+            explicit Mask(U &&rhs,
+                          Common::enable_if_mask_converts_explicitly<T, U> = nullarg);
+#endif
+
+        template<typename Flags = DefaultLoadTag> Vc_INTRINSIC explicit Mask(const bool *mem, Flags f = Flags()) { load(mem, f); }
+
+        template<typename Flags = DefaultLoadTag> Vc_INTRINSIC void load(const bool *mem, Flags = Flags());
+
+        template<typename Flags = DefaultLoadTag> Vc_INTRINSIC void store(bool *mem, Flags = Flags()) const;
+
+        Vc_INTRINSIC Mask &operator=(const Mask &) = default;
+        Vc_INTRINSIC_L Mask &operator=(const std::array<bool, Size> &values) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L operator std::array<bool, Size>() const Vc_INTRINSIC_R;
+
+        // specializations in mask.tcc
+        Vc_INTRINSIC Vc_PURE bool operator==(const Mask &rhs) const
+        { return Detail::movemask(d.v()) == Detail::movemask(rhs.d.v()); }
+
+        Vc_INTRINSIC Vc_PURE bool operator!=(const Mask &rhs) const
+        { return !operator==(rhs); }
+
+        Vc_INTRINSIC Mask operator!() const { return Detail::andnot_(data(), Detail::allone<VectorTypeF>()); }
+
+        Vc_INTRINSIC Mask &operator&=(const Mask &rhs) { d.v() = AVX::avx_cast<VectorType>(Detail::and_(data(), rhs.data())); return *this; }
+        Vc_INTRINSIC Mask &operator|=(const Mask &rhs) { d.v() = AVX::avx_cast<VectorType>(Detail::or_ (data(), rhs.data())); return *this; }
+        Vc_INTRINSIC Mask &operator^=(const Mask &rhs) { d.v() = AVX::avx_cast<VectorType>(Detail::xor_(data(), rhs.data())); return *this; }
+
+        Vc_INTRINSIC Vc_PURE Mask operator&(const Mask &rhs) const { return Detail::and_(data(), rhs.data()); }
+        Vc_INTRINSIC Vc_PURE Mask operator|(const Mask &rhs) const { return Detail::or_(data(), rhs.data()); }
+        Vc_INTRINSIC Vc_PURE Mask operator^(const Mask &rhs) const { return Detail::xor_(data(), rhs.data()); }
 
-#ifndef VC_NO_AUTOMATIC_BOOL_FROM_MASK
-        Vc_ALWAYS_INLINE operator bool() const { return isFull(); }
-#endif
+        Vc_INTRINSIC Vc_PURE Mask operator&&(const Mask &rhs) const { return Detail::and_(data(), rhs.data()); }
+        Vc_INTRINSIC Vc_PURE Mask operator||(const Mask &rhs) const { return Detail::or_(data(), rhs.data()); }
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int shiftMask() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int toInt() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        // no need for expression template optimizations because cmp(n)eq for floats are not bitwise
+        // compares
+        Vc_INTRINSIC_L bool isNotEmpty() const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L bool isEmpty() const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L bool isFull() const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L bool isMix() const Vc_INTRINSIC_R;
+
+        Vc_INTRINSIC Vc_PURE int shiftMask() const { return Detail::movemask(dataI()); }
+        Vc_INTRINSIC Vc_PURE int toInt() const { return Detail::mask_to_int<Size>(dataI()); }
+
+        Vc_INTRINSIC VectorTypeF data () const { return AVX::avx_cast<VectorTypeF>(d.v()); }
+        Vc_INTRINSIC VectorTypeI dataI() const { return AVX::avx_cast<VectorTypeI>(d.v()); }
+        Vc_INTRINSIC VectorTypeD dataD() const { return AVX::avx_cast<VectorTypeD>(d.v()); }
+
+private:
+    friend reference;
+    static Vc_INTRINSIC Vc_PURE value_type get(const Mask &m, int i) noexcept
+    {
+        return m.toInt() & (1 << i);
+    }
+    template <typename U>
+    static Vc_INTRINSIC void set(Mask &m, int i,
+                                 U &&v) noexcept(noexcept(MaskBool(std::declval<U>())))
+    {
+        m.d.set(i, MaskBool(std::forward<U>(v)));
+    }
 
-        Vc_ALWAYS_INLINE m128  data () const { return k; }
-        Vc_ALWAYS_INLINE m128i dataI() const { return avx_cast<m128i>(k); }
-        Vc_ALWAYS_INLINE m128d dataD() const { return avx_cast<m128d>(k); }
+public:
+    Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+    {
+        return {*this, int(index)};
+    }
+    Vc_ALWAYS_INLINE Vc_PURE value_type operator[](size_t index) const noexcept
+    {
+        return get(*this, index);
+    }
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L bool operator[](int index) const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        Vc_INTRINSIC Vc_PURE int count() const { return Detail::popcnt16(toInt()); }
+        Vc_INTRINSIC Vc_PURE int firstOne() const { return _bit_scan_forward(toInt()); }
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int count() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int firstOne() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        template <typename G> static Vc_INTRINSIC_L Mask generate(G &&gen) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vc_PURE_L Mask shifted(int amount) const Vc_INTRINSIC_R Vc_PURE_R;
 
     private:
-#ifdef VC_COMPILE_BENCHMARKS
+#ifdef Vc_COMPILE_BENCHMARKS
     public:
 #endif
-        m128 k;
-};
-
-struct ForeachHelper
-{
-    size_t mask;
-    bool brk;
-    bool outerBreak;
-    Vc_ALWAYS_INLINE ForeachHelper(size_t _mask) : mask(_mask), brk(false), outerBreak(false) {}
-    Vc_ALWAYS_INLINE bool outer() const { return mask != 0 && !outerBreak; }
-    Vc_ALWAYS_INLINE bool inner() { return (brk = !brk); }
-    Vc_ALWAYS_INLINE void noBreak() { outerBreak = false; }
-    Vc_ALWAYS_INLINE size_t next() {
-        outerBreak = true;
-#ifdef VC_GNU_ASM
-        const size_t bit = __builtin_ctzl(mask);
-        __asm__("btr %1,%0" : "+r"(mask) : "r"(bit));
-#else
-#ifdef VC_MSVC
-#pragma warning(suppress : 4267) // conversion from 'size_t' to 'unsigned long', possible loss of data
-#endif
-        const size_t bit = _bit_scan_forward(mask);
-        mask &= ~(1 << bit);
-#endif
-        return bit;
-    }
+        Storage d;
 };
+template <typename T> constexpr size_t Mask<T, VectorAbi::Avx>::Size;
+template <typename T> constexpr size_t Mask<T, VectorAbi::Avx>::MemoryAlignment;
 
-#define Vc_foreach_bit(_it_, _mask_) \
-    for (Vc::AVX::ForeachHelper Vc__make_unique(foreach_bit_obj)((_mask_).toInt()); Vc__make_unique(foreach_bit_obj).outer(); ) \
-        for (_it_ = Vc__make_unique(foreach_bit_obj).next(); Vc__make_unique(foreach_bit_obj).inner(); Vc__make_unique(foreach_bit_obj).noBreak())
-
-// Operators
-namespace Intrinsics
-{
-    static Vc_ALWAYS_INLINE Vc_PURE m256 and_(param256 a, param256 b) { return _mm256_and_ps(a, b); }
-    static Vc_ALWAYS_INLINE Vc_PURE m256  or_(param256 a, param256 b) { return _mm256_or_ps(a, b); }
-    static Vc_ALWAYS_INLINE Vc_PURE m256 xor_(param256 a, param256 b) { return _mm256_xor_ps(a, b); }
-
-    static Vc_ALWAYS_INLINE Vc_PURE m128 and_(param128 a, param128 b) { return _mm_and_ps(a, b); }
-    static Vc_ALWAYS_INLINE Vc_PURE m128  or_(param128 a, param128 b) { return _mm_or_ps(a, b); }
-    static Vc_ALWAYS_INLINE Vc_PURE m128 xor_(param128 a, param128 b) { return _mm_xor_ps(a, b); }
-} // namespace Intrinsics
-
-// binary and/or/xor cannot work with one operand larger than the other
-template<unsigned int LSize, unsigned int RSize, size_t LWidth, size_t RWidth> void operator&(const Mask<LSize, LWidth> &l, const Mask<RSize, RWidth> &r);
-template<unsigned int LSize, unsigned int RSize, size_t LWidth, size_t RWidth> void operator|(const Mask<LSize, LWidth> &l, const Mask<RSize, RWidth> &r);
-template<unsigned int LSize, unsigned int RSize, size_t LWidth, size_t RWidth> void operator^(const Mask<LSize, LWidth> &l, const Mask<RSize, RWidth> &r);
-
-// let binary and/or/xor work for any combination of masks (as long as they have the same sizeof)
-template<unsigned int LSize, unsigned int RSize, size_t Width> Vc_ALWAYS_INLINE Vc_PURE Mask<LSize, Width> operator&(const Mask<LSize, Width> &l, const Mask<RSize, Width> &r) { return Intrinsics::and_(l.data(), r.data()); }
-template<unsigned int LSize, unsigned int RSize, size_t Width> Vc_ALWAYS_INLINE Vc_PURE Mask<LSize, Width> operator|(const Mask<LSize, Width> &l, const Mask<RSize, Width> &r) { return Intrinsics:: or_(l.data(), r.data()); }
-template<unsigned int LSize, unsigned int RSize, size_t Width> Vc_ALWAYS_INLINE Vc_PURE Mask<LSize, Width> operator^(const Mask<LSize, Width> &l, const Mask<RSize, Width> &r) { return Intrinsics::xor_(l.data(), r.data()); }
-
-// disable logical and/or for incompatible masks
-template<unsigned int LSize, unsigned int RSize, size_t LWidth, size_t RWidth> void operator&&(const Mask<LSize, LWidth> &lhs, const Mask<RSize, RWidth> &rhs);
-template<unsigned int LSize, unsigned int RSize, size_t LWidth, size_t RWidth> void operator||(const Mask<LSize, LWidth> &lhs, const Mask<RSize, RWidth> &rhs);
-
-// logical and/or for compatible masks
-template<unsigned int Size, size_t LWidth, size_t RWidth> Vc_ALWAYS_INLINE Vc_PURE Mask<Size, LWidth> operator&&(const Mask<Size, LWidth> &lhs, const Mask<Size, RWidth> &rhs) { return lhs && static_cast<Mask<Size, LWidth> >(rhs); }
-template<unsigned int Size, size_t LWidth, size_t RWidth> Vc_ALWAYS_INLINE Vc_PURE Mask<Size, LWidth> operator||(const Mask<Size, LWidth> &lhs, const Mask<Size, RWidth> &rhs) { return lhs || static_cast<Mask<Size, LWidth> >(rhs); }
-
-template<unsigned int Size, size_t Width> Vc_ALWAYS_INLINE Vc_PURE Mask<Size, Width> operator&&(const Mask<Size, Width> &lhs, const Mask<Size, Width> &rhs) { return Intrinsics::and_(lhs.data(), rhs.data()); }
-template<unsigned int Size, size_t Width> Vc_ALWAYS_INLINE Vc_PURE Mask<Size, Width> operator||(const Mask<Size, Width> &lhs, const Mask<Size, Width> &rhs) { return Intrinsics::or_ (lhs.data(), rhs.data()); }
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Vc
 
 #include "mask.tcc"
-#include "undomacros.h"
 
-#endif // VC_AVX_MASK_H
+#endif // VC_AVX_MASK_H_
diff -Nru vc-0.7.4/avx/mask.tcc vc-1.3.0/avx/mask.tcc
--- vc-0.7.4/avx/mask.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/mask.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,75 +1,292 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+}}}*/
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace AVX
+// store {{{1
+template <typename T>
+template <typename Flags>
+Vc_INTRINSIC void Mask<T, VectorAbi::Avx>::store(bool *mem, Flags f) const
 {
+    Detail::mask_store<Size>(dataI(), mem, f);
+}
 
-template<> Vc_ALWAYS_INLINE Mask<4, 32>::Mask(const Mask<8, 32> &m)
-    : k(concat(_mm_unpacklo_ps(lo128(m.data()), lo128(m.data())),
-                _mm_unpackhi_ps(lo128(m.data()), lo128(m.data()))))
+// load {{{1
+template <typename T>
+template <typename Flags>
+Vc_INTRINSIC void Mask<T, VectorAbi::Avx>::load(const bool *mem, Flags f)
 {
+    d.v() = AVX::avx_cast<VectorType>(Detail::mask_load<VectorTypeF, Size>(mem, f));
 }
 
-template<> Vc_ALWAYS_INLINE Mask<8, 32>::Mask(const Mask<4, 32> &m)
-    // aabb ccdd -> abcd 0000
-    : k(concat(Mem::shuffle<X0, X2, Y0, Y2>(lo128(m.data()), hi128(m.data())),
-                _mm_setzero_ps()))
+// operator[] {{{1
+#ifdef Vc_IMPL_AVX2
+template <>
+Vc_INTRINSIC Vc_PURE bool AVX2::Mask<int16_t>::get(const AVX2::Mask<int16_t> &m,
+                                                   int index) noexcept
 {
+    return m.shiftMask() & (1 << 2 * index);
 }
+template <>
+Vc_INTRINSIC Vc_PURE bool AVX2::Mask<uint16_t>::get(const AVX2::Mask<uint16_t> &m,
+                                                    int index) noexcept
+{
+    return m.shiftMask() & (1 << 2 * index);
+}
+#endif
+// operator== {{{1
+template <> Vc_INTRINSIC Vc_PURE bool AVX2::double_m::operator==(const AVX2::double_m &rhs) const
+{ return Detail::movemask(dataD()) == Detail::movemask(rhs.dataD()); }
+#ifdef Vc_IMPL_AVX2
+template <> Vc_INTRINSIC Vc_PURE bool AVX2::short_m::operator==(const AVX2::short_m &rhs) const
+{ return Detail::movemask(dataI()) == Detail::movemask(rhs.dataI()); }
+template <> Vc_INTRINSIC Vc_PURE bool AVX2::ushort_m::operator==(const AVX2::ushort_m &rhs) const
+{ return Detail::movemask(dataI()) == Detail::movemask(rhs.dataI()); }
+#endif
 
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 32u>::shiftMask() const
+// isFull, isNotEmpty, isEmpty, isMix specializations{{{1
+template <typename T> Vc_INTRINSIC bool Mask<T, VectorAbi::Avx>::isFull() const {
+    if (sizeof(T) == 8) {
+        return 0 != Detail::testc(dataD(), Detail::allone<VectorTypeD>());
+    } else if (sizeof(T) == 4) {
+        return 0 != Detail::testc(data (), Detail::allone<VectorTypeF>());
+    } else {
+        return 0 != Detail::testc(dataI(), Detail::allone<VectorTypeI>());
+    }
+}
+
+template <typename T> Vc_INTRINSIC bool Mask<T, VectorAbi::Avx>::isNotEmpty() const {
+    if (sizeof(T) == 8) {
+        return 0 == Detail::testz(dataD(), dataD());
+    } else if (sizeof(T) == 4) {
+        return 0 == Detail::testz(data (), data ());
+    } else {
+        return 0 == Detail::testz(dataI(), dataI());
+    }
+}
+
+template <typename T> Vc_INTRINSIC bool Mask<T, VectorAbi::Avx>::isEmpty() const {
+    if (sizeof(T) == 8) {
+        return 0 != Detail::testz(dataD(), dataD());
+    } else if (sizeof(T) == 4) {
+        return 0 != Detail::testz(data (), data ());
+    } else {
+        return 0 != Detail::testz(dataI(), dataI());
+    }
+}
+
+template <typename T> Vc_INTRINSIC bool Mask<T, VectorAbi::Avx>::isMix() const {
+    if (sizeof(T) == 8) {
+        return 0 != Detail::testnzc(dataD(), Detail::allone<VectorTypeD>());
+    } else if (sizeof(T) == 4) {
+        return 0 != Detail::testnzc(data (), Detail::allone<VectorTypeF>());
+    } else {
+        return 0 != Detail::testnzc(dataI(), Detail::allone<VectorTypeI>());
+    }
+}
+
+// generate {{{1
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 4 + 32>)
 {
-    return _mm256_movemask_epi8(dataI());
+    return _mm256_setr_epi64x(
+        gen(0) ? 0xffffffffffffffffull : 0, gen(1) ? 0xffffffffffffffffull : 0,
+        gen(2) ? 0xffffffffffffffffull : 0, gen(3) ? 0xffffffffffffffffull : 0);
 }
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 16u>::shiftMask() const
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 8 + 32>)
 {
-    return _mm_movemask_epi8(dataI());
+    return _mm256_setr_epi32(gen(0) ? 0xfffffffful : 0, gen(1) ? 0xfffffffful : 0,
+                             gen(2) ? 0xfffffffful : 0, gen(3) ? 0xfffffffful : 0,
+                             gen(4) ? 0xfffffffful : 0, gen(5) ? 0xfffffffful : 0,
+                             gen(6) ? 0xfffffffful : 0, gen(7) ? 0xfffffffful : 0);
 }
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 16 + 32>)
+{
+    return _mm256_setr_epi16(gen(0) ? 0xfffful : 0, gen(1) ? 0xfffful : 0,
+                             gen(2) ? 0xfffful : 0, gen(3) ? 0xfffful : 0,
+                             gen(4) ? 0xfffful : 0, gen(5) ? 0xfffful : 0,
+                             gen(6) ? 0xfffful : 0, gen(7) ? 0xfffful : 0,
+                             gen(8) ? 0xfffful : 0, gen(9) ? 0xfffful : 0,
+                             gen(10) ? 0xfffful : 0, gen(11) ? 0xfffful : 0,
+                             gen(12) ? 0xfffful : 0, gen(13) ? 0xfffful : 0,
+                             gen(14) ? 0xfffful : 0, gen(15) ? 0xfffful : 0);
+}
+template <typename T>
+template <typename G>
+Vc_INTRINSIC AVX2::Mask<T> Mask<T, VectorAbi::Avx>::generate(G &&gen)
+{
+    return generate_impl<AVX2::Mask<T>>(std::forward<G>(gen),
+                                  std::integral_constant<int, Size + sizeof(Storage)>());
+}
+// shifted {{{1
+template <typename T> Vc_INTRINSIC Vc_PURE AVX2::Mask<T> Mask<T, VectorAbi::Avx>::shifted(int amount) const
+{
+    switch (amount * int(sizeof(VectorEntryType))) {
+    case   0: return *this;
+    case   1: return Detail::shifted<  1>(dataI());
+    case   2: return Detail::shifted<  2>(dataI());
+    case   3: return Detail::shifted<  3>(dataI());
+    case   4: return Detail::shifted<  4>(dataI());
+    case   5: return Detail::shifted<  5>(dataI());
+    case   6: return Detail::shifted<  6>(dataI());
+    case   7: return Detail::shifted<  7>(dataI());
+    case   8: return Detail::shifted<  8>(dataI());
+    case   9: return Detail::shifted<  9>(dataI());
+    case  10: return Detail::shifted< 10>(dataI());
+    case  11: return Detail::shifted< 11>(dataI());
+    case  12: return Detail::shifted< 12>(dataI());
+    case  13: return Detail::shifted< 13>(dataI());
+    case  14: return Detail::shifted< 14>(dataI());
+    case  15: return Detail::shifted< 15>(dataI());
+    case  16: return Detail::shifted< 16>(dataI());
+    case  17: return Detail::shifted< 17>(dataI());
+    case  18: return Detail::shifted< 18>(dataI());
+    case  19: return Detail::shifted< 19>(dataI());
+    case  20: return Detail::shifted< 20>(dataI());
+    case  21: return Detail::shifted< 21>(dataI());
+    case  22: return Detail::shifted< 22>(dataI());
+    case  23: return Detail::shifted< 23>(dataI());
+    case  24: return Detail::shifted< 24>(dataI());
+    case  25: return Detail::shifted< 25>(dataI());
+    case  26: return Detail::shifted< 26>(dataI());
+    case  27: return Detail::shifted< 27>(dataI());
+    case  28: return Detail::shifted< 28>(dataI());
+    case  29: return Detail::shifted< 29>(dataI());
+    case  30: return Detail::shifted< 30>(dataI());
+    case  31: return Detail::shifted< 31>(dataI());
+    case  -1: return Detail::shifted< -1>(dataI());
+    case  -2: return Detail::shifted< -2>(dataI());
+    case  -3: return Detail::shifted< -3>(dataI());
+    case  -4: return Detail::shifted< -4>(dataI());
+    case  -5: return Detail::shifted< -5>(dataI());
+    case  -6: return Detail::shifted< -6>(dataI());
+    case  -7: return Detail::shifted< -7>(dataI());
+    case  -8: return Detail::shifted< -8>(dataI());
+    case  -9: return Detail::shifted< -9>(dataI());
+    case -10: return Detail::shifted<-10>(dataI());
+    case -11: return Detail::shifted<-11>(dataI());
+    case -12: return Detail::shifted<-12>(dataI());
+    case -13: return Detail::shifted<-13>(dataI());
+    case -14: return Detail::shifted<-14>(dataI());
+    case -15: return Detail::shifted<-15>(dataI());
+    case -16: return Detail::shifted<-16>(dataI());
+    case -17: return Detail::shifted<-17>(dataI());
+    case -18: return Detail::shifted<-18>(dataI());
+    case -19: return Detail::shifted<-19>(dataI());
+    case -20: return Detail::shifted<-20>(dataI());
+    case -21: return Detail::shifted<-21>(dataI());
+    case -22: return Detail::shifted<-22>(dataI());
+    case -23: return Detail::shifted<-23>(dataI());
+    case -24: return Detail::shifted<-24>(dataI());
+    case -25: return Detail::shifted<-25>(dataI());
+    case -26: return Detail::shifted<-26>(dataI());
+    case -27: return Detail::shifted<-27>(dataI());
+    case -28: return Detail::shifted<-28>(dataI());
+    case -29: return Detail::shifted<-29>(dataI());
+    case -30: return Detail::shifted<-30>(dataI());
+    case -31: return Detail::shifted<-31>(dataI());
+    }
+    return Zero();
+}
+// }}}1
 
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 4, 32>::toInt() const { return _mm256_movemask_pd(dataD()); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 8, 32>::toInt() const { return _mm256_movemask_ps(data ()); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 8, 16>::toInt() const { return _mm_movemask_epi8(_mm_packs_epi16(dataI(), _mm_setzero_si128())); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<16, 16>::toInt() const { return _mm_movemask_epi8(dataI()); }
+/*
+template<> Vc_INTRINSIC AVX2::Mask< 4, 32> &AVX2::Mask< 4, 32>::operator=(const std::array<bool, 4> &values) {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    unsigned int x = *reinterpret_cast<const unsigned int *>(values.data());
+    x *= 0xffu;
+    __m128i y = _mm_cvtsi32_si128(x); //  4 Bytes
+    y = _mm_unpacklo_epi8(y, y);    //  8 Bytes
+    y = _mm_unpacklo_epi16(y, y);   // 16 Bytes
+    d.v() = AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi32(y, y), _mm_unpackhi_epi32(y, y)));
+    return *this;
+}
+template<> Vc_INTRINSIC AVX2::Mask< 8, 32> &AVX2::Mask< 8, 32>::operator=(const std::array<bool, 8> &values) {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    unsigned long long x = *reinterpret_cast<const unsigned long long *>(values.data());
+    x *= 0xffull;
+    __m128i y = _mm_cvtsi64_si128(x); //  8 Bytes
+    y = _mm_unpacklo_epi8(y, y);   // 16 Bytes
+    d.v() = AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi16(y, y), _mm_unpackhi_epi16(y, y)));
+    return *this;
+}
+template<> Vc_INTRINSIC AVX2::Mask< 8, 16> &AVX2::Mask< 8, 16>::operator=(const std::array<bool, 8> &values) {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    unsigned long long x = *reinterpret_cast<const unsigned long long *>(values.data());
+    x *= 0xffull;
+    __m128i y = _mm_cvtsi64_si128(x); //  8 Bytes
+    d.v() = AVX::avx_cast<__m128>(_mm_unpacklo_epi8(y, y));
+    return *this;
+}
+template<> Vc_INTRINSIC AVX2::Mask<16, 16> &AVX2::Mask<16, 16>::operator=(const std::array<bool, 16> &values) {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    __m128i x = _mm_loadu_si128(reinterpret_cast<const __m128i *>(values.data()));
+    d.v() = _mm_andnot_ps(AVX::_mm_setallone_ps(), AVX::avx_cast<__m128>(_mm_sub_epi8(x, _mm_set1_epi8(1))));
+    return *this;
+}
 
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 4, 32>::operator[](int index) const { return toInt() & (1 << index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 8, 32>::operator[](int index) const { return toInt() & (1 << index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 8, 16>::operator[](int index) const { return shiftMask() & (1 << 2 * index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask<16, 16>::operator[](int index) const { return toInt() & (1 << index); }
+template<> Vc_INTRINSIC AVX2::Mask< 4, 32>::operator std::array<bool, 4>() const {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    __m128i x = _mm_packs_epi32(AVX::lo128(dataI()), AVX::hi128(dataI())); // 64bit -> 32bit
+    x = _mm_packs_epi32(x, x); // 32bit -> 16bit
+    x = _mm_srli_epi16(x, 15);
+    x = _mm_packs_epi16(x, x); // 16bit ->  8bit
+    std::array<bool, 4> r;
+    asm volatile("vmovd %1,%0" : "=m"(*r.data()) : "x"(x));
+    return r;
+}
+template<> Vc_INTRINSIC AVX2::Mask< 8, 32>::operator std::array<bool, 8>() const {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    __m128i x = _mm_packs_epi32(AVX::lo128(dataI()), AVX::hi128(dataI())); // 32bit -> 16bit
+    x = _mm_srli_epi16(x, 15);
+    x = _mm_packs_epi16(x, x); // 16bit ->  8bit
+    std::array<bool, 8> r;
+    asm volatile("vmovq %1,%0" : "=m"(*r.data()) : "x"(x));
+    return r;
+}
+template<> Vc_INTRINSIC AVX2::Mask< 8, 16>::operator std::array<bool, 8>() const {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    __m128i x = _mm_srli_epi16(dataI(), 15);
+    x = _mm_packs_epi16(x, x); // 16bit ->  8bit
+    std::array<bool, 8> r;
+    asm volatile("vmovq %1,%0" : "=m"(*r.data()) : "x"(x));
+    return r;
+}
+template<> Vc_INTRINSIC AVX2::Mask<16, 16>::operator std::array<bool, 16>() const {
+    static_assert(sizeof(bool) == 1, "Vc expects bool to have a sizeof 1 Byte");
+    __m128 x = _mm_and_ps(d.v(), AVX::avx_cast<__m128>(_mm_set1_epi32(0x01010101)));
+    std::array<bool, 16> r;
+    asm volatile("vmovups %1,%0" : "=m"(*r.data()) : "x"(x));
+    return r;
+}
+*/
 
-#ifndef VC_IMPL_POPCNT
-static Vc_ALWAYS_INLINE Vc_CONST unsigned int _mm_popcnt_u32(unsigned int n) {
-    n = (n & 0x55555555U) + ((n >> 1) & 0x55555555U);
-    n = (n & 0x33333333U) + ((n >> 2) & 0x33333333U);
-    n = (n & 0x0f0f0f0fU) + ((n >> 4) & 0x0f0f0f0fU);
-    //n = (n & 0x00ff00ffU) + ((n >> 8) & 0x00ff00ffU);
-    //n = (n & 0x0000ffffU) + ((n >>16) & 0x0000ffffU);
-    return n;
 }
-#endif
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 32u>::count() const { return _mm_popcnt_u32(toInt()); }
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 16u>::count() const { return _mm_popcnt_u32(toInt()); }
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 32u>::firstOne() const { return _bit_scan_forward(toInt()); }
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size, 16u>::firstOne() const { return _bit_scan_forward(toInt()); }
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/math.h vc-1.3.0/avx/math.h
--- vc-0.7.4/avx/math.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/math.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,119 +1,316 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_MATH_H
-#define VC_AVX_MATH_H
+#ifndef VC_AVX_MATH_H_
+#define VC_AVX_MATH_H_
 
 #include "const.h"
 #include "limits.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
+{
+// min & max {{{1
+#ifdef Vc_IMPL_AVX2
+Vc_ALWAYS_INLINE AVX2::int_v    min(const AVX2::int_v    &x, const AVX2::int_v    &y) { return _mm256_min_epi32(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::uint_v   min(const AVX2::uint_v   &x, const AVX2::uint_v   &y) { return _mm256_min_epu32(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::short_v  min(const AVX2::short_v  &x, const AVX2::short_v  &y) { return _mm256_min_epi16(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::ushort_v min(const AVX2::ushort_v &x, const AVX2::ushort_v &y) { return _mm256_min_epu16(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::int_v    max(const AVX2::int_v    &x, const AVX2::int_v    &y) { return _mm256_max_epi32(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::uint_v   max(const AVX2::uint_v   &x, const AVX2::uint_v   &y) { return _mm256_max_epu32(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::short_v  max(const AVX2::short_v  &x, const AVX2::short_v  &y) { return _mm256_max_epi16(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::ushort_v max(const AVX2::ushort_v &x, const AVX2::ushort_v &y) { return _mm256_max_epu16(x.data(), y.data()); }
+#endif
+Vc_ALWAYS_INLINE AVX2::float_v  min(const AVX2::float_v  &x, const AVX2::float_v  &y) { return _mm256_min_ps(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::double_v min(const AVX2::double_v &x, const AVX2::double_v &y) { return _mm256_min_pd(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::float_v  max(const AVX2::float_v  &x, const AVX2::float_v  &y) { return _mm256_max_ps(x.data(), y.data()); }
+Vc_ALWAYS_INLINE AVX2::double_v max(const AVX2::double_v &x, const AVX2::double_v &y) { return _mm256_max_pd(x.data(), y.data()); }
+
+// sqrt {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> sqrt(const AVX2::Vector<T> &x)
+{
+    return AVX::VectorHelper<T>::sqrt(x.data());
+}
+
+// rsqrt {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> rsqrt(const AVX2::Vector<T> &x)
+{
+    return AVX::VectorHelper<T>::rsqrt(x.data());
+}
+
+// reciprocal {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> reciprocal(const AVX2::Vector<T> &x)
+{
+    return AVX::VectorHelper<T>::reciprocal(x.data());
+}
+
+// round {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> round(const AVX2::Vector<T> &x)
+{
+    return AVX::VectorHelper<T>::round(x.data());
+}
+
+// abs {{{1
+Vc_INTRINSIC Vc_CONST AVX2::double_v abs(AVX2::double_v x)
+{
+    return Detail::and_(x.data(), AVX::setabsmask_pd());
+}
+Vc_INTRINSIC Vc_CONST AVX2::float_v abs(AVX2::float_v x)
+{
+    return Detail::and_(x.data(), AVX::setabsmask_ps());
+}
+#ifdef Vc_IMPL_AVX2
+Vc_INTRINSIC Vc_CONST AVX2::int_v abs(AVX2::int_v x)
+{
+    return _mm256_abs_epi32(x.data());
+}
+Vc_INTRINSIC Vc_CONST AVX2::short_v abs(AVX2::short_v x)
+{
+    return _mm256_abs_epi16(x.data());
+}
+#endif
+
+// isfinite {{{1
+Vc_ALWAYS_INLINE Vc_PURE AVX2::double_m isfinite(const AVX2::double_v &x)
+{
+    return AVX::cmpord_pd(x.data(), _mm256_mul_pd(Detail::zero<__m256d>(), x.data()));
+}
+
+Vc_ALWAYS_INLINE Vc_PURE AVX2::float_m isfinite(const AVX2::float_v &x)
+{
+    return AVX::cmpord_ps(x.data(), _mm256_mul_ps(Detail::zero<__m256>(), x.data()));
+}
+
+// isinf {{{1
+Vc_ALWAYS_INLINE Vc_PURE AVX2::double_m isinf(const AVX2::double_v &x)
+{
+    return _mm256_castsi256_pd(AVX::cmpeq_epi64(
+        _mm256_castpd_si256(abs(x).data()),
+        _mm256_castpd_si256(Detail::avx_broadcast(AVX::c_log<double>::d(1)))));
+}
+
+Vc_ALWAYS_INLINE Vc_PURE AVX2::float_m isinf(const AVX2::float_v &x)
+{
+    return _mm256_castsi256_ps(
+        AVX::cmpeq_epi32(_mm256_castps_si256(abs(x).data()),
+                         _mm256_castps_si256(Detail::avx_broadcast(AVX::c_log<float>::d(1)))));
+}
+
+// isnan {{{1
+Vc_ALWAYS_INLINE Vc_PURE AVX2::double_m isnan(const AVX2::double_v &x)
 {
-namespace AVX
+    return AVX::cmpunord_pd(x.data(), x.data());
+}
+
+Vc_ALWAYS_INLINE Vc_PURE AVX2::float_m isnan(const AVX2::float_v &x)
+{
+    return AVX::cmpunord_ps(x.data(), x.data());
+}
+
+// copysign {{{1
+Vc_INTRINSIC Vc_CONST AVX2::float_v copysign(AVX2::float_v mag, AVX2::float_v sign)
+{
+    return _mm256_or_ps(_mm256_and_ps(sign.data(), AVX::setsignmask_ps()),
+                        _mm256_and_ps(mag.data(), AVX::setabsmask_ps()));
+}
+Vc_INTRINSIC Vc_CONST AVX2::double_v copysign(AVX2::double_v::AsArg mag,
+                                              AVX2::double_v::AsArg sign)
 {
-    /**
-     * splits \p v into exponent and mantissa, the sign is kept with the mantissa
-     *
-     * The return value will be in the range [0.5, 1.0[
-     * The \p e value will be an integer defining the power-of-two exponent
-     */
-    inline double_v frexp(double_v::AsArg v, int_v *e) {
-        const m256d exponentBits = Const<double>::exponentMask().dataD();
-        const m256d exponentPart = _mm256_and_pd(v.data(), exponentBits);
-        e->data() = _mm256_sub_epi32(_mm256_srli_epi64(avx_cast<m256i>(exponentPart), 52), _mm256_set1_epi32(0x3fe));
-        const m256d exponentMaximized = _mm256_or_pd(v.data(), exponentBits);
-        double_v ret = _mm256_and_pd(exponentMaximized, _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::frexpMask)));
-        double_m zeroMask = v == double_v::Zero();
-        ret(isnan(v) || !isfinite(v) || zeroMask) = v;
-        e->setZero(zeroMask.data());
-        return ret;
-    }
-    inline float_v frexp(float_v::AsArg v, int_v *e) {
-        const m256 exponentBits = Const<float>::exponentMask().data();
-        const m256 exponentPart = _mm256_and_ps(v.data(), exponentBits);
-        e->data() = _mm256_sub_epi32(_mm256_srli_epi32(avx_cast<m256i>(exponentPart), 23), _mm256_set1_epi32(0x7e));
-        const m256 exponentMaximized = _mm256_or_ps(v.data(), exponentBits);
-        float_v ret = _mm256_and_ps(exponentMaximized, avx_cast<m256>(_mm256_set1_epi32(0xbf7fffffu)));
-        ret(isnan(v) || !isfinite(v) || v == float_v::Zero()) = v;
-        e->setZero(v == float_v::Zero());
-        return ret;
-    }
-    inline sfloat_v frexp(sfloat_v::AsArg v, short_v *e) {
-        const m256 exponentBits = Const<float>::exponentMask().data();
-        const m256 exponentPart = _mm256_and_ps(v.data(), exponentBits);
-        e->data() = _mm_sub_epi16(_mm_packs_epi32(_mm_srli_epi32(avx_cast<m128i>(exponentPart), 23),
-                    _mm_srli_epi32(avx_cast<m128i>(hi128(exponentPart)), 23)), _mm_set1_epi16(0x7e));
-        const m256 exponentMaximized = _mm256_or_ps(v.data(), exponentBits);
-        sfloat_v ret = _mm256_and_ps(exponentMaximized, avx_cast<m256>(_mm256_set1_epi32(0xbf7fffffu)));
-        ret(isnan(v) || !isfinite(v) || v == sfloat_v::Zero()) = v;
-        e->setZero(v == sfloat_v::Zero());
-        return ret;
-    }
-
-    /*             -> x * 2^e
-     * x == NaN    -> NaN
-     * x == (-)inf -> (-)inf
-     */
-    inline double_v ldexp(double_v::AsArg v, int_v::AsArg _e) {
-        int_v e = _e;
-        e.setZero((v == double_v::Zero()).dataI());
-        const m256i exponentBits = _mm256_slli_epi64(e.data(), 52);
-        return avx_cast<m256d>(_mm256_add_epi64(avx_cast<m256i>(v.data()), exponentBits));
-    }
-    inline float_v ldexp(float_v::AsArg v, int_v::AsArg _e) {
-        int_v e = _e;
-        e.setZero(static_cast<int_m>(v == float_v::Zero()));
-        return (v.reinterpretCast<int_v>() + (e << 23)).reinterpretCast<float_v>();
-    }
-    inline sfloat_v ldexp(sfloat_v::AsArg v, short_v::AsArg _e) {
-        short_v e = _e;
-        e.setZero(static_cast<short_m>(v == sfloat_v::Zero()));
-        e = e << (23 - 16);
-        const m256i exponentBits = concat(_mm_unpacklo_epi16(_mm_setzero_si128(), e.data()),
-                _mm_unpackhi_epi16(_mm_setzero_si128(), e.data()));
-        return (v.reinterpretCast<int_v>() + int_v(exponentBits)).reinterpretCast<sfloat_v>();
-    }
-
-    static Vc_ALWAYS_INLINE  float_v trunc( float_v::AsArg v) { return _mm256_round_ps(v.data(), 0x3); }
-    static Vc_ALWAYS_INLINE sfloat_v trunc(sfloat_v::AsArg v) { return _mm256_round_ps(v.data(), 0x3); }
-    static Vc_ALWAYS_INLINE double_v trunc(double_v::AsArg v) { return _mm256_round_pd(v.data(), 0x3); }
-
-    static Vc_ALWAYS_INLINE float_v floor(float_v::AsArg v) { return _mm256_floor_ps(v.data()); }
-    static Vc_ALWAYS_INLINE sfloat_v floor(sfloat_v::AsArg v) { return _mm256_floor_ps(v.data()); }
-    static Vc_ALWAYS_INLINE double_v floor(double_v::AsArg v) { return _mm256_floor_pd(v.data()); }
-
-    static Vc_ALWAYS_INLINE float_v ceil(float_v::AsArg v) { return _mm256_ceil_ps(v.data()); }
-    static Vc_ALWAYS_INLINE sfloat_v ceil(sfloat_v::AsArg v) { return _mm256_ceil_ps(v.data()); }
-    static Vc_ALWAYS_INLINE double_v ceil(double_v::AsArg v) { return _mm256_ceil_pd(v.data()); }
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
-#define VC__USE_NAMESPACE AVX
-#include "../common/trigonometric.h"
-#define VC__USE_NAMESPACE AVX
-#include "../common/logarithm.h"
-#define VC__USE_NAMESPACE AVX
-#include "../common/exponential.h"
-#undef VC__USE_NAMESPACE
+    return _mm256_or_pd(_mm256_and_pd(sign.data(), AVX::setsignmask_pd()),
+                        _mm256_and_pd(mag.data(), AVX::setabsmask_pd()));
+}
+
+//}}}1
+// frexp {{{1
+/**
+ * splits \p v into exponent and mantissa, the sign is kept with the mantissa
+ *
+ * The return value will be in the range [0.5, 1.0[
+ * The \p e value will be an integer defining the power-of-two exponent
+ */
+inline AVX2::double_v frexp(AVX2::double_v::AsArg v, SimdArray<int, 4, SSE::int_v, 4> *e)
+{
+    const __m256d exponentBits = AVX::Const<double>::exponentMask().dataD();
+    const __m256d exponentPart = _mm256_and_pd(v.data(), exponentBits);
+    auto lo = AVX::avx_cast<__m128i>(AVX::lo128(exponentPart));
+    auto hi = AVX::avx_cast<__m128i>(AVX::hi128(exponentPart));
+    lo = _mm_sub_epi32(_mm_srli_epi64(lo, 52), _mm_set1_epi64x(0x3fe));
+    hi = _mm_sub_epi32(_mm_srli_epi64(hi, 52), _mm_set1_epi64x(0x3fe));
+    SSE::int_v exponent = Mem::shuffle<X0, X2, Y0, Y2>(lo, hi);
+    const __m256d exponentMaximized = _mm256_or_pd(v.data(), exponentBits);
+    AVX2::double_v ret =
+        _mm256_and_pd(exponentMaximized,
+                      _mm256_broadcast_sd(reinterpret_cast<const double *>(&AVX::c_general::frexpMask)));
+    const double_m zeroMask = v == AVX2::double_v::Zero();
+    ret(isnan(v) || !isfinite(v) || zeroMask) = v;
+    exponent.setZero(simd_cast<SSE::int_m>(zeroMask));
+    internal_data(*e) = exponent;
+    return ret;
+}
+
+#ifdef Vc_IMPL_AVX2
+inline SimdArray<double, 8, AVX2::double_v, 4> frexp(
+    const SimdArray<double, 8, AVX2::double_v, 4> &v,
+    SimdArray<int, 8, AVX2::int_v, 8> *e)
+{
+    const __m256d exponentBits = AVX::Const<double>::exponentMask().dataD();
+    const __m256d w[2] = {internal_data(internal_data0(v)).data(),
+                          internal_data(internal_data1(v)).data()};
+    const __m256i exponentPart[2] = {
+        _mm256_castpd_si256(_mm256_and_pd(w[0], exponentBits)),
+        _mm256_castpd_si256(_mm256_and_pd(w[1], exponentBits))};
+    const __m256i lo = _mm256_sub_epi32(_mm256_srli_epi64(exponentPart[0], 52),
+                                        _mm256_set1_epi32(0x3fe));   // 0.1. 2.3.
+    const __m256i hi = _mm256_sub_epi32(_mm256_srli_epi64(exponentPart[1], 52),
+                                        _mm256_set1_epi32(0x3fe));   // 4.5. 6.7.
+    const __m256i a = _mm256_unpacklo_epi32(lo, hi);                 // 04.. 26..
+    const __m256i b = _mm256_unpackhi_epi32(lo, hi);                 // 15.. 37..
+    const __m256i tmp = _mm256_unpacklo_epi32(a, b);                 // 0145 2367
+    const __m256i exponent =
+        AVX::concat(_mm_unpacklo_epi64(AVX::lo128(tmp), AVX::hi128(tmp)),
+                    _mm_unpackhi_epi64(AVX::lo128(tmp), AVX::hi128(tmp)));  // 0123 4567
+    const __m256d exponentMaximized[2] = {_mm256_or_pd(w[0], exponentBits),
+                                          _mm256_or_pd(w[1], exponentBits)};
+    const auto frexpMask =
+        _mm256_broadcast_sd(reinterpret_cast<const double *>(&AVX::c_general::frexpMask));
+    SimdArray<double, 8, AVX2::double_v, 4> ret = {
+        SimdArray<double, 4, AVX2::double_v, 4>(
+            _mm256_and_pd(exponentMaximized[0], frexpMask)),
+        SimdArray<double, 4, AVX2::double_v, 4>(
+            _mm256_and_pd(exponentMaximized[1], frexpMask))};
+    const auto zeroMask = v == v.Zero();
+    ret(isnan(v) || !isfinite(v) || zeroMask) = v;
+    internal_data(*e) =
+        Detail::andnot_(simd_cast<AVX2::int_m>(zeroMask).dataI(), exponent);
+    return ret;
+}
+#endif  // Vc_IMPL_AVX2
+
+namespace Detail
+{
+Vc_INTRINSIC AVX2::float_v::IndexType extractExponent(__m256 e)
+{
+    SimdArray<uint, float_v::Size> exponentPart;
+    const auto ee = AVX::avx_cast<__m256i>(e);
+#ifdef Vc_IMPL_AVX2
+    exponentPart = AVX2::uint_v(ee);
+#else
+    internal_data(internal_data0(exponentPart)) = AVX::lo128(ee);
+    internal_data(internal_data1(exponentPart)) = AVX::hi128(ee);
+#endif
+    return (exponentPart >> 23) - 0x7e;
+}
+}  // namespace Detail
+inline AVX2::float_v frexp(AVX2::float_v::AsArg v, AVX2::float_v::IndexType *e)
+{
+    using namespace Detail;
+    using namespace AVX2;
+    const __m256 exponentBits = Const<float>::exponentMask().data();
+    *e = extractExponent(and_(v.data(), exponentBits));
+    const __m256 exponentMaximized = or_(v.data(), exponentBits);
+    AVX2::float_v ret = _mm256_and_ps(exponentMaximized, avx_cast<__m256>(set1_epi32(0xbf7fffffu)));
+    ret(isnan(v) || !isfinite(v) || v == AVX2::float_v::Zero()) = v;
+    e->setZero(simd_cast<decltype(*e == *e)>(v == AVX2::float_v::Zero()));
+    return ret;
+}
+
+// ldexp {{{1
+/*             -> x * 2^e
+ * x == NaN    -> NaN
+ * x == (-)inf -> (-)inf
+ */
+inline AVX2::double_v ldexp(AVX2::double_v::AsArg v,
+                            const SimdArray<int, 4, SSE::int_v, 4> &_e)
+{
+    SSE::int_v e = internal_data(_e);
+    e.setZero(simd_cast<SSE::int_m>(v == AVX2::double_v::Zero()));
+    const __m256i exponentBits =
+        AVX::concat(_mm_slli_epi64(_mm_unpacklo_epi32(e.data(), e.data()), 52),
+                    _mm_slli_epi64(_mm_unpackhi_epi32(e.data(), e.data()), 52));
+    return AVX::avx_cast<__m256d>(
+        AVX::add_epi64(AVX::avx_cast<__m256i>(v.data()), exponentBits));
+}
+inline AVX2::float_v ldexp(AVX2::float_v::AsArg v, SimdArray<int, 8, SSE::int_v, 4> e)
+{
+    e.setZero(simd_cast<decltype(e == e)>(v == AVX2::float_v::Zero()));
+    e <<= 23;
+    return {AVX::avx_cast<__m256>(
+        AVX::concat(_mm_add_epi32(AVX::avx_cast<__m128i>(AVX::lo128(v.data())),
+                                  internal_data(internal_data0(e)).data()),
+                    _mm_add_epi32(AVX::avx_cast<__m128i>(AVX::hi128(v.data())),
+                                  internal_data(internal_data1(e)).data())))};
+}
+
+// trunc {{{1
+Vc_ALWAYS_INLINE AVX2::float_v trunc(AVX2::float_v::AsArg v)
+{
+    return _mm256_round_ps(v.data(), 0x3);
+}
+Vc_ALWAYS_INLINE AVX2::double_v trunc(AVX2::double_v::AsArg v)
+{
+    return _mm256_round_pd(v.data(), 0x3);
+}
+
+// floor {{{1
+Vc_ALWAYS_INLINE AVX2::float_v floor(AVX2::float_v::AsArg v)
+{
+    return _mm256_floor_ps(v.data());
+}
+Vc_ALWAYS_INLINE AVX2::double_v floor(AVX2::double_v::AsArg v)
+{
+    return _mm256_floor_pd(v.data());
+}
+
+// ceil {{{1
+Vc_ALWAYS_INLINE AVX2::float_v ceil(AVX2::float_v::AsArg v)
+{
+    return _mm256_ceil_ps(v.data());
+}
+Vc_ALWAYS_INLINE AVX2::double_v ceil(AVX2::double_v::AsArg v)
+{
+    return _mm256_ceil_pd(v.data());
+}
+
+// fma {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Avx> fma(Vector<T, VectorAbi::Avx> a,
+                                               Vector<T, VectorAbi::Avx> b,
+                                               Vector<T, VectorAbi::Avx> c)
+{
+    return Detail::fma(a.data(), b.data(), c.data(), T());
+}
+
+// }}}1
+}  // namespace Vc
+
+#endif // VC_AVX_MATH_H_
 
-#endif // VC_AVX_MATH_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/prefetches.tcc vc-1.3.0/avx/prefetches.tcc
--- vc-0.7.4/avx/prefetches.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/prefetches.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,58 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010, 2011-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_PREFETCHES_TCC
-#define VC_AVX_PREFETCHES_TCC
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Internal
-{
-
-Vc_ALWAYS_INLINE void HelperImpl<Vc::AVXImpl>::prefetchForOneRead(const void *addr)
-{
-    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_NTA);
-}
-Vc_ALWAYS_INLINE void HelperImpl<Vc::AVXImpl>::prefetchClose(const void *addr)
-{
-    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
-}
-Vc_ALWAYS_INLINE void HelperImpl<Vc::AVXImpl>::prefetchMid(const void *addr)
-{
-    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T1);
-}
-Vc_ALWAYS_INLINE void HelperImpl<Vc::AVXImpl>::prefetchFar(const void *addr)
-{
-    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T2);
-}
-Vc_ALWAYS_INLINE void HelperImpl<Vc::AVXImpl>::prefetchForModify(const void *addr)
-{
-#ifdef __3dNOW__
-    _m_prefetchw(const_cast<void *>(addr));
-#else
-    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
-#endif
-}
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_AVX_PREFETCHES_TCC
diff -Nru vc-0.7.4/avx/shuffle.h vc-1.3.0/avx/shuffle.h
--- vc-0.7.4/avx/shuffle.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/shuffle.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,108 +1,170 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_SHUFFLE_H
-#define VC_AVX_SHUFFLE_H
+#ifndef VC_AVX_SHUFFLE_H_
+#define VC_AVX_SHUFFLE_H_
 
 #include "../sse/shuffle.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-        using AVX::m128;
-        using AVX::m128d;
-        using AVX::m128i;
-        using AVX::m256;
-        using AVX::m256d;
-        using AVX::m256i;
-        using AVX::param128;
-        using AVX::param128d;
-        using AVX::param128i;
-        using AVX::param256;
-        using AVX::param256d;
-        using AVX::param256i;
-    namespace Mem
-    {
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256 Vc_CONST permute128(param256 x) {
-            VC_STATIC_ASSERT(L >= X0 && L <= X1, Incorrect_Range);
-            VC_STATIC_ASSERT(H >= X0 && H <= X1, Incorrect_Range);
-            return _mm256_permute2f128_ps(x, x, L + H * (1 << 4));
-        }
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256d Vc_CONST permute128(param256d x) {
-            VC_STATIC_ASSERT(L >= X0 && L <= X1, Incorrect_Range);
-            VC_STATIC_ASSERT(H >= X0 && H <= X1, Incorrect_Range);
-            return _mm256_permute2f128_pd(x, x, L + H * (1 << 4));
-        }
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256i Vc_CONST permute128(param256i x) {
-            VC_STATIC_ASSERT(L >= X0 && L <= X1, Incorrect_Range);
-            VC_STATIC_ASSERT(H >= X0 && H <= X1, Incorrect_Range);
-            return _mm256_permute2f128_si256(x, x, L + H * (1 << 4));
-        }
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256 Vc_CONST shuffle128(param256 x, param256 y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
+namespace Detail
+{
+template <int... Dst> struct Permutation {};
+template <uint8_t... Sel> struct Mask {};
+
+#ifdef Vc_IMPL_AVX2
+template <uint8_t Sel0, uint8_t Sel1, uint8_t Sel2, uint8_t Sel3, uint8_t Sel4,
+          uint8_t Sel5, uint8_t Sel6, uint8_t Sel7, uint8_t Sel8, uint8_t Sel9,
+          uint8_t Sel10, uint8_t Sel11, uint8_t Sel12, uint8_t Sel13, uint8_t Sel14,
+          uint8_t Sel15>
+Vc_INTRINSIC Vc_CONST __m256i
+blend(__m256i a, __m256i b, Mask<Sel0, Sel1, Sel2, Sel3, Sel4, Sel5, Sel6, Sel7, Sel8,
+                                 Sel9, Sel10, Sel11, Sel12, Sel13, Sel14, Sel15>)
+{
+    static_assert((Sel0 == 0 || Sel0 == 1) && (Sel1 == 0 || Sel1 == 1) &&
+                      (Sel2 == 0 || Sel2 == 1) && (Sel3 == 0 || Sel3 == 1) &&
+                      (Sel4 == 0 || Sel4 == 1) && (Sel5 == 0 || Sel5 == 1) &&
+                      (Sel6 == 0 || Sel6 == 1) && (Sel7 == 0 || Sel7 == 1) &&
+                      (Sel8 == 0 || Sel8 == 1) && (Sel9 == 0 || Sel9 == 1) &&
+                      (Sel10 == 0 || Sel10 == 1) && (Sel11 == 0 || Sel11 == 1) &&
+                      (Sel12 == 0 || Sel12 == 1) && (Sel13 == 0 || Sel13 == 1) &&
+                      (Sel14 == 0 || Sel14 == 1) && (Sel15 == 0 || Sel15 == 1),
+                  "Selectors must be 0 or 1 to select the value from a or b");
+    constexpr uint8_t mask = static_cast<uint8_t>(
+        (Sel0  << 0 ) | (Sel1  << 1 ) | (Sel2  << 2 ) | (Sel3  << 3 ) |
+        (Sel4  << 4 ) | (Sel5  << 5 ) | (Sel6  << 6 ) | (Sel7  << 7 ) |
+        (Sel8  << 8 ) | (Sel9  << 9 ) | (Sel10 << 10) | (Sel11 << 11) |
+        (Sel12 << 12) | (Sel13 << 13) | (Sel14 << 14) | (Sel15 << 15));
+    return _mm256_blend_epi16(a, b, mask);
+}
+#endif  // Vc_IMPL_AVX2
+}  // namespace Detail
+namespace Mem
+{
+#ifdef Vc_IMPL_AVX2
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256i Vc_CONST permuteLo(__m256i x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
+            return _mm256_shufflelo_epi16(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
+        }
+
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256i Vc_CONST permuteHi(__m256i x) {
+            static_assert(Dst0 >= X4 && Dst1 >= X4 && Dst2 >= X4 && Dst3 >= X4, "Incorrect_Range");
+            static_assert(Dst0 <= X7 && Dst1 <= X7 && Dst2 <= X7 && Dst3 <= X7, "Incorrect_Range");
+            return _mm256_shufflehi_epi16(x, (Dst0 - X4) + (Dst1 - X4) * 4 + (Dst2 - X4) * 16 + (Dst3 - X4) * 64);
+        }
+#endif  // Vc_IMPL_AVX2
+
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256 Vc_CONST permute128(__m256 x) {
+            static_assert((L >= X0 && L <= X1) || L == Const0, "Incorrect_Range");
+            static_assert((H >= X0 && H <= X1) || H == Const0, "Incorrect_Range");
+            return _mm256_permute2f128_ps(
+                x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));
+        }
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256d Vc_CONST permute128(__m256d x) {
+            static_assert((L >= X0 && L <= X1) || L == Const0, "Incorrect_Range");
+            static_assert((H >= X0 && H <= X1) || H == Const0, "Incorrect_Range");
+            return _mm256_permute2f128_pd(
+                x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));
+        }
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256i Vc_CONST permute128(__m256i x) {
+            static_assert((L >= X0 && L <= X1) || L == Const0, "Incorrect_Range");
+            static_assert((H >= X0 && H <= X1) || H == Const0, "Incorrect_Range");
+#ifdef Vc_IMPL_AVX2
+            return _mm256_permute2x128_si256(
+                x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));
+#else
+            return _mm256_permute2f128_si256(
+                x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));
+#endif
+        }
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle128(__m256 x, __m256 y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
             return _mm256_permute2f128_ps(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
         }
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256i Vc_CONST shuffle128(param256i x, param256i y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
-            return _mm256_permute2f128_si256(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
-        }
-        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE m256d Vc_CONST shuffle128(param256d x, param256d y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256i Vc_CONST shuffle128(__m256i x, __m256i y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
+#ifdef Vc_IMPL_AVX2
+            return _mm256_permute2x128_si256(
+                x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
+#else
+            return _mm256_permute2f128_si256(
+                x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
+#endif
+        }
+        template<VecPos L, VecPos H> static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle128(__m256d x, __m256d y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
             return _mm256_permute2f128_pd(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
         }
-        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE m256d Vc_CONST permute(param256d x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256d Vc_CONST permute(__m256d x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm256_permute_pd(x, Dst0 + Dst1 * 2 + (Dst2 - X2) * 4 + (Dst3 - X2) * 8);
         }
-        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE m256 Vc_CONST permute(param256 x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm256_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
-        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE m256i Vc_CONST permute(param256i x) {
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256i Vc_CONST permute(__m256i x) {
             return _mm256_castps_si256(permute<Dst0, Dst1, Dst2, Dst3>(_mm256_castsi256_ps(x)));
         }
-        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE m256d Vc_CONST shuffle(param256d x, param256d y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, Incorrect_Range);
+#ifdef Vc_IMPL_AVX2
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256i Vc_CONST permute4x64(__m256i x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
+            return _mm256_permute4x64_epi64(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
+        }
+#endif  // Vc_IMPL_AVX2
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle(__m256d x, __m256d y) {
+            static_assert(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm256_shuffle_pd(x, y, Dst0 + (Dst1 - Y0) * 2 + (Dst2 - X2) * 4 + (Dst3 - Y2) * 8);
         }
-        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE m256 Vc_CONST shuffle(param256 x, param256 y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, Incorrect_Range);
+        template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle(__m256 x, __m256 y) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm256_shuffle_ps(x, y, Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64);
         }
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7>
-        static Vc_ALWAYS_INLINE m256 Vc_CONST blend(param256 x, param256 y) {
-            VC_STATIC_ASSERT(Dst0 == X0 || Dst0 == Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst1 == X1 || Dst1 == Y1, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst2 == X2 || Dst2 == Y2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst3 == X3 || Dst3 == Y3, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst4 == X4 || Dst4 == Y4, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst5 == X5 || Dst5 == Y5, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst6 == X6 || Dst6 == Y6, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst7 == X7 || Dst7 == Y7, Incorrect_Range);
+        static Vc_ALWAYS_INLINE __m256 Vc_CONST blend(__m256 x, __m256 y) {
+            static_assert(Dst0 == X0 || Dst0 == Y0, "Incorrect_Range");
+            static_assert(Dst1 == X1 || Dst1 == Y1, "Incorrect_Range");
+            static_assert(Dst2 == X2 || Dst2 == Y2, "Incorrect_Range");
+            static_assert(Dst3 == X3 || Dst3 == Y3, "Incorrect_Range");
+            static_assert(Dst4 == X4 || Dst4 == Y4, "Incorrect_Range");
+            static_assert(Dst5 == X5 || Dst5 == Y5, "Incorrect_Range");
+            static_assert(Dst6 == X6 || Dst6 == Y6, "Incorrect_Range");
+            static_assert(Dst7 == X7 || Dst7 == Y7, "Incorrect_Range");
             return _mm256_blend_ps(x, y,
                     (Dst0 / Y0) *  1 + (Dst1 / Y1) *  2 +
                     (Dst2 / Y2) *  4 + (Dst3 / Y3) *  8 +
@@ -111,26 +173,26 @@
                     );
         }
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7>
-        static Vc_ALWAYS_INLINE m256i Vc_CONST blend(param256i x, param256i y) {
+        static Vc_ALWAYS_INLINE __m256i Vc_CONST blend(__m256i x, __m256i y) {
             return _mm256_castps_si256(blend<Dst0, Dst1, Dst2, Dst3, Dst4, Dst5, Dst6, Dst7>(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));
         }
         template<VecPos Dst> struct ScaleForBlend { enum { Value = Dst >= X4 ? Dst - X4 + Y0 : Dst }; };
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7>
-        static Vc_ALWAYS_INLINE m256 Vc_CONST permute(param256 x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst0 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst1 >= X0 && Dst1 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst2 >= X0 && Dst2 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst3 >= X0 && Dst3 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst4 >= X0 && Dst4 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst5 >= X0 && Dst5 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst6 >= X0 && Dst6 <= X7, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst7 >= X0 && Dst7 <= X7, Incorrect_Range);
+        static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {
+            static_assert(Dst0 >= X0 && Dst0 <= X7, "Incorrect_Range");
+            static_assert(Dst1 >= X0 && Dst1 <= X7, "Incorrect_Range");
+            static_assert(Dst2 >= X0 && Dst2 <= X7, "Incorrect_Range");
+            static_assert(Dst3 >= X0 && Dst3 <= X7, "Incorrect_Range");
+            static_assert(Dst4 >= X0 && Dst4 <= X7, "Incorrect_Range");
+            static_assert(Dst5 >= X0 && Dst5 <= X7, "Incorrect_Range");
+            static_assert(Dst6 >= X0 && Dst6 <= X7, "Incorrect_Range");
+            static_assert(Dst7 >= X0 && Dst7 <= X7, "Incorrect_Range");
             if (Dst0 + X4 == Dst4 && Dst1 + X4 == Dst5 && Dst2 + X4 == Dst6 && Dst3 + X4 == Dst7) {
                 return permute<Dst0, Dst1, Dst2, Dst3>(x);
             }
-            const m128 loIn = _mm256_castps256_ps128(x);
-            const m128 hiIn = _mm256_extractf128_ps(x, 1);
-            m128 lo, hi;
+            const __m128 loIn = _mm256_castps256_ps128(x);
+            const __m128 hiIn = _mm256_extractf128_ps(x, 1);
+            __m128 lo, hi;
 
             if (Dst0 < X4 && Dst1 < X4 && Dst2 < X4 && Dst3 < X4) {
                 lo = _mm_permute_ps(loIn, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
@@ -176,7 +238,8 @@
 
             return _mm256_insertf128_ps(_mm256_castps128_ps256(lo), hi, 1);
         }
-    } // namespace Mem
+}  // namespace Mem
+}  // namespace Vc
 
     // little endian has the lo bits on the right and high bits on the left
     // with vectors this becomes greatly confusing:
@@ -184,56 +247,62 @@
     // Reg: dcba
     //
     // The shuffles and permutes above use memory ordering. The ones below use register ordering:
-    namespace Reg
-    {
-        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE m256 Vc_CONST permute128(param256 x, param256 y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Reg
+{
+        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE __m256 Vc_CONST permute128(__m256 x, __m256 y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
             return _mm256_permute2f128_ps(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
         }
-        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE m256i Vc_CONST permute128(param256i x, param256i y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
-            return _mm256_permute2f128_si256(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
-        }
-        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE m256d Vc_CONST permute128(param256d x, param256d y) {
-            VC_STATIC_ASSERT(L >= X0 && H >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(L <= Y1 && H <= Y1, Incorrect_Range);
+        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE __m256i Vc_CONST permute128(__m256i x, __m256i y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
+#ifdef Vc_IMPL_AVX2
+            return _mm256_permute2x128_si256(
+                x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
+#else
+            return _mm256_permute2f128_si256(
+                x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
+#endif
+        }
+        template<VecPos H, VecPos L> static Vc_ALWAYS_INLINE __m256d Vc_CONST permute128(__m256d x, __m256d y) {
+            static_assert(L >= X0 && H >= X0, "Incorrect_Range");
+            static_assert(L <= Y1 && H <= Y1, "Incorrect_Range");
             return _mm256_permute2f128_pd(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));
         }
-        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m256d Vc_CONST permute(param256d x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m256d Vc_CONST permute(__m256d x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm256_permute_pd(x, Dst0 + Dst1 * 2 + (Dst2 - X2) * 4 + (Dst3 - X2) * 8);
         }
-        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m256 Vc_CONST permute(param256 x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm256_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
-        template<VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m128d Vc_CONST permute(param128d x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= X1, Incorrect_Range);
+        template<VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128d Vc_CONST permute(__m128d x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= X1, "Incorrect_Range");
             return _mm_permute_pd(x, Dst0 + Dst1 * 2);
         }
-        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m128 Vc_CONST permute(param128 x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128 Vc_CONST permute(__m128 x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
-        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m256d Vc_CONST shuffle(param256d x, param256d y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, Incorrect_Range);
+        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle(__m256d x, __m256d y) {
+            static_assert(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm256_shuffle_pd(x, y, Dst0 + (Dst1 - Y0) * 2 + (Dst2 - X2) * 4 + (Dst3 - Y2) * 8);
         }
-        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE m256 Vc_CONST shuffle(param256 x, param256 y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, Incorrect_Range);
+        template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle(__m256 x, __m256 y) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm256_shuffle_ps(x, y, Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64);
         }
-    } // namespace Reg
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
+}  // namespace Reg
+}  // namespace Vc
 
-#endif // VC_AVX_SHUFFLE_H
+#endif // VC_AVX_SHUFFLE_H_
diff -Nru vc-0.7.4/avx/simd_cast_caller.tcc vc-1.3.0/avx/simd_cast_caller.tcc
--- vc-0.7.4/avx/simd_cast_caller.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/avx/simd_cast_caller.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,55 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef Vc_AVX_SIMD_CAST_CALLER_TCC_
+#define Vc_AVX_SIMD_CAST_CALLER_TCC_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#if Vc_IS_VERSION_1
+template <typename T>
+template <typename U, typename>
+Vc_INTRINSIC Vector<T, VectorAbi::Avx>::Vector(U &&x)
+    : d(simd_cast<Vector>(std::forward<U>(x)).data())
+{
+}
+
+template <typename T>
+template <typename U>
+Vc_INTRINSIC Mask<T, VectorAbi::Avx>::Mask(U &&rhs,
+                                 Common::enable_if_mask_converts_explicitly<T, U>)
+    : Mask(simd_cast<Mask>(std::forward<U>(rhs)))
+{
+}
+#endif  // Vc_IS_VERSION_1
+}
+
+#endif  // Vc_AVX_SIMD_CAST_CALLER_TCC_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/simd_cast.h vc-1.3.0/avx/simd_cast.h
--- vc-0.7.4/avx/simd_cast.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/avx/simd_cast.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,2735 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_AVX_SIMD_CAST_H_
+#define VC_AVX_SIMD_CAST_H_
+
+#ifndef VC_AVX_VECTOR_H_
+#error "Vc/avx/vector.h needs to be included before Vc/avx/simd_cast.h"
+#endif
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+// Declarations: helper macros Vc_SIMD_CAST_AVX_[124] & Vc_SIMD_CAST_[124] {{{1
+#define Vc_SIMD_CAST_AVX_1(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        AVX2::from_ x, enable_if<std::is_same<To, AVX2::to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_AVX_2(from_, to_)                                                   \
+    static_assert(AVX2::from_::size() * 2 <= AVX2::to_::size(),                          \
+                  "this type combination is wrong");                                     \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        AVX2::from_ x0, AVX2::from_ x1,                                                  \
+        enable_if<std::is_same<To, AVX2::to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_AVX_3(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2,                                  \
+        enable_if<std::is_same<To, AVX2::to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_AVX_4(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2, AVX2::from_ x3,                  \
+        enable_if<std::is_same<To, AVX2::to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_1(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x, enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_2(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_3(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_4(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3,                                          \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_5(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3, from_ x4,                                \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_6(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5,                      \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_7(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, from_ x6,            \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_8(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, from_ x6, from_ x7,  \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_OFFSET(from_, to_, offset_)                                         \
+    static_assert(from_::size() >= to_::size() * (offset_ + 1),                          \
+                  "this offset cannot exist for this type combination");                 \
+    template <typename To, int offset>                                                   \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x,                                                                         \
+        enable_if<(offset == offset_ && std::is_same<To, to_>::value)> = nullarg)
+
+// Declaration: SSE -> AVX where the AVX Vector is integral and thus of equal size() {{{1
+// as the equivalent SSE Vector
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x, enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                             SSE::Vector<typename To::EntryType>::Size == To::Size)> =
+                      nullarg);
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To simd_cast(
+    From x0, From x1,
+    enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+               SSE::Vector<typename To::EntryType>::Size == To::Size)> = nullarg);
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To simd_cast(
+    From x0, From x1, From x2,
+    enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+               SSE::Vector<typename To::EntryType>::Size == To::Size)> = nullarg);
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To simd_cast(
+    From x0, From x1, From x2, From x3,
+    enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+               SSE::Vector<typename To::EntryType>::Size == To::Size)> = nullarg);
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To simd_cast(
+    From x0, From x1, From x2, From x3, From x4, From x5, From x6, From x7,
+    enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+               SSE::Vector<typename To::EntryType>::Size == To::Size)> = nullarg);
+
+// Declarations: Vector casts without offset {{{1
+// AVX2::Vector {{{2
+Vc_SIMD_CAST_AVX_1( float_v, double_v);
+
+Vc_SIMD_CAST_AVX_1(double_v,  float_v);
+Vc_SIMD_CAST_AVX_2(double_v,  float_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(   int_v, double_v);
+Vc_SIMD_CAST_AVX_1(  uint_v, double_v);
+Vc_SIMD_CAST_AVX_1( short_v, double_v);
+Vc_SIMD_CAST_AVX_1(ushort_v, double_v);
+
+Vc_SIMD_CAST_AVX_1(   int_v,  float_v);
+Vc_SIMD_CAST_AVX_1(  uint_v,  float_v);
+Vc_SIMD_CAST_AVX_1( short_v,  float_v);
+Vc_SIMD_CAST_AVX_1(ushort_v,  float_v);
+
+Vc_SIMD_CAST_AVX_1(double_v,    int_v);
+Vc_SIMD_CAST_AVX_1( float_v,    int_v);
+Vc_SIMD_CAST_AVX_1(  uint_v,    int_v);
+Vc_SIMD_CAST_AVX_1( short_v,    int_v);
+Vc_SIMD_CAST_AVX_1(ushort_v,    int_v);
+Vc_SIMD_CAST_AVX_2(double_v,    int_v);
+
+Vc_SIMD_CAST_AVX_1(double_v,   uint_v);
+Vc_SIMD_CAST_AVX_1( float_v,   uint_v);
+Vc_SIMD_CAST_AVX_1(   int_v,   uint_v);
+Vc_SIMD_CAST_AVX_1( short_v,   uint_v);
+Vc_SIMD_CAST_AVX_1(ushort_v,   uint_v);
+Vc_SIMD_CAST_AVX_2(double_v,   uint_v);
+
+Vc_SIMD_CAST_AVX_1(double_v,  short_v);
+Vc_SIMD_CAST_AVX_1( float_v,  short_v);
+Vc_SIMD_CAST_AVX_1(   int_v,  short_v);
+Vc_SIMD_CAST_AVX_1(  uint_v,  short_v);
+Vc_SIMD_CAST_AVX_1(ushort_v,  short_v);
+Vc_SIMD_CAST_AVX_2(double_v,  short_v);
+Vc_SIMD_CAST_AVX_2( float_v,  short_v);
+Vc_SIMD_CAST_AVX_2(   int_v,  short_v);
+Vc_SIMD_CAST_AVX_2(  uint_v,  short_v);
+Vc_SIMD_CAST_AVX_3(double_v,  short_v);
+Vc_SIMD_CAST_AVX_4(double_v,  short_v);
+
+Vc_SIMD_CAST_AVX_1(double_v, ushort_v);
+Vc_SIMD_CAST_AVX_1( float_v, ushort_v);
+Vc_SIMD_CAST_AVX_1(   int_v, ushort_v);
+Vc_SIMD_CAST_AVX_1(  uint_v, ushort_v);
+Vc_SIMD_CAST_AVX_1( short_v, ushort_v);
+Vc_SIMD_CAST_AVX_2(double_v, ushort_v);
+Vc_SIMD_CAST_AVX_2( float_v, ushort_v);
+Vc_SIMD_CAST_AVX_2(   int_v, ushort_v);
+Vc_SIMD_CAST_AVX_2(  uint_v, ushort_v);
+Vc_SIMD_CAST_AVX_3(double_v, ushort_v);
+Vc_SIMD_CAST_AVX_4(double_v, ushort_v);
+#endif
+
+// 1 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::double_v);
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::double_v);
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::double_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::double_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::double_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::double_v);
+
+Vc_SIMD_CAST_1(SSE::double_v, AVX2:: float_v);
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2:: float_v);
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2:: float_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2:: float_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2:: float_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2:: float_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::   int_v);
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::  uint_v);
+Vc_SIMD_CAST_1(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::   int_v);
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::  uint_v);
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2:: short_v);
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::   int_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::   int_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::   int_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::   int_v);
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::  uint_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::  uint_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::  uint_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::  uint_v);
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2:: short_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2:: short_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2:: short_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2:: short_v);
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::ushort_v);
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::ushort_v);
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::ushort_v);
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::ushort_v);
+#endif
+
+// 2 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::double_v);
+
+Vc_SIMD_CAST_2(SSE::double_v, AVX2:: float_v);
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2:: float_v);
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2:: float_v);
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2:: float_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::   int_v);
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::  uint_v);
+Vc_SIMD_CAST_2(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::   int_v);
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::  uint_v);
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2:: short_v);
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::   int_v);
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::   int_v);
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::  uint_v);
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::  uint_v);
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2:: short_v);
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2:: short_v);
+Vc_SIMD_CAST_2(SSE:: short_v, AVX2:: short_v);
+Vc_SIMD_CAST_2(SSE::ushort_v, AVX2:: short_v);
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::ushort_v);
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::ushort_v);
+Vc_SIMD_CAST_2(SSE:: short_v, AVX2::ushort_v);
+Vc_SIMD_CAST_2(SSE::ushort_v, AVX2::ushort_v);
+#endif
+
+// 3 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_3(SSE::double_v, AVX2:: float_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::   int_v);
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::  uint_v);
+Vc_SIMD_CAST_3(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_3(SSE:: float_v, AVX2:: short_v);
+Vc_SIMD_CAST_3(SSE:: float_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_3(SSE::   int_v, AVX2:: short_v);
+Vc_SIMD_CAST_3(SSE::  uint_v, AVX2:: short_v);
+
+Vc_SIMD_CAST_3(SSE::   int_v, AVX2::ushort_v);
+Vc_SIMD_CAST_3(SSE::  uint_v, AVX2::ushort_v);
+#endif
+
+// 4 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_4(SSE::double_v, AVX2:: float_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::   int_v);
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::  uint_v);
+Vc_SIMD_CAST_4(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_4(SSE:: float_v, AVX2:: short_v);
+Vc_SIMD_CAST_4(SSE:: float_v, AVX2::ushort_v);
+
+Vc_SIMD_CAST_4(SSE::   int_v, AVX2:: short_v);
+Vc_SIMD_CAST_4(SSE::  uint_v, AVX2:: short_v);
+
+Vc_SIMD_CAST_4(SSE::   int_v, AVX2::ushort_v);
+Vc_SIMD_CAST_4(SSE::  uint_v, AVX2::ushort_v);
+#endif
+
+// 5 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_5(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_5(SSE::double_v, AVX2::ushort_v);
+#endif
+
+// 6 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_6(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_6(SSE::double_v, AVX2::ushort_v);
+#endif
+
+// 7 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_7(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_7(SSE::double_v, AVX2::ushort_v);
+#endif
+
+// 8 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_8(SSE::double_v, AVX2:: short_v);
+Vc_SIMD_CAST_8(SSE::double_v, AVX2::ushort_v);
+#endif
+
+// 1 AVX2::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2::double_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2::double_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::ushort_v);
+
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::ushort_v);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::ushort_v);
+
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::ushort_v);
+
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::ushort_v);
+
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::double_v);
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE:: float_v);
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::   int_v);
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::  uint_v);
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE:: short_v);
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::ushort_v);
+#endif
+
+// 2 AVX2::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_2(AVX2::double_v, SSE:: short_v);
+Vc_SIMD_CAST_2(AVX2::double_v, SSE::ushort_v);
+
+// 1 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 2 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 3 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 4 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 5 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 6 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 7 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 8 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::float_v>::value> = nullarg);
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 9 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 10 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 11 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 12 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 13 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 14 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 15 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 16 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          Scalar::Vector<T> x15,
+          enable_if<std::is_same<Return, AVX2::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          Scalar::Vector<T> x15,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value> = nullarg);
+#endif
+
+// 1 AVX2::Vector to 1 Scalar::Vector {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::Vector<FromT> x,
+                                   enable_if<Scalar::is_vector<To>::value> = nullarg);
+
+// Declarations: Mask casts without offset {{{1
+// 1 AVX2::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(const AVX2::Mask<T> &k, enable_if<AVX2::is_mask<Return>::value> = nullarg);
+
+// 2 AVX2::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_AVX_2(double_m,  float_m);
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_m,    int_m);
+Vc_SIMD_CAST_AVX_2(double_m,   uint_m);
+Vc_SIMD_CAST_AVX_2(double_m,  short_m);
+Vc_SIMD_CAST_AVX_2(double_m, ushort_m);
+
+Vc_SIMD_CAST_AVX_2( float_m,  short_m);
+Vc_SIMD_CAST_AVX_2( float_m, ushort_m);
+
+Vc_SIMD_CAST_AVX_2(   int_m,  short_m);
+Vc_SIMD_CAST_AVX_2(   int_m, ushort_m);
+
+Vc_SIMD_CAST_AVX_2(  uint_m,  short_m);
+Vc_SIMD_CAST_AVX_2(  uint_m, ushort_m);
+#endif
+
+// 4 AVX2::Mask to 1 AVX2::Mask {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_4(double_m,  short_m);
+Vc_SIMD_CAST_AVX_4(double_m, ushort_m);
+#endif
+
+// 1 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::double_m);
+Vc_SIMD_CAST_1(SSE::double_m, AVX2:: float_m);
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::  uint_m);
+Vc_SIMD_CAST_1(SSE::double_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::ushort_m);
+#endif
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::double_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::double_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::double_m);
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::double_m);
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::double_m);
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2:: float_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2:: float_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2:: float_m);
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2:: float_m);
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2:: float_m);
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::  uint_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::  uint_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::  uint_m);
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2:: short_m);
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::ushort_m);
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::ushort_m);
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::ushort_m);
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::ushort_m);
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::ushort_m);
+
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::  uint_m);
+
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::   int_m);
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::  uint_m);
+#endif
+
+// 2 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::double_m);
+Vc_SIMD_CAST_2(SSE::double_m, AVX2:: float_m);
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2:: float_m);
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2:: float_m);
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2:: float_m);
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::   int_m);
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::  uint_m);
+Vc_SIMD_CAST_2(SSE::double_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::ushort_m);
+
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::   int_m);
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::  uint_m);
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::ushort_m);
+
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::   int_m);
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::  uint_m);
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::ushort_m);
+
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::   int_m);
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::  uint_m);
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::ushort_m);
+
+Vc_SIMD_CAST_2(SSE:: short_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE:: short_m, AVX2::ushort_m);
+Vc_SIMD_CAST_2(SSE::ushort_m, AVX2:: short_m);
+Vc_SIMD_CAST_2(SSE::ushort_m, AVX2::ushort_m);
+#endif
+
+// 4 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_4(SSE::double_m, AVX2:: float_m);
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::   int_m);
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::  uint_m);
+Vc_SIMD_CAST_4(SSE::double_m, AVX2:: short_m);
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::ushort_m);
+Vc_SIMD_CAST_4(SSE:: float_m, AVX2:: short_m);
+Vc_SIMD_CAST_4(SSE:: float_m, AVX2::ushort_m);
+Vc_SIMD_CAST_4(SSE::   int_m, AVX2:: short_m);
+Vc_SIMD_CAST_4(SSE::   int_m, AVX2::ushort_m);
+Vc_SIMD_CAST_4(SSE::  uint_m, AVX2:: short_m);
+Vc_SIMD_CAST_4(SSE::  uint_m, AVX2::ushort_m);
+#endif
+
+// 1 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k,
+          enable_if<AVX2::is_mask<Return>::value> = nullarg);
+
+// 2 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1,
+          enable_if<AVX2::is_mask<Return>::value> = nullarg);
+
+// 4 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+    enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 4)> = nullarg);
+
+// 8 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+    Scalar::Mask<T> k4, Scalar::Mask<T> k5, Scalar::Mask<T> k6, Scalar::Mask<T> k7,
+    enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 8)> = nullarg);
+
+// 16 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+          Scalar::Mask<T> k4, Scalar::Mask<T> k5, Scalar::Mask<T> k6, Scalar::Mask<T> k7,
+          Scalar::Mask<T> k8, Scalar::Mask<T> k9, Scalar::Mask<T> k10,
+          Scalar::Mask<T> k11, Scalar::Mask<T> k12, Scalar::Mask<T> k13,
+          Scalar::Mask<T> k14, Scalar::Mask<T> k15,
+          enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 16)> = nullarg);
+
+// 1 AVX2::Mask to 1 SSE::Mask {{{2
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2::double_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2::double_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::ushort_m);
+
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::ushort_m);
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::ushort_m);
+
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::ushort_m);
+
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::ushort_m);
+
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::double_m);
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE:: float_m);
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::   int_m);
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::  uint_m);
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE:: short_m);
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::ushort_m);
+#endif
+
+// 2 AVX2::Mask to 1 SSE::Mask {{{2
+Vc_SIMD_CAST_2(AVX2::double_m, SSE:: short_m);
+Vc_SIMD_CAST_2(AVX2::double_m, SSE::ushort_m);
+
+// 1 AVX2::Mask to 1 Scalar::Mask {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::Mask<FromT> x,
+                                   enable_if<Scalar::is_mask<To>::value> = nullarg);
+
+// Declaration: offset == 0 | convert from AVX2::Mask/Vector {{{1
+template <typename Return, int offset, typename From>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (offset == 0 &&
+     ((AVX2::is_vector<From>::value && !Scalar::is_vector<Return>::value &&
+       Traits::is_simd_vector<Return>::value && !Traits::isSimdArray<Return>::value) ||
+      (AVX2::is_mask<From>::value && !Scalar::is_mask<Return>::value &&
+       Traits::is_simd_mask<Return>::value &&
+       !Traits::isSimdMaskArray<Return>::value))),
+    Return>
+simd_cast(const From &x);
+// Declaration: offset == 0 | convert from SSE::Mask/Vector to AVX2::Mask/Vector {{{1
+template <typename Return, int offset, typename From>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    const From &x,
+    enable_if<offset == 0 && ((SSE::is_vector<From>::value &&
+                               AVX2::is_vector<Return>::value) ||
+                              (SSE::is_mask<From>::value &&
+                               AVX2::is_mask<Return>::value))> = nullarg);
+
+// Declarations: Vector casts with offset {{{1
+// AVX2 to AVX2 {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(AVX2::is_vector<Return>::value && offset != 0),
+                                Return>
+simd_cast(AVX2::Vector<T> x);
+// AVX2 to SSE (Vector<T>) {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector<Return>::value &&
+                                 sizeof(AVX2::Vector<T>) == 32),
+                                Return>
+simd_cast(AVX2::Vector<T> x);
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector<Return>::value &&
+                                 sizeof(AVX2::Vector<T>) == 16),
+                                Return>
+simd_cast(AVX2::Vector<T> x);
+// SSE to AVX2 {{{2
+Vc_SIMD_CAST_OFFSET(SSE:: short_v, AVX2::double_v, 1);
+Vc_SIMD_CAST_OFFSET(SSE::ushort_v, AVX2::double_v, 1);
+
+// Declarations: Mask casts with offset {{{1
+// 1 AVX2::Mask to N AVX2::Mask {{{2
+/* This declaration confuses GCC (4.9.2). If the declarations are there the definitions
+ * are ignored by the compiler. ;-(
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC_L Vc_CONST_L Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<sizeof(k) == 32 && sizeof(Return) == 32 && offset == 1 &&
+                    AVX2::is_mask<Return>::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC_L Vc_CONST_L Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<sizeof(k) == 32 && sizeof(Return) == 16 && offset == 1 &&
+                    AVX2::is_mask<Return>::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC_L Vc_CONST_L Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<sizeof(k) == 16 && sizeof(Return) == 32 && offset == 1 &&
+                    AVX2::is_mask<Return>::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC_L Vc_CONST_L Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<sizeof(k) == 16 && sizeof(Return) == 16 && offset == 1 &&
+                    AVX2::is_mask<Return>::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;
+                    */
+
+// 1 SSE::Mask to N AVX2(2)::Mask {{{2
+Vc_SIMD_CAST_OFFSET(SSE:: short_m, AVX2::double_m, 1);
+Vc_SIMD_CAST_OFFSET(SSE::ushort_m, AVX2::double_m, 1);
+
+// AVX2 to SSE (Mask<T>) {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask<Return>::value &&
+                                 sizeof(AVX2::Mask<T>) == 32),
+                                Return>
+simd_cast(AVX2::Mask<T> x);
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask<Return>::value &&
+                                 sizeof(AVX2::Mask<T>) == 16),
+                                Return>
+simd_cast(AVX2::Mask<T> x);
+
+// helper macros Vc_SIMD_CAST_AVX_[124] & Vc_SIMD_CAST_[124] {{{1
+#undef Vc_SIMD_CAST_AVX_1
+#define Vc_SIMD_CAST_AVX_1(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x,                                    \
+                                       enable_if<std::is_same<To, AVX2::to_>::value>)
+
+#undef Vc_SIMD_CAST_AVX_2
+#define Vc_SIMD_CAST_AVX_2(from_, to_)                                                   \
+    static_assert(AVX2::from_::size() * 2 <= AVX2::to_::size(),                          \
+                  "this type combination is wrong");                                     \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1,                   \
+                                       enable_if<std::is_same<To, AVX2::to_>::value>)
+
+#undef Vc_SIMD_CAST_AVX_3
+#define Vc_SIMD_CAST_AVX_3(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2,   \
+                                       enable_if<std::is_same<To, AVX2::to_>::value>)
+
+#undef Vc_SIMD_CAST_AVX_4
+#define Vc_SIMD_CAST_AVX_4(from_, to_)                                                   \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2,   \
+                                       AVX2::from_ x3,                                   \
+                                       enable_if<std::is_same<To, AVX2::to_>::value>)
+
+#undef Vc_SIMD_CAST_1
+#define Vc_SIMD_CAST_1(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x, enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_2
+#define Vc_SIMD_CAST_2(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1,                               \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_3
+#define Vc_SIMD_CAST_3(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2,                     \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_4
+#define Vc_SIMD_CAST_4(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3,           \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_5
+#define Vc_SIMD_CAST_5(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_6
+#define Vc_SIMD_CAST_6(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \
+                                       from_ x5,                                         \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_7
+#define Vc_SIMD_CAST_7(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \
+                                       from_ x5, from_ x6,                               \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_8
+#define Vc_SIMD_CAST_8(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \
+                                       from_ x5, from_ x6, from_ x7,                     \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#undef Vc_SIMD_CAST_OFFSET
+#define Vc_SIMD_CAST_OFFSET(from_, to_, offset_)                                         \
+    static_assert(from_::size() >= to_::size() * (offset_ + 1),                          \
+                  "this offset cannot exist for this type combination");                 \
+    template <typename To, int offset>                                                   \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x, enable_if<(offset == offset_ && std::is_same<To, to_>::value)>)
+
+// SSE -> AVX2 where the AVX2 Vector is integral and thus of equal size() as the {{{1
+// equivalent SSE Vector
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x, enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                             SSE::Vector<typename To::EntryType>::Size == To::Size)>)
+{
+    return simd_cast<SSE::Vector<typename To::EntryType>>(x).data();
+}
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x0, From x1,
+          enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                     SSE::Vector<typename To::EntryType>::Size == To::Size)>)
+{
+    return simd_cast<SSE::Vector<typename To::EntryType>>(x0, x1).data();
+}
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x0, From x1, From x2,
+          enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                     SSE::Vector<typename To::EntryType>::Size == To::Size)>)
+{
+    return simd_cast<SSE::Vector<typename To::EntryType>>(x0, x1, x2).data();
+}
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x0, From x1, From x2, From x3,
+          enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                     SSE::Vector<typename To::EntryType>::Size == To::Size)>)
+{
+    return simd_cast<SSE::Vector<typename To::EntryType>>(x0, x1, x2, x3).data();
+}
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From x0, From x1, From x2, From x3, From x4, From x5, From x6, From x7,
+          enable_if<(AVX2::is_vector<To>::value && SSE::is_vector<From>::value &&
+                     SSE::Vector<typename To::EntryType>::Size == To::Size)>)
+{
+    return simd_cast<SSE::Vector<typename To::EntryType>>(x0, x1, x2, x3, x4, x5, x6, x7)
+        .data();
+}
+
+// Vector casts without offset {{{1
+// AVX2::Vector {{{2
+// 1: to double_v {{{3
+Vc_SIMD_CAST_AVX_1( float_v, double_v) { return _mm256_cvtps_pd(AVX::lo128(x.data())); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(   int_v, double_v) { return AVX::convert<   int, double>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_AVX_1(  uint_v, double_v) { return AVX::convert<  uint, double>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_AVX_1( short_v, double_v) { return AVX::convert< short, double>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_AVX_1(ushort_v, double_v) { return AVX::convert<ushort, double>(AVX::lo128(x.data())); }
+#endif
+
+// 1: to float_v {{{3
+Vc_SIMD_CAST_AVX_1(double_v,  float_v) { return AVX::zeroExtend(_mm256_cvtpd_ps(x.data())); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(   int_v,  float_v) { return AVX::convert<   int, float>(x.data()); }
+Vc_SIMD_CAST_AVX_1(  uint_v,  float_v) { return AVX::convert<  uint, float>(x.data()); }
+Vc_SIMD_CAST_AVX_1( short_v,  float_v) { return AVX::convert< short, float>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_AVX_1(ushort_v,  float_v) { return AVX::convert<ushort, float>(AVX::lo128(x.data())); }
+#endif
+
+// 2: to float_v {{{3
+Vc_SIMD_CAST_AVX_2(double_v,  float_v) { return AVX::concat(_mm256_cvtpd_ps(x0.data()), _mm256_cvtpd_ps(x1.data())); }
+
+// 1: to int_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(double_v,    int_v) { return AVX::zeroExtend(_mm256_cvttpd_epi32(x.data())); }
+Vc_SIMD_CAST_AVX_1( float_v,    int_v) { return _mm256_cvttps_epi32(x.data()); }
+Vc_SIMD_CAST_AVX_1(  uint_v,    int_v) { return x.data(); }
+Vc_SIMD_CAST_AVX_1( short_v,    int_v) {
+    const auto tmp = Mem::permute4x64<X0, X2, X1, X3>(x.data());
+    return _mm256_srai_epi32(_mm256_unpacklo_epi16(tmp, tmp), 16);
+}
+Vc_SIMD_CAST_AVX_1(ushort_v,    int_v) {
+    const auto tmp = Mem::permute4x64<X0, X2, X1, X3>(x.data());
+    return _mm256_srli_epi32(_mm256_unpacklo_epi16(tmp, tmp), 16);
+}
+#endif
+
+// 2: to int_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_v,    int_v) { return AVX::concat(_mm256_cvttpd_epi32(x0.data()), _mm256_cvttpd_epi32(x1.data())); }
+#endif
+
+// 1: to uint_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(double_v,   uint_v) { return AVX::zeroExtend(AVX::convert<double, uint>(x.data())); }
+Vc_SIMD_CAST_AVX_1( float_v,   uint_v) {
+    return _mm256_blendv_epi8(
+        _mm256_cvttps_epi32(x.data()),
+        _mm256_add_epi32(
+            _mm256_cvttps_epi32(_mm256_sub_ps(x.data(), AVX::set2power31_ps())),
+            AVX::set2power31_epu32()),
+        _mm256_castps_si256(AVX::cmpge_ps(x.data(), AVX::set2power31_ps())));
+}
+Vc_SIMD_CAST_AVX_1(   int_v,   uint_v) { return x.data(); }
+Vc_SIMD_CAST_AVX_1( short_v,   uint_v) {
+    const auto tmp = Mem::permute4x64<X0, X2, X1, X3>(x.data());
+    return _mm256_srai_epi32(_mm256_unpacklo_epi16(tmp, tmp), 16);
+}
+Vc_SIMD_CAST_AVX_1(ushort_v,   uint_v) {
+    const auto tmp = Mem::permute4x64<X0, X2, X1, X3>(x.data());
+    return _mm256_srli_epi32(_mm256_unpacklo_epi16(tmp, tmp), 16);
+}
+#endif
+
+// 2: to uint_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_v,   uint_v) { return AVX::concat(AVX::convert<double, uint>(x0.data()), AVX::convert<double, uint>(x1.data())); }
+#endif
+
+// 1: to short_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(double_v, short_v) { return AVX::zeroExtend(_mm_packs_epi32(_mm256_cvttpd_epi32(x.data()), _mm_setzero_si128())); }
+Vc_SIMD_CAST_AVX_1( float_v, short_v) {
+    const auto tmp = _mm256_cvttps_epi32(x.data());
+    return AVX::zeroExtend(_mm_packs_epi32(AVX::lo128(tmp), AVX::hi128(tmp)));
+}
+Vc_SIMD_CAST_AVX_1(   int_v,  short_v) { return AVX::zeroExtend(AVX::convert< int, short>(x.data())); }
+Vc_SIMD_CAST_AVX_1(  uint_v,  short_v) { return AVX::zeroExtend(AVX::convert<uint, short>(x.data())); }
+Vc_SIMD_CAST_AVX_1(ushort_v,  short_v) { return x.data(); }
+#endif
+
+// 2: to short_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_v,  short_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    return AVX::zeroExtend(_mm_packs_epi32(tmp0, tmp1));
+}
+Vc_SIMD_CAST_AVX_2( float_v,  short_v) {
+    using AVX2::short_v;
+    using AVX2::int_v;
+    return simd_cast<short_v>(simd_cast<int_v>(x0), simd_cast<int_v>(x1));
+}
+Vc_SIMD_CAST_AVX_2(   int_v,  short_v) {
+    auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());
+    auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());
+    auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);
+    return Mem::permute4x64<X0, X2, X1, X3>(_mm256_unpacklo_epi16(tmp2, tmp3));
+}
+Vc_SIMD_CAST_AVX_2(  uint_v,  short_v) {
+    auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());
+    auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());
+    auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);
+    return Mem::permute4x64<X0, X2, X1, X3>(_mm256_unpacklo_epi16(tmp2, tmp3));
+}
+#endif
+
+// 3: to short_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_3(double_v,  short_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    const auto tmp2 = _mm256_cvttpd_epi32(x2.data());
+    return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, _mm_setzero_si128()));
+}
+#endif
+
+// 4: to short_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_4(double_v,  short_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    const auto tmp2 = _mm256_cvttpd_epi32(x2.data());
+    const auto tmp3 = _mm256_cvttpd_epi32(x3.data());
+    return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, tmp3));
+}
+#endif
+
+// 1: to ushort_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_1(double_v, ushort_v) {
+    const auto tmp = _mm256_cvttpd_epi32(x.data());
+    return AVX::zeroExtend(_mm_packs_epi32(tmp, _mm_setzero_si128()));
+}
+Vc_SIMD_CAST_AVX_1( float_v, ushort_v) {
+    const auto tmp = _mm256_cvttps_epi32(x.data());
+    return AVX::zeroExtend(_mm_packs_epi32(AVX::lo128(tmp), AVX::hi128(tmp)));
+}
+Vc_SIMD_CAST_AVX_1(   int_v, ushort_v) { return AVX::zeroExtend(AVX::convert< int, ushort>(x.data())); }
+Vc_SIMD_CAST_AVX_1(  uint_v, ushort_v) { return AVX::zeroExtend(AVX::convert<uint, ushort>(x.data())); }
+Vc_SIMD_CAST_AVX_1( short_v, ushort_v) { return x.data(); }
+#endif
+
+// 2: to ushort_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_v, ushort_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    return AVX::zeroExtend(_mm_packs_epi32(tmp0, tmp1));
+}
+Vc_SIMD_CAST_AVX_2( float_v, ushort_v) {
+    using AVX2::ushort_v;
+    using AVX2::int_v;
+    return simd_cast<ushort_v>(simd_cast<int_v>(x0), simd_cast<int_v>(x1));
+}
+Vc_SIMD_CAST_AVX_2(   int_v, ushort_v) {
+    auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());
+    auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());
+    auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);
+    return Mem::permute4x64<X0, X2, X1, X3>(_mm256_unpacklo_epi16(tmp2, tmp3));
+}
+Vc_SIMD_CAST_AVX_2(  uint_v, ushort_v) {
+    auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());
+    auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());
+    auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);
+    auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);
+    return Mem::permute4x64<X0, X2, X1, X3>(_mm256_unpacklo_epi16(tmp2, tmp3));
+}
+#endif
+
+// 3: to ushort_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_3(double_v, ushort_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    const auto tmp2 = _mm256_cvttpd_epi32(x2.data());
+    return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, _mm_setzero_si128()));
+}
+#endif
+
+// 4: to ushort_v {{{3
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_4(double_v, ushort_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    const auto tmp2 = _mm256_cvttpd_epi32(x2.data());
+    const auto tmp3 = _mm256_cvttpd_epi32(x3.data());
+    return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, tmp3));
+}
+#endif
+
+// 1 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::double_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::double_v) { return _mm256_cvtps_pd(x.data()); }
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::double_v) { return _mm256_cvtepi32_pd(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::double_v) { using namespace AvxIntrinsics; return _mm256_add_pd(_mm256_cvtepi32_pd(_mm_sub_epi32(x.data(), _mm_setmin_epi32())), set1_pd(1u << 31)); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::double_v) { return simd_cast<AVX2::double_v>(simd_cast<SSE::int_v>(x)); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::double_v) { return simd_cast<AVX2::double_v>(simd_cast<SSE::int_v>(x)); }
+
+Vc_SIMD_CAST_1(SSE::double_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast<SSE:: float_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2:: float_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2:: float_v) { return AVX::zeroExtend(_mm_cvtepi32_ps(x.data())); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast<SSE::float_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2:: float_v) { return AVX::convert< short, float>(x.data()); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2:: float_v) { return AVX::convert<ushort, float>(x.data()); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::   int_v) { return AVX::zeroExtend(simd_cast<SSE::   int_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::  uint_v) { return AVX::zeroExtend(simd_cast<SSE::  uint_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x).data()); }
+
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::   int_v) { return AVX::zeroExtend(simd_cast<SSE::int_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::  uint_v) { return AVX::zeroExtend(simd_cast<SSE::uint_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE::short_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: float_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x).data()); }
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::   int_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::   int_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::   int_v) { return AVX::convert< short,  int>(x.data()); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::   int_v) { return AVX::convert<ushort,  int>(x.data()); }
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::  uint_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::  uint_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::  uint_v) { return AVX::convert< short, uint>(x.data()); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::  uint_v) { return AVX::convert<ushort, uint>(x.data()); }
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE::short_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE::short_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2:: short_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2:: short_v) { return AVX::zeroExtend(x.data()); }
+
+Vc_SIMD_CAST_1(SSE::   int_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE::  uint_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: short_v, AVX2::ushort_v) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::ushort_v, AVX2::ushort_v) { return AVX::zeroExtend(x.data()); }
+#endif
+
+// 2 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::double_v) { return AVX::concat(x0.data(), x1.data()); }
+
+Vc_SIMD_CAST_2(SSE::double_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast<SSE:: float_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2:: float_v) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2:: float_v) { return AVX::convert< int, float>(AVX::concat(x0.data(), x1.data())); }
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2:: float_v) { return AVX::convert<uint, float>(AVX::concat(x0.data(), x1.data())); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::   int_v) { return AVX::zeroExtend(simd_cast<SSE::   int_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::  uint_v) { return AVX::zeroExtend(simd_cast<SSE::  uint_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1).data()); }
+
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::   int_v) { return simd_cast<AVX2:: int_v>(simd_cast<AVX2::float_v>(x0, x1)); }
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::  uint_v) { return simd_cast<AVX2::uint_v>(simd_cast<AVX2::float_v>(x0, x1)); }
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE:: float_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1).data()); }
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::   int_v) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::   int_v) { return AVX::concat(x0.data(), x1.data()); }
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::  uint_v) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::  uint_v) { return AVX::concat(x0.data(), x1.data()); }
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE:: short_v, AVX2:: short_v) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::ushort_v, AVX2:: short_v) { return AVX::concat(x0.data(), x1.data()); }
+
+Vc_SIMD_CAST_2(SSE::   int_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE::  uint_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1).data()); }
+Vc_SIMD_CAST_2(SSE:: short_v, AVX2::ushort_v) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::ushort_v, AVX2::ushort_v) { return AVX::concat(x0.data(), x1.data()); }
+#endif
+// 3 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_3(SSE::double_v, AVX2:: float_v) { return simd_cast<AVX2:: float_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2)); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::   int_v) { return simd_cast<AVX2:: int_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2)); }
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::  uint_v) { return simd_cast<AVX2::uint_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2)); }
+Vc_SIMD_CAST_3(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1, x2).data()); }
+Vc_SIMD_CAST_3(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1, x2).data()); }
+
+Vc_SIMD_CAST_3(SSE:: float_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::float_v>(x0, x1), simd_cast<AVX2::float_v>(x2)); }
+Vc_SIMD_CAST_3(SSE:: float_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::float_v>(x0, x1), simd_cast<AVX2::float_v>(x2)); }
+
+Vc_SIMD_CAST_3(SSE::   int_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2:: int_v>(x0, x1), simd_cast<AVX2:: int_v>(x2)); }
+Vc_SIMD_CAST_3(SSE::  uint_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::uint_v>(x0, x1), simd_cast<AVX2::uint_v>(x2)); }
+
+Vc_SIMD_CAST_3(SSE::   int_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2:: int_v>(x0, x1), simd_cast<AVX2:: int_v>(x2)); }
+Vc_SIMD_CAST_3(SSE::  uint_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::uint_v>(x0, x1), simd_cast<AVX2::uint_v>(x2)); }
+#endif
+
+// 4 SSE::Vector to 1 AVX2::Vector {{{2
+Vc_SIMD_CAST_4(SSE::double_v, AVX2:: float_v) { return simd_cast<AVX2:: float_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3)); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::   int_v) { return simd_cast<AVX2:: int_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3)); }
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::  uint_v) { return simd_cast<AVX2::uint_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3)); }
+Vc_SIMD_CAST_4(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast<SSE:: short_v>(x0, x1, x2, x3).data()); }
+Vc_SIMD_CAST_4(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast<SSE::ushort_v>(x0, x1, x2, x3).data()); }
+
+Vc_SIMD_CAST_4(SSE:: float_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::float_v>(x0, x1), simd_cast<AVX2::float_v>(x2, x3)); }
+Vc_SIMD_CAST_4(SSE:: float_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::float_v>(x0, x1), simd_cast<AVX2::float_v>(x2, x3)); }
+
+Vc_SIMD_CAST_4(SSE::   int_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2:: int_v>(x0, x1), simd_cast<AVX2:: int_v>(x2, x3)); }
+Vc_SIMD_CAST_4(SSE::  uint_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::uint_v>(x0, x1), simd_cast<AVX2::uint_v>(x2, x3)); }
+
+Vc_SIMD_CAST_4(SSE::   int_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2:: int_v>(x0, x1), simd_cast<AVX2:: int_v>(x2, x3)); }
+Vc_SIMD_CAST_4(SSE::  uint_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::uint_v>(x0, x1), simd_cast<AVX2::uint_v>(x2, x3)); }
+#endif
+
+// 5 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_5(SSE::double_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4)); }
+Vc_SIMD_CAST_5(SSE::double_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4)); }
+#endif
+
+// 6 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_6(SSE::double_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5)); }
+Vc_SIMD_CAST_6(SSE::double_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5)); }
+#endif
+
+// 7 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_7(SSE::double_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5), simd_cast<AVX2::double_v>(x6)); }
+Vc_SIMD_CAST_7(SSE::double_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5), simd_cast<AVX2::double_v>(x6)); }
+#endif
+
+// 8 SSE::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_8(SSE::double_v, AVX2:: short_v) { return simd_cast<AVX2:: short_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5), simd_cast<AVX2::double_v>(x6, x7)); }
+Vc_SIMD_CAST_8(SSE::double_v, AVX2::ushort_v) { return simd_cast<AVX2::ushort_v>(simd_cast<AVX2::double_v>(x0, x1), simd_cast<AVX2::double_v>(x2, x3), simd_cast<AVX2::double_v>(x4, x5), simd_cast<AVX2::double_v>(x6, x7)); }
+#endif
+
+// 1 AVX2::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::double_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE:: float_v) { return AVX::lo128(x.data()); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::   int_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::  uint_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE:: short_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::ushort_v) { return AVX::lo128(x.data()); }
+#endif
+
+Vc_SIMD_CAST_1(AVX2::double_v, SSE:: float_v) { return simd_cast<SSE:: float_v>(simd_cast<AVX2:: float_v>(x)); }
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::   int_v) { return AVX::convert<double, int>(x.data()); }
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::  uint_v) { return AVX::convert<double, unsigned int>(x.data()); }
+Vc_SIMD_CAST_1(AVX2::double_v, SSE:: short_v) { return AVX::convert<double, short>(x.data()); }
+Vc_SIMD_CAST_1(AVX2::double_v, SSE::ushort_v) { return AVX::convert<double, unsigned short>(x.data()); }
+
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::double_v) { return simd_cast<SSE::double_v>(simd_cast<SSE:: float_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::   int_v) { return simd_cast<SSE::   int_v>(simd_cast<SSE:: float_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::  uint_v) { return simd_cast<SSE::  uint_v>(simd_cast<SSE:: float_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE:: short_v) { return AVX::convert<float, short>(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: float_v, SSE::ushort_v) { return AVX::convert<float, unsigned short>(x.data()); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::double_v) { return SSE::convert<int, double>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE:: float_v) { return SSE::convert<int, float>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::  uint_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE:: short_v) { return AVX::convert<int,  short>(x.data()); }
+Vc_SIMD_CAST_1(AVX2::   int_v, SSE::ushort_v) { return AVX::convert<int, ushort>(x.data()); }
+
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::double_v) { return SSE::convert<uint, double>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE:: float_v) { return SSE::convert<uint, float>(AVX::lo128(x.data())); }
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::   int_v) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE:: short_v) { return AVX::convert<uint,  short>(x.data()); }
+Vc_SIMD_CAST_1(AVX2::  uint_v, SSE::ushort_v) { return AVX::convert<uint, ushort>(x.data()); }
+
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::double_v) { return simd_cast<SSE::double_v>(simd_cast<SSE:: short_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE:: float_v) { return simd_cast<SSE:: float_v>(simd_cast<SSE:: short_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::   int_v) { return simd_cast<SSE::   int_v>(simd_cast<SSE:: short_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::  uint_v) { return simd_cast<SSE::  uint_v>(simd_cast<SSE:: short_v>(x)); }
+Vc_SIMD_CAST_1(AVX2:: short_v, SSE::ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE:: short_v>(x)); }
+
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::double_v) { return simd_cast<SSE::double_v>(simd_cast<SSE::ushort_v>(x)); }
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE:: float_v) { return simd_cast<SSE:: float_v>(simd_cast<SSE::ushort_v>(x)); }
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::   int_v) { return simd_cast<SSE::   int_v>(simd_cast<SSE::ushort_v>(x)); }
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE::  uint_v) { return simd_cast<SSE::  uint_v>(simd_cast<SSE::ushort_v>(x)); }
+Vc_SIMD_CAST_1(AVX2::ushort_v, SSE:: short_v) { return simd_cast<SSE:: short_v>(simd_cast<SSE::ushort_v>(x)); }
+#endif
+
+// 2 AVX2::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_2(AVX2::double_v, SSE:: short_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    return _mm_packs_epi32(tmp0, tmp1);
+}
+Vc_SIMD_CAST_2(AVX2::double_v, SSE::ushort_v) {
+    const auto tmp0 = _mm256_cvttpd_epi32(x0.data());
+    const auto tmp1 = _mm256_cvttpd_epi32(x1.data());
+    return _mm_packs_epi32(tmp0, tmp1);
+}
+
+// 1 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::double_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_pd(x.data(), 0.));
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_ps(x.data(), 0.f, 0.f, 0.f));
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x.data(), 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x.data()), 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 2 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::double_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_pd(x0.data(), x1.data()));
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), 0.f, 0.f));
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 3 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::double_v>::value>)
+{
+    return _mm256_setr_pd(x0.data(), x1.data(), x2.data(), 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), x2.data(), 0));
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()), 0, 0, 0,
+                             0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 4 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::double_v>::value>)
+{
+    return _mm256_setr_pd(x0.data(), x1.data(), x2.data(), x3.data());
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), x2.data(), x3.data()));
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                             uint(x3.data()), 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 5 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                             uint(x3.data()), uint(x4.data()), 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 6 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), 0, 0);
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                             uint(x3.data()), uint(x4.data()), uint(x5.data()), 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 7 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), 0);
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                             uint(x3.data()), uint(x4.data()), uint(x5.data()),
+                             uint(x6.data()), 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 8 Scalar::Vector to 1 AVX2::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::float_v>::value>)
+{
+    return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), x7.data());
+}
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::int_v>::value>)
+{
+    return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data());
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::uint_v>::value>)
+{
+    return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                             uint(x3.data()), uint(x4.data()), uint(x5.data()),
+                             uint(x6.data()), uint(x7.data()));
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), x7.data(), 0, 0, 0, 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), x7.data(), 0, 0, 0, 0, 0, 0, 0, 0);
+}
+#endif
+
+// 9 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), 0, 0, 0, 0, 0, 0,
+                             0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), 0, 0, 0, 0, 0, 0,
+                             0);
+}
+#endif
+
+// 10 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(), 0, 0,
+                             0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(), 0, 0,
+                             0, 0, 0, 0);
+}
+#endif
+
+// 11 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), 0, 0, 0, 0, 0);
+}
+#endif
+
+// 12 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), 0, 0, 0, 0);
+}
+#endif
+
+// 13 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), 0, 0, 0);
+}
+#endif
+
+// 14 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), 0, 0);
+}
+#endif
+
+// 15 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),
+                             0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),
+                             0);
+}
+#endif
+
+// 16 Scalar::Vector to 1 AVX2::Vector {{{2
+#ifdef Vc_IMPL_AVX2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          Scalar::Vector<T> x15, enable_if<std::is_same<Return, AVX2::short_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),
+                             x15.data());
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+          Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+          Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+          Scalar::Vector<T> x15, enable_if<std::is_same<Return, AVX2::ushort_v>::value>)
+{
+    return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                             x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),
+                             x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),
+                             x15.data());
+}
+#endif
+
+// 1 AVX2::Vector to 1 Scalar::Vector {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(AVX2::Vector<FromT> x, enable_if<Scalar::is_vector<To>::value>)
+{
+    return static_cast<To>(x[0]);
+}
+
+// Mask casts without offset {{{1
+// 1 AVX2::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(const AVX2::Mask<T> &k, enable_if<AVX2::is_mask<Return>::value>)
+{
+    return {Detail::mask_cast<Mask<T, VectorAbi::Avx>::Size, Return::Size,
+                              typename Return::VectorTypeF>(k.dataI())};
+}
+
+// 2 AVX2::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_AVX_2(double_m,  float_m) { return AVX::concat(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_2(double_m,    int_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi32(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_AVX_2(double_m,   uint_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi32(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_AVX_2(double_m,  short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI())))); }
+Vc_SIMD_CAST_AVX_2(double_m, ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI())))); }
+
+Vc_SIMD_CAST_AVX_2( float_m,  short_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_AVX_2( float_m, ushort_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+
+Vc_SIMD_CAST_AVX_2(   int_m,  short_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_AVX_2(   int_m, ushort_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+
+Vc_SIMD_CAST_AVX_2(  uint_m,  short_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_AVX_2(  uint_m, ushort_m) { return Mem::permute4x64<X0, X2, X1, X3>(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }
+#endif
+
+// 4 AVX2::Mask to 1 AVX2::Mask {{{2
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_AVX_4(double_m, short_m)
+{
+    using namespace AVX;
+    const auto tmp = _mm256_packs_epi32(
+        _mm256_packs_epi32(x0.dataI(), x1.dataI())  // a0 a1 b0 b1 a2 a3 b2 b3
+        ,
+        _mm256_packs_epi32(x2.dataI(), x3.dataI())  // c0 c1 d0 d1 c2 c3 d2 d3
+        );  // a0 a1 b0 b1 c0 c1 d0 d1 a2 a3 b2 b3 c2 c3 d2 d3
+    return concat(_mm_unpacklo_epi32(lo128(tmp), hi128(tmp)),   // a0 a1 a2 a3 b0 b1 b2 b3
+                  _mm_unpackhi_epi32(lo128(tmp), hi128(tmp)));  // c0 c1 c2 c3 d0 d1 d2 d3
+}
+Vc_SIMD_CAST_AVX_4(double_m, ushort_m) { return simd_cast<AVX2::short_m>(x0, x1, x2, x3).data(); }
+#endif
+
+// 1 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::double_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::double_m, AVX2:: float_m) { return AVX::zeroExtend(simd_cast<SSE:: float_m>(x).data()); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::   int_m) { return AVX::zeroExtend(simd_cast<SSE::   int_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::  uint_m) { return AVX::zeroExtend(simd_cast<SSE::  uint_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+#endif
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.data(), x.data()), _mm_unpackhi_ps(x.data(), x.data())); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.data(), x.data()), _mm_unpackhi_ps(x.data(), x.data())); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.data(), x.data()), _mm_unpackhi_ps(x.data(), x.data())); }
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::double_m) { auto tmp = _mm_unpacklo_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::double_m) { auto tmp = _mm_unpacklo_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2:: float_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2:: float_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2:: float_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2:: float_m) { return AVX::concat(_mm_unpacklo_epi16(x.dataI(), x.dataI()), _mm_unpackhi_epi16(x.dataI(), x.dataI())); }
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2:: float_m) { return AVX::concat(_mm_unpacklo_epi16(x.dataI(), x.dataI()), _mm_unpackhi_epi16(x.dataI(), x.dataI())); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::   int_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::  uint_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::   int_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::  uint_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::   int_m) { return AVX::zeroExtend(x.data()); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::  uint_m) { return AVX::zeroExtend(x.data()); }
+
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast<SSE:: short_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: float_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::   int_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::  uint_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast<SSE::ushort_m>(x).data()); }
+
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::   int_m) { const auto v = Mem::permute4x64<X0, X2, X1, X3>(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }
+Vc_SIMD_CAST_1(SSE:: short_m, AVX2::  uint_m) { const auto v = Mem::permute4x64<X0, X2, X1, X3>(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }
+
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::   int_m) { const auto v = Mem::permute4x64<X0, X2, X1, X3>(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }
+Vc_SIMD_CAST_1(SSE::ushort_m, AVX2::  uint_m) { const auto v = Mem::permute4x64<X0, X2, X1, X3>(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }
+#endif
+
+// 2 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::double_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::double_m, AVX2:: float_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::   int_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::  uint_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_setzero_si128())); }
+Vc_SIMD_CAST_2(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_setzero_si128())); }
+
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::   int_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::  uint_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE:: float_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::   int_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::  uint_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE::   int_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::   int_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::  uint_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+Vc_SIMD_CAST_2(SSE::  uint_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }
+
+Vc_SIMD_CAST_2(SSE:: short_m, AVX2:: short_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE:: short_m, AVX2::ushort_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::ushort_m, AVX2:: short_m) { return AVX::concat(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(SSE::ushort_m, AVX2::ushort_m) { return AVX::concat(x0.data(), x1.data()); }
+#endif
+
+// 4 SSE::Mask to 1 AVX2::Mask {{{2
+Vc_SIMD_CAST_4(SSE::double_m, AVX2:: float_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::   int_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::  uint_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI()))); }
+Vc_SIMD_CAST_4(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI()))); }
+Vc_SIMD_CAST_4(SSE:: float_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE:: float_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::   int_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::   int_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::  uint_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+Vc_SIMD_CAST_4(SSE::  uint_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }
+#endif
+
+// 1 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k, enable_if<AVX2::is_mask<Return>::value>)
+{
+    Return r{false};
+    r[0] = k.data();
+    return r;
+}
+
+// 2 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1,
+          enable_if<AVX2::is_mask<Return>::value>)
+{
+    Return r{false};
+    r[0] = k0.data();
+    r[1] = k1.data();
+    return r;
+}
+
+// 4 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+          enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 4)>)
+{
+    Return r{false};
+    r[0] = k0.data();
+    r[1] = k1.data();
+    r[2] = k2.data();
+    r[3] = k3.data();
+    return r;
+}
+
+// 8 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+          Scalar::Mask<T> k4, Scalar::Mask<T> k5, Scalar::Mask<T> k6, Scalar::Mask<T> k7,
+          enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 8)>)
+{
+    Return r{false};
+    r[0] = k0.data();
+    r[1] = k1.data();
+    r[2] = k2.data();
+    r[3] = k3.data();
+    r[4] = k4.data();
+    r[5] = k5.data();
+    r[6] = k6.data();
+    r[7] = k7.data();
+    return r;
+}
+
+// 16 Scalar::Mask to 1 AVX2::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Mask<T> k0, Scalar::Mask<T> k1, Scalar::Mask<T> k2, Scalar::Mask<T> k3,
+          Scalar::Mask<T> k4, Scalar::Mask<T> k5, Scalar::Mask<T> k6, Scalar::Mask<T> k7,
+          Scalar::Mask<T> k8, Scalar::Mask<T> k9, Scalar::Mask<T> k10,
+          Scalar::Mask<T> k11, Scalar::Mask<T> k12, Scalar::Mask<T> k13,
+          Scalar::Mask<T> k14, Scalar::Mask<T> k15,
+          enable_if<(AVX2::is_mask<Return>::value && Return::Size >= 16)>)
+{
+    Return r{false};
+    r[0] = k0.data();
+    r[1] = k1.data();
+    r[2] = k2.data();
+    r[3] = k3.data();
+    r[4] = k4.data();
+    r[5] = k5.data();
+    r[6] = k6.data();
+    r[7] = k7.data();
+    r[8] = k8.data();
+    r[9] = k9.data();
+    r[10] = k10.data();
+    r[11] = k11.data();
+    r[12] = k12.data();
+    r[13] = k13.data();
+    r[14] = k14.data();
+    r[15] = k15.data();
+    return r;
+}
+
+// 1 AVX2::Mask to 1 SSE::Mask {{{2
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::double_m) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2::double_m, SSE:: float_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::   int_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::  uint_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::double_m, SSE:: short_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1(AVX2::double_m, SSE::ushort_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())), _mm_setzero_si128()); }
+
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::double_m) { return _mm_unpacklo_ps(AVX::lo128(x.data()), AVX::lo128(x.data())); }
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE:: float_m) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::   int_m) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::  uint_m) { return AVX::lo128(x.data()); }
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2:: float_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+
+#ifdef Vc_IMPL_AVX2
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::double_m) { return _mm_unpacklo_epi32(AVX::lo128(x.dataI()), AVX::lo128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE:: float_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::   int_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::  uint_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::   int_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::double_m) { return _mm_unpacklo_epi32(AVX::lo128(x.dataI()), AVX::lo128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE:: float_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::   int_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::  uint_m) { return AVX::lo128(x.dataI()); }
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+Vc_SIMD_CAST_1(AVX2::  uint_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }
+
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::double_m) { return simd_cast<SSE::double_m>(SSE::short_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE:: float_m) { return simd_cast<SSE:: float_m>(SSE::short_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::   int_m) { return simd_cast<SSE::   int_m>(SSE::short_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::  uint_m) { return simd_cast<SSE::  uint_m>(SSE::short_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE:: short_m) { return simd_cast<SSE:: short_m>(SSE::short_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2:: short_m, SSE::ushort_m) { return simd_cast<SSE::ushort_m>(SSE::short_m(AVX::lo128(x.data()))); }
+
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::double_m) { return simd_cast<SSE::double_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE:: float_m) { return simd_cast<SSE:: float_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::   int_m) { return simd_cast<SSE::   int_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::  uint_m) { return simd_cast<SSE::  uint_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE:: short_m) { return simd_cast<SSE:: short_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+Vc_SIMD_CAST_1(AVX2::ushort_m, SSE::ushort_m) { return simd_cast<SSE::ushort_m>(SSE::ushort_m(AVX::lo128(x.data()))); }
+#endif
+
+// 2 AVX2::Mask to 1 SSE::Mask {{{2
+Vc_SIMD_CAST_2(AVX2::double_m, SSE:: short_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }
+Vc_SIMD_CAST_2(AVX2::double_m, SSE::ushort_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }
+
+// 1 AVX2::Mask to 1 Scalar::Mask {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(AVX2::Mask<FromT> x, enable_if<Scalar::is_mask<To>::value>)
+{
+    return static_cast<To>(x[0]);
+}
+
+// offset == 0 | convert from AVX2::Mask/Vector {{{1
+template <typename Return, int offset, typename From>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (offset == 0 &&
+     ((AVX2::is_vector<From>::value && !Scalar::is_vector<Return>::value &&
+       Traits::is_simd_vector<Return>::value && !Traits::isSimdArray<Return>::value) ||
+      (AVX2::is_mask<From>::value && !Scalar::is_mask<Return>::value &&
+       Traits::is_simd_mask<Return>::value &&
+       !Traits::isSimdMaskArray<Return>::value))),
+    Return>
+simd_cast(const From &x)
+{
+    return simd_cast<Return>(x);
+}
+
+// offset == 0 | convert from SSE::Mask/Vector to AVX2::Mask/Vector {{{1
+template <typename Return, int offset, typename From>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(const From &x,
+          enable_if<offset == 0 && ((SSE::is_vector<From>::value &&
+                                     AVX2::is_vector<Return>::value) ||
+                                    (SSE::is_mask<From>::value &&
+                                     AVX2::is_mask<Return>::value))>)
+{
+    return simd_cast<Return>(x);
+}
+
+// Vector casts with offset {{{1
+// AVX2 to AVX2 {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(AVX2::is_vector<Return>::value && offset != 0),
+                                Return>
+    simd_cast(AVX2::Vector<T> x)
+{
+    // TODO: there certainly is potential for leaving out the shift/permute
+    // instruction at the cost of a lot more specializations
+    using V = AVX2::Vector<T>;
+    constexpr int shift = sizeof(T) * offset * Return::Size;
+    static_assert(shift > 0 && shift < sizeof(x), "");
+    if (shift < 16) {
+        return simd_cast<Return>(V{AVX::avx_cast<typename V::VectorType>(
+            _mm_srli_si128(AVX::avx_cast<__m128i>(AVX::lo128(x.data())), shift))});
+    } else if (shift == 16) {
+        return simd_cast<Return>(V{Mem::permute128<X1, Const0>(x.data())});
+    } else {
+#ifdef Vc_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4556)  // value of intrinsic immediate argument '-8' is out of
+                                 // range '0 - 255'
+#endif
+        return simd_cast<Return>(V{AVX::avx_cast<typename V::VectorType>(
+            _mm_srli_si128(AVX::avx_cast<__m128i>(AVX::hi128(x.data())), shift - 16))});
+#ifdef Vc_MSVC
+#pragma warning(pop)
+#endif
+    }
+}
+// AVX2 to SSE (Vector<T>) {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector<Return>::value &&
+                                 sizeof(AVX2::Vector<T>) == 32),
+                                Return>
+    simd_cast(AVX2::Vector<T> x)
+{
+    using V = AVX2::Vector<T>;
+    constexpr int shift = sizeof(V) / V::Size * offset * Return::Size;
+    static_assert(shift > 0, "");
+    static_assert(shift < sizeof(V), "");
+    using SseVector = SSE::Vector<typename V::EntryType>;
+    if (shift == 16) {
+        return simd_cast<Return>(SseVector{AVX::hi128(x.data())});
+    }
+    using Intrin = typename SseVector::VectorType;
+    return simd_cast<Return>(SseVector{AVX::avx_cast<Intrin>(
+        _mm_alignr_epi8(AVX::avx_cast<__m128i>(AVX::hi128(x.data())),
+                        AVX::avx_cast<__m128i>(AVX::lo128(x.data())), shift))});
+}
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector<Return>::value &&
+                                 sizeof(AVX2::Vector<T>) == 16),
+                                Return>
+    simd_cast(AVX2::Vector<T> x)
+{
+    using V = AVX2::Vector<T>;
+    constexpr int shift = sizeof(V) / V::Size * offset * Return::Size;
+    static_assert(shift > 0, "");
+    static_assert(shift < sizeof(V), "");
+    using SseVector = SSE::Vector<typename V::EntryType>;
+    return simd_cast<Return>(SseVector{_mm_srli_si128(x.data(), shift)});
+}
+// SSE to AVX2 {{{2
+Vc_SIMD_CAST_OFFSET(SSE:: short_v, AVX2::double_v, 1) { return simd_cast<AVX2::double_v>(simd_cast<SSE::int_v, 1>(x)); }
+Vc_SIMD_CAST_OFFSET(SSE::ushort_v, AVX2::double_v, 1) { return simd_cast<AVX2::double_v>(simd_cast<SSE::int_v, 1>(x)); }
+
+// Mask casts with offset {{{1
+// 1 AVX2::Mask to N AVX2::Mask {{{2
+// float_v and (u)int_v have size 8, double_v has size 4, and (u)short_v have size 16. Consequently,
+// offset can 0, 1, 2, or 3.
+// - offset == 0 is already done.
+// - offset == 1 can be 16 -> 8, 16 -> 4, 8 -> 4, and 16 -> 4
+// - offset == 2 && offset == 3 can only be 16 -> 4
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<(AVX2::is_mask<Return>::value && offset == 1 &&
+                     AVX2::Mask<T>::Size == Return::Size * 2)> = nullarg)
+{
+    const auto tmp = AVX::hi128(k.dataI());
+    return AVX::concat(_mm_unpacklo_epi8(tmp, tmp), _mm_unpackhi_epi8(tmp, tmp));
+}
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<(AVX2::is_mask<Return>::value && offset == 1 &&
+                     AVX2::Mask<T>::Size == Return::Size * 4)> = nullarg)
+{
+    auto tmp = AVX::lo128(k.dataI());
+    tmp = _mm_unpackhi_epi8(tmp, tmp);
+    return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));
+}
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<(AVX2::is_mask<Return>::value && offset == 2 &&
+                     AVX2::Mask<T>::Size == Return::Size * 4)> = nullarg)
+{
+    auto tmp = AVX::hi128(k.dataI());
+    tmp = _mm_unpacklo_epi8(tmp, tmp);
+    return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));
+}
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(const AVX2::Mask<T> &k,
+          enable_if<(AVX2::is_mask<Return>::value && offset == 3 &&
+                     AVX2::Mask<T>::Size == Return::Size * 4)> = nullarg)
+{
+    auto tmp = AVX::hi128(k.dataI());
+    tmp = _mm_unpackhi_epi8(tmp, tmp);
+    return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));
+}
+
+// 1 SSE::Mask to N AVX2::Mask {{{2
+Vc_SIMD_CAST_OFFSET(SSE:: short_m, AVX2::double_m, 1) { auto tmp = _mm_unpackhi_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }
+Vc_SIMD_CAST_OFFSET(SSE::ushort_m, AVX2::double_m, 1) { auto tmp = _mm_unpackhi_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }
+
+// AVX2 to SSE (Mask<T>) {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask<Return>::value &&
+                                 sizeof(AVX2::Mask<T>) == 32),
+                                Return>
+    simd_cast(AVX2::Mask<T> x)
+{
+    using M = AVX2::Mask<T>;
+    constexpr int shift = sizeof(M) / M::Size * offset * Return::Size;
+    static_assert(shift > 0, "");
+    static_assert(shift < sizeof(M), "");
+    using SseVector = SSE::Mask<Traits::entry_type_of<typename M::Vector>>;
+    if (shift == 16) {
+        return simd_cast<Return>(SseVector{AVX::hi128(x.data())});
+    }
+    using Intrin = typename SseVector::VectorType;
+    return simd_cast<Return>(SseVector{AVX::avx_cast<Intrin>(
+        _mm_alignr_epi8(AVX::hi128(x.dataI()), AVX::lo128(x.dataI()), shift))});
+}
+
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask<Return>::value &&
+                                 sizeof(AVX2::Mask<T>) == 16),
+                                Return>
+    simd_cast(AVX2::Mask<T> x)
+{
+    return simd_cast<Return, offset>(simd_cast<SSE::Mask<T>>(x));
+}
+
+// undef Vc_SIMD_CAST_AVX_[1234] & Vc_SIMD_CAST_[12345678] {{{1
+#undef Vc_SIMD_CAST_AVX_1
+#undef Vc_SIMD_CAST_AVX_2
+#undef Vc_SIMD_CAST_AVX_3
+#undef Vc_SIMD_CAST_AVX_4
+
+#undef Vc_SIMD_CAST_1
+#undef Vc_SIMD_CAST_2
+#undef Vc_SIMD_CAST_3
+#undef Vc_SIMD_CAST_4
+#undef Vc_SIMD_CAST_5
+#undef Vc_SIMD_CAST_6
+#undef Vc_SIMD_CAST_7
+#undef Vc_SIMD_CAST_8
+
+#undef Vc_SIMD_CAST_OFFSET
+// }}}1
+
+}  // namespace Vc
+
+#endif // VC_AVX_SIMD_CAST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/sorthelper.h vc-1.3.0/avx/sorthelper.h
--- vc-0.7.4/avx/sorthelper.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/sorthelper.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,45 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_SORTHELPER_H
-#define VC_AVX_SORTHELPER_H
-
-#include "types.h"
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace AVX
-{
-template<typename T> struct SortHelper
-{
-    typedef typename VectorTypeHelper<T>::Type VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-    typedef const VectorType & VTArg;
-#else
-    typedef const VectorType VTArg;
-#endif
-    static VectorType sort(VTArg);
-    static void sort(VectorType &, VectorType &);
-};
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_AVX_SORTHELPER_H
diff -Nru vc-0.7.4/avx/types.h vc-1.3.0/avx/types.h
--- vc-0.7.4/avx/types.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/types.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,111 +1,116 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_AVX_TYPES_H_
+#define VC_AVX_TYPES_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef AVX_TYPES_H
-#define AVX_TYPES_H
-
-#include "intrinsics.h"
-#include "../common/storage.h"
+#include "../sse/types.h"
+#include "../traits/type_traits.h"
 #include "macros.h"
 
-#define VC_DOUBLE_V_SIZE 4
-#define VC_FLOAT_V_SIZE 8
-#define VC_SFLOAT_V_SIZE 8
-#define VC_INT_V_SIZE 8
-#define VC_UINT_V_SIZE 8
-#define VC_SHORT_V_SIZE 8
-#define VC_USHORT_V_SIZE 8
-
-#include "../common/types.h"
+#ifdef Vc_DEFAULT_IMPL_AVX2
+#define Vc_DOUBLE_V_SIZE 4
+#define Vc_FLOAT_V_SIZE 8
+#define Vc_INT_V_SIZE 8
+#define Vc_UINT_V_SIZE 8
+#define Vc_SHORT_V_SIZE 16
+#define Vc_USHORT_V_SIZE 16
+#elif defined Vc_DEFAULT_IMPL_AVX
+#define Vc_DOUBLE_V_SIZE 4
+#define Vc_FLOAT_V_SIZE 8
+#define Vc_INT_V_SIZE 4
+#define Vc_UINT_V_SIZE 4
+#define Vc_SHORT_V_SIZE 8
+#define Vc_USHORT_V_SIZE 8
+#endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
-    template<typename T> class Vector;
+template <typename T> using Vector = Vc::Vector<T, VectorAbi::Avx1Abi<T>>;
+typedef Vector<double>         double_v;
+typedef Vector<float>           float_v;
+typedef Vector<int>               int_v;
+typedef Vector<unsigned int>     uint_v;
+typedef Vector<short>           short_v;
+typedef Vector<unsigned short> ushort_v;
+
+template <typename T> using Mask = Vc::Mask<T, VectorAbi::Avx1Abi<T>>;
+typedef Mask<double>         double_m;
+typedef Mask<float>           float_m;
+typedef Mask<int>               int_m;
+typedef Mask<unsigned int>     uint_m;
+typedef Mask<short>           short_m;
+typedef Mask<unsigned short> ushort_m;
+
+template <typename T> struct Const;
+
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace AVX
 
-    template<unsigned int VectorSize, size_t RegisterWidth> class Mask;
+namespace AVX2
+{
+template <typename T> using Vector = Vc::Vector<T, VectorAbi::Avx>;
+using double_v = Vector<double>;
+using  float_v = Vector< float>;
+using    int_v = Vector<   int>;
+using   uint_v = Vector<  uint>;
+using  short_v = Vector< short>;
+using ushort_v = Vector<ushort>;
+
+template <typename T> using Mask = Vc::Mask<T, VectorAbi::Avx>;
+using double_m = Mask<double>;
+using  float_m = Mask< float>;
+using  llong_m = Mask< llong>;
+using ullong_m = Mask<ullong>;
+using   long_m = Mask<  long>;
+using  ulong_m = Mask< ulong>;
+using    int_m = Mask<   int>;
+using   uint_m = Mask<  uint>;
+using  short_m = Mask< short>;
+using ushort_m = Mask<ushort>;
+using  schar_m = Mask< schar>;
+using  uchar_m = Mask< uchar>;
+
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace AVX2
 
-    template<typename T> struct VectorHelper {};
-    template<typename T> struct GatherHelper;
-    template<typename T> struct ScatterHelper;
-
-    template<typename T> struct IndexTypeHelper;
-    template<> struct IndexTypeHelper<         char > { typedef unsigned char  Type; };
-    template<> struct IndexTypeHelper<unsigned char > { typedef unsigned char  Type; };
-    template<> struct IndexTypeHelper<         short> { typedef unsigned short Type; };
-    template<> struct IndexTypeHelper<unsigned short> { typedef unsigned short Type; };
-    template<> struct IndexTypeHelper<         int  > { typedef unsigned int   Type; };
-    template<> struct IndexTypeHelper<unsigned int  > { typedef unsigned int   Type; };
-    template<> struct IndexTypeHelper<         float> { typedef unsigned int   Type; };
-    template<> struct IndexTypeHelper<        sfloat> { typedef unsigned short Type; };
-    template<> struct IndexTypeHelper<        double> { typedef unsigned int   Type; }; // _M128I based int32 would be nice
-
-    template<typename T> struct VectorTypeHelper;
-    template<> struct VectorTypeHelper<         char > { typedef m128i Type; };
-    template<> struct VectorTypeHelper<unsigned char > { typedef m128i Type; };
-    template<> struct VectorTypeHelper<         short> { typedef m128i Type; };
-    template<> struct VectorTypeHelper<unsigned short> { typedef m128i Type; };
-    template<> struct VectorTypeHelper<         int  > { typedef m256i Type; };
-    template<> struct VectorTypeHelper<unsigned int  > { typedef m256i Type; };
-    template<> struct VectorTypeHelper<         float> { typedef m256  Type; };
-    template<> struct VectorTypeHelper<        sfloat> { typedef m256  Type; };
-    template<> struct VectorTypeHelper<        double> { typedef m256d Type; };
-
-    template<typename T> struct SseVectorType;
-    template<> struct SseVectorType<m256 > { typedef m128  Type; };
-    template<> struct SseVectorType<m256i> { typedef m128i Type; };
-    template<> struct SseVectorType<m256d> { typedef m128d Type; };
-    template<> struct SseVectorType<m128 > { typedef m128  Type; };
-    template<> struct SseVectorType<m128i> { typedef m128i Type; };
-    template<> struct SseVectorType<m128d> { typedef m128d Type; };
-
-    template<typename T> struct HasVectorDivisionHelper { enum { Value = 1 }; };
-    //template<> struct HasVectorDivisionHelper<unsigned int> { enum { Value = 0 }; };
-
-    template<typename T> struct VectorHelperSize;
-
-#ifdef VC_MSVC
-    // MSVC's __declspec(align(#)) only works with numbers, no enums or sizeof allowed ;(
-    template<size_t size> class _VectorAlignedBaseHack;
-    template<> class STRUCT_ALIGN1( 8) _VectorAlignedBaseHack< 8> {} STRUCT_ALIGN2( 8);
-    template<> class STRUCT_ALIGN1(16) _VectorAlignedBaseHack<16> {} STRUCT_ALIGN2(16);
-    template<> class STRUCT_ALIGN1(32) _VectorAlignedBaseHack<32> {} STRUCT_ALIGN2(32);
-    template<> class STRUCT_ALIGN1(64) _VectorAlignedBaseHack<64> {} STRUCT_ALIGN2(64);
-    template<typename V = Vector<float> >
-    class VectorAlignedBaseT : public _VectorAlignedBaseHack<sizeof(V)>
-    {
-        public:
-            FREE_STORE_OPERATORS_ALIGNED(sizeof(V))
-    };
-#else
-    template<typename V = Vector<float> >
-    class STRUCT_ALIGN1(sizeof(V)) VectorAlignedBaseT
-    {
-        public:
-            FREE_STORE_OPERATORS_ALIGNED(sizeof(V))
-    } STRUCT_ALIGN2(sizeof(V));
-#endif
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
+namespace Traits
+{
+template<typename T> struct is_simd_mask_internal<Mask<T, VectorAbi::Avx>> : public std::true_type {};
+template<typename T> struct is_simd_vector_internal<Vector<T, VectorAbi::Avx>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace Vc
 
-#endif // AVX_TYPES_H
+#endif // VC_AVX_TYPES_H_
diff -Nru vc-0.7.4/avx/undomacros.h vc-1.3.0/avx/undomacros.h
--- vc-0.7.4/avx/undomacros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/undomacros.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,26 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_UNDOMACROS_H
-#define VC_AVX_UNDOMACROS_H
-#undef VC_AVX_MACROS_H
-
-#endif // VC_AVX_UNDOMACROS_H
-
-#include "../common/undomacros.h"
diff -Nru vc-0.7.4/avx/vector.h vc-1.3.0/avx/vector.h
--- vc-0.7.4/avx/vector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,34 +1,44 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef AVX_VECTOR_H
-#define AVX_VECTOR_H
+#ifndef VC_AVX_VECTOR_H_
+#define VC_AVX_VECTOR_H_
 
 #include "intrinsics.h"
+#include "casts.h"
+#include "../sse/vector.h"
+#include "shuffle.h"
 #include "vectorhelper.h"
 #include "mask.h"
-#include "writemaskedvector.h"
-#include "sorthelper.h"
 #include <algorithm>
 #include <cmath>
 #include "../common/aliasingentryhelper.h"
 #include "../common/memoryfwd.h"
+#include "../common/where.h"
 #include "macros.h"
 
 #ifdef isfinite
@@ -38,307 +48,292 @@
 #undef isnan
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
 {
-namespace AVX
+template <typename T, typename Abi> struct VectorTraits
 {
-enum VectorAlignmentEnum { VectorAlignment = 32 };
+    using mask_type = Vc::Mask<T, Abi>;
+    using vector_type = Vc::Vector<T, Abi>;
+    using writemasked_vector_type = Common::WriteMaskedVector<vector_type, mask_type>;
+    using intrinsic_type = typename AVX::VectorTypeHelper<T>::Type;
+};
+}  // namespace Detail
 
-template<typename T> class Vector
+#define Vc_CURRENT_CLASS_NAME Vector
+template <typename T> class Vector<T, VectorAbi::Avx>
 {
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(32)
+public:
+    using abi = VectorAbi::Avx;
 
-        typedef typename VectorTypeHelper<T>::Type VectorType;
-        typedef typename DetermineEntryType<T>::Type EntryType;
+private:
+    using traits_type = Detail::VectorTraits<T, abi>;
+    static_assert(
+        std::is_arithmetic<T>::value,
+        "Vector<T> only accepts arithmetic builtin types as template parameter T.");
+
+    using WriteMaskedVector = typename traits_type::writemasked_vector_type;
+
+public:
+    using VectorType = typename traits_type::intrinsic_type;
+    using vector_type = VectorType;
+
+    using mask_type = typename traits_type::mask_type;
+    using Mask = mask_type;
+    using MaskType = mask_type;
+    using MaskArg Vc_DEPRECATED_ALIAS("Use MaskArgument instead.") = typename Mask::AsArg;
+    using MaskArgument = typename Mask::AsArg;
+    using reference = Detail::ElementReference<Vector>;
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(VectorType));
+
+    Vc_ALIGNED_TYPEDEF(sizeof(T), T, EntryType);
+        using value_type = EntryType;
+        typedef EntryType VectorEntryType;
+        static constexpr size_t Size = sizeof(VectorType) / sizeof(EntryType);
+        static constexpr size_t MemoryAlignment = alignof(VectorType);
         enum Constants {
-            Size = sizeof(VectorType) / sizeof(EntryType),
-            HasVectorDivision = HasVectorDivisionHelper<T>::Value
+            HasVectorDivision = AVX::HasVectorDivisionHelper<T>::Value
         };
-        typedef Vector<typename IndexTypeHelper<T>::Type> IndexType;
-        typedef typename Vc::AVX::Mask<Size, sizeof(VectorType)> Mask;
-        typedef typename Mask::AsArg MaskArg;
-        typedef Vc::Memory<Vector<T>, Size> Memory;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-        typedef const Vector<T> &AsArg;
-        typedef const VectorType &VectorTypeArg;
+#ifdef Vc_IMPL_AVX2
+        typedef typename std::conditional<
+            (Size >= 8), SimdArray<int, Size, AVX2::int_v, 8>,
+            typename std::conditional<(Size >= 4), SimdArray<int, Size, SSE::int_v, 4>,
+                                      SimdArray<int, Size, Scalar::int_v, 1>>::type>::type
+            IndexType;
 #else
-        typedef Vector<T> AsArg;
-        typedef VectorType VectorTypeArg;
+        typedef typename std::conditional<(Size >= 4),
+                                          SimdArray<int, Size, SSE::int_v, 4>,
+                                          SimdArray<int, Size, Scalar::int_v, 1>>::type IndexType;
 #endif
+        typedef Vector<T, abi> AsArg;
+        typedef VectorType VectorTypeArg;
 
     protected:
+        template <typename U> using V = Vector<U, abi>;
+
         // helper that specializes on VectorType
-        typedef VectorHelper<VectorType> HV;
+        typedef AVX::VectorHelper<VectorType> HV;
 
         // helper that specializes on T
-        typedef VectorHelper<T> HT;
+        typedef AVX::VectorHelper<T> HT;
 
         // cast any m256/m128 to VectorType
-        static Vc_INTRINSIC VectorType _cast(param128  v) { return avx_cast<VectorType>(v); }
-        static Vc_INTRINSIC VectorType _cast(param128i v) { return avx_cast<VectorType>(v); }
-        static Vc_INTRINSIC VectorType _cast(param128d v) { return avx_cast<VectorType>(v); }
-        static Vc_INTRINSIC VectorType _cast(param256  v) { return avx_cast<VectorType>(v); }
-        static Vc_INTRINSIC VectorType _cast(param256i v) { return avx_cast<VectorType>(v); }
-        static Vc_INTRINSIC VectorType _cast(param256d v) { return avx_cast<VectorType>(v); }
+        template <typename V> static Vc_INTRINSIC VectorType _cast(V v)
+        {
+            return AVX::avx_cast<VectorType>(v);
+        }
 
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-        typedef Common::VectorMemoryUnion<VectorType, EntryType, typename VectorType::Base> StorageType;
-#else
         typedef Common::VectorMemoryUnion<VectorType, EntryType> StorageType;
-#endif
         StorageType d;
 
+        using WidthT = Common::WidthT<VectorType>;
+        // ICC can't compile this:
+        // static constexpr WidthT Width = WidthT();
+
     public:
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // uninitialized
-        Vc_ALWAYS_INLINE Vector() {}
+#include "../common/generalinterface.h"
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // constants
-        explicit Vc_ALWAYS_INLINE_L Vector(VectorSpecialInitializerZero::ZEnum) Vc_ALWAYS_INLINE_R;
-        explicit Vc_ALWAYS_INLINE_L Vector(VectorSpecialInitializerOne::OEnum) Vc_ALWAYS_INLINE_R;
-        explicit Vc_ALWAYS_INLINE_L Vector(VectorSpecialInitializerIndexesFromZero::IEnum) Vc_ALWAYS_INLINE_R;
-        static Vc_INTRINSIC_L Vc_CONST_L Vector Zero() Vc_INTRINSIC_R Vc_CONST_R;
-        static Vc_INTRINSIC_L Vc_CONST_L Vector One() Vc_INTRINSIC_R Vc_CONST_R;
-        static Vc_INTRINSIC_L Vc_CONST_L Vector IndexesFromZero() Vc_INTRINSIC_R Vc_CONST_R;
         static Vc_ALWAYS_INLINE_L Vector Random() Vc_ALWAYS_INLINE_R;
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // internal: required to enable returning objects of VectorType
         Vc_ALWAYS_INLINE Vector(VectorTypeArg x) : d(x) {}
-#ifdef VC_UNCONDITIONAL_AVX2_INTRINSICS
-        Vc_ALWAYS_INLINE Vector(typename VectorType::Base x) : d(x) {}
-#endif
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // static_cast / copy ctor
-        template<typename T2> explicit Vector(VC_ALIGNED_PARAMETER(Vector<T2>) x);
-
-        // implicit cast
-        template<typename OtherT> Vc_INTRINSIC_L Vector &operator=(const Vector<OtherT> &x) Vc_INTRINSIC_R;
 
-        // copy assignment
-        Vc_ALWAYS_INLINE Vector &operator=(AsArg v) { d.v() = v.d.v(); return *this; }
+        // implict conversion from compatible Vector<U, abi>
+        template <typename U>
+        Vc_INTRINSIC Vector(
+            V<U> x, typename std::enable_if<Traits::is_implicit_cast_allowed<U, T>::value,
+                                            void *>::type = nullptr)
+            : d(AVX::convert<U, T>(x.data()))
+        {
+        }
+
+#if Vc_IS_VERSION_1
+        // static_cast from the remaining Vector<U, abi>
+        template <typename U>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "vector types") Vc_INTRINSIC explicit Vector(
+            V<U> x,
+            typename std::enable_if<!Traits::is_implicit_cast_allowed<U, T>::value,
+                                    void *>::type = nullptr)
+            : d(Detail::zeroExtendIfNeeded(AVX::convert<U, T>(x.data())))
+        {
+        }
+
+        // static_cast from other types, implemented via the non-member simd_cast function in
+        // simd_cast_caller.tcc
+        template <typename U,
+                  typename = enable_if<Traits::is_simd_vector<U>::value &&
+                                       !std::is_same<Vector, Traits::decay<U>>::value>>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "vector types") Vc_INTRINSIC_L
+            explicit Vector(U &&x) Vc_INTRINSIC_R;
+#endif
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // broadcast
-        explicit Vc_ALWAYS_INLINE_L Vector(EntryType a) Vc_ALWAYS_INLINE_R;
-        template<typename TT> Vc_INTRINSIC Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *) = 0) : d(HT::set(x)) {}
-        Vc_ALWAYS_INLINE Vector &operator=(EntryType a) { d.v() = HT::set(a); return *this; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load ctors
-        explicit Vc_INTRINSIC_L
-            Vector(const EntryType *x) Vc_INTRINSIC_R;
-        template<typename Alignment> Vc_INTRINSIC_L
-            Vector(const EntryType *x, Alignment align) Vc_INTRINSIC_R;
-        template<typename OtherT> explicit Vc_INTRINSIC_L
-            Vector(const OtherT    *x) Vc_INTRINSIC_R;
-        template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
-            Vector(const OtherT    *x, Alignment align) Vc_INTRINSIC_R;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load member functions
-        Vc_INTRINSIC_L
-            void load(const EntryType *mem) Vc_INTRINSIC_R;
-        template<typename Alignment> Vc_INTRINSIC_L
-            void load(const EntryType *mem, Alignment align) Vc_INTRINSIC_R;
-        template<typename OtherT> Vc_INTRINSIC_L
-            void load(const OtherT    *mem) Vc_INTRINSIC_R;
-        template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
-            void load(const OtherT    *mem, Alignment align) Vc_INTRINSIC_R;
+        Vc_INTRINSIC Vector(EntryType a) : d(Detail::avx_broadcast(a)) {}
+        template <typename U>
+        Vc_INTRINSIC Vector(U a,
+                            typename std::enable_if<std::is_same<U, int>::value &&
+                                                        !std::is_same<U, EntryType>::value,
+                                                    void *>::type = nullptr)
+            : Vector(static_cast<EntryType>(a))
+        {
+        }
+
+        //template<typename U>
+        explicit Vector(std::initializer_list<EntryType>)
+        {
+            static_assert(std::is_same<EntryType, void>::value,
+                          "A SIMD vector object cannot be initialized from an initializer list "
+                          "because the number of entries in the vector is target-dependent.");
+        }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // expand/merge 1 float_v <=> 2 double_v          XXX rationale? remove it for release? XXX
-        explicit inline Vector(const Vector<typename HT::ConcatType> *a);
-        inline void expand(Vector<typename HT::ConcatType> *x) const;
+#include "../common/loadinterface.h"
+#include "../common/storeinterface.h"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // zeroing
         Vc_INTRINSIC_L void setZero() Vc_INTRINSIC_R;
         Vc_INTRINSIC_L void setZero(const Mask &k) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L void setZeroInverted(const Mask &k) Vc_INTRINSIC_R;
 
         Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L void setQnan(MaskArg k) Vc_INTRINSIC_R;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // stores
-        Vc_INTRINSIC_L void store(EntryType *mem) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask) const Vc_INTRINSIC_R;
-        template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, A align) const Vc_INTRINSIC_R;
-        template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask, A align) const Vc_INTRINSIC_R;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // swizzles
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T> &abcd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  cdab() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  badc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  aaaa() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bbbb() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  cccc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dddd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bcad() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bcda() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dabc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  acbd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dbca() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dcba() const Vc_INTRINSIC_R Vc_PURE_R;
+        Vc_INTRINSIC_L void setQnan(MaskArgument k) Vc_INTRINSIC_R;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // gathers
-        template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes);
-        template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes);
-        template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes, MaskArg mask);
-        template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes, MaskArg mask);
-        template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
-        template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
-        template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes);
-        template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask);
-#ifdef VC_USE_SET_GATHERS
-        template<typename IT> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IT>) indexes, MaskArg mask);
-#endif
-        template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
-        template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // scatters
-        template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const;
-        template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask) const;
-        template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes) const;
-        template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
-        template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes) const;
-        template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
-        template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes) const;
-        template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask) const;
+#include "../common/gatherinterface.h"
+#include "../common/scatterinterface.h"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         //prefix
-        Vc_ALWAYS_INLINE Vector &operator++() { data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return *this; }
-        Vc_ALWAYS_INLINE Vector &operator--() { data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return *this; }
+        Vc_ALWAYS_INLINE Vector &operator++() { data() = Detail::add(data(), Detail::one(T()), T()); return *this; }
+        Vc_ALWAYS_INLINE Vector &operator--() { data() = Detail::sub(data(), Detail::one(T()), T()); return *this; }
         //postfix
-        Vc_ALWAYS_INLINE Vector operator++(int) { const Vector<T> r = *this; data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return r; }
-        Vc_ALWAYS_INLINE Vector operator--(int) { const Vector<T> r = *this; data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return r; }
+        Vc_ALWAYS_INLINE Vector operator++(int) { const Vector r = *this; data() = Detail::add(data(), Detail::one(T()), T()); return r; }
+        Vc_ALWAYS_INLINE Vector operator--(int) { const Vector r = *this; data() = Detail::sub(data(), Detail::one(T()), T()); return r; }
 
-        Vc_INTRINSIC Common::AliasingEntryHelper<StorageType> operator[](size_t index) {
-#if defined(VC_GCC) && VC_GCC >= 0x40300 && VC_GCC < 0x40400
-            ::Vc::Warnings::_operator_bracket_warning();
-#endif
-            return d.m(index);
+    private:
+        friend reference;
+        Vc_INTRINSIC static value_type get(const Vector &o, int i) noexcept
+        {
+            return o.d.m(i);
+        }
+        template <typename U>
+        Vc_INTRINSIC static void set(Vector &o, int i, U &&v) noexcept(
+            noexcept(std::declval<value_type &>() = v))
+        {
+            return o.d.set(i, v);
         }
-        Vc_ALWAYS_INLINE EntryType operator[](size_t index) const {
+
+    public:
+        Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+        {
+            static_assert(noexcept(reference{std::declval<Vector &>(), int()}), "");
+            return {*this, int(index)};
+        }
+        Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept
+        {
             return d.m(index);
         }
 
-        Vc_ALWAYS_INLINE Vector operator~() const { return VectorHelper<VectorType>::andnot_(data(), VectorHelper<VectorType>::allone()); }
-        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector<typename NegateTypeHelper<T>::Type> operator-() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        Vc_INTRINSIC_L Vc_PURE_L Vector operator[](Permutation::ReversedTag) const Vc_INTRINSIC_R Vc_PURE_R;
+        Vc_INTRINSIC_L Vc_PURE_L Vector operator[](const IndexType &perm) const Vc_INTRINSIC_R Vc_PURE_R;
+
+        Vc_INTRINSIC Vc_PURE Mask operator!() const
+        {
+            return *this == Zero();
+        }
+        Vc_ALWAYS_INLINE Vector operator~() const
+        {
+#ifndef Vc_ENABLE_FLOAT_BIT_OPERATORS
+            static_assert(std::is_integral<T>::value,
+                          "bit-complement can only be used with Vectors of integral type");
+#endif
+            return Detail::andnot_(data(), Detail::allone<VectorType>());
+        }
+        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector operator-() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
         Vc_INTRINSIC Vc_PURE Vector operator+() const { return *this; }
 
-#define OP1(fun) \
-        Vc_ALWAYS_INLINE Vector fun() const { return Vector<T>(VectorHelper<T>::fun(data())); } \
-        Vc_ALWAYS_INLINE Vector &fun##_eq() { data() = VectorHelper<T>::fun(data()); return *this; }
-        OP1(sqrt)
-        OP1(abs)
-#undef OP1
-
-#define OP(symbol, fun) \
-        Vc_ALWAYS_INLINE Vector &operator symbol##=(const Vector<T> &x) { data() = VectorHelper<T>::fun(data(), x.data()); return *this; } \
-        Vc_ALWAYS_INLINE Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector(x)); } \
-        Vc_ALWAYS_INLINE Vector operator symbol(const Vector<T> &x) const { return Vector<T>(VectorHelper<T>::fun(data(), x.data())); } \
-        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Vector) operator symbol(TT x) const { return operator symbol(Vector(x)); }
-
-        OP(+, add)
-        OP(-, sub)
-        OP(*, mul)
-#undef OP
-        inline Vector &operator/=(EntryType x);
-        template<typename TT> inline Vc_PURE_L VC_EXACT_TYPE(TT, EntryType, Vector) operator/(TT x) const Vc_PURE_R;
-        inline Vector &operator/=(const Vector<T> &x);
-        inline Vc_PURE_L Vector  operator/ (const Vector<T> &x) const Vc_PURE_R;
-
-        // bitwise ops
-#define OP_VEC(op) \
-        Vc_ALWAYS_INLINE_L Vector<T> &operator op##=(AsArg x) Vc_ALWAYS_INLINE_R; \
-        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector<T>  operator op   (AsArg x) const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-#define OP_ENTRY(op) \
-        Vc_ALWAYS_INLINE Vector<T> &operator op##=(EntryType x) { return operator op##=(Vector(x)); } \
-        template<typename TT> Vc_ALWAYS_INLINE Vc_PURE VC_EXACT_TYPE(TT, EntryType, Vector) operator op(TT x) const { return operator op(Vector(x)); }
-        VC_ALL_BINARY(OP_VEC)
-        VC_ALL_BINARY(OP_ENTRY)
-        VC_ALL_SHIFTS(OP_VEC)
-#undef OP_VEC
-#undef OP_ENTRY
-
-        Vc_ALWAYS_INLINE_L Vector<T> &operator>>=(int x) Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L Vector<T> &operator<<=(int x) Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L Vector<T> operator>>(int x) const Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L Vector<T> operator<<(int x) const Vc_ALWAYS_INLINE_R;
-
-#define OPcmp(symbol, fun) \
-        Vc_ALWAYS_INLINE Mask operator symbol(AsArg x) const { return VectorHelper<T>::fun(data(), x.data()); } \
-        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Mask) operator symbol(TT x) const { return operator symbol(Vector(x)); }
-
-        OPcmp(==, cmpeq)
-        OPcmp(!=, cmpneq)
-        OPcmp(>=, cmpnlt)
-        OPcmp(>, cmpnle)
-        OPcmp(<, cmplt)
-        OPcmp(<=, cmple)
-#undef OPcmp
-        Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R;
-
-        Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector<T> &factor, const Vector<T> &summand) {
-            VectorHelper<T>::fma(data(), factor.data(), summand.data());
-        }
-
-        Vc_ALWAYS_INLINE void assign( const Vector<T> &v, const Mask &mask ) {
-            const VectorType k = avx_cast<VectorType>(mask.data());
-            data() = VectorHelper<VectorType>::blend(data(), v.data(), k);
-        }
-
-        template<typename V2> Vc_ALWAYS_INLINE V2 staticCast() const { return V2(*this); }
-        template<typename V2> Vc_ALWAYS_INLINE V2 reinterpretCast() const { return avx_cast<typename V2::VectorType>(data()); }
-
-        Vc_ALWAYS_INLINE WriteMaskedVector<T> operator()(const Mask &k) { return WriteMaskedVector<T>(this, k); }
-
-        /**
-         * \return \p true  This vector was completely filled. m2 might be 0 or != 0. You still have
-         *                  to test this.
-         *         \p false This vector was not completely filled. m2 is all 0.
-         */
-        //inline bool pack(Mask &m1, Vector<T> &v2, Mask &m2) {
-            //return VectorHelper<T>::pack(data(), m1.data, v2.data(), m2.data);
-        //}
+        // shifts
+#define Vc_OP_VEC(op)                                                                    \
+    Vc_INTRINSIC Vector &operator op##=(AsArg x);                                        \
+    Vc_INTRINSIC Vc_PURE Vector operator op(AsArg x) const                               \
+    {                                                                                    \
+        static_assert(                                                                   \
+            std::is_integral<T>::value,                                                  \
+            "bitwise-operators can only be used with Vectors of integral type");         \
+    }
+    Vc_ALL_SHIFTS(Vc_OP_VEC);
+#undef Vc_OP_VEC
+
+        Vc_ALWAYS_INLINE_L Vector &operator>>=(int x) Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L Vector &operator<<=(int x) Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L Vector operator>>(int x) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L Vector operator<<(int x) const Vc_ALWAYS_INLINE_R;
+
+        Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC Vc_PURE Mask
+            isNegative() const
+        {
+            return Vc::isnegative(*this);
+        }
+
+        Vc_ALWAYS_INLINE void assign( const Vector &v, const Mask &mask ) {
+            const VectorType k = _cast(mask.data());
+            data() = Detail::blend(data(), v.data(), k);
+        }
+
+        template <typename V2>
+        Vc_DEPRECATED("Use simd_cast instead of Vector::staticCast") Vc_ALWAYS_INLINE V2
+            staticCast() const
+        {
+            return V2(*this);
+        }
+        template <typename V2>
+        Vc_DEPRECATED("use reinterpret_components_cast instead") Vc_ALWAYS_INLINE V2
+            reinterpretCast() const
+        {
+            return AVX::avx_cast<typename V2::VectorType>(data());
+        }
+
+        Vc_ALWAYS_INLINE WriteMaskedVector operator()(const Mask &k)
+        {
+            return {*this, k};
+        }
 
         Vc_ALWAYS_INLINE VectorType &data() { return d.v(); }
-        Vc_ALWAYS_INLINE const VectorType data() const { return d.v(); }
+        Vc_ALWAYS_INLINE const VectorType &data() const { return d.v(); }
+
+        template<int Index>
+        Vc_INTRINSIC_L Vector broadcast() const Vc_INTRINSIC_R;
+
+        Vc_INTRINSIC_L std::pair<Vector, int> minIndex() const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L std::pair<Vector, int> maxIndex() const Vc_INTRINSIC_R;
 
-        Vc_ALWAYS_INLINE EntryType min() const { return VectorHelper<T>::min(data()); }
-        Vc_ALWAYS_INLINE EntryType max() const { return VectorHelper<T>::max(data()); }
-        Vc_ALWAYS_INLINE EntryType product() const { return VectorHelper<T>::mul(data()); }
-        Vc_ALWAYS_INLINE EntryType sum() const { return VectorHelper<T>::add(data()); }
-        Vc_ALWAYS_INLINE_L EntryType min(MaskArg m) const Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L EntryType max(MaskArg m) const Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L EntryType product(MaskArg m) const Vc_ALWAYS_INLINE_R;
-        Vc_ALWAYS_INLINE_L EntryType sum(MaskArg m) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE EntryType min() const { return Detail::min(data(), T()); }
+        Vc_ALWAYS_INLINE EntryType max() const { return Detail::max(data(), T()); }
+        Vc_ALWAYS_INLINE EntryType product() const { return Detail::mul(data(), T()); }
+        Vc_ALWAYS_INLINE EntryType sum() const { return Detail::add(data(), T()); }
+        Vc_ALWAYS_INLINE_L Vector partialSum() const Vc_ALWAYS_INLINE_R;
+        //template<typename BinaryOperation> Vc_ALWAYS_INLINE_L Vector partialSum(BinaryOperation op) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L EntryType min(MaskArgument m) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L EntryType max(MaskArgument m) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L EntryType product(MaskArgument m) const Vc_ALWAYS_INLINE_R;
+        Vc_ALWAYS_INLINE_L EntryType sum(MaskArgument m) const Vc_ALWAYS_INLINE_R;
 
+        Vc_INTRINSIC_L Vector shifted(int amount, Vector shiftIn) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R;
-        Vc_ALWAYS_INLINE Vector sorted() const { return SortHelper<T>::sort(data()); }
+        Vc_INTRINSIC_L Vc_PURE_L Vector reversed() const Vc_INTRINSIC_R Vc_PURE_R;
+        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector sorted() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
 
-        template<typename F> void callWithValuesSorted(F &f) {
+        template <typename F> void callWithValuesSorted(F &&f)
+        {
             EntryType value = d.m(0);
             f(value);
-            for (int i = 1; i < Size; ++i) {
+            for (size_t i = 1; i < Size; ++i) {
                 if (d.m(i) != value) {
                     value = d.m(i);
                     f(value);
@@ -346,121 +341,119 @@
             }
         }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f) const {
-            for_all_vector_entries(i,
-                    f(EntryType(d.m(i)));
-                    );
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f) const {
-            for_all_vector_entries(i,
-                    f(EntryType(d.m(i)));
-                    );
+        template <typename F> Vc_INTRINSIC void call(F &&f) const
+        {
+            Common::for_all_vector_entries<Size>([&](size_t i) { f(EntryType(d.m(i))); });
         }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f, const Mask &mask) const {
-            Vc_foreach_bit(size_t i, mask) {
-                f(EntryType(d.m(i)));
-            }
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f, const Mask &mask) const {
-            Vc_foreach_bit(size_t i, mask) {
+        template <typename F> Vc_INTRINSIC void call(F &&f, const Mask &mask) const
+        {
+            for (size_t i : where(mask)) {
                 f(EntryType(d.m(i)));
             }
         }
 
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
-            Vector<T> r;
-            for_all_vector_entries(i,
-                    r.d.m(i) = f(EntryType(d.m(i)));
-                    );
-            return r;
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
-            Vector<T> r;
-            for_all_vector_entries(i,
-                    r.d.m(i) = f(EntryType(d.m(i)));
-                    );
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f) const
+        {
+            Vector r;
+            Common::for_all_vector_entries<Size>(
+                [&](size_t i) { r.d.set(i, f(EntryType(d.m(i)))); });
             return r;
         }
 
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f, const Mask &mask) const {
-            Vector<T> r(*this);
-            Vc_foreach_bit (size_t i, mask) {
-                r.d.m(i) = f(EntryType(r.d.m(i)));
-            }
-            return r;
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f, const Mask &mask) const {
-            Vector<T> r(*this);
-            Vc_foreach_bit (size_t i, mask) {
-                r.d.m(i) = f(EntryType(r.d.m(i)));
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f, const Mask &mask) const
+        {
+            Vector r(*this);
+            for (size_t i : where(mask)) {
+                r.d.set(i, f(EntryType(r.d.m(i))));
             }
             return r;
         }
 
         template<typename IndexT> Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {
-            for_all_vector_entries(i,
-                    d.m(i) = f(i);
-                    );
+            Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f(i)); });
         }
         Vc_INTRINSIC void fill(EntryType (&f)()) {
-            for_all_vector_entries(i,
-                    d.m(i) = f();
-                    );
+            Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f()); });
         }
 
-        Vc_INTRINSIC_L Vector copySign(AsArg reference) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R;
+        template <typename G> static Vc_INTRINSIC_L Vector generate(G gen) Vc_INTRINSIC_R;
+
+        Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC Vector
+            copySign(AsArg reference) const
+        {
+            return Vc::copysign(*this, reference);
+        }
+
+        Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC Vector exponent() const
+        {
+            Vc::exponent(*this);
+        }
+
+        Vc_INTRINSIC_L Vector interleaveLow(Vector x) const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vector interleaveHigh(Vector x) const Vc_INTRINSIC_R;
 };
+#undef Vc_CURRENT_CLASS_NAME
+template <typename T> constexpr size_t Vector<T, VectorAbi::Avx>::Size;
+template <typename T> constexpr size_t Vector<T, VectorAbi::Avx>::MemoryAlignment;
+
+static_assert(Traits::is_simd_vector<AVX2::double_v>::value, "is_simd_vector<double_v>::value");
+static_assert(Traits::is_simd_vector<AVX2:: float_v>::value, "is_simd_vector< float_v>::value");
+static_assert(Traits::is_simd_vector<AVX2::   int_v>::value, "is_simd_vector<   int_v>::value");
+static_assert(Traits::is_simd_vector<AVX2::  uint_v>::value, "is_simd_vector<  uint_v>::value");
+static_assert(Traits::is_simd_vector<AVX2:: short_v>::value, "is_simd_vector< short_v>::value");
+static_assert(Traits::is_simd_vector<AVX2::ushort_v>::value, "is_simd_vector<ushort_v>::value");
+static_assert(Traits::is_simd_mask  <AVX2::double_m>::value, "is_simd_mask  <double_m>::value");
+static_assert(Traits::is_simd_mask  <AVX2:: float_m>::value, "is_simd_mask  < float_m>::value");
+static_assert(Traits::is_simd_mask  <AVX2::   int_m>::value, "is_simd_mask  <   int_m>::value");
+static_assert(Traits::is_simd_mask  <AVX2::  uint_m>::value, "is_simd_mask  <  uint_m>::value");
+static_assert(Traits::is_simd_mask  <AVX2:: short_m>::value, "is_simd_mask  < short_m>::value");
+static_assert(Traits::is_simd_mask  <AVX2::ushort_m>::value, "is_simd_mask  <ushort_m>::value");
+
+#ifdef Vc_IMPL_AVX2
+static_assert(!std::is_convertible<float *, AVX2::short_v>::value, "A float* should never implicitly convert to short_v. Something is broken.");
+static_assert(!std::is_convertible<int *  , AVX2::short_v>::value, "An int* should never implicitly convert to short_v. Something is broken.");
+static_assert(!std::is_convertible<short *, AVX2::short_v>::value, "A short* should never implicitly convert to short_v. Something is broken.");
+#endif
+
+#define Vc_CONDITIONAL_ASSIGN(name_, op_)                                                \
+    template <Operator O, typename T, typename M, typename U>                            \
+    Vc_INTRINSIC enable_if<O == Operator::name_, void> conditional_assign(               \
+        AVX2::Vector<T> &lhs, M &&mask, U &&rhs)                                         \
+    {                                                                                    \
+        lhs(mask) op_ rhs;                                                               \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(          Assign,  =);
+Vc_CONDITIONAL_ASSIGN(      PlusAssign, +=);
+Vc_CONDITIONAL_ASSIGN(     MinusAssign, -=);
+Vc_CONDITIONAL_ASSIGN(  MultiplyAssign, *=);
+Vc_CONDITIONAL_ASSIGN(    DivideAssign, /=);
+Vc_CONDITIONAL_ASSIGN( RemainderAssign, %=);
+Vc_CONDITIONAL_ASSIGN(       XorAssign, ^=);
+Vc_CONDITIONAL_ASSIGN(       AndAssign, &=);
+Vc_CONDITIONAL_ASSIGN(        OrAssign, |=);
+Vc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);
+Vc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);
+#undef Vc_CONDITIONAL_ASSIGN
+
+#define Vc_CONDITIONAL_ASSIGN(name_, expr_)                                              \
+    template <Operator O, typename T, typename M>                                        \
+    Vc_INTRINSIC enable_if<O == Operator::name_, AVX2::Vector<T>> conditional_assign(    \
+        AVX2::Vector<T> &lhs, M &&mask)                                                  \
+    {                                                                                    \
+        return expr_;                                                                    \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++);
+Vc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask));
+Vc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--);
+Vc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask));
+#undef Vc_CONDITIONAL_ASSIGN
 
-typedef Vector<double>         double_v;
-typedef Vector<float>          float_v;
-typedef Vector<sfloat>         sfloat_v;
-typedef Vector<int>            int_v;
-typedef Vector<unsigned int>   uint_v;
-typedef Vector<short>          short_v;
-typedef Vector<unsigned short> ushort_v;
-typedef double_v::Mask double_m;
-typedef  float_v::Mask float_m;
-typedef sfloat_v::Mask sfloat_m;
-typedef    int_v::Mask int_m;
-typedef   uint_v::Mask uint_m;
-typedef  short_v::Mask short_m;
-typedef ushort_v::Mask ushort_m;
-
-template<typename T> class SwizzledVector : public Vector<T> {};
-
-static Vc_ALWAYS_INLINE int_v    min(const int_v    &x, const int_v    &y) { return _mm256_min_epi32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE uint_v   min(const uint_v   &x, const uint_v   &y) { return _mm256_min_epu32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE short_v  min(const short_v  &x, const short_v  &y) { return _mm_min_epi16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE ushort_v min(const ushort_v &x, const ushort_v &y) { return _mm_min_epu16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE float_v  min(const float_v  &x, const float_v  &y) { return _mm256_min_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE sfloat_v min(const sfloat_v &x, const sfloat_v &y) { return _mm256_min_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE double_v min(const double_v &x, const double_v &y) { return _mm256_min_pd(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE int_v    max(const int_v    &x, const int_v    &y) { return _mm256_max_epi32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE uint_v   max(const uint_v   &x, const uint_v   &y) { return _mm256_max_epu32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE short_v  max(const short_v  &x, const short_v  &y) { return _mm_max_epi16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE ushort_v max(const ushort_v &x, const ushort_v &y) { return _mm_max_epu16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE float_v  max(const float_v  &x, const float_v  &y) { return _mm256_max_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE sfloat_v max(const sfloat_v &x, const sfloat_v &y) { return _mm256_max_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE double_v max(const double_v &x, const double_v &y) { return _mm256_max_pd(x.data(), y.data()); }
-
-  template<typename T> static Vc_ALWAYS_INLINE Vector<T> sqrt (const Vector<T> &x) { return VectorHelper<T>::sqrt(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vector<T> rsqrt(const Vector<T> &x) { return VectorHelper<T>::rsqrt(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vector<T> abs  (const Vector<T> &x) { return VectorHelper<T>::abs(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vector<T> reciprocal(const Vector<T> &x) { return VectorHelper<T>::reciprocal(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vector<T> round(const Vector<T> &x) { return VectorHelper<T>::round(x.data()); }
-
-  template<typename T> static Vc_ALWAYS_INLINE typename Vector<T>::Mask isfinite(const Vector<T> &x) { return VectorHelper<T>::isFinite(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE typename Vector<T>::Mask isnan(const Vector<T> &x) { return VectorHelper<T>::isNaN(x.data()); }
-
-#include "forceToRegisters.tcc"
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Vc
 
 #include "vector.tcc"
-#include "math.h"
-#include "undomacros.h"
+#include "simd_cast.h"
 
-#endif // AVX_VECTOR_H
+#endif // VC_AVX_VECTOR_H_
diff -Nru vc-0.7.4/avx/vectorhelper.h vc-1.3.0/avx/vectorhelper.h
--- vc-0.7.4/avx/vectorhelper.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/vectorhelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,258 +1,116 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef AVX_VECTORHELPER_H
-#define AVX_VECTORHELPER_H
+#ifndef VC_AVX_VECTORHELPER_H_
+#define VC_AVX_VECTORHELPER_H_
 
 #include <limits>
 #include "types.h"
 #include "intrinsics.h"
 #include "casts.h"
+#include "../common/loadstoreflags.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
-
-namespace Internal
-{
-Vc_INTRINSIC Vc_CONST m256 exponent(param256 v)
-{
-    m128i tmp0 = _mm_srli_epi32(avx_cast<m128i>(v), 23);
-    m128i tmp1 = _mm_srli_epi32(avx_cast<m128i>(hi128(v)), 23);
-    tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x7f));
-    tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x7f));
-    return _mm256_cvtepi32_ps(concat(tmp0, tmp1));
-}
-Vc_INTRINSIC Vc_CONST m256d exponent(param256d v)
-{
-    m128i tmp0 = _mm_srli_epi64(avx_cast<m128i>(v), 52);
-    m128i tmp1 = _mm_srli_epi64(avx_cast<m128i>(hi128(v)), 52);
-    tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x3ff));
-    tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x3ff));
-    return _mm256_cvtepi32_pd(avx_cast<m128i>(Mem::shuffle<X0, X2, Y0, Y2>(avx_cast<m128>(tmp0), avx_cast<m128>(tmp1))));
-}
-} // namespace Internal
-
-#define OP0(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name() { return code; }
-#define OP1(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(VTArg a) { return code; }
-#define OP2(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(VTArg a, VTArg b) { return code; }
-#define OP3(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(VTArg a, VTArg b, VTArg c) { return code; }
-
-        template<> struct VectorHelper<m256>
+        template<> struct VectorHelper<__m256>
         {
-            typedef m256 VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
+            typedef __m256 VectorType;
             typedef const VectorType VTArg;
-#endif
-            template<typename A> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const float *x, A) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, VTArg m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, VTArg m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, VTArg m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cdab(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(2, 3, 0, 1)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType badc(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(1, 0, 3, 2)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType aaaa(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(0, 0, 0, 0)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType bbbb(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(1, 1, 1, 1)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cccc(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(2, 2, 2, 2)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType dddd(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(3, 3, 3, 3)); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType dacb(VTArg x) { return _mm256_permute_ps(x, _MM_SHUFFLE(3, 0, 2, 1)); }
-
-            OP0(allone, _mm256_setallone_ps())
-            OP0(zero, _mm256_setzero_ps())
-            OP2(or_, _mm256_or_ps(a, b))
-            OP2(xor_, _mm256_xor_ps(a, b))
-            OP2(and_, _mm256_and_ps(a, b))
-            OP2(andnot_, _mm256_andnot_ps(a, b))
-            OP3(blend, _mm256_blendv_ps(a, b, c))
-        };
 
-        template<> struct VectorHelper<m256d>
-        {
-            typedef m256d VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
-            typedef const VectorType VTArg;
-#endif
-            template<typename A> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const double *x, A) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, VTArg m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, VTArg m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, VTArg m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-            static VectorType cdab(VTArg x) { return _mm256_permute_pd(x, 5); }
-            static VectorType badc(VTArg x) { return _mm256_permute2f128_pd(x, x, 1); }
-            // aaaa bbbb cccc dddd specialized in vector.tcc
-            static VectorType dacb(VTArg x) {
-                const m128d cb = avx_cast<m128d>(_mm_alignr_epi8(avx_cast<m128i>(lo128(x)),
-                            avx_cast<m128i>(hi128(x)), sizeof(double))); // XXX: lo and hi swapped?
-                const m128d da = _mm_blend_pd(lo128(x), hi128(x), 0 + 2); // XXX: lo and hi swapped?
-                return concat(cb, da);
-            }
-
-            OP0(allone, _mm256_setallone_pd())
-            OP0(zero, _mm256_setzero_pd())
-            OP2(or_, _mm256_or_pd(a, b))
-            OP2(xor_, _mm256_xor_pd(a, b))
-            OP2(and_, _mm256_and_pd(a, b))
-            OP2(andnot_, _mm256_andnot_pd(a, b))
-            OP3(blend, _mm256_blendv_pd(a, b, c))
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfAligned               = nullptr) { _mm256_store_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfStreaming             = nullptr) { _mm256_stream_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_ps()); }
+
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, VTArg m, typename std::enable_if<!Flags::IsStreaming, void *>::type = nullptr) { _mm256_maskstore(mem, m, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }
         };
 
-        template<> struct VectorHelper<m256i>
+        template<> struct VectorHelper<__m256d>
         {
-            typedef m256i VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
+            typedef __m256d VectorType;
             typedef const VectorType VTArg;
-#endif
-            template<typename T> static VectorType load(const T *x, AlignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, UnalignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, StreamingAndAlignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, StreamingAndUnalignedFlag) Vc_PURE;
-            template<typename T> static void store(T *mem, VTArg x, AlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, UnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, StreamingAndAlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, StreamingAndUnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, AlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, UnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, StreamingAndAlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag);
-
-            static VectorType cdab(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(2, 3, 0, 1))); }
-            static VectorType badc(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(1, 0, 3, 2))); }
-            static VectorType aaaa(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(0, 0, 0, 0))); }
-            static VectorType bbbb(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(1, 1, 1, 1))); }
-            static VectorType cccc(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(2, 2, 2, 2))); }
-            static VectorType dddd(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(3, 3, 3, 3))); }
-            static VectorType dacb(VTArg x) { return avx_cast<VectorType>(_mm256_permute_ps(avx_cast<m256>(x), _MM_SHUFFLE(3, 0, 2, 1))); }
-
-            OP0(allone, _mm256_setallone_si256())
-            OP0(zero, _mm256_setzero_si256())
-            OP2(or_, _mm256_or_si256(a, b))
-            OP2(xor_, _mm256_xor_si256(a, b))
-            OP2(and_, _mm256_and_si256(a, b))
-            OP2(andnot_, _mm256_andnot_si256(a, b))
-            OP3(blend, _mm256_blendv_epi8(a, b, c))
+
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfAligned               = nullptr) { _mm256_store_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfStreaming             = nullptr) { _mm256_stream_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_pd()); }
+
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, VTArg m, typename std::enable_if<!Flags::IsStreaming, void *>::type = nullptr) { _mm256_maskstore(mem, m, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }
         };
 
-        template<> struct VectorHelper<m128i>
+        template<> struct VectorHelper<__m256i>
         {
-            typedef m128i VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
+            typedef __m256i VectorType;
             typedef const VectorType VTArg;
-#endif
-            template<typename T> static VectorType load(const T *x, AlignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, UnalignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, StreamingAndAlignedFlag) Vc_PURE;
-            template<typename T> static VectorType load(const T *x, StreamingAndUnalignedFlag) Vc_PURE;
-            template<typename T> static void store(T *mem, VTArg x, AlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, UnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, StreamingAndAlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, StreamingAndUnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, AlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, UnalignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, StreamingAndAlignedFlag);
-            template<typename T> static void store(T *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag);
-
-            static VectorType cdab(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(2, 3, 0, 1)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(2, 3, 0, 1)); }
-            static VectorType badc(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(1, 0, 3, 2)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(1, 0, 3, 2)); }
-            static VectorType aaaa(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(0, 0, 0, 0)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(0, 0, 0, 0)); }
-            static VectorType bbbb(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(1, 1, 1, 1)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(1, 1, 1, 1)); }
-            static VectorType cccc(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(2, 2, 2, 2)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(2, 2, 2, 2)); }
-            static VectorType dddd(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(3, 3, 3, 3)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(3, 3, 3, 3)); }
-            static VectorType dacb(VTArg x) { const __m128i tmp = _mm_shufflelo_epi16(x, _MM_SHUFFLE(3, 0, 2, 1)); return _mm_shufflehi_epi16(tmp, _MM_SHUFFLE(3, 0, 2, 1)); }
-
-            OP0(allone, _mm_setallone_si128())
-            OP0(zero, _mm_setzero_si128())
-            OP2(or_, _mm_or_si128(a, b))
-            OP2(xor_, _mm_xor_si128(a, b))
-            OP2(and_, _mm_and_si128(a, b))
-            OP2(andnot_, _mm_andnot_si128(a, b))
-            OP3(blend, _mm_blendv_epi8(a, b, c))
+
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfAligned               = nullptr) { _mm256_store_si256(reinterpret_cast<__m256i *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_si256(reinterpret_cast<__m256i *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfStreaming             = nullptr) { _mm256_stream_si256(reinterpret_cast<__m256i *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_si256()); }
+
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, VTArg m, typename std::enable_if<!Flags::IsStreaming, void *>::type = nullptr) { _mm256_maskstore(mem, m, x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }
         };
-#undef OP1
-#undef OP2
-#undef OP3
-
-#define OP1(op) \
-        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a) { return CAT(_mm256_##op##_, SUFFIX)(a); }
-#define OP(op) \
-        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return CAT(_mm256_##op##_ , SUFFIX)(a, b); }
-#define OP_(op) \
-        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return CAT(_mm256_##op    , SUFFIX)(a, b); }
-#define OPx(op, op2) \
-        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return CAT(_mm256_##op2##_, SUFFIX)(a, b); }
-#define OPcmp(op) \
-        static Vc_INTRINSIC VectorType Vc_CONST cmp##op(VTArg a, VTArg b) { return CAT(_mm256_cmp##op##_, SUFFIX)(a, b); }
-#define OP_CAST_(op) \
-        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return CAT(_mm256_castps_, SUFFIX)( \
-            _mm256_##op##ps(CAT(CAT(_mm256_cast, SUFFIX), _ps)(a), \
-              CAT(CAT(_mm256_cast, SUFFIX), _ps)(b))); \
-        }
-#define MINMAX \
-        static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return CAT(_mm256_min_, SUFFIX)(a, b); } \
-        static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return CAT(_mm256_max_, SUFFIX)(a, b); }
+
+#define Vc_OP1(op) \
+        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a) { return Vc_CAT2(_mm256_##op##_, Vc_SUFFIX)(a); }
+#define Vc_OP(op) \
+        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(op##_ , Vc_SUFFIX)(a, b); }
+#define Vc_OP_(op) \
+        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(_mm256_##op    , Vc_SUFFIX)(a, b); }
+#define Vc_OPx(op, op2) \
+        static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(_mm256_##op2##_, Vc_SUFFIX)(a, b); }
 
         template<> struct VectorHelper<double> {
-            typedef m256d VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
+            typedef __m256d VectorType;
             typedef const VectorType VTArg;
-#endif
             typedef double EntryType;
-            typedef double ConcatType;
-#define SUFFIX pd
+#define Vc_SUFFIX pd
 
-            static Vc_ALWAYS_INLINE VectorType notMaskedToZero(VTArg a, param256 mask) { return CAT(_mm256_and_, SUFFIX)(_mm256_castps_pd(mask), a); }
-            static Vc_ALWAYS_INLINE VectorType set(const double a) { return CAT(_mm256_set1_, SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE VectorType notMaskedToZero(VTArg a, __m256 mask) { return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(_mm256_castps_pd(mask), a); }
+            static Vc_ALWAYS_INLINE VectorType set(const double a) { return Vc_CAT2(_mm256_set1_, Vc_SUFFIX)(a); }
             static Vc_ALWAYS_INLINE VectorType set(const double a, const double b, const double c, const double d) {
-                return CAT(_mm256_set_, SUFFIX)(a, b, c, d);
+                return Vc_CAT2(_mm256_set_, Vc_SUFFIX)(a, b, c, d);
             }
-            static Vc_ALWAYS_INLINE VectorType zero() { return CAT(_mm256_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE VectorType one()  { return CAT(_mm256_setone_, SUFFIX)(); }// set(1.); }
+            static Vc_ALWAYS_INLINE VectorType zero() { return Vc_CAT2(_mm256_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE VectorType one()  { return Vc_CAT2(setone_, Vc_SUFFIX)(); }// set(1.); }
 
             static inline void fma(VectorType &v1, VTArg v2, VTArg v3) {
-#ifdef VC_IMPL_FMA4
+#ifdef Vc_IMPL_FMA4
                 v1 = _mm256_macc_pd(v1, v2, v3);
 #else
                 VectorType h1 = _mm256_and_pd(v1, _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::highMaskDouble)));
                 VectorType h2 = _mm256_and_pd(v2, _mm256_broadcast_sd(reinterpret_cast<const double *>(&c_general::highMaskDouble)));
-#if defined(VC_GCC) && VC_GCC < 0x40703
+#if defined(Vc_GCC) && Vc_GCC < 0x40703
                 // GCC before 4.7.3 uses an incorrect optimization where it replaces the subtraction with an andnot
                 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54703
                 asm("":"+x"(h1), "+x"(h2));
@@ -263,57 +121,51 @@
                 const VectorType lh = add(mul(l1, h2), mul(h1, l2));
                 const VectorType hh = mul(h1, h2);
                 // ll < lh < hh for all entries is certain
-                const VectorType lh_lt_v3 = cmplt(abs(lh), abs(v3)); // |lh| < |v3|
+                const VectorType lh_lt_v3 = cmplt_pd(abs(lh), abs(v3)); // |lh| < |v3|
                 const VectorType b = _mm256_blendv_pd(v3, lh, lh_lt_v3);
                 const VectorType c = _mm256_blendv_pd(lh, v3, lh_lt_v3);
                 v1 = add(add(ll, b), add(c, hh));
 #endif
             }
 
-            OP(add) OP(sub) OP(mul)
-            OPcmp(eq) OPcmp(neq)
-            OPcmp(lt) OPcmp(nlt)
-            OPcmp(le) OPcmp(nle)
+            static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm256_add_pd(a,b); }
+            static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm256_sub_pd(a,b); }
+            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mul_pd(a,b); }
 
-            OP1(sqrt)
+            Vc_OP1(sqrt)
             static Vc_ALWAYS_INLINE Vc_CONST VectorType rsqrt(VTArg x) {
                 return _mm256_div_pd(one(), sqrt(x));
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType reciprocal(VTArg x) {
                 return _mm256_div_pd(one(), x);
             }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType isNaN(VTArg x) {
-                return _mm256_cmpunord_pd(x, x);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType isFinite(VTArg x) {
-                return _mm256_cmpord_pd(x, _mm256_mul_pd(zero(), x));
-            }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(VTArg a) {
-                return CAT(_mm256_and_, SUFFIX)(a, _mm256_setabsmask_pd());
+                return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(a, setabsmask_pd());
             }
 
-            MINMAX
+            static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm256_min_pd(a, b); }
+            static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm256_max_pd(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VTArg a) {
-                m128d b = _mm_min_pd(avx_cast<m128d>(a), _mm256_extractf128_pd(a, 1));
+                __m128d b = _mm_min_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));
                 b = _mm_min_sd(b, _mm_unpackhi_pd(b, b));
                 return _mm_cvtsd_f64(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType max(VTArg a) {
-                m128d b = _mm_max_pd(avx_cast<m128d>(a), _mm256_extractf128_pd(a, 1));
+                __m128d b = _mm_max_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));
                 b = _mm_max_sd(b, _mm_unpackhi_pd(b, b));
                 return _mm_cvtsd_f64(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VTArg a) {
-                m128d b = _mm_mul_pd(avx_cast<m128d>(a), _mm256_extractf128_pd(a, 1));
+                __m128d b = _mm_mul_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));
                 b = _mm_mul_sd(b, _mm_shuffle_pd(b, b, _MM_SHUFFLE2(0, 1)));
                 return _mm_cvtsd_f64(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType add(VTArg a) {
-                m128d b = _mm_add_pd(avx_cast<m128d>(a), _mm256_extractf128_pd(a, 1));
+                __m128d b = _mm_add_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));
                 b = _mm_hadd_pd(b, b); // or: b = _mm_add_sd(b, _mm256_shuffle_pd(b, b, _MM_SHUFFLE2(0, 1)));
                 return _mm_cvtsd_f64(b);
             }
-#undef SUFFIX
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) {
                 return _mm256_round_pd(a, _MM_FROUND_NINT);
             }
@@ -321,445 +173,85 @@
 
         template<> struct VectorHelper<float> {
             typedef float EntryType;
-            typedef m256 VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
+            typedef __m256 VectorType;
             typedef const VectorType VTArg;
-#endif
-            typedef double ConcatType;
-#define SUFFIX ps
+#define Vc_SUFFIX ps
 
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VTArg a, param256 mask) { return CAT(_mm256_and_, SUFFIX)(mask, a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) { return CAT(_mm256_set1_, SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VTArg a, __m256 mask) { return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(mask, a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) { return Vc_CAT2(_mm256_set1_, Vc_SUFFIX)(a); }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d,
                     const float e, const float f, const float g, const float h) {
-                return CAT(_mm256_set_, SUFFIX)(a, b, c, d, e, f, g, h); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm256_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return CAT(_mm256_setone_, SUFFIX)(); }// set(1.f); }
-            static Vc_ALWAYS_INLINE Vc_CONST m256 concat(param256d a, param256d b) { return _mm256_insertf128_ps(avx_cast<m256>(_mm256_cvtpd_ps(a)), _mm256_cvtpd_ps(b), 1); }
+                return Vc_CAT2(_mm256_set_, Vc_SUFFIX)(a, b, c, d, e, f, g, h); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm256_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return Vc_CAT2(setone_, Vc_SUFFIX)(); }// set(1.f); }
+            static Vc_ALWAYS_INLINE Vc_CONST __m256 concat(__m256d a, __m256d b) { return _mm256_insertf128_ps(avx_cast<__m256>(_mm256_cvtpd_ps(a)), _mm256_cvtpd_ps(b), 1); }
 
             static inline void fma(VectorType &v1, VTArg v2, VTArg v3) {
-#ifdef VC_IMPL_FMA4
+#ifdef Vc_IMPL_FMA4
                 v1 = _mm256_macc_ps(v1, v2, v3);
 #else
-                m256d v1_0 = _mm256_cvtps_pd(lo128(v1));
-                m256d v1_1 = _mm256_cvtps_pd(hi128(v1));
-                m256d v2_0 = _mm256_cvtps_pd(lo128(v2));
-                m256d v2_1 = _mm256_cvtps_pd(hi128(v2));
-                m256d v3_0 = _mm256_cvtps_pd(lo128(v3));
-                m256d v3_1 = _mm256_cvtps_pd(hi128(v3));
+                __m256d v1_0 = _mm256_cvtps_pd(lo128(v1));
+                __m256d v1_1 = _mm256_cvtps_pd(hi128(v1));
+                __m256d v2_0 = _mm256_cvtps_pd(lo128(v2));
+                __m256d v2_1 = _mm256_cvtps_pd(hi128(v2));
+                __m256d v3_0 = _mm256_cvtps_pd(lo128(v3));
+                __m256d v3_1 = _mm256_cvtps_pd(hi128(v3));
                 v1 = AVX::concat(
                         _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_0, v2_0), v3_0)),
                         _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_1, v2_1), v3_1)));
 #endif
             }
 
-            OP(add) OP(sub) OP(mul)
-            OPcmp(eq) OPcmp(neq)
-            OPcmp(lt) OPcmp(nlt)
-            OPcmp(le) OPcmp(nle)
-
-            OP1(sqrt) OP1(rsqrt)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType isNaN(VTArg x) {
-                return _mm256_cmpunord_ps(x, x);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType isFinite(VTArg x) {
-                return _mm256_cmpord_ps(x, _mm256_mul_ps(zero(), x));
-            }
+            static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm256_add_ps(a, b); }
+            static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm256_sub_ps(a, b); }
+            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mul_ps(a, b); }
+
+            Vc_OP1(sqrt) Vc_OP1(rsqrt)
             static Vc_ALWAYS_INLINE Vc_CONST VectorType reciprocal(VTArg x) {
                 return _mm256_rcp_ps(x);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(VTArg a) {
-                return CAT(_mm256_and_, SUFFIX)(a, _mm256_setabsmask_ps());
+                return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(a, setabsmask_ps());
             }
 
-            MINMAX
+            static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm256_min_ps(a, b); }
+            static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm256_max_ps(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VTArg a) {
-                m128 b = _mm_min_ps(avx_cast<m128>(a), _mm256_extractf128_ps(a, 1));
+                __m128 b = _mm_min_ps(lo128(a), hi128(a));
                 b = _mm_min_ps(b, _mm_movehl_ps(b, b));   // b = min(a0, a2), min(a1, a3), min(a2, a2), min(a3, a3)
                 b = _mm_min_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1))); // b = min(a0, a1), a1, a2, a3
                 return _mm_cvtss_f32(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType max(VTArg a) {
-                m128 b = _mm_max_ps(avx_cast<m128>(a), _mm256_extractf128_ps(a, 1));
+                __m128 b = _mm_max_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));
                 b = _mm_max_ps(b, _mm_movehl_ps(b, b));   // b = max(a0, a2), max(a1, a3), max(a2, a2), max(a3, a3)
                 b = _mm_max_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1))); // b = max(a0, a1), a1, a2, a3
                 return _mm_cvtss_f32(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VTArg a) {
-                m128 b = _mm_mul_ps(avx_cast<m128>(a), _mm256_extractf128_ps(a, 1));
+                __m128 b = _mm_mul_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));
                 b = _mm_mul_ps(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 1, 2, 3)));
                 b = _mm_mul_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 2, 0, 1)));
                 return _mm_cvtss_f32(b);
             }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType add(VTArg a) {
-                m128 b = _mm_add_ps(avx_cast<m128>(a), _mm256_extractf128_ps(a, 1));
+                __m128 b = _mm_add_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));
                 b = _mm_add_ps(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 1, 2, 3)));
                 b = _mm_add_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 2, 0, 1)));
                 return _mm_cvtss_f32(b);
             }
-#undef SUFFIX
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) {
                 return _mm256_round_ps(a, _MM_FROUND_NINT);
             }
         };
 
-        template<> struct VectorHelper<sfloat> : public VectorHelper<float> {};
-
-        template<> struct VectorHelper<int> {
-            typedef int EntryType;
-            typedef m256i VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
-            typedef const VectorType VTArg;
-#endif
-            typedef long long ConcatType;
-#define SUFFIX si256
-
-            OP_(or_) OP_(and_) OP_(xor_)
-            static Vc_INTRINSIC VectorType Vc_CONST zero() { return CAT(_mm256_setzero_, SUFFIX)(); }
-            static Vc_INTRINSIC VectorType Vc_CONST notMaskedToZero(VTArg a, param256 mask) { return CAT(_mm256_and_, SUFFIX)(_mm256_castps_si256(mask), a); }
-#undef SUFFIX
-#define SUFFIX epi32
-            static Vc_INTRINSIC VectorType Vc_CONST one() { return CAT(_mm256_setone_, SUFFIX)(); }
-
-            static Vc_INTRINSIC VectorType Vc_CONST set(const int a) { return CAT(_mm256_set1_, SUFFIX)(a); }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const int a, const int b, const int c, const int d,
-                    const int e, const int f, const int g, const int h) {
-                return CAT(_mm256_set_, SUFFIX)(a, b, c, d, e, f, g, h); }
-
-            static Vc_INTRINSIC void fma(VectorType &v1, VTArg v2, VTArg v3) { v1 = add(mul(v1, v2), v3); }
-
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VTArg a, int shift) {
-                return CAT(_mm256_slli_, SUFFIX)(a, shift);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VTArg a, int shift) {
-                return CAT(_mm256_srai_, SUFFIX)(a, shift);
-            }
-            OP1(abs)
-
-            MINMAX
-            static Vc_INTRINSIC EntryType Vc_CONST min(VTArg a) {
-                m128i b = _mm_min_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_min_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_min_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2))); // using lo_epi16 for speed here
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST max(VTArg a) {
-                m128i b = _mm_max_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_max_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_max_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2))); // using lo_epi16 for speed here
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST add(VTArg a) {
-                m128i b = _mm_add_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_add_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_add_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST mul(VTArg a) {
-                m128i b = _mm_mullo_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_mullo_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_mullo_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                return _mm_cvtsi128_si32(b);
-            }
-
-            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mullo_epi32(a, b); }
-
-            OP(add) OP(sub)
-            OPcmp(eq)
-            OPcmp(lt)
-            OPcmp(gt)
-            static Vc_INTRINSIC VectorType Vc_CONST cmpneq(VTArg a, VTArg b) { m256i x = cmpeq(a, b); return _mm256_andnot_si256(x, _mm256_setallone_si256()); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpnlt(VTArg a, VTArg b) { m256i x = cmplt(a, b); return _mm256_andnot_si256(x, _mm256_setallone_si256()); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmple (VTArg a, VTArg b) { m256i x = cmpgt(a, b); return _mm256_andnot_si256(x, _mm256_setallone_si256()); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpnle(VTArg a, VTArg b) { return cmpgt(a, b); }
-#undef SUFFIX
-            static Vc_INTRINSIC VectorType Vc_CONST round(VTArg a) { return a; }
-        };
-
-        template<> struct VectorHelper<unsigned int> {
-            typedef unsigned int EntryType;
-            typedef m256i VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
-            typedef const VectorType VTArg;
-#endif
-            typedef unsigned long long ConcatType;
-#define SUFFIX si256
-            OP_CAST_(or_) OP_CAST_(and_) OP_CAST_(xor_)
-            static Vc_INTRINSIC VectorType Vc_CONST zero() { return CAT(_mm256_setzero_, SUFFIX)(); }
-            static Vc_INTRINSIC VectorType Vc_CONST notMaskedToZero(VTArg a, param256 mask) { return CAT(_mm256_and_, SUFFIX)(_mm256_castps_si256(mask), a); }
-
-#undef SUFFIX
-#define SUFFIX epu32
-            static Vc_INTRINSIC VectorType Vc_CONST one() { return CAT(_mm256_setone_, SUFFIX)(); }
-
-            MINMAX
-            static Vc_INTRINSIC EntryType Vc_CONST min(VTArg a) {
-                m128i b = _mm_min_epu32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_min_epu32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_min_epu32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2))); // using lo_epi16 for speed here
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST max(VTArg a) {
-                m128i b = _mm_max_epu32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_max_epu32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_max_epu32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2))); // using lo_epi16 for speed here
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST add(VTArg a) {
-                m128i b = _mm_add_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_add_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_add_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                return _mm_cvtsi128_si32(b);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST mul(VTArg a) {
-                m128i b = _mm_mullo_epi32(avx_cast<m128i>(a), _mm256_extractf128_si256(a, 1));
-                b = _mm_mullo_epi32(b, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                b = _mm_mullo_epi32(b, _mm_shufflelo_epi16(b, _MM_SHUFFLE(1, 0, 3, 2)));
-                return _mm_cvtsi128_si32(b);
-            }
-
-            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mullo_epi32(a, b); }
-            static Vc_INTRINSIC void fma(VectorType &v1, VTArg v2, VTArg v3) { v1 = add(mul(v1, v2), v3); }
-
-#undef SUFFIX
-#define SUFFIX epi32
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VTArg a, int shift) {
-                return CAT(_mm256_slli_, SUFFIX)(a, shift);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VTArg a, int shift) {
-                return CAT(_mm256_srli_, SUFFIX)(a, shift);
-            }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const unsigned int a) { return CAT(_mm256_set1_, SUFFIX)(a); }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const unsigned int a, const unsigned int b, const unsigned int c, const unsigned int d,
-                    const unsigned int e, const unsigned int f, const unsigned int g, const unsigned int h) {
-                return CAT(_mm256_set_, SUFFIX)(a, b, c, d, e, f, g, h); }
-
-            OP(add) OP(sub)
-            OPcmp(eq)
-            static Vc_INTRINSIC VectorType Vc_CONST cmpneq(VTArg a, VTArg b) { return _mm256_andnot_si256(cmpeq(a, b), _mm256_setallone_si256()); }
-
-#ifndef USE_INCORRECT_UNSIGNED_COMPARE
-            static Vc_INTRINSIC VectorType Vc_CONST cmplt(VTArg a, VTArg b) {
-                return _mm256_cmplt_epu32(a, b);
-            }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpgt(VTArg a, VTArg b) {
-                return _mm256_cmpgt_epu32(a, b);
-            }
-#else
-            OPcmp(lt)
-            OPcmp(gt)
-#endif
-            static Vc_INTRINSIC VectorType Vc_CONST cmpnlt(VTArg a, VTArg b) { return _mm256_andnot_si256(cmplt(a, b), _mm256_setallone_si256()); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmple (VTArg a, VTArg b) { return _mm256_andnot_si256(cmpgt(a, b), _mm256_setallone_si256()); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpnle(VTArg a, VTArg b) { return cmpgt(a, b); }
-
-#undef SUFFIX
-            static Vc_INTRINSIC VectorType Vc_CONST round(VTArg a) { return a; }
-        };
-
-        template<> struct VectorHelper<signed short> {
-            typedef VectorTypeHelper<signed short>::Type VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
-            typedef const VectorType VTArg;
-#endif
-            typedef signed short EntryType;
-            typedef int ConcatType;
-
-            static Vc_INTRINSIC VectorType Vc_CONST or_(VTArg a, VTArg b) { return _mm_or_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST and_(VTArg a, VTArg b) { return _mm_and_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST xor_(VTArg a, VTArg b) { return _mm_xor_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST zero() { return _mm_setzero_si128(); }
-            static Vc_INTRINSIC VectorType Vc_CONST notMaskedToZero(VTArg a, param128 mask) { return _mm_and_si128(_mm_castps_si128(mask), a); }
-
-#define SUFFIX epi16
-            static Vc_INTRINSIC VectorType Vc_CONST one() { return CAT(_mm_setone_, SUFFIX)(); }
-
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VTArg a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VTArg a, int shift) {
-                return CAT(_mm_srai_, SUFFIX)(a, shift);
-            }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const EntryType a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const EntryType a, const EntryType b, const EntryType c, const EntryType d,
-                    const EntryType e, const EntryType f, const EntryType g, const EntryType h) {
-                return CAT(_mm_set_, SUFFIX)(a, b, c, d, e, f, g, h);
-            }
-
-            static Vc_INTRINSIC void fma(VectorType &v1, VTArg v2, VTArg v3) {
-                v1 = add(mul(v1, v2), v3);
-            }
-
-            static Vc_INTRINSIC VectorType Vc_CONST abs(VTArg a) { return _mm_abs_epi16(a); }
-            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm_mullo_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm_min_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm_max_epi16(a, b); }
-
-            static Vc_INTRINSIC EntryType Vc_CONST min(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = min(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST max(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = max(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST mul(VTArg _a) {
-                VectorType a = mul(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = mul(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = mul(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST add(VTArg _a) {
-                VectorType a = add(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-
-            static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm_add_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm_sub_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpeq(VTArg a, VTArg b) { return _mm_cmpeq_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmplt(VTArg a, VTArg b) { return _mm_cmplt_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpgt(VTArg a, VTArg b) { return _mm_cmpgt_epi16(a, b); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(VTArg a, VTArg b) { m128i x = cmpeq(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(VTArg a, VTArg b) { m128i x = cmplt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (VTArg a, VTArg b) { m128i x = cmpgt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(VTArg a, VTArg b) { return cmpgt(a, b); }
-#undef SUFFIX
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) { return a; }
-        };
-
-        template<> struct VectorHelper<unsigned short> {
-            typedef VectorTypeHelper<unsigned short>::Type VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType & VTArg;
-#else
-            typedef const VectorType VTArg;
-#endif
-            typedef unsigned short EntryType;
-            typedef unsigned int ConcatType;
-
-            static Vc_INTRINSIC VectorType Vc_CONST or_(VTArg a, VTArg b) { return _mm_or_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST and_(VTArg a, VTArg b) { return _mm_and_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST xor_(VTArg a, VTArg b) { return _mm_xor_si128(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST zero() { return _mm_setzero_si128(); }
-            static Vc_INTRINSIC VectorType Vc_CONST notMaskedToZero(VTArg a, param128 mask) { return _mm_and_si128(_mm_castps_si128(mask), a); }
-            static Vc_INTRINSIC VectorType Vc_CONST one() { return _mm_setone_epu16(); }
-
-            static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm_mullo_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm_min_epu16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm_max_epu16(a, b); }
-
-#define SUFFIX epi16
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VTArg a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VTArg a, int shift) {
-                return CAT(_mm_srli_, SUFFIX)(a, shift);
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST min(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = min(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST max(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = max(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST mul(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = mul(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = mul(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = mul(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC EntryType Vc_CONST add(VTArg _a) {
-                // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
-                VectorType a = add(_a, _mm_shuffle_epi32(_a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
-                a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
-                return _mm_cvtsi128_si32(a); // & 0xffff is implicit
-            }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const EntryType a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_INTRINSIC VectorType Vc_CONST set(const EntryType a, const EntryType b, const EntryType c,
-                    const EntryType d, const EntryType e, const EntryType f,
-                    const EntryType g, const EntryType h) {
-                return CAT(_mm_set_, SUFFIX)(a, b, c, d, e, f, g, h);
-            }
-            static Vc_INTRINSIC void fma(VectorType &v1, VTArg v2, VTArg v3) { v1 = add(mul(v1, v2), v3); }
-
-            static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm_add_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm_sub_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpeq(VTArg a, VTArg b) { return _mm_cmpeq_epi16(a, b); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(VTArg a, VTArg b) { return _mm_andnot_si128(cmpeq(a, b), _mm_setallone_si128()); }
-
-#ifndef USE_INCORRECT_UNSIGNED_COMPARE
-            static Vc_INTRINSIC VectorType Vc_CONST cmplt(VTArg a, VTArg b) { return _mm_cmplt_epu16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpgt(VTArg a, VTArg b) { return _mm_cmpgt_epu16(a, b); }
-#else
-            static Vc_INTRINSIC VectorType Vc_CONST cmplt(VTArg a, VTArg b) { return _mm_cmplt_epi16(a, b); }
-            static Vc_INTRINSIC VectorType Vc_CONST cmpgt(VTArg a, VTArg b) { return _mm_cmpgt_epi16(a, b); }
-#endif
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(VTArg a, VTArg b) { return _mm_andnot_si128(cmplt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (VTArg a, VTArg b) { return _mm_andnot_si128(cmpgt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(VTArg a, VTArg b) { return cmpgt(a, b); }
-#undef SUFFIX
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) { return a; }
-        };
-#undef OP1
-#undef OP
-#undef OP_
-#undef OPx
-#undef OPcmp
-
-template<> struct VectorHelper<char>
-{
-    typedef VectorTypeHelper<char>::Type VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-    typedef const VectorType & VTArg;
-#else
-    typedef const VectorType VTArg;
-#endif
-    typedef char EntryType;
-    typedef short ConcatType;
-};
-
-template<> struct VectorHelper<unsigned char>
-{
-    typedef VectorTypeHelper<unsigned char>::Type VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-    typedef const VectorType & VTArg;
-#else
-    typedef const VectorType VTArg;
-#endif
-    typedef unsigned char EntryType;
-    typedef unsigned short ConcatType;
-};
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+#undef Vc_OP1
+#undef Vc_OP
+#undef Vc_OP_
+#undef Vc_OPx
 
-#include "vectorhelper.tcc"
-#include "undomacros.h"
+}  // namespace AVX(2)
+}  // namespace Vc
 
-#endif // AVX_VECTORHELPER_H
+#endif // VC_AVX_VECTORHELPER_H_
diff -Nru vc-0.7.4/avx/vectorhelper.tcc vc-1.3.0/avx/vectorhelper.tcc
--- vc-0.7.4/avx/vectorhelper.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/vectorhelper.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,270 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "casts.h"
-#include <cstdlib>
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace AVX
-{
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// float_v
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// loads
-template<> Vc_ALWAYS_INLINE Vc_PURE m256 VectorHelper<m256>::load(const float *m, AlignedFlag)
-{
-    return _mm256_load_ps(m);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256 VectorHelper<m256>::load(const float *m, UnalignedFlag)
-{
-    return _mm256_loadu_ps(m);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256 VectorHelper<m256>::load(const float *m, StreamingAndAlignedFlag)
-{
-    return avx_cast<m256>(concat(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<float *>(m))),
-                _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<float *>(&m[4])))));
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256
-    VC_WARN("AVX does not support streaming unaligned loads. Will use non-streaming unaligned load instead.")
-VectorHelper<m256>::load(const float *m, StreamingAndUnalignedFlag)
-{
-    return _mm256_loadu_ps(m);
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// stores
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, AlignedFlag)
-{
-    _mm256_store_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, UnalignedFlag)
-{
-    _mm256_storeu_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, StreamingAndAlignedFlag)
-{
-    _mm256_stream_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm256_extractf128_si256(avx_cast<m256i>(x), 1), _mm_setallone_si128(), reinterpret_cast<char *>(mem + 4));
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, VTArg m, AlignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, VTArg m, UnalignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, VTArg m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), avx_cast<m128i>(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm256_extractf128_si256(avx_cast<m256i>(x), 1), _mm256_extractf128_si256(avx_cast<m256i>(m), 1), reinterpret_cast<char *>(mem + 4));
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256>::store(float *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), avx_cast<m128i>(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm256_extractf128_si256(avx_cast<m256i>(x), 1), _mm256_extractf128_si256(avx_cast<m256i>(m), 1), reinterpret_cast<char *>(mem + 4));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// double_v
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// loads
-template<> Vc_ALWAYS_INLINE Vc_PURE m256d VectorHelper<m256d>::load(const double *m, AlignedFlag)
-{
-    return _mm256_load_pd(m);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256d VectorHelper<m256d>::load(const double *m, UnalignedFlag)
-{
-    return _mm256_loadu_pd(m);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256d VectorHelper<m256d>::load(const double *m, StreamingAndAlignedFlag)
-{
-    return avx_cast<m256d>(concat(
-                _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<double *>(m))),
-                _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<double *>(&m[2])))));
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE m256d
-    VC_WARN("AVX does not support streaming unaligned loads. Will use non-streaming unaligned load instead.")
-VectorHelper<m256d>::load(const double *m, StreamingAndUnalignedFlag)
-{
-    return _mm256_loadu_pd(m);
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// stores
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, AlignedFlag)
-{
-    _mm256_store_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, UnalignedFlag)
-{
-    _mm256_storeu_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, StreamingAndAlignedFlag)
-{
-    _mm256_stream_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(avx_cast<m128i>(_mm256_extractf128_pd(x, 1)), _mm_setallone_si128(), reinterpret_cast<char *>(mem + 2));
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, VTArg m, AlignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, VTArg m, UnalignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, VTArg m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), avx_cast<m128i>(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(avx_cast<m128i>(_mm256_extractf128_pd(x, 1)), avx_cast<m128i>(_mm256_extractf128_pd(m, 1)), reinterpret_cast<char *>(mem + 2));
-}
-Vc_ALWAYS_INLINE void VectorHelper<m256d>::store(double *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), avx_cast<m128i>(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(avx_cast<m128i>(_mm256_extractf128_pd(x, 1)), avx_cast<m128i>(_mm256_extractf128_pd(m, 1)), reinterpret_cast<char *>(mem + 2));
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// (u)int_v
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// loads
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m256i VectorHelper<m256i>::load(const T *m, AlignedFlag)
-{
-    return _mm256_load_si256(reinterpret_cast<const __m256i *>(m));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m256i VectorHelper<m256i>::load(const T *m, UnalignedFlag)
-{
-    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(m));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m256i VectorHelper<m256i>::load(const T *m, StreamingAndAlignedFlag)
-{
-    return concat(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<T *>(m))),
-            _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<T *>(&m[4]))));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m256i
-    VC_WARN("AVX does not support streaming unaligned loads. Will use non-streaming unaligned load instead.")
-VectorHelper<m256i>::load(const T *m, StreamingAndUnalignedFlag)
-{
-    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(m));
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// stores
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, AlignedFlag)
-{
-    _mm256_store_si256(reinterpret_cast<__m256i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, UnalignedFlag)
-{
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, StreamingAndAlignedFlag)
-{
-    _mm256_stream_si256(reinterpret_cast<__m256i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(avx_cast<m128i>(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm256_extractf128_si256(x, 1), _mm_setallone_si128(), reinterpret_cast<char *>(mem + 4));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, VTArg m, AlignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, VTArg m, UnalignedFlag)
-{
-    _mm256_maskstore(mem, m, x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, VTArg m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(lo128(x), lo128(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(hi128(x), hi128(m), reinterpret_cast<char *>(mem + 4));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m256i>::store(T *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(lo128(x), lo128(m), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(hi128(x), hi128(m), reinterpret_cast<char *>(mem + 4));
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// (u)short_v
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// loads
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m128i VectorHelper<m128i>::load(const T *m, AlignedFlag)
-{
-    return _mm_load_si128(reinterpret_cast<const __m128i *>(m));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m128i VectorHelper<m128i>::load(const T *m, UnalignedFlag)
-{
-    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(m));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m128i VectorHelper<m128i>::load(const T *m, StreamingAndAlignedFlag)
-{
-    return _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<T *>(m)));
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE m128i
-    VC_WARN("AVX does not support streaming unaligned loads. Will use non-streaming unaligned load instead.")
-VectorHelper<m128i>::load(const T *m, StreamingAndUnalignedFlag)
-{
-    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(m));
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//// stores
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, AlignedFlag)
-{
-    _mm_store_si128(reinterpret_cast<__m128i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, UnalignedFlag)
-{
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, StreamingAndAlignedFlag)
-{
-    _mm_stream_si128(reinterpret_cast<__m128i *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(x, _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, VTArg m, AlignedFlag align)
-{
-    store(mem, _mm_blendv_epi8(load(mem, align), x, m), align);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, VTArg m, UnalignedFlag align)
-{
-    store(mem, _mm_blendv_epi8(load(mem, align), x, m), align);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, VTArg m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(x, m, reinterpret_cast<char *>(mem));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<m128i>::store(T *mem, VTArg x, VTArg m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(x, m, reinterpret_cast<char *>(mem));
-}
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
diff -Nru vc-0.7.4/avx/vector.tcc vc-1.3.0/avx/vector.tcc
--- vc-0.7.4/avx/vector.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/vector.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,1406 +1,918 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "../common/x86_prefetches.h"
+#include "../common/gatherimplementation.h"
+#include "../common/scatterimplementation.h"
 #include "limits.h"
 #include "const.h"
+#include "../common/set.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-ALIGN(64) extern unsigned int RandomState[16];
-
-namespace AVX
+namespace Detail
 {
-
+// compare operators {{{1
+Vc_INTRINSIC AVX2::double_m operator==(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpeq_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator==(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpeq_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator==(AVX2::   int_v a, AVX2::   int_v b) { return AVX::cmpeq_epi32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::  uint_m operator==(AVX2::  uint_v a, AVX2::  uint_v b) { return AVX::cmpeq_epi32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: short_m operator==(AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmpeq_epi16(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::ushort_m operator==(AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmpeq_epi16(a.data(), b.data()); }
+
+Vc_INTRINSIC AVX2::double_m operator!=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpneq_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator!=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpneq_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator!=(AVX2::   int_v a, AVX2::   int_v b) { return not_(AVX::cmpeq_epi32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::  uint_m operator!=(AVX2::  uint_v a, AVX2::  uint_v b) { return not_(AVX::cmpeq_epi32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2:: short_m operator!=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmpeq_epi16(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::ushort_m operator!=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmpeq_epi16(a.data(), b.data())); }
+
+Vc_INTRINSIC AVX2::double_m operator>=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpnlt_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator>=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpnlt_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator>=(AVX2::   int_v a, AVX2::   int_v b) { return not_(AVX::cmplt_epi32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::  uint_m operator>=(AVX2::  uint_v a, AVX2::  uint_v b) { return not_(AVX::cmplt_epu32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2:: short_m operator>=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmplt_epi16(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::ushort_m operator>=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmplt_epu16(a.data(), b.data())); }
+
+Vc_INTRINSIC AVX2::double_m operator<=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmple_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator<=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmple_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator<=(AVX2::   int_v a, AVX2::   int_v b) { return not_(AVX::cmpgt_epi32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::  uint_m operator<=(AVX2::  uint_v a, AVX2::  uint_v b) { return not_(AVX::cmpgt_epu32(a.data(), b.data())); }
+Vc_INTRINSIC AVX2:: short_m operator<=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmpgt_epi16(a.data(), b.data())); }
+Vc_INTRINSIC AVX2::ushort_m operator<=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmpgt_epu16(a.data(), b.data())); }
+
+Vc_INTRINSIC AVX2::double_m operator> (AVX2::double_v a, AVX2::double_v b) { return AVX::cmpgt_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator> (AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpgt_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator> (AVX2::   int_v a, AVX2::   int_v b) { return AVX::cmpgt_epi32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::  uint_m operator> (AVX2::  uint_v a, AVX2::  uint_v b) { return AVX::cmpgt_epu32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: short_m operator> (AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmpgt_epi16(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::ushort_m operator> (AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmpgt_epu16(a.data(), b.data()); }
+
+Vc_INTRINSIC AVX2::double_m operator< (AVX2::double_v a, AVX2::double_v b) { return AVX::cmplt_pd(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: float_m operator< (AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmplt_ps(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::   int_m operator< (AVX2::   int_v a, AVX2::   int_v b) { return AVX::cmplt_epi32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::  uint_m operator< (AVX2::  uint_v a, AVX2::  uint_v b) { return AVX::cmplt_epu32(a.data(), b.data()); }
+Vc_INTRINSIC AVX2:: short_m operator< (AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmplt_epi16(a.data(), b.data()); }
+Vc_INTRINSIC AVX2::ushort_m operator< (AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmplt_epu16(a.data(), b.data()); }
+
+// bitwise operators {{{1
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator^(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return xor_(a.data(), b.data());
+}
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator&(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return and_(a.data(), b.data());
+}
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator|(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return or_(a.data(), b.data());
+}
+// }}}1
+// arithmetic operators {{{1
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator+(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return add(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator-(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return sub(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator*(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return mul(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC AVX2::Vector<T> operator/(AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return div(a.data(), b.data(), T());
+}
+Vc_INTRINSIC AVX2::Vector<ushort> operator/(AVX2::Vector<ushort> a,
+                                            AVX2::Vector<ushort> b)
+{
+    using namespace AVX;
+    const __m256 lo = _mm256_div_ps(convert<ushort, float>(lo128(a.data())),
+                                    convert<ushort, float>(lo128(b.data())));
+    const __m256 hi = _mm256_div_ps(convert<ushort, float>(hi128(a.data())),
+                                    convert<ushort, float>(hi128(b.data())));
+    const float_v threshold = 32767.f;
+    using Detail::operator>;
+    const __m128i loShort = (Vc_IS_UNLIKELY((float_v(lo) > threshold).isNotEmpty()))
+                                ? convert<float, ushort>(lo)
+                                : convert<float, short>(lo);
+    const __m128i hiShort = (Vc_IS_UNLIKELY((float_v(hi) > threshold).isNotEmpty()))
+                                ? convert<float, ushort>(hi)
+                                : convert<float, short>(hi);
+    return concat(loShort, hiShort);
+}
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_integral<T>::value, AVX2::Vector<T>> operator%(
+    AVX2::Vector<T> a, AVX2::Vector<T> b)
+{
+    return a - a / b * b;
+}
+// }}}1
+}  // namespace Detail
 ///////////////////////////////////////////////////////////////////////////////////////////
-// constants {{{1
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(VectorSpecialInitializerZero::ZEnum) : d(HT::zero()) {}
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(VectorSpecialInitializerOne::OEnum) : d(HT::one()) {}
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(VectorSpecialInitializerIndexesFromZero::IEnum)
-    : d(HV::load(IndexesFromZeroData<T>::address(), Aligned)) {}
-
-template<typename T> Vc_INTRINSIC Vector<T> Vc_CONST Vector<T>::Zero() { return HT::zero(); }
-template<typename T> Vc_INTRINSIC Vector<T> Vc_CONST Vector<T>::One() { return HT::one(); }
-template<typename T> Vc_INTRINSIC Vector<T> Vc_CONST Vector<T>::IndexesFromZero() { return HV::load(IndexesFromZeroData<T>::address(), Aligned); }
-
-template<typename T> template<typename T2> Vc_ALWAYS_INLINE Vector<T>::Vector(VC_ALIGNED_PARAMETER(Vector<T2>) x)
-    : d(StaticCastHelper<T2, T>::cast(x.data())) {}
-
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(EntryType x) : d(HT::set(x)) {}
-template<> Vc_ALWAYS_INLINE Vector<double>::Vector(EntryType x) : d(_mm256_set1_pd(x)) {}
+// generate {{{1
+template <> template <typename G> Vc_INTRINSIC AVX2::double_v AVX2::double_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    return _mm256_setr_pd(tmp0, tmp1, tmp2, tmp3);
+}
+template <> template <typename G> Vc_INTRINSIC AVX2::float_v AVX2::float_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    return _mm256_setr_ps(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
+}
+#ifdef Vc_IMPL_AVX2
+template <> template <typename G> Vc_INTRINSIC AVX2::int_v AVX2::int_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    return _mm256_setr_epi32(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
+}
+template <> template <typename G> Vc_INTRINSIC AVX2::uint_v AVX2::uint_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    return _mm256_setr_epi32(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
+}
+template <> template <typename G> Vc_INTRINSIC AVX2::short_v AVX2::short_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    const auto tmp8 = gen(8);
+    const auto tmp9 = gen(9);
+    const auto tmp10 = gen(10);
+    const auto tmp11 = gen(11);
+    const auto tmp12 = gen(12);
+    const auto tmp13 = gen(13);
+    const auto tmp14 = gen(14);
+    const auto tmp15 = gen(15);
+    return _mm256_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15);
+}
+template <> template <typename G> Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    const auto tmp8 = gen(8);
+    const auto tmp9 = gen(9);
+    const auto tmp10 = gen(10);
+    const auto tmp11 = gen(11);
+    const auto tmp12 = gen(12);
+    const auto tmp13 = gen(13);
+    const auto tmp14 = gen(14);
+    const auto tmp15 = gen(15);
+    return _mm256_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15);
+}
+#endif
 
+// constants {{{1
+template <typename T> Vc_INTRINSIC Vector<T, VectorAbi::Avx>::Vector(VectorSpecialInitializerZero) : d{} {}
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// load ctors {{{1
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *x) { load(x); }
-template<typename T> template<typename A> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *x, A a) { load(x, a); }
-template<typename T> template<typename OtherT> Vc_ALWAYS_INLINE Vector<T>::Vector(const OtherT *x) { load(x); }
-template<typename T> template<typename OtherT, typename A> Vc_ALWAYS_INLINE Vector<T>::Vector(const OtherT *x, A a) { load(x, a); }
+template <> Vc_INTRINSIC Vector<double, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_pd()) {}
+template <> Vc_INTRINSIC Vector< float, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_ps()) {}
+#ifdef Vc_IMPL_AVX2
+template <> Vc_INTRINSIC Vector<   int, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi32()) {}
+template <> Vc_INTRINSIC Vector<  uint, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu32()) {}
+template <> Vc_INTRINSIC Vector< short, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi16()) {}
+template <> Vc_INTRINSIC Vector<ushort, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu16()) {}
+template <> Vc_INTRINSIC Vector< schar, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi8()) {}
+template <> Vc_INTRINSIC Vector< uchar, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu8()) {}
+#endif
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// load member functions {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::load(const EntryType *mem)
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Avx>::Vector(
+    VectorSpecialInitializerIndexesFromZero)
+    : Vector(AVX::IndexesFromZeroData<T>::address(), Vc::Aligned)
 {
-    load(mem, Aligned);
 }
 
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::load(const EntryType *mem, A align)
+template <>
+Vc_ALWAYS_INLINE Vector<float, VectorAbi::Avx>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : Vector(AVX::IndexesFromZeroData<int>::address(), Vc::Aligned)
 {
-    d.v() = HV::load(mem, align);
 }
-
-template<typename T> template<typename OtherT> Vc_INTRINSIC void Vector<T>::load(const OtherT *mem)
+template <>
+Vc_ALWAYS_INLINE Vector<double, VectorAbi::Avx>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : Vector(AVX::IndexesFromZeroData<int>::address(), Vc::Aligned)
 {
-    load(mem, Aligned);
 }
 
-// LoadHelper {{{2
-template<typename DstT, typename SrcT, typename Flags> struct LoadHelper;
-
-// float {{{2
-template<typename Flags> struct LoadHelper<float, double, Flags> {
-    static m256 load(const double *mem, Flags f)
-    {
-        return concat(_mm256_cvtpd_ps(VectorHelper<m256d>::load(&mem[0], f)),
-                      _mm256_cvtpd_ps(VectorHelper<m256d>::load(&mem[4], f)));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned int, Flags> {
-    static m256 load(const unsigned int *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned int, float>::cast(VectorHelper<m256i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, int, Flags> {
-    static m256 load(const int *mem, Flags f)
-    {
-        return StaticCastHelper<int, float>::cast(VectorHelper<m256i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned short, Flags> {
-    static m256 load(const unsigned short *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned short, float>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, short, Flags> {
-    static m256 load(const short *mem, Flags f)
-    {
-        return StaticCastHelper<short, float>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned char, Flags> {
-    static m256 load(const unsigned char *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned int, float>::cast(LoadHelper<unsigned int, unsigned char, Flags>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, signed char, Flags> {
-    static m256 load(const signed char *mem, Flags f)
-    {
-        return StaticCastHelper<int, float>::cast(LoadHelper<int, signed char, Flags>::load(mem, f));
-    }
-};
-
-template<typename SrcT, typename Flags> struct LoadHelper<sfloat, SrcT, Flags> : public LoadHelper<float, SrcT, Flags> {};
-
-// int {{{2
-template<typename Flags> struct LoadHelper<int, unsigned int, Flags> {
-    static m256i load(const unsigned int *mem, Flags f)
-    {
-        return VectorHelper<m256i>::load(mem, f);
-    }
-};
-template<typename Flags> struct LoadHelper<int, unsigned short, Flags> {
-    static m256i load(const unsigned short *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned short, unsigned int>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<int, short, Flags> {
-    static m256i load(const short *mem, Flags f)
-    {
-        return StaticCastHelper<short, int>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<int, unsigned char, Flags> {
-    static m256i load(const unsigned char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epu8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        const m128i epu16 = _mm_cvtepu8_epi16(epu8);
-        return StaticCastHelper<unsigned short, unsigned int>::cast(epu16);
-    }
-};
-template<typename Flags> struct LoadHelper<int, signed char, Flags> {
-    static m256i load(const signed char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epi8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        const m128i epi16 = _mm_cvtepi8_epi16(epi8);
-        return StaticCastHelper<short, int>::cast(epi16);
-    }
-};
-
-// unsigned int {{{2
-template<typename Flags> struct LoadHelper<unsigned int, unsigned short, Flags> {
-    static m256i load(const unsigned short *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned short, unsigned int>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<unsigned int, unsigned char, Flags> {
-    static m256i load(const unsigned char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epu8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        const m128i epu16 = _mm_cvtepu8_epi16(epu8);
-        return StaticCastHelper<unsigned short, unsigned int>::cast(epu16);
-    }
-};
-
-// short {{{2
-template<typename Flags> struct LoadHelper<short, unsigned short, Flags> {
-    static m128i load(const unsigned short *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned short, short>::cast(VectorHelper<m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<short, unsigned char, Flags> {
-    static m128i load(const unsigned char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epu8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        return _mm_cvtepu8_epi16(epu8);
-    }
-};
-template<typename Flags> struct LoadHelper<short, signed char, Flags> {
-    static m128i load(const signed char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epi8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        return _mm_cvtepi8_epi16(epi8);
-    }
-};
-
-// unsigned short {{{2
-template<typename Flags> struct LoadHelper<unsigned short, unsigned char, Flags> {
-    static m128i load(const unsigned char *mem, Flags)
-    {
-        // the only available streaming load loads 16 bytes - twice as much as we need => can't use
-        // it, or we risk an out-of-bounds read and an unaligned load exception
-        const m128i epu8 = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem));
-        return _mm_cvtepu8_epi16(epu8);
-    }
-};
-
+///////////////////////////////////////////////////////////////////////////////////////////
+// load member functions {{{1
 // general load, implemented via LoadHelper {{{2
-template<typename DstT> template<typename SrcT, typename Flags> Vc_INTRINSIC void Vector<DstT>::load(const SrcT *x, Flags f)
+template <typename DstT>
+template <typename SrcT, typename Flags>
+Vc_INTRINSIC typename Vector<DstT, VectorAbi::Avx>::
+#ifndef Vc_MSVC
+template
+#endif
+load_concept<SrcT, Flags>::type Vector<DstT, VectorAbi::Avx>::load(const SrcT *mem, Flags flags)
 {
-    d.v() = LoadHelper<DstT, SrcT, Flags>::load(x, f);
+    Common::handleLoadPrefetches(mem, flags);
+    d.v() = Detail::load<VectorType, DstT>(mem, flags);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 // zeroing {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::setZero()
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Avx>::setZero()
 {
-    data() = HV::zero();
+    data() = Detail::zero<VectorType>();
 }
-template<typename T> Vc_INTRINSIC void Vector<T>::setZero(const Mask &k)
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Avx>::setZero(const Mask &k)
 {
-    data() = HV::andnot_(avx_cast<VectorType>(k.data()), data());
+    data() = Detail::andnot_(AVX::avx_cast<VectorType>(k.data()), data());
 }
-
-template<> Vc_INTRINSIC void Vector<double>::setQnan()
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Avx>::setZeroInverted(const Mask &k)
 {
-    data() = _mm256_setallone_pd();
+    data() = Detail::and_(AVX::avx_cast<VectorType>(k.data()), data());
 }
-template<> Vc_INTRINSIC void Vector<double>::setQnan(MaskArg k)
-{
-    data() = _mm256_or_pd(data(), k.dataD());
-}
-template<> Vc_INTRINSIC void Vector<float>::setQnan()
+
+template<> Vc_INTRINSIC void Vector<double, VectorAbi::Avx>::setQnan()
 {
-    data() = _mm256_setallone_ps();
+    data() = Detail::allone<VectorType>();
 }
-template<> Vc_INTRINSIC void Vector<float>::setQnan(MaskArg k)
+template<> Vc_INTRINSIC void Vector<double, VectorAbi::Avx>::setQnan(MaskArgument k)
 {
-    data() = _mm256_or_ps(data(), k.data());
+    data() = _mm256_or_pd(data(), k.dataD());
 }
-template<> Vc_INTRINSIC void Vector<sfloat>::setQnan()
+template<> Vc_INTRINSIC void Vector<float, VectorAbi::Avx>::setQnan()
 {
-    data() = _mm256_setallone_ps();
+    data() = Detail::allone<VectorType>();
 }
-template<> Vc_INTRINSIC void Vector<sfloat>::setQnan(MaskArg k)
+template<> Vc_INTRINSIC void Vector<float, VectorAbi::Avx>::setQnan(MaskArgument k)
 {
     data() = _mm256_or_ps(data(), k.data());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 // stores {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::store(EntryType *mem) const
-{
-    HV::store(mem, data(), Aligned);
-}
-template<typename T> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, const Mask &mask) const
-{
-    HV::store(mem, data(), avx_cast<VectorType>(mask.data()), Aligned);
-}
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, A align) const
-{
-    HV::store(mem, data(), align);
-}
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, const Mask &mask, A align) const
+template <typename T>
+template <typename U,
+          typename Flags,
+          typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Avx>::store(U *mem, Flags flags) const
+{
+    Common::handleStorePrefetches(mem, flags);
+    HV::template store<Flags>(mem, data());
+}
+
+template <typename T>
+template <typename U,
+          typename Flags,
+          typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Avx>::store(U *mem, Mask mask, Flags flags) const
 {
-    HV::store(mem, data(), avx_cast<VectorType>(mask.data()), align);
+    Common::handleStorePrefetches(mem, flags);
+    HV::template store<Flags>(mem, data(), AVX::avx_cast<VectorType>(mask.data()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// expand/merge 1 float_v <=> 2 double_v          XXX rationale? remove it for release? XXX {{{1
-template<typename T> Vc_ALWAYS_INLINE Vc_FLATTEN Vector<T>::Vector(const Vector<typename HT::ConcatType> *a)
-    : d(a[0])
-{
+// integer ops {{{1
+#ifdef Vc_IMPL_AVX2
+template <> Vc_ALWAYS_INLINE AVX2::Vector<   int> Vector<   int, VectorAbi::Avx>::operator<<(AsArg x) const { return _mm256_sllv_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector<  uint> Vector<  uint, VectorAbi::Avx>::operator<<(AsArg x) const { return _mm256_sllv_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector<   int> Vector<   int, VectorAbi::Avx>::operator>>(AsArg x) const { return _mm256_srav_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector<  uint> Vector<  uint, VectorAbi::Avx>::operator>>(AsArg x) const { return _mm256_srlv_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector< short> Vector< short, VectorAbi::Avx>::operator<<(AsArg x) const { return generate([&](int i) { return get(*this, i) << get(x, i); }); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector<ushort> Vector<ushort, VectorAbi::Avx>::operator<<(AsArg x) const { return generate([&](int i) { return get(*this, i) << get(x, i); }); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector< short> Vector< short, VectorAbi::Avx>::operator>>(AsArg x) const { return generate([&](int i) { return get(*this, i) >> get(x, i); }); }
+template <> Vc_ALWAYS_INLINE AVX2::Vector<ushort> Vector<ushort, VectorAbi::Avx>::operator>>(AsArg x) const { return generate([&](int i) { return get(*this, i) >> get(x, i); }); }
+template <typename T>
+Vc_ALWAYS_INLINE AVX2::Vector<T> &Vector<T, VectorAbi::Avx>::operator<<=(AsArg x)
+{
+    static_assert(std::is_integral<T>::value,
+                  "bitwise-operators can only be used with Vectors of integral type");
+    return *this = *this << x;
+}
+template <typename T>
+Vc_ALWAYS_INLINE AVX2::Vector<T> &Vector<T, VectorAbi::Avx>::operator>>=(AsArg x)
+{
+    static_assert(std::is_integral<T>::value,
+                  "bitwise-operators can only be used with Vectors of integral type");
+    return *this = *this >> x;
 }
-template<> Vc_ALWAYS_INLINE Vc_FLATTEN Vector<float>::Vector(const Vector<HT::ConcatType> *a)
-    : d(concat(_mm256_cvtpd_ps(a[0].data()), _mm256_cvtpd_ps(a[1].data())))
-{
+#endif
+
+template<typename T> Vc_ALWAYS_INLINE AVX2::Vector<T> &Vector<T, VectorAbi::Avx>::operator>>=(int shift) {
+    d.v() = Detail::shiftRight(d.v(), shift, T());
+    return *static_cast<AVX2::Vector<T> *>(this);
 }
-template<> Vc_ALWAYS_INLINE Vc_FLATTEN Vector<short>::Vector(const Vector<HT::ConcatType> *a)
-    : d(_mm_packs_epi32(lo128(a->data()), hi128(a->data())))
-{
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::operator>>(int shift) const {
+    return Detail::shiftRight(d.v(), shift, T());
 }
-template<> Vc_ALWAYS_INLINE Vc_FLATTEN Vector<unsigned short>::Vector(const Vector<HT::ConcatType> *a)
-    : d(_mm_packus_epi32(lo128(a->data()), hi128(a->data())))
-{
+template<typename T> Vc_ALWAYS_INLINE AVX2::Vector<T> &Vector<T, VectorAbi::Avx>::operator<<=(int shift) {
+    d.v() = Detail::shiftLeft(d.v(), shift, T());
+    return *static_cast<AVX2::Vector<T> *>(this);
 }
-template<typename T> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::expand(Vector<typename HT::ConcatType> *x) const
-{
-    x[0] = *this;
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::operator<<(int shift) const {
+    return Detail::shiftLeft(d.v(), shift, T());
 }
-template<> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::expand(Vector<HT::ConcatType> *x) const
+
+// isnegative {{{1
+Vc_INTRINSIC Vc_CONST AVX2::float_m isnegative(AVX2::float_v x)
 {
-    x[0].data() = _mm256_cvtps_pd(lo128(d.v()));
-    x[1].data() = _mm256_cvtps_pd(hi128(d.v()));
+    return AVX::avx_cast<__m256>(AVX::srai_epi32<31>(
+        AVX::avx_cast<__m256i>(_mm256_and_ps(AVX::setsignmask_ps(), x.data()))));
 }
-template<> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::expand(Vector<HT::ConcatType> *x) const
+Vc_INTRINSIC Vc_CONST AVX2::double_m isnegative(AVX2::double_v x)
 {
-    x[0].data() = concat(_mm_cvtepi16_epi32(d.v()),
-            _mm_cvtepi16_epi32(_mm_unpackhi_epi64(d.v(), d.v())));
+    return Mem::permute<X1, X1, X3, X3>(AVX::avx_cast<__m256>(AVX::srai_epi32<31>(
+        AVX::avx_cast<__m256i>(_mm256_and_pd(AVX::setsignmask_pd(), x.data())))));
 }
-template<> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::expand(Vector<HT::ConcatType> *x) const
+// gathers {{{1
+template <>
+template <typename MT, typename IT>
+inline void AVX2::double_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    x[0].data() = concat(_mm_cvtepu16_epi32(d.v()),
-            _mm_cvtepu16_epi32(_mm_unpackhi_epi64(d.v(), d.v())));
+    d.v() = _mm256_setr_pd(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// swizzles {{{1
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE &Vector<T>::abcd() const { return *this; }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::cdab() const { return Mem::permute<X2, X3, X0, X1>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::badc() const { return Mem::permute<X1, X0, X3, X2>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::aaaa() const { return Mem::permute<X0, X0, X0, X0>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::bbbb() const { return Mem::permute<X1, X1, X1, X1>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::cccc() const { return Mem::permute<X2, X2, X2, X2>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::dddd() const { return Mem::permute<X3, X3, X3, X3>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::bcad() const { return Mem::permute<X1, X2, X0, X3>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::bcda() const { return Mem::permute<X1, X2, X3, X0>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::dabc() const { return Mem::permute<X3, X0, X1, X2>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::acbd() const { return Mem::permute<X0, X2, X1, X3>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::dbca() const { return Mem::permute<X3, X1, X2, X0>(data()); }
-template<typename T> Vc_INTRINSIC const Vector<T> Vc_PURE  Vector<T>::dcba() const { return Mem::permute<X3, X2, X1, X0>(data()); }
-
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::cdab() const { return Mem::shuffle128<X1, X0>(data(), data()); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::badc() const { return Mem::permute<X1, X0, X3, X2>(data()); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::aaaa() const { const double &tmp = d.m(0); return _mm256_broadcast_sd(&tmp); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::bbbb() const { const double &tmp = d.m(1); return _mm256_broadcast_sd(&tmp); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::cccc() const { const double &tmp = d.m(2); return _mm256_broadcast_sd(&tmp); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::dddd() const { const double &tmp = d.m(3); return _mm256_broadcast_sd(&tmp); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::bcad() const { return Mem::shuffle<X1, Y0, X2, Y3>(Mem::shuffle128<X0, X0>(data(), data()), Mem::shuffle128<X1, X1>(data(), data())); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::bcda() const { return Mem::shuffle<X1, Y0, X3, Y2>(data(), Mem::shuffle128<X1, X0>(data(), data())); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::dabc() const { return Mem::shuffle<X1, Y0, X3, Y2>(Mem::shuffle128<X1, X0>(data(), data()), data()); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::acbd() const { return Mem::shuffle<X0, Y0, X3, Y3>(Mem::shuffle128<X0, X0>(data(), data()), Mem::shuffle128<X1, X1>(data(), data())); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::dbca() const { return Mem::shuffle<X1, Y1, X2, Y2>(Mem::shuffle128<X1, X1>(data(), data()), Mem::shuffle128<X0, X0>(data(), data())); }
-template<> Vc_INTRINSIC const double_v Vc_PURE Vector<double>::dcba() const { return cdab().badc(); }
-
-#define VC_SWIZZLES_16BIT_IMPL(T) \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::cdab() const { return Mem::permute<X2, X3, X0, X1, X6, X7, X4, X5>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::badc() const { return Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::aaaa() const { return Mem::permute<X0, X0, X0, X0, X4, X4, X4, X4>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::bbbb() const { return Mem::permute<X1, X1, X1, X1, X5, X5, X5, X5>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::cccc() const { return Mem::permute<X2, X2, X2, X2, X6, X6, X6, X6>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::dddd() const { return Mem::permute<X3, X3, X3, X3, X7, X7, X7, X7>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::bcad() const { return Mem::permute<X1, X2, X0, X3, X5, X6, X4, X7>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::bcda() const { return Mem::permute<X1, X2, X3, X0, X5, X6, X7, X4>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::dabc() const { return Mem::permute<X3, X0, X1, X2, X7, X4, X5, X6>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::acbd() const { return Mem::permute<X0, X2, X1, X3, X4, X6, X5, X7>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::dbca() const { return Mem::permute<X3, X1, X2, X0, X7, X5, X6, X4>(data()); } \
-template<> Vc_INTRINSIC const Vector<T> Vc_PURE Vector<T>::dcba() const { return Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(data()); }
-VC_SWIZZLES_16BIT_IMPL(short)
-VC_SWIZZLES_16BIT_IMPL(unsigned short)
-#undef VC_SWIZZLES_16BIT_IMPL
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// division {{{1
-template<typename T> inline Vector<T> &Vector<T>::operator/=(EntryType x)
-{
-    if (HasVectorDivision) {
-        return operator/=(Vector<T>(x));
-    }
-    for_all_vector_entries(i,
-            d.m(i) /= x;
-            );
-    return *this;
+template <>
+template <typename MT, typename IT>
+inline void AVX2::float_v::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = _mm256_setr_ps(mem[indexes[0]],
+                           mem[indexes[1]],
+                           mem[indexes[2]],
+                           mem[indexes[3]],
+                           mem[indexes[4]],
+                           mem[indexes[5]],
+                           mem[indexes[6]],
+                           mem[indexes[7]]);
+}
+
+#ifdef Vc_IMPL_AVX2
+template <>
+template <typename MT, typename IT>
+inline void AVX2::int_v::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = _mm256_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]],
+                              mem[indexes[3]], mem[indexes[4]], mem[indexes[5]],
+                              mem[indexes[6]], mem[indexes[7]]);
+}
+
+template <>
+template <typename MT, typename IT>
+inline void AVX2::uint_v::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = _mm256_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]],
+                              mem[indexes[3]], mem[indexes[4]], mem[indexes[5]],
+                              mem[indexes[6]], mem[indexes[7]]);
+}
+
+template <>
+template <typename MT, typename IT>
+inline void AVX2::short_v::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = _mm256_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]],
+                              mem[indexes[3]], mem[indexes[4]], mem[indexes[5]],
+                              mem[indexes[6]], mem[indexes[7]], mem[indexes[8]],
+                              mem[indexes[9]], mem[indexes[10]], mem[indexes[11]],
+                              mem[indexes[12]], mem[indexes[13]], mem[indexes[14]],
+                              mem[indexes[15]]);
+}
+
+template <>
+template <typename MT, typename IT>
+inline void AVX2::ushort_v::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = _mm256_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]],
+                              mem[indexes[3]], mem[indexes[4]], mem[indexes[5]],
+                              mem[indexes[6]], mem[indexes[7]], mem[indexes[8]],
+                              mem[indexes[9]], mem[indexes[10]], mem[indexes[11]],
+                              mem[indexes[12]], mem[indexes[13]], mem[indexes[14]],
+                              mem[indexes[15]]);
 }
-template<typename T> template<typename TT> inline Vc_PURE VC_EXACT_TYPE(TT, typename DetermineEntryType<T>::Type, Vector<T>) Vector<T>::operator/(TT x) const
-{
-    if (HasVectorDivision) {
-        return operator/(Vector<T>(x));
-    }
-    Vector<T> r;
-    for_all_vector_entries(i,
-            r.d.m(i) = d.m(i) / x;
-            );
-    return r;
-}
-// per default fall back to scalar division
-template<typename T> inline Vector<T> &Vector<T>::operator/=(const Vector<T> &x)
-{
-    for_all_vector_entries(i,
-            d.m(i) /= x.d.m(i);
-            );
-    return *this;
+#endif
+
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Avx>::gatherImplementation(const MT *mem, IT &&indexes, MaskArgument mask)
+{
+    using Selector = std::integral_constant < Common::GatherScatterImplementation,
+#ifdef Vc_USE_SET_GATHERS
+          Traits::is_simd_vector<IT>::value ? Common::GatherScatterImplementation::SetIndexZero :
+#endif
+#ifdef Vc_USE_BSF_GATHERS
+                                            Common::GatherScatterImplementation::BitScanLoop
+#elif defined Vc_USE_POPCNT_BSF_GATHERS
+              Common::GatherScatterImplementation::PopcntSwitch
+#else
+              Common::GatherScatterImplementation::SimpleLoop
+#endif
+                                                > ;
+    Common::executeGather(Selector(), *this, mem, std::forward<IT>(indexes), mask);
 }
 
-template<typename T> inline Vector<T> Vc_PURE Vector<T>::operator/(const Vector<T> &x) const
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Avx>::scatterImplementation(MT *mem, IT &&indexes) const
 {
-    Vector<T> r;
-    for_all_vector_entries(i,
-            r.d.m(i) = d.m(i) / x.d.m(i);
-            );
-    return r;
-}
-// specialize division on type
-static Vc_INTRINSIC m256i Vc_CONST divInt(param256i a, param256i b) {
-    const m256d lo1 = _mm256_cvtepi32_pd(lo128(a));
-    const m256d lo2 = _mm256_cvtepi32_pd(lo128(b));
-    const m256d hi1 = _mm256_cvtepi32_pd(hi128(a));
-    const m256d hi2 = _mm256_cvtepi32_pd(hi128(b));
-    return concat(
-            _mm256_cvttpd_epi32(_mm256_div_pd(lo1, lo2)),
-            _mm256_cvttpd_epi32(_mm256_div_pd(hi1, hi2))
-            );
+    Common::unrolled_loop<std::size_t, 0, Size>([&](std::size_t i) { mem[indexes[i]] = d.m(i); });
 }
-template<> inline Vector<int> &Vector<int>::operator/=(const Vector<int> &x)
-{
-    d.v() = divInt(d.v(), x.d.v());
-    return *this;
-}
-template<> inline Vector<int> Vc_PURE Vector<int>::operator/(const Vector<int> &x) const
+
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Avx>::scatterImplementation(MT *mem, IT &&indexes, MaskArgument mask) const
 {
-    return divInt(d.v(), x.d.v());
-}
-static inline m256i Vc_CONST divUInt(param256i a, param256i b) {
-    m256d loa = _mm256_cvtepi32_pd(lo128(a));
-    m256d hia = _mm256_cvtepi32_pd(hi128(a));
-    m256d lob = _mm256_cvtepi32_pd(lo128(b));
-    m256d hib = _mm256_cvtepi32_pd(hi128(b));
-    // if a >= 2^31 then after conversion to double it will contain a negative number (i.e. a-2^32)
-    // to get the right number back we have to add 2^32 where a >= 2^31
-    loa = _mm256_add_pd(loa, _mm256_and_pd(_mm256_cmp_pd(loa, _mm256_setzero_pd(), _CMP_LT_OS), _mm256_set1_pd(4294967296.)));
-    hia = _mm256_add_pd(hia, _mm256_and_pd(_mm256_cmp_pd(hia, _mm256_setzero_pd(), _CMP_LT_OS), _mm256_set1_pd(4294967296.)));
-    // we don't do the same for b because division by b >= 2^31 should be a seldom corner case and
-    // we rather want the standard stuff fast
-    //
-    // there is one remaining problem: a >= 2^31 and b == 1
-    // in that case the return value would be 2^31
-    return avx_cast<m256i>(_mm256_blendv_ps(avx_cast<m256>(concat(
-                        _mm256_cvttpd_epi32(_mm256_div_pd(loa, lob)),
-                        _mm256_cvttpd_epi32(_mm256_div_pd(hia, hib))
-                        )), avx_cast<m256>(a), avx_cast<m256>(concat(
-                            _mm_cmpeq_epi32(lo128(b), _mm_setone_epi32()),
-                            _mm_cmpeq_epi32(hi128(b), _mm_setone_epi32())))));
+    using Selector = std::integral_constant < Common::GatherScatterImplementation,
+#ifdef Vc_USE_SET_GATHERS
+          Traits::is_simd_vector<IT>::value ? Common::GatherScatterImplementation::SetIndexZero :
+#endif
+#ifdef Vc_USE_BSF_GATHERS
+                                            Common::GatherScatterImplementation::BitScanLoop
+#elif defined Vc_USE_POPCNT_BSF_GATHERS
+              Common::GatherScatterImplementation::PopcntSwitch
+#else
+              Common::GatherScatterImplementation::SimpleLoop
+#endif
+                                                > ;
+    Common::executeScatter(Selector(), *this, mem, std::forward<IT>(indexes), mask);
 }
-template<> Vc_ALWAYS_INLINE Vector<unsigned int> &Vector<unsigned int>::operator/=(const Vector<unsigned int> &x)
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// operator- {{{1
+#ifdef Vc_USE_BUILTIN_VECTOR_TYPES
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::operator-() const
 {
-    d.v() = divUInt(d.v(), x.d.v());
-    return *this;
+    return VectorType(-d.builtin());
 }
-template<> Vc_ALWAYS_INLINE Vector<unsigned int> Vc_PURE Vector<unsigned int>::operator/(const Vector<unsigned int> &x) const
+#else
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::operator-() const
 {
-    return divUInt(d.v(), x.d.v());
+    return Detail::negate(d.v(), std::integral_constant<std::size_t, sizeof(T)>());
 }
-template<typename T> static inline m128i Vc_CONST divShort(param128i a, param128i b)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// horizontal ops {{{1
+template <typename T>
+Vc_INTRINSIC std::pair<Vector<T, VectorAbi::Avx>, int>
+Vector<T, VectorAbi::Avx>::minIndex() const
 {
-    const m256 r = _mm256_div_ps(StaticCastHelper<T, float>::cast(a),
-            StaticCastHelper<T, float>::cast(b));
-    return StaticCastHelper<float, T>::cast(r);
+    AVX2::Vector<T> x = min();
+    return std::make_pair(x, (*this == x).firstOne());
 }
-template<> Vc_ALWAYS_INLINE Vector<short> &Vector<short>::operator/=(const Vector<short> &x)
+template <typename T>
+Vc_INTRINSIC std::pair<Vector<T, VectorAbi::Avx>, int>
+Vector<T, VectorAbi::Avx>::maxIndex() const
 {
-    d.v() = divShort<short>(d.v(), x.d.v());
-    return *this;
+    AVX2::Vector<T> x = max();
+    return std::make_pair(x, (*this == x).firstOne());
 }
-template<> Vc_ALWAYS_INLINE Vector<short> Vc_PURE Vector<short>::operator/(const Vector<short> &x) const
+template <> Vc_INTRINSIC std::pair<AVX2::float_v, int> AVX2::float_v::minIndex() const
 {
-    return divShort<short>(d.v(), x.d.v());
+    /*
+    // 28 cycles latency:
+    __m256 x = _mm256_min_ps(Mem::permute128<X1, X0>(d.v()), d.v());
+    x = _mm256_min_ps(x, Reg::permute<X2, X3, X0, X1>(x));
+    AVX2::float_v xx = _mm256_min_ps(x, Reg::permute<X1, X0, X3, X2>(x));
+    AVX2::uint_v idx = AVX2::uint_v::IndexesFromZero();
+    idx = _mm256_castps_si256(
+        _mm256_or_ps((*this != xx).data(), _mm256_castsi256_ps(idx.data())));
+    return std::make_pair(xx, (*this == xx).firstOne());
+
+    __m128 loData = AVX::lo128(d.v());
+    __m128 hiData = AVX::hi128(d.v());
+    const __m128 less2 = _mm_cmplt_ps(hiData, loData);
+    loData = _mm_min_ps(loData, hiData);
+    hiData = Mem::permute<X2, X3, X0, X1>(loData);
+    const __m128 less1 = _mm_cmplt_ps(hiData, loData);
+    loData = _mm_min_ps(loData, hiData);
+    hiData = Mem::permute<X1, X0, X3, X2>(loData);
+    const __m128 less0 = _mm_cmplt_ps(hiData, loData);
+    unsigned bits = _mm_movemask_ps(less0) & 0x1;
+    bits |= ((_mm_movemask_ps(less1) << 1) - bits) & 0x2;
+    bits |= ((_mm_movemask_ps(less2) << 3) - bits) & 0x4;
+    loData = _mm_min_ps(loData, hiData);
+    return std::make_pair(AVX::concat(loData, loData), bits);
+    */
+
+    // 28 cycles Latency:
+    __m256 x = d.v();
+    __m256 idx = Vector<float>::IndexesFromZero().data();
+    __m256 y = Mem::permute128<X1, X0>(x);
+    __m256 idy = Mem::permute128<X1, X0>(idx);
+    __m256 less = AVX::cmplt_ps(x, y);
+
+    x = _mm256_blendv_ps(y, x, less);
+    idx = _mm256_blendv_ps(idy, idx, less);
+    y = Reg::permute<X2, X3, X0, X1>(x);
+    idy = Reg::permute<X2, X3, X0, X1>(idx);
+    less = AVX::cmplt_ps(x, y);
+
+    x = _mm256_blendv_ps(y, x, less);
+    idx = _mm256_blendv_ps(idy, idx, less);
+    y = Reg::permute<X1, X0, X3, X2>(x);
+    idy = Reg::permute<X1, X0, X3, X2>(idx);
+    less = AVX::cmplt_ps(x, y);
+
+    idx = _mm256_blendv_ps(idy, idx, less);
+
+    const auto index = _mm_cvtsi128_si32(AVX::avx_cast<__m128i>(idx));
+#ifdef Vc_GNU_ASM
+    __asm__ __volatile__(""); // help GCC to order the instructions better
+#endif
+    x = _mm256_blendv_ps(y, x, less);
+    return std::make_pair(x, index);
 }
-template<> Vc_ALWAYS_INLINE Vector<unsigned short> &Vector<unsigned short>::operator/=(const Vector<unsigned short> &x)
+template<typename T> Vc_ALWAYS_INLINE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::partialSum() const
 {
-    d.v() = divShort<unsigned short>(d.v(), x.d.v());
-    return *this;
+    //   a    b    c    d    e    f    g    h
+    // +      a    b    c    d    e    f    g    -> a ab bc  cd   de    ef     fg      gh
+    // +           a    ab   bc   cd   de   ef   -> a ab abc abcd bcde  cdef   defg    efgh
+    // +                     a    ab   abc  abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh
+    AVX2::Vector<T> tmp = *this;
+    if (Size >  1) tmp += tmp.shifted(-1);
+    if (Size >  2) tmp += tmp.shifted(-2);
+    if (Size >  4) tmp += tmp.shifted(-4);
+    if (Size >  8) tmp += tmp.shifted(-8);
+    if (Size > 16) tmp += tmp.shifted(-16);
+    return tmp;
+}
+
+/* This function requires correct masking because the neutral element of \p op is not necessarily 0
+ *
+template<typename T> template<typename BinaryOperation> Vc_ALWAYS_INLINE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::partialSum(BinaryOperation op) const
+{
+    //   a    b    c    d    e    f    g    h
+    // +      a    b    c    d    e    f    g    -> a ab bc  cd   de    ef     fg      gh
+    // +           a    ab   bc   cd   de   ef   -> a ab abc abcd bcde  cdef   defg    efgh
+    // +                     a    ab   abc  abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh
+    AVX2::Vector<T> tmp = *this;
+    Mask mask(true);
+    if (Size >  1) tmp(mask) = op(tmp, tmp.shifted(-1));
+    if (Size >  2) tmp(mask) = op(tmp, tmp.shifted(-2));
+    if (Size >  4) tmp(mask) = op(tmp, tmp.shifted(-4));
+    if (Size >  8) tmp(mask) = op(tmp, tmp.shifted(-8));
+    if (Size > 16) tmp(mask) = op(tmp, tmp.shifted(-16));
+    return tmp;
 }
-template<> Vc_ALWAYS_INLINE Vector<unsigned short> Vc_PURE Vector<unsigned short>::operator/(const Vector<unsigned short> &x) const
+*/
+
+template<typename T> Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Avx>::EntryType Vector<T, VectorAbi::Avx>::min(MaskArgument m) const
 {
-    return divShort<unsigned short>(d.v(), x.d.v());
+    AVX2::Vector<T> tmp = std::numeric_limits<AVX2::Vector<T> >::max();
+    tmp(m) = *this;
+    return tmp.min();
 }
-template<> Vc_INTRINSIC float_v &float_v::operator/=(const float_v &x)
+template<typename T> Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Avx>::EntryType Vector<T, VectorAbi::Avx>::max(MaskArgument m) const
 {
-    d.v() = _mm256_div_ps(d.v(), x.d.v());
-    return *this;
+    AVX2::Vector<T> tmp = std::numeric_limits<AVX2::Vector<T> >::min();
+    tmp(m) = *this;
+    return tmp.max();
 }
-template<> Vc_INTRINSIC float_v Vc_PURE float_v::operator/(const float_v &x) const
+template<typename T> Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Avx>::EntryType Vector<T, VectorAbi::Avx>::product(MaskArgument m) const
 {
-    return _mm256_div_ps(d.v(), x.d.v());
+    AVX2::Vector<T> tmp(Vc::One);
+    tmp(m) = *this;
+    return tmp.product();
 }
-template<> Vc_INTRINSIC sfloat_v &sfloat_v::operator/=(const sfloat_v &x)
+template<typename T> Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Avx>::EntryType Vector<T, VectorAbi::Avx>::sum(MaskArgument m) const
 {
-    d.v() = _mm256_div_ps(d.v(), x.d.v());
-    return *this;
-}
-template<> Vc_INTRINSIC sfloat_v Vc_PURE sfloat_v::operator/(const sfloat_v &x) const
+    AVX2::Vector<T> tmp(Vc::Zero);
+    tmp(m) = *this;
+    return tmp.sum();
+}//}}}
+// exponent {{{1
+namespace Detail
 {
-    return _mm256_div_ps(d.v(), x.d.v());
-}
-template<> Vc_INTRINSIC double_v &double_v::operator/=(const double_v &x)
+Vc_INTRINSIC Vc_CONST __m256 exponent(__m256 v)
 {
-    d.v() = _mm256_div_pd(d.v(), x.d.v());
-    return *this;
+    using namespace AVX;
+    __m128i tmp0 = _mm_srli_epi32(avx_cast<__m128i>(v), 23);
+    __m128i tmp1 = _mm_srli_epi32(avx_cast<__m128i>(hi128(v)), 23);
+    tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x7f));
+    tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x7f));
+    return _mm256_cvtepi32_ps(concat(tmp0, tmp1));
 }
-template<> Vc_INTRINSIC double_v Vc_PURE double_v::operator/(const double_v &x) const
+Vc_INTRINSIC Vc_CONST __m256d exponent(__m256d v)
 {
-    return _mm256_div_pd(d.v(), x.d.v());
+    using namespace AVX;
+    __m128i tmp0 = _mm_srli_epi64(avx_cast<__m128i>(v), 52);
+    __m128i tmp1 = _mm_srli_epi64(avx_cast<__m128i>(hi128(v)), 52);
+    tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x3ff));
+    tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x3ff));
+    return _mm256_cvtepi32_pd(avx_cast<__m128i>(Mem::shuffle<X0, X2, Y0, Y2>(avx_cast<__m128>(tmp0), avx_cast<__m128>(tmp1))));
 }
+} // namespace Detail
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// integer ops {{{1
-#define OP_IMPL(T, symbol) \
-template<> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator symbol##=(AsArg x) \
-{ \
-    for_all_vector_entries(i, d.m(i) symbol##= x.d.m(i); ); \
-    return *this; \
-} \
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<T>  Vector<T>::operator symbol(AsArg x) const \
-{ \
-    Vector<T> r; \
-    for_all_vector_entries(i, r.d.m(i) = d.m(i) symbol x.d.m(i); ); \
-    return r; \
-}
-OP_IMPL(int, <<)
-OP_IMPL(int, >>)
-OP_IMPL(unsigned int, <<)
-OP_IMPL(unsigned int, >>)
-OP_IMPL(short, <<)
-OP_IMPL(short, >>)
-OP_IMPL(unsigned short, <<)
-OP_IMPL(unsigned short, >>)
-#undef OP_IMPL
-
-template<typename T> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator>>=(int shift) {
-    d.v() = VectorHelper<T>::shiftRight(d.v(), shift);
-    return *static_cast<Vector<T> *>(this);
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T> Vector<T>::operator>>(int shift) const {
-    return VectorHelper<T>::shiftRight(d.v(), shift);
-}
-template<typename T> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator<<=(int shift) {
-    d.v() = VectorHelper<T>::shiftLeft(d.v(), shift);
-    return *static_cast<Vector<T> *>(this);
-}
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T> Vector<T>::operator<<(int shift) const {
-    return VectorHelper<T>::shiftLeft(d.v(), shift);
-}
-
-#define OP_IMPL(T, symbol, fun) \
-  template<> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator symbol##=(AsArg x) { d.v() = HV::fun(d.v(), x.d.v()); return *this; } \
-  template<> Vc_ALWAYS_INLINE Vc_PURE Vector<T>  Vector<T>::operator symbol(AsArg x) const { return Vector<T>(HV::fun(d.v(), x.d.v())); }
-  OP_IMPL(int, &, and_)
-  OP_IMPL(int, |, or_)
-  OP_IMPL(int, ^, xor_)
-  OP_IMPL(unsigned int, &, and_)
-  OP_IMPL(unsigned int, |, or_)
-  OP_IMPL(unsigned int, ^, xor_)
-  OP_IMPL(short, &, and_)
-  OP_IMPL(short, |, or_)
-  OP_IMPL(short, ^, xor_)
-  OP_IMPL(unsigned short, &, and_)
-  OP_IMPL(unsigned short, |, or_)
-  OP_IMPL(unsigned short, ^, xor_)
-  OP_IMPL(float, &, and_)
-  OP_IMPL(float, |, or_)
-  OP_IMPL(float, ^, xor_)
-  OP_IMPL(sfloat, &, and_)
-  OP_IMPL(sfloat, |, or_)
-  OP_IMPL(sfloat, ^, xor_)
-  OP_IMPL(double, &, and_)
-  OP_IMPL(double, |, or_)
-  OP_IMPL(double, ^, xor_)
-#undef OP_IMPL
-
-// operators {{{1
-#include "../common/operators.h"
-// isNegative {{{1
-template<> Vc_INTRINSIC Vc_PURE float_m float_v::isNegative() const
-{
-    return avx_cast<m256>(_mm256_srai_epi32(avx_cast<m256i>(_mm256_and_ps(_mm256_setsignmask_ps(), d.v())), 31));
-}
-template<> Vc_INTRINSIC Vc_PURE sfloat_m sfloat_v::isNegative() const
-{
-    return avx_cast<m256>(_mm256_srai_epi32(avx_cast<m256i>(_mm256_and_ps(_mm256_setsignmask_ps(), d.v())), 31));
-}
-template<> Vc_INTRINSIC Vc_PURE double_m double_v::isNegative() const
-{
-    return Mem::permute<X1, X1, X3, X3>(avx_cast<m256>(
-                _mm256_srai_epi32(avx_cast<m256i>(_mm256_and_pd(_mm256_setsignmask_pd(), d.v())), 31)
-                ));
-}
-// gathers {{{1
-// Better implementation (hopefully) with _mm256_set_
-//X template<typename T> template<typename Index> Vector<T>::Vector(const EntryType *mem, const Index *indexes)
-//X {
-//X     for_all_vector_entries(int i,
-//X             d.m(i) = mem[indexes[i]];
-//X             );
-//X }
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, const IndexT *indexes)
+Vc_INTRINSIC Vc_CONST AVX2::float_v exponent(AVX2::float_v x)
 {
-    gather(mem, indexes);
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return Detail::exponent(x.data());
 }
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes)
+Vc_INTRINSIC Vc_CONST AVX2::double_v exponent(AVX2::double_v x)
 {
-    gather(mem, indexes);
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return Detail::exponent(x.data());
 }
-
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, const IndexT *indexes, MaskArg mask)
-    : d(HT::zero())
+// }}}1
+// Random {{{1
+static Vc_ALWAYS_INLINE __m256i _doRandomStep()
 {
-    gather(mem, indexes, mask);
+    using Detail::operator*;
+    using Detail::operator+;
+#ifdef Vc_IMPL_AVX2
+    using AVX2::uint_v;
+    uint_v state0(&Common::RandomState[0]);
+    uint_v state1(&Common::RandomState[uint_v::Size]);
+    (state1 * uint_v(0xdeece66du) + uint_v(11)).store(&Common::RandomState[uint_v::Size]);
+    uint_v(Detail::xor_((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),
+                        _mm256_srli_epi32(state1.data(), 16)))
+        .store(&Common::RandomState[0]);
+    return state0.data();
+#else
+    using SSE::uint_v;
+    uint_v state0(&Common::RandomState[0]);
+    uint_v state1(&Common::RandomState[uint_v::Size]);
+    uint_v state2(&Common::RandomState[2 * uint_v::Size]);
+    uint_v state3(&Common::RandomState[3 * uint_v::Size]);
+    (state2 * uint_v(0xdeece66du) + uint_v(11))
+        .store(&Common::RandomState[2 * uint_v::Size]);
+    (state3 * uint_v(0xdeece66du) + uint_v(11))
+        .store(&Common::RandomState[3 * uint_v::Size]);
+    uint_v(Detail::xor_((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),
+                        _mm_srli_epi32(state2.data(), 16)))
+        .store(&Common::RandomState[0]);
+    uint_v(Detail::xor_((state1 * uint_v(0xdeece66du) + uint_v(11)).data(),
+                        _mm_srli_epi32(state3.data(), 16)))
+        .store(&Common::RandomState[uint_v::Size]);
+    return AVX::concat(state0.data(), state1.data());
+#endif
 }
 
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes, MaskArg mask)
-    : d(HT::zero())
+#ifdef Vc_IMPL_AVX2
+template<typename T> Vc_ALWAYS_INLINE AVX2::Vector<T> Vector<T, VectorAbi::Avx>::Random()
 {
-    gather(mem, indexes, mask);
+    return {_doRandomStep()};
 }
+#endif
 
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    gather(array, member1, indexes);
-}
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(array, member1, indexes, mask);
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    gather(array, member1, member2, indexes);
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(array, member1, member2, indexes, mask);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    gather(array, ptrMember1, outerIndexes, innerIndexes);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask)
-    : d(HT::zero())
+template <> Vc_ALWAYS_INLINE AVX2::float_v AVX2::float_v::Random()
 {
-    gather(array, ptrMember1, outerIndexes, innerIndexes, mask);
+    return HT::sub(Detail::or_(_cast(AVX::srli_epi32<2>(_doRandomStep())), HT::one()),
+                   HT::one());
 }
 
-template<typename T, size_t Size> struct IndexSizeChecker { static void check() {} };
-template<typename T, size_t Size> struct IndexSizeChecker<Vector<T>, Size>
+template<> Vc_ALWAYS_INLINE AVX2::double_v AVX2::double_v::Random()
 {
-    static void check() {
-        VC_STATIC_ASSERT(Vector<T>::Size >= Size, IndexVector_must_have_greater_or_equal_number_of_entries);
+    const __m256i state = Detail::load(&Common::RandomState[0], Vc::Aligned,
+                                       Detail::LoadTag<__m256i, int>());
+    for (size_t k = 0; k < 8; k += 2) {
+        typedef unsigned long long uint64 Vc_MAY_ALIAS;
+        const uint64 stateX = *reinterpret_cast<const uint64 *>(&Common::RandomState[k]);
+        *reinterpret_cast<uint64 *>(&Common::RandomState[k]) = (stateX * 0x5deece66dull + 11);
     }
-};
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
-{
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm256_setr_pd(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
+    return HT::sub(Detail::or_(_cast(AVX::srli_epi64<12>(state)), HT::one()), HT::one());
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
-{
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm256_setr_ps(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
-}
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<sfloat>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
-{
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm256_setr_ps(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
-}
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
-{
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm256_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
-}
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+// }}}1
+// shifted / rotated {{{1
+template<typename T> Vc_INTRINSIC AVX2::Vector<T> Vector<T, VectorAbi::Avx>::shifted(int amount) const
 {
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm256_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
+    return Detail::shifted<EntryType>(d.v(), amount);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <typename VectorType>
+Vc_INTRINSIC Vc_CONST VectorType shifted_shortcut(VectorType left, VectorType right, Common::WidthT<__m128>)
 {
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
+    return Mem::shuffle<X2, X3, Y0, Y1>(left, right);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+template <typename VectorType>
+Vc_INTRINSIC Vc_CONST VectorType shifted_shortcut(VectorType left, VectorType right, Common::WidthT<__m256>)
 {
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-                mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
+    return Mem::shuffle128<X1, Y0>(left, right);
 }
 
-#ifdef VC_USE_SET_GATHERS
-template<typename T> template<typename IT> Vc_ALWAYS_INLINE void Vector<T>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IT>) indexes, MaskArg mask)
+template<typename T> Vc_INTRINSIC AVX2::Vector<T> Vector<T, VectorAbi::Avx>::shifted(int amount, Vector shiftIn) const
 {
-    IndexSizeChecker<Vector<IT>, Size>::check();
-    Vector<IT> indexesTmp = indexes;
-    indexesTmp.setZero(!mask);
-    (*this)(mask) = Vector<T>(mem, indexesTmp);
-}
-#endif
-
-#ifdef VC_USE_BSF_GATHERS
-#define VC_MASKED_GATHER                        \
-    int bits = mask.toInt();                    \
-    while (bits) {                              \
-        const int i = _bit_scan_forward(bits);  \
-        bits &= ~(1 << i); /* btr? */           \
-        d.m(i) = ith_value(i);                  \
-    }
-#elif defined(VC_USE_POPCNT_BSF_GATHERS)
-#define VC_MASKED_GATHER                        \
-    unsigned int bits = mask.toInt();           \
-    unsigned int low, high = 0;                 \
-    switch (_mm_popcnt_u32(bits)) {             \
-    case 8:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 7:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 6:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 5:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 4:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 3:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 2:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-    case 1:                                     \
-        low = _bit_scan_forward(bits);          \
-        d.m(low) = ith_value(low);              \
-    case 0:                                     \
-        break;                                  \
-    }
-#else
-#define VC_MASKED_GATHER                        \
-    if (mask.isEmpty()) {                       \
-        return;                                 \
-    }                                           \
-    for_all_vector_entries(i,                   \
-            if (mask[i]) d.m(i) = ith_value(i); \
-            );
-#endif
-
-template<typename T> template<typename Index>
-Vc_INTRINSIC void Vector<T>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask)
-{
-    IndexSizeChecker<Index, Size>::check();
-#define ith_value(_i_) (mem[indexes[_i_]])
-    VC_MASKED_GATHER
-#undef ith_value
-}
-
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_pd(array[indexes[0]].*(member1), array[indexes[1]].*(member1),
-            array[indexes[2]].*(member1), array[indexes[3]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_ps(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<sfloat>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_ps(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_epi32(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_epi32(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<typename T> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-{
-    IndexSizeChecker<IT, Size>::check();
-#define ith_value(_i_) (array[indexes[_i_]].*(member1))
-    VC_MASKED_GATHER
-#undef ith_value
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_pd(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2),
-            array[indexes[2]].*(member1).*(member2), array[indexes[3]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_ps(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<sfloat>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_ps(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_epi32(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm256_setr_epi32(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<typename T> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-{
-    IndexSizeChecker<IT, Size>::check();
-#define ith_value(_i_) (array[indexes[_i_]].*(member1).*(member2))
-    VC_MASKED_GATHER
-#undef ith_value
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm256_setr_pd((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm256_setr_ps((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<sfloat>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm256_setr_ps((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm256_setr_epi32((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm256_setr_epi32((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi16((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi16((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-#define ith_value(_i_) (array[outerIndexes[_i_]].*(ptrMember1))[innerIndexes[_i_]]
-    VC_MASKED_GATHER
-#undef ith_value
-}
-
-#undef VC_MASKED_GATHER
-#ifdef VC_USE_BSF_SCATTERS
-#define VC_MASKED_SCATTER                       \
-    int bits = mask.toInt();                    \
-    while (bits) {                              \
-        const int i = _bit_scan_forward(bits);  \
-        bits ^= (1 << i); /* btr? */            \
-        ith_value(i) = d.m(i);                  \
-    }
-#elif defined(VC_USE_POPCNT_BSF_SCATTERS)
-#define VC_MASKED_SCATTER                       \
-    unsigned int bits = mask.toInt();           \
-    unsigned int low, high = 0;                 \
-    switch (_mm_popcnt_u32(bits)) {             \
-    case 8:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 7:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 6:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 5:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 4:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 3:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 2:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-    case 1:                                     \
-        low = _bit_scan_forward(bits);          \
-        ith_value(low) = d.m(low);              \
-    case 0:                                     \
-        break;                                  \
+#ifdef __GNUC__
+    if (__builtin_constant_p(amount)) {
+        switch (amount * 2) {
+        case int(Size):
+            return shifted_shortcut(d.v(), shiftIn.d.v(), WidthT());
+        case -int(Size):
+            return shifted_shortcut(shiftIn.d.v(), d.v(), WidthT());
+        }
     }
-#else
-#define VC_MASKED_SCATTER                       \
-    if (mask.isEmpty()) {                       \
-        return;                                 \
-    }                                           \
-    for_all_vector_entries(i,                   \
-            if (mask[i]) ith_value(i) = d.m(i); \
-            );
 #endif
-
-template<typename T> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const
-{
-    for_all_vector_entries(i,
-            mem[indexes[i]] = d.m(i);
-            );
-}
-#if defined(VC_MSVC) && VC_MSVC >= 170000000
-// MSVC miscompiles the store mem[indexes[1]] = d.m(1) for T = (u)short
-template<> template<typename Index> Vc_ALWAYS_INLINE void short_v::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const
-{
-    const unsigned int tmp = d.v()._d.m128i_u32[0];
-    mem[indexes[0]] = tmp & 0xffff;
-    mem[indexes[1]] = tmp >> 16;
-    mem[indexes[2]] = _mm_extract_epi16(d.v(), 2);
-    mem[indexes[3]] = _mm_extract_epi16(d.v(), 3);
-    mem[indexes[4]] = _mm_extract_epi16(d.v(), 4);
-    mem[indexes[5]] = _mm_extract_epi16(d.v(), 5);
-    mem[indexes[6]] = _mm_extract_epi16(d.v(), 6);
-    mem[indexes[7]] = _mm_extract_epi16(d.v(), 7);
-}
-template<> template<typename Index> Vc_ALWAYS_INLINE void ushort_v::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const
-{
-    const unsigned int tmp = d.v()._d.m128i_u32[0];
-    mem[indexes[0]] = tmp & 0xffff;
-    mem[indexes[1]] = tmp >> 16;
-    mem[indexes[2]] = _mm_extract_epi16(d.v(), 2);
-    mem[indexes[3]] = _mm_extract_epi16(d.v(), 3);
-    mem[indexes[4]] = _mm_extract_epi16(d.v(), 4);
-    mem[indexes[5]] = _mm_extract_epi16(d.v(), 5);
-    mem[indexes[6]] = _mm_extract_epi16(d.v(), 6);
-    mem[indexes[7]] = _mm_extract_epi16(d.v(), 7);
+    using Detail::operator|;
+    return shifted(amount) | (amount > 0 ?
+                              shiftIn.shifted(amount - Size) :
+                              shiftIn.shifted(Size + amount));
 }
-#endif
-template<typename T> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask) const
+template<typename T> Vc_INTRINSIC AVX2::Vector<T> Vector<T, VectorAbi::Avx>::rotated(int amount) const
 {
-#define ith_value(_i_) mem[indexes[_i_]]
-    VC_MASKED_SCATTER
-#undef ith_value
+    return Detail::rotated<EntryType, size()>(d.v(), amount);
 }
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes) const
+// sorted {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Avx> Vector<T, VectorAbi::Avx>::sorted()
+    const
 {
-    for_all_vector_entries(i,
-            array[indexes[i]].*(member1) = d.m(i);
-            );
+    return Detail::sorted(*this);
 }
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const
+// interleaveLow/-High {{{1
+template <> Vc_INTRINSIC AVX2::double_v AVX2::double_v::interleaveLow(AVX2::double_v x) const
 {
-#define ith_value(_i_) array[indexes[_i_]].*(member1)
-    VC_MASKED_SCATTER
-#undef ith_value
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_pd(data(), x.data()),
+                                   _mm256_unpackhi_pd(data(), x.data()));
 }
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes) const
+template <> Vc_INTRINSIC AVX2::double_v AVX2::double_v::interleaveHigh(AVX2::double_v x) const
 {
-    for_all_vector_entries(i,
-            array[indexes[i]].*(member1).*(member2) = d.m(i);
-            );
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_pd(data(), x.data()),
+                                   _mm256_unpackhi_pd(data(), x.data()));
 }
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const
+template <> Vc_INTRINSIC AVX2::float_v AVX2::float_v::interleaveLow(AVX2::float_v x) const
 {
-#define ith_value(_i_) array[indexes[_i_]].*(member1).*(member2)
-    VC_MASKED_SCATTER
-#undef ith_value
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_ps(data(), x.data()),
+                                   _mm256_unpackhi_ps(data(), x.data()));
 }
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes) const
+template <> Vc_INTRINSIC AVX2::float_v AVX2::float_v::interleaveHigh(AVX2::float_v x) const
 {
-    for_all_vector_entries(i,
-            (array[innerIndexes[i]].*(ptrMember1))[outerIndexes[i]] = d.m(i);
-            );
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_ps(data(), x.data()),
+                                   _mm256_unpackhi_ps(data(), x.data()));
 }
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask) const
-{
-#define ith_value(_i_) (array[outerIndexes[_i_]].*(ptrMember1))[innerIndexes[_i_]]
-    VC_MASKED_SCATTER
-#undef ith_value
+#ifdef Vc_IMPL_AVX2
+template <> Vc_INTRINSIC    AVX2::int_v    AVX2::int_v::interleaveLow (   AVX2::int_v x) const {
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_epi32(data(), x.data()),
+                                   _mm256_unpackhi_epi32(data(), x.data()));
 }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// operator- {{{1
-template<> Vc_ALWAYS_INLINE Vector<double> Vc_PURE Vc_FLATTEN Vector<double>::operator-() const
-{
-    return _mm256_xor_pd(d.v(), _mm256_setsignmask_pd());
+template <> Vc_INTRINSIC    AVX2::int_v    AVX2::int_v::interleaveHigh(   AVX2::int_v x) const {
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_epi32(data(), x.data()),
+                                   _mm256_unpackhi_epi32(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<float> Vc_PURE Vc_FLATTEN Vector<float>::operator-() const
-{
-    return _mm256_xor_ps(d.v(), _mm256_setsignmask_ps());
+template <> Vc_INTRINSIC   AVX2::uint_v   AVX2::uint_v::interleaveLow (  AVX2::uint_v x) const {
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_epi32(data(), x.data()),
+                                   _mm256_unpackhi_epi32(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<sfloat> Vc_PURE Vc_FLATTEN Vector<sfloat>::operator-() const
-{
-    return _mm256_xor_ps(d.v(), _mm256_setsignmask_ps());
+template <> Vc_INTRINSIC   AVX2::uint_v   AVX2::uint_v::interleaveHigh(  AVX2::uint_v x) const {
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_epi32(data(), x.data()),
+                                   _mm256_unpackhi_epi32(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<int> Vc_PURE Vc_FLATTEN Vector<int>::operator-() const
-{
-    return _mm256_sign_epi32(d.v(), _mm256_setallone_si256());
+template <> Vc_INTRINSIC  AVX2::short_v  AVX2::short_v::interleaveLow ( AVX2::short_v x) const {
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_epi16(data(), x.data()),
+                                   _mm256_unpackhi_epi16(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<int> Vc_PURE Vc_FLATTEN Vector<unsigned int>::operator-() const
-{
-    return _mm256_sign_epi32(d.v(), _mm256_setallone_si256());
+template <> Vc_INTRINSIC  AVX2::short_v  AVX2::short_v::interleaveHigh( AVX2::short_v x) const {
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_epi16(data(), x.data()),
+                                   _mm256_unpackhi_epi16(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<short> Vc_PURE Vc_FLATTEN Vector<short>::operator-() const
-{
-    return _mm_sign_epi16(d.v(), _mm_setallone_si128());
+template <> Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::interleaveLow (AVX2::ushort_v x) const {
+    return Mem::shuffle128<X0, Y0>(_mm256_unpacklo_epi16(data(), x.data()),
+                                   _mm256_unpackhi_epi16(data(), x.data()));
 }
-template<> Vc_ALWAYS_INLINE Vector<short> Vc_PURE Vc_FLATTEN Vector<unsigned short>::operator-() const
-{
-    return _mm_sign_epi16(d.v(), _mm_setallone_si128());
+template <> Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::interleaveHigh(AVX2::ushort_v x) const {
+    return Mem::shuffle128<X1, Y1>(_mm256_unpacklo_epi16(data(), x.data()),
+                                   _mm256_unpackhi_epi16(data(), x.data()));
 }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// horizontal ops {{{1
-template<typename T> Vc_ALWAYS_INLINE typename Vector<T>::EntryType Vector<T>::min(MaskArg m) const
+#endif
+// permutation via operator[] {{{1
+template <> Vc_INTRINSIC Vc_PURE AVX2::double_v AVX2::double_v::operator[](Permutation::ReversedTag) const
 {
-    Vector<T> tmp = std::numeric_limits<Vector<T> >::max();
-    tmp(m) = *this;
-    return tmp.min();
+    return Mem::permute128<X1, X0>(Mem::permute<X1, X0, X3, X2>(d.v()));
 }
-template<typename T> Vc_ALWAYS_INLINE typename Vector<T>::EntryType Vector<T>::max(MaskArg m) const
+template <> Vc_INTRINSIC Vc_PURE AVX2::float_v AVX2::float_v::operator[](Permutation::ReversedTag) const
 {
-    Vector<T> tmp = std::numeric_limits<Vector<T> >::min();
-    tmp(m) = *this;
-    return tmp.max();
+    return Mem::permute128<X1, X0>(Mem::permute<X3, X2, X1, X0>(d.v()));
 }
-template<typename T> Vc_ALWAYS_INLINE typename Vector<T>::EntryType Vector<T>::product(MaskArg m) const
+#ifdef Vc_IMPL_AVX2
+template <>
+Vc_INTRINSIC Vc_PURE AVX2::int_v AVX2::int_v::operator[](Permutation::ReversedTag) const
 {
-    Vector<T> tmp(VectorSpecialInitializerOne::One);
-    tmp(m) = *this;
-    return tmp.product();
+    return Mem::permute128<X1, X0>(Mem::permute<X3, X2, X1, X0>(d.v()));
 }
-template<typename T> Vc_ALWAYS_INLINE typename Vector<T>::EntryType Vector<T>::sum(MaskArg m) const
+template <>
+Vc_INTRINSIC Vc_PURE AVX2::uint_v AVX2::uint_v::operator[](Permutation::ReversedTag) const
 {
-    Vector<T> tmp(VectorSpecialInitializerZero::Zero);
-    tmp(m) = *this;
-    return tmp.sum();
-}//}}}
-// copySign {{{1
-template<> Vc_INTRINSIC Vector<float> Vector<float>::copySign(Vector<float>::AsArg reference) const
-{
-    return _mm256_or_ps(
-            _mm256_and_ps(reference.d.v(), _mm256_setsignmask_ps()),
-            _mm256_and_ps(d.v(), _mm256_setabsmask_ps())
-            );
-}
-template<> Vc_INTRINSIC Vector<sfloat> Vector<sfloat>::copySign(Vector<sfloat>::AsArg reference) const
-{
-    return _mm256_or_ps(
-            _mm256_and_ps(reference.d.v(), _mm256_setsignmask_ps()),
-            _mm256_and_ps(d.v(), _mm256_setabsmask_ps())
-            );
-}
-template<> Vc_INTRINSIC Vector<double> Vector<double>::copySign(Vector<double>::AsArg reference) const
-{
-    return _mm256_or_pd(
-            _mm256_and_pd(reference.d.v(), _mm256_setsignmask_pd()),
-            _mm256_and_pd(d.v(), _mm256_setabsmask_pd())
-            );
-}//}}}1
-// exponent {{{1
-template<> Vc_INTRINSIC Vector<float> Vector<float>::exponent() const
-{
-    VC_ASSERT((*this >= 0.f).isFull());
-    return Internal::exponent(d.v());
-}
-template<> Vc_INTRINSIC Vector<sfloat> Vector<sfloat>::exponent() const
-{
-    VC_ASSERT((*this >= 0.f).isFull());
-    return Internal::exponent(d.v());
+    return Mem::permute128<X1, X0>(Mem::permute<X3, X2, X1, X0>(d.v()));
 }
-template<> Vc_INTRINSIC Vector<double> Vector<double>::exponent() const
+template <>
+Vc_INTRINSIC Vc_PURE AVX2::short_v AVX2::short_v::operator[](
+    Permutation::ReversedTag) const
 {
-    VC_ASSERT((*this >= 0.).isFull());
-    return Internal::exponent(d.v());
+    return Mem::permute128<X1, X0>(AVX::avx_cast<__m256i>(Mem::shuffle<X1, Y0, X3, Y2>(
+        AVX::avx_cast<__m256d>(Mem::permuteHi<X7, X6, X5, X4>(d.v())),
+        AVX::avx_cast<__m256d>(Mem::permuteLo<X3, X2, X1, X0>(d.v())))));
 }
-// }}}1
-// Random {{{1
-static Vc_ALWAYS_INLINE void _doRandomStep(Vector<unsigned int> &state0,
-        Vector<unsigned int> &state1)
+template <>
+Vc_INTRINSIC Vc_PURE AVX2::ushort_v AVX2::ushort_v::operator[](
+    Permutation::ReversedTag) const
 {
-    state0.load(&Vc::RandomState[0]);
-    state1.load(&Vc::RandomState[uint_v::Size]);
-    (state1 * 0xdeece66du + 11).store(&Vc::RandomState[uint_v::Size]);
-    uint_v(_mm256_xor_si256((state0 * 0xdeece66du + 11).data(), _mm256_srli_epi32(state1.data(), 16))).store(&Vc::RandomState[0]);
+    return Mem::permute128<X1, X0>(AVX::avx_cast<__m256i>(Mem::shuffle<X1, Y0, X3, Y2>(
+        AVX::avx_cast<__m256d>(Mem::permuteHi<X7, X6, X5, X4>(d.v())),
+        AVX::avx_cast<__m256d>(Mem::permuteLo<X3, X2, X1, X0>(d.v())))));
 }
-
-template<typename T> Vc_ALWAYS_INLINE Vector<T> Vector<T>::Random()
-{
-    Vector<unsigned int> state0, state1;
-    _doRandomStep(state0, state1);
-    return state0.reinterpretCast<Vector<T> >();
-}
-
-template<> Vc_ALWAYS_INLINE Vector<float> Vector<float>::Random()
+#endif
+template <> Vc_INTRINSIC AVX2::float_v Vector<float, VectorAbi::Avx>::operator[](const IndexType &/*perm*/) const
 {
-    Vector<unsigned int> state0, state1;
-    _doRandomStep(state0, state1);
-    return HT::sub(HV::or_(_cast(_mm256_srli_epi32(state0.data(), 2)), HT::one()), HT::one());
+    // TODO
+    return *this;
+#ifdef Vc_IMPL_AVX2
+#else
+    /*
+    const int_m cross128 = AVX::concat(_mm_cmpgt_epi32(AVX::lo128(perm.data()), _mm_set1_epi32(3)),
+                                  _mm_cmplt_epi32(AVX::hi128(perm.data()), _mm_set1_epi32(4)));
+    if (cross128.isNotEmpty()) {
+    AVX2::float_v x = _mm256_permutevar_ps(d.v(), perm.data());
+        x(cross128) = _mm256_permutevar_ps(Mem::permute128<X1, X0>(d.v()), perm.data());
+        return x;
+    } else {
+    */
+#endif
 }
 
-template<> Vc_ALWAYS_INLINE Vector<sfloat> Vector<sfloat>::Random()
+// reversed {{{1
+template <typename T>
+Vc_INTRINSIC Vc_PURE Vector<T, VectorAbi::Avx> Vector<T, VectorAbi::Avx>::reversed() const
 {
-    Vector<unsigned int> state0, state1;
-    _doRandomStep(state0, state1);
-    return HT::sub(HV::or_(_cast(_mm256_srli_epi32(state0.data(), 2)), HT::one()), HT::one());
+    return (*this)[Permutation::Reversed];
 }
 
-template<> Vc_ALWAYS_INLINE Vector<double> Vector<double>::Random()
+// broadcast from constexpr index {{{1
+template <> template <int Index> Vc_INTRINSIC AVX2::float_v AVX2::float_v::broadcast() const
 {
-    const m256i state = VectorHelper<m256i>::load(&Vc::RandomState[0], Vc::Aligned);
-    for (size_t k = 0; k < 8; k += 2) {
-        typedef unsigned long long uint64 Vc_MAY_ALIAS;
-        const uint64 stateX = *reinterpret_cast<const uint64 *>(&Vc::RandomState[k]);
-        *reinterpret_cast<uint64 *>(&Vc::RandomState[k]) = (stateX * 0x5deece66dull + 11);
-    }
-    return (Vector<double>(_cast(_mm256_srli_epi64(state, 12))) | One()) - One();
+    constexpr VecPos Inner = static_cast<VecPos>(Index & 0x3);
+    constexpr VecPos Outer = static_cast<VecPos>((Index & 0x4) / 4);
+    return Mem::permute<Inner, Inner, Inner, Inner>(Mem::permute128<Outer, Outer>(d.v()));
 }
-// }}}1
-// shifted / rotated {{{1
-template<size_t SIMDWidth, size_t Size, typename VectorType, typename EntryType> struct VectorShift;
-template<> struct VectorShift<32, 4, m256d, double>
-{
-    static Vc_INTRINSIC m256d shifted(param256d v, int amount)
-    {
-        switch (amount) {
-        case  0: return v;
-        case  1: return avx_cast<m256d>(_mm256_srli_si256(avx_cast<m256i>(v), 1 * sizeof(double)));
-        case  2: return avx_cast<m256d>(_mm256_srli_si256(avx_cast<m256i>(v), 2 * sizeof(double)));
-        case  3: return avx_cast<m256d>(_mm256_srli_si256(avx_cast<m256i>(v), 3 * sizeof(double)));
-        case -1: return avx_cast<m256d>(_mm256_slli_si256(avx_cast<m256i>(v), 1 * sizeof(double)));
-        case -2: return avx_cast<m256d>(_mm256_slli_si256(avx_cast<m256i>(v), 2 * sizeof(double)));
-        case -3: return avx_cast<m256d>(_mm256_slli_si256(avx_cast<m256i>(v), 3 * sizeof(double)));
-        }
-        return _mm256_setzero_pd();
-    }
-};
-template<typename VectorType, typename EntryType> struct VectorShift<32, 8, VectorType, EntryType>
-{
-    typedef typename SseVectorType<VectorType>::Type SmallV;
-    static Vc_INTRINSIC VectorType shifted(VC_ALIGNED_PARAMETER(VectorType) v, int amount)
-    {
-        switch (amount) {
-        case  0: return v;
-        case  1: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 1 * sizeof(EntryType)));
-        case  2: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 2 * sizeof(EntryType)));
-        case  3: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 3 * sizeof(EntryType)));
-        case  4: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 4 * sizeof(EntryType)));
-        case  5: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 5 * sizeof(EntryType)));
-        case  6: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 6 * sizeof(EntryType)));
-        case  7: return avx_cast<VectorType>(_mm256_srli_si256(avx_cast<m256i>(v), 7 * sizeof(EntryType)));
-        case -1: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 1 * sizeof(EntryType)));
-        case -2: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 2 * sizeof(EntryType)));
-        case -3: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 3 * sizeof(EntryType)));
-        case -4: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 4 * sizeof(EntryType)));
-        case -5: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 5 * sizeof(EntryType)));
-        case -6: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 6 * sizeof(EntryType)));
-        case -7: return avx_cast<VectorType>(_mm256_slli_si256(avx_cast<m256i>(v), 7 * sizeof(EntryType)));
-        }
-        return avx_cast<VectorType>(_mm256_setzero_ps());
-    }
-};
-template<typename VectorType, typename EntryType> struct VectorShift<16, 8, VectorType, EntryType>
-{
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    static Vc_INTRINSIC VectorType shifted(VC_ALIGNED_PARAMETER(VectorType) v, int amount)
-    {
-        switch (amount) {
-        case  0: return v;
-        case  1: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 1 * EntryTypeSizeof));
-        case  2: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 2 * EntryTypeSizeof));
-        case  3: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 3 * EntryTypeSizeof));
-        case  4: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 4 * EntryTypeSizeof));
-        case  5: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 5 * EntryTypeSizeof));
-        case  6: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 6 * EntryTypeSizeof));
-        case  7: return avx_cast<VectorType>(_mm_srli_si128(avx_cast<m128i>(v), 7 * EntryTypeSizeof));
-        case -1: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 1 * EntryTypeSizeof));
-        case -2: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 2 * EntryTypeSizeof));
-        case -3: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 3 * EntryTypeSizeof));
-        case -4: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 4 * EntryTypeSizeof));
-        case -5: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 5 * EntryTypeSizeof));
-        case -6: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 6 * EntryTypeSizeof));
-        case -7: return avx_cast<VectorType>(_mm_slli_si128(avx_cast<m128i>(v), 7 * EntryTypeSizeof));
-        }
-        return _mm_setzero_si128();
-    }
-};
-template<typename T> Vc_INTRINSIC Vector<T> Vector<T>::shifted(int amount) const
+template <> template <int Index> Vc_INTRINSIC AVX2::double_v AVX2::double_v::broadcast() const
 {
-    return VectorShift<sizeof(VectorType), Size, VectorType, EntryType>::shifted(d.v(), amount);
-}
-template<size_t SIMDWidth, size_t Size, typename VectorType, typename EntryType> struct VectorRotate;
-template<typename VectorType, typename EntryType> struct VectorRotate<32, 4, VectorType, EntryType>
-{
-    typedef typename SseVectorType<VectorType>::Type SmallV;
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount)
-    {
-        const m128i vLo = avx_cast<m128i>(lo128(v));
-        const m128i vHi = avx_cast<m128i>(hi128(v));
-        switch (static_cast<unsigned int>(amount) % 4) {
-        case  0: return v;
-        case  1: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 1 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 1 * EntryTypeSizeof)));
-        case  2: return Mem::permute128<X1, X0>(v);
-        case  3: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 1 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 1 * EntryTypeSizeof)));
-        }
-        return _mm256_setzero_pd();
-    }
-};
-template<typename VectorType, typename EntryType> struct VectorRotate<32, 8, VectorType, EntryType>
-{
-    typedef typename SseVectorType<VectorType>::Type SmallV;
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount)
-    {
-        const m128i vLo = avx_cast<m128i>(lo128(v));
-        const m128i vHi = avx_cast<m128i>(hi128(v));
-        switch (static_cast<unsigned int>(amount) % 8) {
-        case  0: return v;
-        case  1: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 1 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 1 * EntryTypeSizeof)));
-        case  2: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 2 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 2 * EntryTypeSizeof)));
-        case  3: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 3 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 3 * EntryTypeSizeof)));
-        case  4: return Mem::permute128<X1, X0>(v);
-        case  5: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 1 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 1 * EntryTypeSizeof)));
-        case  6: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 2 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 2 * EntryTypeSizeof)));
-        case  7: return concat(avx_cast<SmallV>(_mm_alignr_epi8(vLo, vHi, 3 * EntryTypeSizeof)), avx_cast<SmallV>(_mm_alignr_epi8(vHi, vLo, 3 * EntryTypeSizeof)));
-        }
-        return avx_cast<VectorType>(_mm256_setzero_ps());
-    }
-};
-template<typename VectorType, typename EntryType> struct VectorRotate<16, 8, VectorType, EntryType>
-{
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount)
-    {
-        switch (static_cast<unsigned int>(amount) % 8) {
-        case  0: return v;
-        case  1: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 1 * EntryTypeSizeof));
-        case  2: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 2 * EntryTypeSizeof));
-        case  3: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 3 * EntryTypeSizeof));
-        case  4: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 4 * EntryTypeSizeof));
-        case  5: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 5 * EntryTypeSizeof));
-        case  6: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 6 * EntryTypeSizeof));
-        case  7: return avx_cast<VectorType>(_mm_alignr_epi8(v, v, 7 * EntryTypeSizeof));
-        }
-        return _mm_setzero_si128();
-    }
-};
-template<typename T> Vc_INTRINSIC Vector<T> Vector<T>::rotated(int amount) const
-{
-    return VectorRotate<sizeof(VectorType), Size, VectorType, EntryType>::rotated(d.v(), amount);
-    /*
-    const m128i v0 = avx_cast<m128i>(d.v()[0]);
-    const m128i v1 = avx_cast<m128i>(d.v()[1]);
-    switch (static_cast<unsigned int>(amount) % Size) {
-    case  0: return *this;
-    case  1: return concat(avx_cast<m128>(_mm_alignr_epi8(v1, v0, 1 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v0, v1, 1 * sizeof(EntryType))));
-    case  2: return concat(avx_cast<m128>(_mm_alignr_epi8(v1, v0, 2 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v0, v1, 2 * sizeof(EntryType))));
-    case  3: return concat(avx_cast<m128>(_mm_alignr_epi8(v1, v0, 3 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v0, v1, 3 * sizeof(EntryType))));
-    case  4: return concat(d.v()[1], d.v()[0]);
-    case  5: return concat(avx_cast<m128>(_mm_alignr_epi8(v0, v1, 1 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v1, v0, 1 * sizeof(EntryType))));
-    case  6: return concat(avx_cast<m128>(_mm_alignr_epi8(v0, v1, 2 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v1, v0, 2 * sizeof(EntryType))));
-    case  7: return concat(avx_cast<m128>(_mm_alignr_epi8(v0, v1, 3 * sizeof(EntryType))), avx_cast<m128>(_mm_alignr_epi8(v1, v0, 3 * sizeof(EntryType))));
-    }
-    */
+    constexpr VecPos Inner = static_cast<VecPos>(Index & 0x1);
+    constexpr VecPos Outer = static_cast<VecPos>((Index & 0x2) / 2);
+    return Mem::permute<Inner, Inner>(Mem::permute128<Outer, Outer>(d.v()));
 }
 // }}}1
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace Vc
 
 // vim: foldmethod=marker
diff -Nru vc-0.7.4/avx/writemaskedvector.h vc-1.3.0/avx/writemaskedvector.h
--- vc-0.7.4/avx/writemaskedvector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/writemaskedvector.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,82 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_AVX_WRITEMASKEDVECTOR_H
-#define VC_AVX_WRITEMASKEDVECTOR_H
-
-#include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace AVX
-{
-
-template<typename T>
-class WriteMaskedVector
-{
-    friend class Vector<T>;
-    typedef typename VectorTypeHelper<T>::Type VectorType;
-    typedef typename DetermineEntryType<T>::Type EntryType;
-    enum Constants { Size = sizeof(VectorType) / sizeof(EntryType) };
-    typedef typename Vc::AVX::Mask<Size, sizeof(VectorType)> Mask;
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(32)
-        //prefix
-        Vector<T> Vc_ALWAYS_INLINE_L &operator++() Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE_L &operator--() Vc_ALWAYS_INLINE_R;
-        //postfix
-        Vector<T> Vc_ALWAYS_INLINE_L operator++(int) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE_L operator--(int) Vc_ALWAYS_INLINE_R;
-
-        Vector<T> Vc_ALWAYS_INLINE_L &operator+=(const Vector<T> &x) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE_L &operator-=(const Vector<T> &x) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE_L &operator*=(const Vector<T> &x) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE_L &operator/=(const Vector<T> &x) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE &operator+=(EntryType x) { return operator+=(Vector<T>(x)); }
-        Vector<T> Vc_ALWAYS_INLINE &operator-=(EntryType x) { return operator-=(Vector<T>(x)); }
-        Vector<T> Vc_ALWAYS_INLINE &operator*=(EntryType x) { return operator*=(Vector<T>(x)); }
-        Vector<T> Vc_ALWAYS_INLINE &operator/=(EntryType x) { return operator/=(Vector<T>(x)); }
-
-        Vector<T> Vc_ALWAYS_INLINE_L &operator=(const Vector<T> &x) Vc_ALWAYS_INLINE_R;
-        Vector<T> Vc_ALWAYS_INLINE &operator=(EntryType x) { return operator=(Vector<T>(x)); }
-
-        template<typename F> Vc_INTRINSIC void call(const F &f) const {
-            return vec->call(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f) const {
-            return vec->call(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
-            return vec->apply(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
-            return vec->apply(f, mask);
-        }
-    private:
-        Vc_ALWAYS_INLINE WriteMaskedVector(Vector<T> *v, const Mask &k) : vec(v), mask(k) {}
-        Vector<T> *const vec;
-        Mask mask;
-};
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "writemaskedvector.tcc"
-#include "undomacros.h"
-#endif // VC_AVX_WRITEMASKEDVECTOR_H
diff -Nru vc-0.7.4/avx/writemaskedvector.tcc vc-1.3.0/avx/writemaskedvector.tcc
--- vc-0.7.4/avx/writemaskedvector.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/avx/writemaskedvector.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,93 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace AVX
-{
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator++()
-{
-    vec->data() = VectorHelper<T>::add(vec->data(),
-            VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-            );
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator--() {
-    vec->data() = VectorHelper<T>::sub(vec->data(),
-            VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-            );
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> WriteMaskedVector<T>::operator++(int) {
-    Vector<T> ret(*vec);
-    vec->data() = VectorHelper<T>::add(vec->data(),
-            VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-            );
-    return ret;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> WriteMaskedVector<T>::operator--(int) {
-    Vector<T> ret(*vec);
-    vec->data() = VectorHelper<T>::sub(vec->data(),
-            VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-            );
-    return ret;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator+=(const Vector<T> &x) {
-    vec->data() = VectorHelper<T>::add(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator-=(const Vector<T> &x) {
-    vec->data() = VectorHelper<T>::sub(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator*=(const Vector<T> &x) {
-    vec->assign(VectorHelper<T>::mul(vec->data(), x.data()), mask);
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator/=(const Vector<T> &x) {
-    vec->assign(*vec / x, mask);
-    return *vec;
-}
-
-template<typename T>
-Vc_ALWAYS_INLINE Vector<T> &WriteMaskedVector<T>::operator=(const Vector<T> &x) {
-    vec->assign(x, mask);
-    return *vec;
-}
-
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
diff -Nru vc-0.7.4/.clang-format vc-1.3.0/.clang-format
--- vc-0.7.4/.clang-format	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/.clang-format	2016-10-27 02:05:02.000000000 -0500
@@ -18,6 +18,8 @@
 #    If true, while (true) continue; can be put on a single line.
 AllowShortLoopsOnASingleLine: false
 
+AllowShortFunctionsOnASingleLine: true
+
 #    If true, always break before multiline string literals.
 AlwaysBreakBeforeMultilineStrings: false
 
@@ -25,7 +27,7 @@
 AlwaysBreakTemplateDeclarations: false
 
 #    If false, a function call’s or function definition’s parameters will either all be on the same line or will have one line each.
-BinPackParameters: false
+BinPackParameters: true
 
 #    If true, binary operators will be placed after line breaks.
 BreakBeforeBinaryOperators: false
@@ -43,7 +45,7 @@
 
 #    The column limit.
 #    A column limit of 0 means that there is no column limit. In this case, clang-format will respect the input’s line breaking decisions within statements.
-ColumnLimit: 100
+ColumnLimit: 90
 
 #    If the constructor initializers don’t fit on a line, put each initializer on its own line.
 #ConstructorInitializerAllOnOneLineOrOnePerLine (bool)
diff -Nru vc-0.7.4/cmake/AddCompilerFlag.cmake vc-1.3.0/cmake/AddCompilerFlag.cmake
--- vc-0.7.4/cmake/AddCompilerFlag.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/AddCompilerFlag.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -5,7 +5,7 @@
 #                        [CXX_RESULT <var>])
 
 #=============================================================================
-# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
+# Copyright 2010-2015 Matthias Kretz <kretz@kde.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -18,10 +18,9 @@
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
 #
-#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-#    any consortium members, or of any contributors, may not be used to
-#    endorse or promote products derived from this software without
-#    specific prior written permission.
+#  * Neither the names of contributing organizations nor the
+#    names of its contributors may be used to endorse or promote products
+#    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -38,14 +37,20 @@
 get_filename_component(_currentDir "${CMAKE_CURRENT_LIST_FILE}" PATH)
 include("${_currentDir}/CheckCCompilerFlag.cmake")
 include("${_currentDir}/CheckCXXCompilerFlag.cmake")
+include("${_currentDir}/CheckMicCCompilerFlag.cmake")
+include("${_currentDir}/CheckMicCXXCompilerFlag.cmake")
 
 macro(AddCompilerFlag _flag)
    string(REGEX REPLACE "[-.+/:= ]" "_" _flag_esc "${_flag}")
 
    set(_c_flags "CMAKE_C_FLAGS")
    set(_cxx_flags "CMAKE_CXX_FLAGS")
+   set(_mic_c_flags "CMAKE_MIC_C_FLAGS")
+   set(_mic_cxx_flags "CMAKE_MIC_CXX_FLAGS")
    set(_c_result tmp)
    set(_cxx_result tmp)
+   set(_mic_c_result)
+   set(_mic_cxx_result)
    if(${ARGC} EQUAL 2)
       message(WARNING "Deprecated use of the AddCompilerFlag macro.")
       unset(_c_result)
@@ -54,23 +59,41 @@
       set(state 0)
       unset(_c_flags)
       unset(_cxx_flags)
+      unset(_mic_c_flags)
+      unset(_mic_cxx_flags)
       unset(_c_result)
       unset(_cxx_result)
+      unset(_mic_c_result)
+      unset(_mic_cxx_result)
       foreach(_arg ${ARGN})
-         if(_arg STREQUAL "C_FLAGS")
+         if("x${_arg}" STREQUAL "xC_FLAGS")
             set(state 1)
             if(NOT DEFINED _c_result)
-               set(_c_result tmp)
+               set(_c_result tmp0)
             endif()
-         elseif(_arg STREQUAL "CXX_FLAGS")
+         elseif("x${_arg}" STREQUAL "xCXX_FLAGS")
             set(state 2)
             if(NOT DEFINED _cxx_result)
-               set(_cxx_result tmp)
+               set(_cxx_result tmp1)
             endif()
-         elseif(_arg STREQUAL "C_RESULT")
+         elseif("x${_arg}" STREQUAL "xC_RESULT")
             set(state 3)
-         elseif(_arg STREQUAL "CXX_RESULT")
+         elseif("x${_arg}" STREQUAL "xCXX_RESULT")
             set(state 4)
+         elseif("x${_arg}" STREQUAL "xMIC_C_RESULT")
+            set(state 5)
+         elseif("x${_arg}" STREQUAL "xMIC_CXX_RESULT")
+            set(state 6)
+         elseif("x${_arg}" STREQUAL "xMIC_C_FLAGS")
+            if(NOT DEFINED _mic_c_result)
+               set(_mic_c_result tmp2)
+            endif()
+            set(state 7)
+         elseif("x${_arg}" STREQUAL "xMIC_CXX_FLAGS")
+            if(NOT DEFINED _mic_cxx_result)
+               set(_mic_cxx_result tmp3)
+            endif()
+            set(state 8)
          elseif(state EQUAL 1)
             set(_c_flags "${_arg}")
          elseif(state EQUAL 2)
@@ -79,40 +102,79 @@
             set(_c_result "${_arg}")
          elseif(state EQUAL 4)
             set(_cxx_result "${_arg}")
+         elseif(state EQUAL 5)
+            set(_mic_c_result "${_arg}")
+         elseif(state EQUAL 6)
+            set(_mic_cxx_result "${_arg}")
+         elseif(state EQUAL 7)
+            set(_mic_c_flags "${_arg}")
+         elseif(state EQUAL 8)
+            set(_mic_cxx_flags "${_arg}")
          else()
             message(FATAL_ERROR "Syntax error for AddCompilerFlag")
          endif()
       endforeach()
    endif()
 
+   set(_c_code "int main() { return 0; }")
+   set(_cxx_code "int main() { return 0; }")
    if("${_flag}" STREQUAL "-mfma")
       # Compiling with FMA3 support may fail only at the assembler level.
       # In that case we need to have such an instruction in the test code
-      set(_code "#include <immintrin.h>
+      set(_c_code "#include <immintrin.h>
       __m128 foo(__m128 x) { return _mm_fmadd_ps(x, x, x); }
       int main() { return 0; }")
+      set(_cxx_code "${_c_code}")
    elseif("${_flag}" STREQUAL "-stdlib=libc++")
       # Compiling with libc++ not only requires a compiler that understands it, but also
       # the libc++ headers itself
-      set(_code "#include <iostream>
+      set(_cxx_code "#include <iostream>
+      #include <cstdio>
       int main() { return 0; }")
    else()
-      set(_code "int main() { return 0; }")
+      set(_cxx_code "#include <cstdio>
+      int main() { return 0; }")
    endif()
 
    if(DEFINED _c_result)
-      check_c_compiler_flag("${_flag}" check_c_compiler_flag_${_flag_esc} "${_code}")
+      check_c_compiler_flag("${_flag}" check_c_compiler_flag_${_flag_esc} "${_c_code}")
       set(${_c_result} ${check_c_compiler_flag_${_flag_esc}})
    endif()
    if(DEFINED _cxx_result)
-      check_cxx_compiler_flag("${_flag}" check_cxx_compiler_flag_${_flag_esc} "${_code}")
+      check_cxx_compiler_flag("${_flag}" check_cxx_compiler_flag_${_flag_esc} "${_cxx_code}")
       set(${_cxx_result} ${check_cxx_compiler_flag_${_flag_esc}})
    endif()
 
+   macro(my_append _list _flag _special)
+      if("x${_list}" STREQUAL "x${_special}")
+         set(${_list} "${${_list}} ${_flag}")
+      else()
+         list(APPEND ${_list} "${_flag}")
+      endif()
+   endmacro()
+
    if(check_c_compiler_flag_${_flag_esc} AND DEFINED _c_flags)
-      set(${_c_flags} "${${_c_flags}} ${_flag}")
+      my_append(${_c_flags} "${_flag}" CMAKE_C_FLAGS)
    endif()
    if(check_cxx_compiler_flag_${_flag_esc} AND DEFINED _cxx_flags)
-      set(${_cxx_flags} "${${_cxx_flags}} ${_flag}")
+      my_append(${_cxx_flags} "${_flag}" CMAKE_CXX_FLAGS)
+   endif()
+
+   if(MIC_NATIVE_FOUND)
+      if(DEFINED _mic_c_result)
+         check_mic_c_compiler_flag("${_flag}" check_mic_c_compiler_flag_${_flag_esc} "${_c_code}")
+         set(${_mic_c_result} ${check_mic_c_compiler_flag_${_flag_esc}})
+      endif()
+      if(DEFINED _mic_cxx_result)
+         check_mic_cxx_compiler_flag("${_flag}" check_mic_cxx_compiler_flag_${_flag_esc} "${_cxx_code}")
+         set(${_mic_cxx_result} ${check_mic_cxx_compiler_flag_${_flag_esc}})
+      endif()
+
+      if(check_mic_c_compiler_flag_${_flag_esc} AND DEFINED _mic_c_flags)
+         my_append(${_mic_c_flags} "${_flag}" CMAKE_MIC_C_FLAGS)
+      endif()
+      if(check_mic_cxx_compiler_flag_${_flag_esc} AND DEFINED _mic_cxx_flags)
+         my_append(${_mic_cxx_flags} "${_flag}" CMAKE_MIC_CXX_FLAGS)
+      endif()
    endif()
 endmacro(AddCompilerFlag)
diff -Nru vc-0.7.4/cmake/AddTargetProperty.cmake vc-1.3.0/cmake/AddTargetProperty.cmake
--- vc-0.7.4/cmake/AddTargetProperty.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/AddTargetProperty.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 #=============================================================================
-# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
+# Copyright 2010-2015 Matthias Kretz <kretz@kde.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -7,15 +7,12 @@
 #
 #  * Redistributions of source code must retain the above copyright notice,
 #    this list of conditions and the following disclaimer.
-#
 #  * Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
-#
-#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-#    any consortium members, or of any contributors, may not be used to
-#    endorse or promote products derived from this software without
-#    specific prior written permission.
+#  * Neither the names of contributing organizations nor the
+#    names of its contributors may be used to endorse or promote products
+#    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff -Nru vc-0.7.4/cmake/CheckCCompilerFlag.cmake vc-1.3.0/cmake/CheckCCompilerFlag.cmake
--- vc-0.7.4/cmake/CheckCCompilerFlag.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/CheckCCompilerFlag.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -57,10 +57,14 @@
      FAIL_REGEX "unrecognized .*option"                     # GNU
      FAIL_REGEX "ignored for target"                        # GNU
      FAIL_REGEX "ignoring unknown option"                   # MSVC
+     FAIL_REGEX "warning D9002"                             # MSVC
      FAIL_REGEX "[Uu]nknown option"                         # HP
      FAIL_REGEX "[Ww]arning: [Oo]ption"                     # SunPro
      FAIL_REGEX "command option .* is not recognized"       # XL
      FAIL_REGEX "WARNING: unknown flag:"                    # Open64
+     FAIL_REGEX "command line error"                        # ICC
+     FAIL_REGEX "command line warning"                      # ICC
+     FAIL_REGEX "#10236:"                                   # ICC: File not found
      FAIL_REGEX " #10159: "                                 # ICC
      FAIL_REGEX " #10353: "                                 # ICC: option '-mfma' ignored, suggest using '-march=core-avx2'
      )
diff -Nru vc-0.7.4/cmake/CheckCXXCompilerFlag.cmake vc-1.3.0/cmake/CheckCXXCompilerFlag.cmake
--- vc-0.7.4/cmake/CheckCXXCompilerFlag.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/CheckCXXCompilerFlag.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -57,10 +57,14 @@
      FAIL_REGEX "unrecognized .*option"                     # GNU
      FAIL_REGEX "ignored for target"                        # GNU
      FAIL_REGEX "ignoring unknown option"                   # MSVC
+     FAIL_REGEX "warning D9002"                             # MSVC
      FAIL_REGEX "[Uu]nknown option"                         # HP
      FAIL_REGEX "[Ww]arning: [Oo]ption"                     # SunPro
      FAIL_REGEX "command option .* is not recognized"       # XL
      FAIL_REGEX "WARNING: unknown flag:"                    # Open64
+     FAIL_REGEX "command line error"                        # ICC
+     FAIL_REGEX "command line warning"                      # ICC
+     FAIL_REGEX "#10236:"                                   # ICC: File not found
      FAIL_REGEX " #10159: "                                 # ICC
      FAIL_REGEX " #10353: "                                 # ICC: option '-mfma' ignored, suggest using '-march=core-avx2'
      )
diff -Nru vc-0.7.4/cmake/CheckMicCCompilerFlag.cmake vc-1.3.0/cmake/CheckMicCCompilerFlag.cmake
--- vc-0.7.4/cmake/CheckMicCCompilerFlag.cmake	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/cmake/CheckMicCCompilerFlag.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,101 @@
+# - Check whether the MIC C compiler supports a given flag.
+# CHECK_MIC_C_COMPILER_FLAG(<flag> <var>)
+#  <flag> - the compiler flag
+#  <var>  - variable to store the result
+# This internally calls the check_c_source_compiles macro.  See help
+# for CheckCSourceCompiles for a listing of variables that can
+# modify the build.
+
+#=============================================================================
+# Copyright 2006-2009 Kitware, Inc.
+# Copyright 2006 Alexander Neundorf <neundorf@kde.org>
+# Copyright 2011-2013 Matthias Kretz <kretz@kde.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
+#    any consortium members, or of any contributors, may not be used to
+#    endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#=============================================================================
+
+macro(check_mic_c_compiler_flag _FLAG _RESULT)
+   if(NOT DEFINED "${_RESULT}")
+      set(_tmpdir "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp")
+      if(${ARGC} GREATER 2)
+         file(WRITE "${_tmpdir}/src.c" "${ARGV2}")
+      else()
+         file(WRITE "${_tmpdir}/src.c" "int main() { return 0; }")
+      endif()
+
+      execute_process(
+         COMMAND "${MIC_CC}" -mmic -c -o "${_tmpdir}/src.o"
+         "${_FLAG}" "${_tmpdir}/src.c"
+         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+         RESULT_VARIABLE ${_RESULT}
+         OUTPUT_VARIABLE OUTPUT
+         ERROR_VARIABLE OUTPUT
+         )
+
+      if(${_RESULT} EQUAL 0)
+         foreach(_fail_regex
+               "error: bad value (.*) for .* switch"       # GNU
+               "argument unused during compilation"        # clang
+               "is valid for .* but not for C"             # GNU
+               "unrecognized .*option"                     # GNU
+               "ignored for target"                        # GNU
+               "ignoring unknown option"                   # MSVC
+               "[Uu]nknown option"                         # HP
+               "[Ww]arning: [Oo]ption"                     # SunPro
+               "command option .* is not recognized"       # XL
+               "WARNING: unknown flag:"                    # Open64
+               "command line error"                        # ICC
+               "command line warning"                      # ICC
+               "#10236:"                                   # ICC: File not found
+               )
+            if("${OUTPUT}" MATCHES "${_fail_regex}")
+               set(${_RESULT} 1)
+            endif()
+         endforeach()
+      endif()
+
+      if(${_RESULT} EQUAL 0)
+         set(${_RESULT} 1 CACHE INTERNAL "Test ${_FLAG}")
+         message(STATUS "Performing Test Check MIC C   Compiler flag ${_FLAG} - Success")
+         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+            "Performing MIC C Compiler Flag Test ${_FLAG} succeded with the following output:\n"
+            "${OUTPUT}\n"
+            "COMMAND: ${MIC_CC} -mmic -c -o ${_tmpdir}/src.o ${_FLAG} ${_tmpdir}/src.cpp\n"
+            )
+      else()
+         message(STATUS "Performing Test Check MIC C   Compiler flag ${_FLAG} - Failed")
+         set(${_RESULT} "" CACHE INTERNAL "Test ${_FLAG}")
+         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+            "Performing MIC C Compiler Flag Test ${_FLAG} failed with the following output:\n"
+            "${OUTPUT}\n"
+            "COMMAND: ${MIC_CC} -mmic -c -o ${_tmpdir}/src.o ${_FLAG} ${_tmpdir}/src.cpp\n"
+            )
+      endif()
+   endif()
+endmacro()
+
diff -Nru vc-0.7.4/cmake/CheckMicCXXCompilerFlag.cmake vc-1.3.0/cmake/CheckMicCXXCompilerFlag.cmake
--- vc-0.7.4/cmake/CheckMicCXXCompilerFlag.cmake	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/cmake/CheckMicCXXCompilerFlag.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,101 @@
+# - Check whether the MIC CXX compiler supports a given flag.
+# CHECK_MIC_CXX_COMPILER_FLAG(<flag> <var>)
+#  <flag> - the compiler flag
+#  <var>  - variable to store the result
+# This internally calls the check_cxx_source_compiles macro.  See help
+# for CheckCXXSourceCompiles for a listing of variables that can
+# modify the build.
+
+#=============================================================================
+# Copyright 2006-2009 Kitware, Inc.
+# Copyright 2006 Alexander Neundorf <neundorf@kde.org>
+# Copyright 2011-2013 Matthias Kretz <kretz@kde.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
+#    any consortium members, or of any contributors, may not be used to
+#    endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#=============================================================================
+
+macro(check_mic_cxx_compiler_flag _FLAG _RESULT)
+   if(NOT DEFINED "${_RESULT}")
+      set(_tmpdir "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp")
+      if(${ARGC} GREATER 2)
+         file(WRITE "${_tmpdir}/src.cpp" "${ARGV2}")
+      else()
+         file(WRITE "${_tmpdir}/src.cpp" "int main() { return 0; }")
+      endif()
+
+      execute_process(
+         COMMAND "${MIC_CXX}" -mmic -c -o "${_tmpdir}/src.o"
+         "${_FLAG}" "${_tmpdir}/src.cpp"
+         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+         RESULT_VARIABLE ${_RESULT}
+         OUTPUT_VARIABLE OUTPUT
+         ERROR_VARIABLE OUTPUT
+         )
+
+      if(${_RESULT} EQUAL 0)
+         foreach(_fail_regex
+               "error: bad value (.*) for .* switch"       # GNU
+               "argument unused during compilation"        # clang
+               "is valid for .* but not for C\\\\+\\\\+"   # GNU
+               "unrecognized .*option"                     # GNU
+               "ignored for target"                        # GNU
+               "ignoring unknown option"                   # MSVC
+               "[Uu]nknown option"                         # HP
+               "[Ww]arning: [Oo]ption"                     # SunPro
+               "command option .* is not recognized"       # XL
+               "WARNING: unknown flag:"                    # Open64
+               "command line error"                        # ICC
+               "command line warning"                      # ICC
+               "#10236:"                                   # ICC: File not found
+               )
+            if("${OUTPUT}" MATCHES "${_fail_regex}")
+               set(${_RESULT} 1)
+            endif()
+         endforeach()
+      endif()
+
+      if(${_RESULT} EQUAL 0)
+         set(${_RESULT} 1 CACHE INTERNAL "Test ${_FLAG}")
+         message(STATUS "Performing Test Check MIC C++ Compiler flag ${_FLAG} - Success")
+         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+            "Performing MIC C++ Compiler Flag Test ${_FLAG} succeded with the following output:\n"
+            "${OUTPUT}\n"
+            "COMMAND: ${MIC_CXX} -mmic -c -o ${_tmpdir}/src.o ${_FLAG} ${_tmpdir}/src.cpp\n"
+            )
+      else()
+         message(STATUS "Performing Test Check MIC C++ Compiler flag ${_FLAG} - Failed")
+         set(${_RESULT} "" CACHE INTERNAL "Test ${_FLAG}")
+         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+            "Performing MIC C++ Compiler Flag Test ${_FLAG} failed with the following output:\n"
+            "${OUTPUT}\n"
+            "COMMAND: ${MIC_CXX} -mmic -c -o ${_tmpdir}/src.o ${_FLAG} ${_tmpdir}/src.cpp\n"
+            )
+      endif()
+   endif()
+endmacro()
+
diff -Nru vc-0.7.4/cmake/FindMIC.cmake vc-1.3.0/cmake/FindMIC.cmake
--- vc-0.7.4/cmake/FindMIC.cmake	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/cmake/FindMIC.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,449 @@
+#=============================================================================
+# Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the names of contributing organizations nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#=============================================================================
+#
+# This check will search for a MIC compiler and check whether the C and C++
+# compilers are able to offload via offload pragma and target(mic) attribute.
+# The project may choose to either build native MIC binaries, or offload
+# binaries (hybrid code), or both. In the case where only native MIC binaries
+# are built, the compiler does not need to support offloading
+#
+# MIC_NATIVE_FOUND is true if native MIC binaries can be built
+# MIC_OFFLOAD_FOUND is true if hybrid host/MIC binaries via offload can be built
+# MIC_FOUND is true if either MIC_NATIVE_FOUND or MIC_OFFLOAD_FOUND is true
+#
+# When MIC_NATIVE_FOUND is true you can use the macros
+# mic_add_definitions
+# mic_include_directories
+# mic_set_link_libraries
+# mic_add_library
+# mic_add_executable
+# for building native libraries/executables
+#
+# When MIC_OFFLOAD_FOUND is true you use the standard cmake macros to build
+# libraries and executables but have to make sure manually that the necessary
+# offload compiler switches are present. You might want to add something like:
+# if(MIC_OFFLOAD_FOUND)
+#    AddCompilerFlag("-offload-build")
+#    AddCompilerFlag("-offload-copts=-vec-report=3 -H")
+#    AddCompilerFlag("-offload-ldopts=-lmylib")
+#    AddCompilerFlag("-opt-report-phase=offload")
+# endif()
+
+set(MIC_FOUND false)
+set(MIC_NATIVE_FOUND false)
+set(MIC_OFFLOAD_FOUND false)
+
+option(ENABLE_MIC "Enable native builds for the MIC architecture (Intel Knights Corner)" ON)
+if(ENABLE_MIC)
+   file(GLOB _intel_dirs "/opt/intel/compilers_and_libraries_*/linux")
+   if ("${_intel_dirs}" STREQUAL "")
+      file(GLOB _intel_dirs "/opt/intel/composer_xe_*")
+   endif()
+
+   list(SORT _intel_dirs)
+   list(REVERSE _intel_dirs)
+   find_path(MIC_SDK_DIR bin/intel64_mic/icpc PATHS
+      "$ENV{MIC_SDK_DIR}"
+      ${_intel_dirs}
+      )
+   mark_as_advanced(MIC_SDK_DIR)
+
+   ##############################################################################
+   # First check whether offload works
+
+   # For now offload is not supported so skip it
+#   if(NOT DEFINED c_compiler_can_offload OR NOT DEFINED cxx_compiler_can_offload)
+#      set(c_compiler_can_offload FALSE)
+#      set(cxx_compiler_can_offload FALSE)
+#
+#      include(CheckCSourceCompiles)
+#      include(CheckCXXSourceCompiles)
+#
+#      #find_library(MIC_HOST_IMF_LIBRARY   imf   HINTS ENV LIBRARY_PATH)
+#      #find_library(MIC_HOST_SVML_LIBRARY  svml  HINTS ENV LIBRARY_PATH)
+#      #find_library(MIC_HOST_INTLC_LIBRARY intlc HINTS ENV LIBRARY_PATH)
+#
+#      #set(MIC_HOST_LIBS ${MIC_HOST_IMF_LIBRARY} ${MIC_HOST_SVML_LIBRARY} ${MIC_HOST_INTLC_LIBRARY})
+#
+#      set(_mic_offload_test_source "
+##ifdef __MIC__
+##include <immintrin.h>
+##endif
+#__attribute__((target(mic))) void test()
+#{
+##ifdef __MIC__
+# __m512 v = _mm512_setzero_ps();
+# (void)v;
+##endif
+#}
+#
+#int main()
+#{
+##pragma offload target(mic)
+# test();
+# return 0;
+#}
+#")
+#      set(CMAKE_REQUIRED_FLAGS "-offload-build")
+#      check_c_source_compiles("${_mic_offload_test_source}" c_compiler_can_offload)
+#      check_cxx_source_compiles("${_mic_offload_test_source}" cxx_compiler_can_offload)
+#      set(CMAKE_REQUIRED_FLAGS)
+#   endif()
+#
+#   if(c_compiler_can_offload AND cxx_compiler_can_offload)
+#      message(STATUS "C/C++ Compiler can offload to MIC.")
+#      set(MIC_OFFLOAD_FOUND true)
+#   else()
+#      message(STATUS "C/C++ Compiler can NOT offload to MIC.")
+#   endif()
+
+   ##############################################################################
+   # Next check whether everything required for native builds is available
+
+   find_path(MIC_TARGET_TOOLS_DIR bin/x86_64-k1om-linux-ar HINTS
+      "$ENV{MIC_TARGET_TOOLS_DIR}"
+      "${MIC_SDK_DIR}/target"
+      "/usr/linux-k1om-4.7"
+      )
+   find_program(MIC_AR x86_64-k1om-linux-ar PATHS "${MIC_TARGET_TOOLS_DIR}/bin")
+   find_program(MIC_RANLIB x86_64-k1om-linux-ranlib PATHS "${MIC_TARGET_TOOLS_DIR}/bin")
+   find_program(MIC_OBJCOPY x86_64-k1om-linux-objcopy PATHS "${MIC_TARGET_TOOLS_DIR}/bin")
+   find_program(MIC_NATIVELOAD micnativeloadex PATHS ENV PATH)
+   mark_as_advanced(MIC_TARGET_TOOLS_DIR MIC_AR MIC_RANLIB MIC_NATIVELOAD MIC_OBJCOPY)
+
+   if(MIC_SDK_DIR AND MIC_AR AND MIC_RANLIB)
+      find_program(MIC_CC  icc  HINTS "${MIC_SDK_DIR}/bin" "${MIC_SDK_DIR}/bin/intel64")
+      find_program(MIC_CXX icpc HINTS "${MIC_SDK_DIR}/bin" "${MIC_SDK_DIR}/bin/intel64")
+
+      find_library(MIC_IMF_LIBRARY   imf      HINTS "${MIC_SDK_DIR}/compiler/lib/mic")
+      find_library(MIC_SVML_LIBRARY  svml     HINTS "${MIC_SDK_DIR}/compiler/lib/mic")
+      find_library(MIC_INTLC_LIBRARY intlc    HINTS "${MIC_SDK_DIR}/compiler/lib/mic")
+      mark_as_advanced(MIC_CC MIC_CXX MIC_IMF_LIBRARY MIC_SVML_LIBRARY MIC_INTLC_LIBRARY)
+
+      set(MIC_LIBS ${MIC_IMF_LIBRARY} ${MIC_SVML_LIBRARY} ${MIC_INTLC_LIBRARY})
+      set(MIC_CFLAGS "-O2 -vec")
+
+      exec_program(${MIC_CXX} ARGS -V OUTPUT_VARIABLE _mic_icc_version_string RETURN_VALUE _mic_icc_ok)
+      if(0 EQUAL _mic_icc_ok)
+         string(REGEX MATCH "Version (Mainline)?[0-9. a-zA-Z]+" Vc_MIC_ICC_VERSION "${_mic_icc_version_string}")
+         string(SUBSTRING "${Vc_MIC_ICC_VERSION}" 8 -1 Vc_MIC_ICC_VERSION)
+         message(STATUS "MIC ICC Version: \"${Vc_MIC_ICC_VERSION}\"")
+
+         if(MIC_CC AND MIC_CXX AND MIC_IMF_LIBRARY AND MIC_SVML_LIBRARY AND MIC_INTLC_LIBRARY)
+            set(MIC_NATIVE_FOUND true)
+         endif()
+      else()
+         message(STATUS "MIC ICC found, but not usable.")
+      endif()
+   endif()
+endif(ENABLE_MIC)
+
+if(MIC_NATIVE_FOUND OR MIC_OFFLOAD_FOUND)
+   set(MIC_FOUND true)
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-diag-disable 2338") # this switch statement does not have a default clause
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-diag-disable 193") # zero used for undefined preprocessing identifier "Vc_GCC"
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-diag-disable 61") # warning #61: integer operation result is out of range
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-diag-disable 173") # warning #173: floating-point value does not fit in required integral type
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-diag-disable 264") # warning #264: floating-point value does not fit in required floating-point type
+
+   list(APPEND CMAKE_MIC_CXX_FLAGS "-fp-model source") # fix IEEE FP comliance
+
+   set(Vc_MIC_CXX_FLAGS "")
+
+   macro(mic_add_definitions)
+      add_definitions(${ARGN})
+      foreach(_def ${ARGN})
+         set(_mic_cflags ${_mic_cflags} "${_def}")
+      endforeach()
+   endmacro()
+   macro(mic_include_directories)
+      foreach(_dir ${ARGN})
+         set(_mic_cflags ${_mic_cflags} "-I${_dir}")
+      endforeach()
+      include_directories(${ARGN})
+   endmacro()
+   if(NOT DEFINED MIC_C_FLAGS)
+      set(MIC_C_FLAGS)
+   endif()
+   if(NOT DEFINED MIC_CXX_FLAGS)
+      set(MIC_CXX_FLAGS)
+   endif()
+else()
+   message(STATUS "MIC SDK was not found!")
+endif()
+
+if(MIC_NATIVE_FOUND)
+   macro(_mic_add_object _target _source _output)
+      get_property(_deps SOURCE "${_source}" PROPERTY OBJECT_DEPENDS)
+      get_filename_component(_abs "${_source}" ABSOLUTE)
+      get_filename_component(_ext "${_source}" EXT)
+      get_filename_component(_tmp "${_source}" NAME_WE)
+      set(${_output} "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_target}.dir/${_tmp}${_ext}.mic.o")
+      set(_lang CXX)
+      set(_compiler "${MIC_CXX}")
+      if(_ext STREQUAL "c")
+         set(_lang C)
+         set(_compiler "${MIC_CC}")
+      endif()
+
+      string(TOUPPER "${CMAKE_BUILD_TYPE}" _tmp)
+      string(STRIP "${CMAKE_MIC_${_lang}_FLAGS} ${CMAKE_${_lang}_FLAGS_${_tmp}} ${_mic_cflags} ${Vc_MIC_CXX_FLAGS}" _flags)
+      string(REPLACE " " ";" _flags "${_flags} ${ARGN}")
+      get_directory_property(_inc INCLUDE_DIRECTORIES)
+      foreach(_i ${_inc})
+         list(APPEND _flags "-I${_i}")
+      endforeach()
+
+      get_property(_launch_rule GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
+      string(REPLACE "\"" "" _launch_rule "${_launch_rule}")
+      string(REPLACE " " ";" _launch_rule "${_launch_rule}")
+      string(REPLACE "<TARGET_NAME>" "${_target}" _launch_rule "${_launch_rule}")
+      string(REPLACE "<CMAKE_CURRENT_BINARY_DIR>" "${CMAKE_CURRENT_BINARY_DIR}" _launch_rule "${_launch_rule}")
+      string(REPLACE "<OBJECT>" "${${_output}}" _launch_rule "${_launch_rule}")
+      string(REPLACE "<SOURCE>" "${_abs}" _launch_rule "${_launch_rule}")
+      string(REPLACE "<LANGUAGE>" "C++" _launch_rule "${_launch_rule}")
+      add_custom_command(OUTPUT "${${_output}}"
+         COMMAND ${_launch_rule} "${_compiler}" -mmic
+         -DVc_IMPL=MIC
+         ${_flags} -c -o "${${_output}}" "${_abs}"
+         DEPENDS "${_abs}" ${_deps}
+         IMPLICIT_DEPENDS ${_lang} "${_abs}"
+         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+         COMMENT "Compiling (MIC) ${${_output}}"
+         VERBATIM
+         )
+   endmacro()
+   macro(mic_set_link_libraries)
+      set(_mic_lflags)
+      foreach(_lib ${ARGN})
+         get_filename_component(_lpath "${_lib}" PATH)
+         get_filename_component(_lname "${_lib}" NAME)
+         set(_mic_lflags ${_mic_lflags} "-L${_lpath}" "-l${_lname}")
+      endforeach()
+   endmacro()
+   macro(mic_add_library _target)
+      set(_state 0)
+      if(BUILD_SHARED_LIBS)
+         set(_type SHARED)
+      else()
+         set(_type STATIC)
+      endif()
+      set(_all ALL)
+      set(_srcs)
+      set(_cflags)
+      set(_libs)
+      foreach(_arg ${ARGN})
+         if(_arg MATCHES "^(STATIC|SHARED|MODULE)$")
+            set(_type ${_arg})
+         elseif(_arg STREQUAL "EXCLUDE_FROM_ALL")
+            set(_all)
+         elseif(_arg STREQUAL "COMPILE_FLAGS" OR _arg STREQUAL "COMPILE_OPTIONS")
+            set(_state 1)
+         elseif(_arg STREQUAL "LINK_LIBRARIES")
+            set(_state 2)
+         elseif(_arg STREQUAL "SOURCES")
+            set(_state 0)
+         elseif(_state EQUAL 0) # SOURCES
+            set(_srcs ${_srcs} "${_arg}")
+         elseif(_state EQUAL 1) # COMPILE_FLAGS
+            list(APPEND _cflags ${_arg})
+         elseif(_state EQUAL 2) # LINK_LIBRARIES
+            get_filename_component(_lpath "${_arg}" PATH)
+            get_filename_component(_lname "${_arg}" NAME)
+            set(_libs ${_libs} "-L${_lpath}" "-l${_lname}")
+         endif()
+      endforeach()
+      set(_objects)
+      set(_objectsStr)
+      foreach(_src ${_srcs})
+         _mic_add_object("${_target}" "${_src}" _obj ${_cflags})
+         list(APPEND _objects "${_obj}")
+         set(_objectsStr "${_objectsStr} \"${_obj}\"")
+      endforeach()
+
+      set(_outdir "${CMAKE_CURRENT_BINARY_DIR}/x86_64-k1om-linux")
+      file(MAKE_DIRECTORY "${_outdir}")
+
+      #TODO: handle STATIC/SHARED/MODULE differently
+      set(_output "lib${_target}.a")
+      set(_linkscript "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_target}.dir/link.txt")
+      set(_cleanscript "CMakeFiles/${_target}.dir/cmake_clean_target.cmake")
+      file(WRITE "${_linkscript}"
+         "${MIC_AR} cr ${_output} ${_objectsStr}
+${MIC_RANLIB} ${_output}
+")
+      file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_cleanscript}"
+         "FILE(REMOVE_RECURSE \"${_output}\")
+")
+      add_custom_command(OUTPUT "${_outdir}/${_output}"
+         COMMAND "${CMAKE_COMMAND}" -E cmake_link_script "${_linkscript}" --verbose=$(VERBOSE)
+         DEPENDS ${_objects}
+         WORKING_DIRECTORY "${_outdir}"
+         COMMENT "Linking (MIC) ${_output}"
+         VERBATIM
+         )
+      add_custom_target("${_target}" ${_all}
+         DEPENDS "${_outdir}/${_output}"
+         COMMENT ""
+         SOURCES ${_srcs}
+         )
+      set_target_properties("${_target}" PROPERTIES
+         OUTPUT_NAME "${_outdir}/${_output}"
+         )
+   endmacro()
+
+   macro(mic_add_executable _target)
+      set(_state 0)
+      set(_all ALL)
+      set(_srcs)
+      set(_cflags)
+      set(_libs)
+      set(_libTargets)
+      set(_dump_asm false)
+      set(_exec_output_name "${_target}")
+      set(_objects)
+      set(_objectsStr)
+      foreach(_arg ${ARGN})
+         if(_arg STREQUAL "EXCLUDE_FROM_ALL")
+            set(_all)
+         elseif(_arg STREQUAL "COMPILE_FLAGS")
+            set(_state 1)
+         elseif(_arg STREQUAL "LINK_LIBRARIES")
+            set(_state 2)
+         elseif(_arg STREQUAL "OUTPUT_NAME")
+            set(_state 3)
+         elseif(_arg STREQUAL "SOURCES")
+            set(_state 0)
+         elseif(_arg STREQUAL "OBJECTS")
+            set(_state 4)
+         elseif(_arg STREQUAL "DUMP_ASM")
+            set(_dump_asm true)
+         elseif(_state EQUAL 0) # SOURCES
+            set(_srcs ${_srcs} "${_arg}")
+         elseif(_state EQUAL 1) # COMPILE_FLAGS
+            set(_cflags ${_cflags} "${_arg}")
+         elseif(_state EQUAL 2) # LINK_LIBRARIES
+            if(TARGET ${_arg})
+               get_target_property(_tmp "${_arg}" OUTPUT_NAME)
+               if(_tmp)
+                  set(_libs ${_libs} "${_tmp}")
+                  set(_libTargets ${_libTargets} "${_tmp}" "${_arg}")
+               else()
+                  set(_libs ${_libs} "${_arg}")
+                  if(EXISTS "${_arg}")
+                     set(_libTargets ${_libTargets} "${_arg}")
+                  endif()
+               endif()
+            else()
+               set(_libs ${_libs} "${_arg}")
+               if(EXISTS "${_arg}")
+                  set(_libTargets ${_libTargets} "${_arg}")
+               endif()
+            endif()
+         elseif(_state EQUAL 3) # OUTPUT_NAME
+            set(_exec_output_name "${_arg}")
+         elseif(_state EQUAL 4) # OBJECTS
+            set(_objects ${_objects} "${_arg}")
+            set(_objectsStr "${_objectsStr} \"${_arg}\"")
+         endif()
+      endforeach()
+      foreach(_src ${_srcs})
+         _mic_add_object("${_target}" "${_src}" _obj ${_cflags})
+         set(_objects ${_objects} "${_obj}")
+         set(_objectsStr "${_objectsStr} \"${_obj}\"")
+      endforeach()
+
+      set(_exec_output "${CMAKE_CURRENT_BINARY_DIR}/${_exec_output_name}")
+      get_property(_launch_rule GLOBAL PROPERTY RULE_LAUNCH_LINK)
+      string(REPLACE "\"" "" _launch_rule "${_launch_rule}")
+      string(REPLACE " " ";" _launch_rule "${_launch_rule}")
+      string(REPLACE "<TARGET_NAME>" "${_target}" _launch_rule "${_launch_rule}")
+      string(REPLACE "<CMAKE_CURRENT_BINARY_DIR>" "${CMAKE_CURRENT_BINARY_DIR}" _launch_rule "${_launch_rule}")
+      add_custom_command(OUTPUT "${_exec_output}"
+         COMMAND ${_launch_rule} "${MIC_CXX}" -mmic
+         "-L${MIC_SDK_DIR}/compiler/lib/mic/"
+         ${_mic_lflags} ${_objects} -o "${_exec_output}"
+         ${_libs}
+         DEPENDS ${_objects} ${_libTargets}
+         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+         COMMENT "Linking (MIC) ${_exec_output}"
+         VERBATIM
+         )
+      set(_dump_asm_output)
+      if(_dump_asm)
+         foreach(_src ${_srcs})
+            get_filename_component(_abs "${_src}" ABSOLUTE)
+            get_filename_component(_name "${_src}" NAME)
+            add_custom_command(OUTPUT "${_name}.s"
+               COMMAND "${MIC_CXX}" -mmic
+               -DVc_IMPL=MIC ${_mic_cflags} ${_cflags} ${Vc_MIC_CXX_FLAGS}
+               ${_abs}
+               -S -fsource-asm -fno-verbose-asm -o "${_name}.x"
+               COMMAND sh -c "grep -v ___tag_value '${_name}.x' | c++filt > '${_name}.s'"
+               COMMAND rm "${_name}.x"
+               DEPENDS ${_abs}
+               WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+               COMMENT "Creating MIC Assembly ${_name}.s"
+               VERBATIM
+               )
+            set(_dump_asm_output ${_dump_asm_output} "${CMAKE_CURRENT_BINARY_DIR}/${_name}.s")
+         endforeach()
+      endif()
+      add_custom_target("${_target}" ${_all}
+         DEPENDS "${_exec_output}" ${_dump_asm_output}
+         COMMENT ""
+         SOURCES ${_srcs}
+         )
+      set_target_properties("${_target}" PROPERTIES OUTPUT_NAME "${_exec_output_name}")
+   endmacro()
+endif()
+
+if(MIC_OFFLOAD_FOUND)
+   macro(mic_offload _target)
+      set(_mic_debug)
+      if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+         set(_mic_debug "-g")
+      endif()
+      add_target_property(${_target} COMPILE_FLAGS "-offload-build -DCAN_OFFLOAD ${_mic_debug}")
+      set(_offload_ldflags "${_mic_debug}")
+      set(_libTargets)
+      foreach(_lib ${ARGN})
+         get_target_property(_tmp "${_lib}" OUTPUT_NAME)
+         if(_tmp)
+            set(_offload_ldflags "${_offload_ldflags} ${_tmp}")
+            set(_libTargets ${_libTargets} "${_arg}")
+         else()
+            get_filename_component(_lpath "${_arg}" PATH)
+            get_filename_component(_lname "${_arg}" NAME)
+            set(_offload_ldflags "${_offload_ldflags} -L${_lpath} -l${_lname}")
+         endif()
+      endforeach()
+      add_target_property(${_target} LINK_FLAGS "-offload-build -offload-ldopts=\"${_offload_ldflags}\" ${_mic_debug}")
+      if(_libTargets)
+         add_dependencies(${_target} ${_libTargets})
+      endif()
+   endmacro()
+endif()
diff -Nru vc-0.7.4/cmake/FindVc.cmake vc-1.3.0/cmake/FindVc.cmake
--- vc-0.7.4/cmake/FindVc.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/FindVc.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -1,4 +1,4 @@
-# Locate the Vc template library. Vc can be found at http://gitorious.org/Vc/
+# Locate the Vc template library. Vc can be found at https://github.com/VcDevel/Vc
 #
 # This file is meant to be copied into projects that want to use Vc. It will
 # search for VcConfig.cmake, which ships with Vc and will provide up-to-date
@@ -10,6 +10,9 @@
 # Vc_INCLUDE_DIR
 # Vc_LIBRARIES
 # Vc_DEFINITIONS
+# Vc_COMPILE_FLAGS
+# Vc_ARCHITECTURE_FLAGS
+# Vc_ALL_FLAGS (the union of the above three variables)
 # Vc_VERSION_MAJOR
 # Vc_VERSION_MINOR
 # Vc_VERSION_PATCH
@@ -25,7 +28,7 @@
 # Vc_AVX_INTRINSICS_BROKEN
 #
 #=============================================================================
-# Copyright 2009-2012   Matthias Kretz <kretz@kde.org>
+# Copyright 2009-2015   Matthias Kretz <kretz@kde.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -33,15 +36,12 @@
 #
 #  * Redistributions of source code must retain the above copyright notice,
 #    this list of conditions and the following disclaimer.
-#
 #  * Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
-#
-#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-#    any consortium members, or of any contributors, may not be used to
-#    endorse or promote products derived from this software without
-#    specific prior written permission.
+#  * Neither the names of contributing organizations nor the
+#    names of its contributors may be used to endorse or promote products
+#    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff -Nru vc-0.7.4/cmake/OptimizeForArchitecture.cmake vc-1.3.0/cmake/OptimizeForArchitecture.cmake
--- vc-0.7.4/cmake/OptimizeForArchitecture.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/OptimizeForArchitecture.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,23 @@
+# Determine the host CPU feature set and determine the best set of compiler
+# flags to enable all supported SIMD relevant features. Alternatively, the
+# target CPU can be explicitly selected (for generating more generic binaries
+# or for targeting a different system).
+# Compilers provide e.g. the -march=native flag to achieve a similar result.
+# This fails to address the need for building for a different microarchitecture
+# than the current host.
+# The script tries to deduce all settings from the model and family numbers of
+# the CPU instead of reading the CPUID flags from e.g. /proc/cpuinfo. This makes
+# the detection more independent from the CPUID code in the kernel (e.g. avx2 is
+# not listed on older kernels).
+#
+# Usage:
+# OptimizeForArchitecture()
+# If either of Vc_SSE_INTRINSICS_BROKEN, Vc_AVX_INTRINSICS_BROKEN,
+# Vc_AVX2_INTRINSICS_BROKEN is defined and set, the OptimizeForArchitecture
+# macro will consequently disable the relevant features via compiler flags.
+
 #=============================================================================
-# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
+# Copyright 2010-2015 Matthias Kretz <kretz@kde.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -7,15 +25,12 @@
 #
 #  * Redistributions of source code must retain the above copyright notice,
 #    this list of conditions and the following disclaimer.
-#
 #  * Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
-#
-#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-#    any consortium members, or of any contributors, may not be used to
-#    endorse or promote products derived from this software without
-#    specific prior written permission.
+#  * Neither the names of contributing organizations nor the
+#    names of its contributors may be used to endorse or promote products
+#    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -31,7 +46,7 @@
 
 get_filename_component(_currentDir "${CMAKE_CURRENT_LIST_FILE}" PATH)
 include("${_currentDir}/AddCompilerFlag.cmake")
-include(CheckIncludeFile)
+include(CheckIncludeFileCXX)
 
 macro(_my_find _list _value _ret)
    list(FIND ${_list} "${_value}" _found)
@@ -70,37 +85,58 @@
    endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    if(_vendor_id STREQUAL "GenuineIntel")
       if(_cpu_family EQUAL 6)
-         # Any recent Intel CPU except NetBurst
-         if(_cpu_model EQUAL 62)
+         # taken from the Intel ORM
+         # http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html
+         # CPUID Signature Values of Of Recent Intel Microarchitectures
+         # 4E 5E       | Skylake microarchitecture
+         # 3D 47 56    | Broadwell microarchitecture
+         # 3C 45 46 3F | Haswell microarchitecture
+         # 3A 3E       | Ivy Bridge microarchitecture
+         # 2A 2D       | Sandy Bridge microarchitecture
+         # 25 2C 2F    | Intel microarchitecture Westmere
+         # 1A 1E 1F 2E | Intel microarchitecture Nehalem
+         # 17 1D       | Enhanced Intel Core microarchitecture
+         # 0F          | Intel Core microarchitecture
+         #
+         # Values from the Intel SDE:
+         # 5C | Goldmont
+         # 5A | Silvermont
+         # 57 | Knights Landing
+         # 66 | Cannonlake
+         # 55 | Skylake Server
+         # 4E | Skylake Client
+         # 3C | Broadwell (likely a bug in the SDE)
+         # 3C | Haswell
+         if(_cpu_model EQUAL 87)
+            set(TARGET_ARCHITECTURE "knl")  # Knights Landing
+         elseif(_cpu_model EQUAL 92)
+            set(TARGET_ARCHITECTURE "goldmont")
+         elseif(_cpu_model EQUAL 90)
+            set(TARGET_ARCHITECTURE "silvermont")
+         elseif(_cpu_model EQUAL 102)
+            set(TARGET_ARCHITECTURE "cannonlake")
+         elseif(_cpu_model EQUAL 85) # 55
+            set(TARGET_ARCHITECTURE "skylake-avx512")
+         elseif(_cpu_model EQUAL 78 OR _cpu_model EQUAL 94) # 4E, 5E
+            set(TARGET_ARCHITECTURE "skylake")
+         elseif(_cpu_model EQUAL 61 OR _cpu_model EQUAL 71 OR _cpu_model EQUAL 86)
+            set(TARGET_ARCHITECTURE "broadwell")
+         elseif(_cpu_model EQUAL 60 OR _cpu_model EQUAL 69 OR _cpu_model EQUAL 70 OR _cpu_model EQUAL 63)
+            set(TARGET_ARCHITECTURE "haswell")
+         elseif(_cpu_model EQUAL 58 OR _cpu_model EQUAL 62)
             set(TARGET_ARCHITECTURE "ivy-bridge")
-         elseif(_cpu_model EQUAL 58)
-            set(TARGET_ARCHITECTURE "ivy-bridge")
-         elseif(_cpu_model EQUAL 47) # Xeon E7 4860
-            set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 46) # Xeon 7500 series
-            set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 45) # Xeon TNG
-            set(TARGET_ARCHITECTURE "sandy-bridge")
-         elseif(_cpu_model EQUAL 44) # Xeon 5600 series
-            set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 42) # Core TNG
+         elseif(_cpu_model EQUAL 42 OR _cpu_model EQUAL 45)
             set(TARGET_ARCHITECTURE "sandy-bridge")
-         elseif(_cpu_model EQUAL 37) # Core i7/i5/i3
-            set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 31) # Core i7/i5
+         elseif(_cpu_model EQUAL 37 OR _cpu_model EQUAL 44 OR _cpu_model EQUAL 47)
             set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 30) # Core i7/i5
-            set(TARGET_ARCHITECTURE "westmere")
-         elseif(_cpu_model EQUAL 29)
-            set(TARGET_ARCHITECTURE "penryn")
-         elseif(_cpu_model EQUAL 28)
-            set(TARGET_ARCHITECTURE "atom")
-         elseif(_cpu_model EQUAL 26)
+         elseif(_cpu_model EQUAL 26 OR _cpu_model EQUAL 30 OR _cpu_model EQUAL 31 OR _cpu_model EQUAL 46)
             set(TARGET_ARCHITECTURE "nehalem")
-         elseif(_cpu_model EQUAL 23)
+         elseif(_cpu_model EQUAL 23 OR _cpu_model EQUAL 29)
             set(TARGET_ARCHITECTURE "penryn")
          elseif(_cpu_model EQUAL 15)
             set(TARGET_ARCHITECTURE "merom")
+         elseif(_cpu_model EQUAL 28)
+            set(TARGET_ARCHITECTURE "atom")
          elseif(_cpu_model EQUAL 14)
             set(TARGET_ARCHITECTURE "core")
          elseif(_cpu_model LESS 14)
@@ -142,7 +178,15 @@
 endmacro()
 
 macro(OptimizeForArchitecture)
-   set(TARGET_ARCHITECTURE "auto" CACHE STRING "CPU architecture to optimize for. Using an incorrect setting here can result in crashes of the resulting binary because of invalid instructions used.\nSetting the value to \"auto\" will try to optimize for the architecture where cmake is called.\nOther supported values are: \"none\", \"generic\", \"core\", \"merom\" (65nm Core2), \"penryn\" (45nm Core2), \"nehalem\", \"westmere\", \"sandy-bridge\", \"ivy-bridge\", \"atom\", \"k8\", \"k8-sse3\", \"barcelona\", \"istanbul\", \"magny-cours\", \"bulldozer\", \"interlagos\", \"piledriver\", \"AMD 14h\", \"AMD 16h\".")
+   set(TARGET_ARCHITECTURE "auto" CACHE STRING "CPU architecture to optimize for. \
+Using an incorrect setting here can result in crashes of the resulting binary because of invalid instructions used. \
+Setting the value to \"auto\" will try to optimize for the architecture where cmake is called. \
+Other supported values are: \"none\", \"generic\", \"core\", \"merom\" (65nm Core2), \
+\"penryn\" (45nm Core2), \"nehalem\", \"westmere\", \"sandy-bridge\", \"ivy-bridge\", \
+\"haswell\", \"broadwell\", \"skylake\", \"skylake-avx512\", \"cannonlake\", \"silvermont\", \
+\"goldmont\", \"knl\" (Knights Landing), \"atom\", \"k8\", \"k8-sse3\", \"barcelona\", \
+\"istanbul\", \"magny-cours\", \"bulldozer\", \"interlagos\", \"piledriver\", \
+\"AMD 14h\", \"AMD 16h\".")
    set(_force)
    if(NOT _last_target_arch STREQUAL "${TARGET_ARCHITECTURE}")
       message(STATUS "target changed from \"${_last_target_arch}\" to \"${TARGET_ARCHITECTURE}\"")
@@ -160,6 +204,58 @@
       message(STATUS "Detected CPU: ${TARGET_ARCHITECTURE}")
    endif(TARGET_ARCHITECTURE STREQUAL "auto")
 
+   macro(_nehalem)
+      list(APPEND _march_flag_list "nehalem")
+      list(APPEND _march_flag_list "corei7")
+      list(APPEND _march_flag_list "core2")
+      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2")
+   endmacro()
+   macro(_westmere)
+      list(APPEND _march_flag_list "westmere")
+      _nehalem()
+   endmacro()
+   macro(_sandybridge)
+      list(APPEND _march_flag_list "sandybridge")
+      list(APPEND _march_flag_list "corei7-avx")
+      _westmere()
+      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2" "avx")
+   endmacro()
+   macro(_ivybridge)
+      list(APPEND _march_flag_list "ivybridge")
+      list(APPEND _march_flag_list "core-avx-i")
+      _sandybridge()
+      list(APPEND _available_vector_units_list "rdrnd" "f16c")
+   endmacro()
+   macro(_haswell)
+      list(APPEND _march_flag_list "haswell")
+      list(APPEND _march_flag_list "core-avx2")
+      _ivybridge()
+      list(APPEND _available_vector_units_list "avx2" "fma" "bmi" "bmi2")
+   endmacro()
+   macro(_broadwell)
+      list(APPEND _march_flag_list "broadwell")
+      _haswell()
+   endmacro()
+   macro(_skylake)
+      list(APPEND _march_flag_list "skylake")
+      _broadwell()
+   endmacro()
+   macro(_skylake_avx512)
+      list(APPEND _march_flag_list "skylake-avx512")
+      _skylake()
+      list(APPEND _available_vector_units_list "avx512f" "avx512cd" "avx512dq" "avx512bw" "avx512vl")
+   endmacro()
+   macro(_cannonlake)
+      list(APPEND _march_flag_list "cannonlake")
+      _skylake_avx512()
+      list(APPEND _available_vector_units_list "avx512ifma" "avx512vbmi")
+   endmacro()
+   macro(_knightslanding)
+      list(APPEND _march_flag_list "knl")
+      _broadwell()
+      list(APPEND _available_vector_units_list "avx512f" "avx512pf" "avx512er" "avx512cd")
+   endmacro()
+
    if(TARGET_ARCHITECTURE STREQUAL "core")
       list(APPEND _march_flag_list "core2")
       list(APPEND _available_vector_units_list "sse" "sse2" "sse3")
@@ -178,27 +274,26 @@
       else()
          message(STATUS "SSE4.1: disabled (auto-detected from this computer's CPU flags)")
       endif()
-   elseif(TARGET_ARCHITECTURE STREQUAL "nehalem")
-      list(APPEND _march_flag_list "nehalem")
-      list(APPEND _march_flag_list "corei7")
-      list(APPEND _march_flag_list "core2")
-      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2")
-   elseif(TARGET_ARCHITECTURE STREQUAL "westmere")
-      list(APPEND _march_flag_list "westmere")
-      list(APPEND _march_flag_list "corei7")
-      list(APPEND _march_flag_list "core2")
-      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2")
+   elseif(TARGET_ARCHITECTURE STREQUAL "knl")
+      _knightslanding()
+   elseif(TARGET_ARCHITECTURE STREQUAL "cannonlake")
+      _cannonlake()
+   elseif(TARGET_ARCHITECTURE STREQUAL "skylake-xeon" OR TARGET_ARCHITECTURE STREQUAL "skylake-avx512")
+      _skylake_avx512()
+   elseif(TARGET_ARCHITECTURE STREQUAL "skylake")
+      _skylake()
+   elseif(TARGET_ARCHITECTURE STREQUAL "broadwell")
+      _broadwell()
+   elseif(TARGET_ARCHITECTURE STREQUAL "haswell")
+      _haswell()
    elseif(TARGET_ARCHITECTURE STREQUAL "ivy-bridge")
-      list(APPEND _march_flag_list "core-avx-i")
-      list(APPEND _march_flag_list "corei7-avx")
-      list(APPEND _march_flag_list "core2")
-      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2" "avx" "rdrnd" "f16c")
+      _ivybridge()
    elseif(TARGET_ARCHITECTURE STREQUAL "sandy-bridge")
-      list(APPEND _march_flag_list "sandybridge")
-      list(APPEND _march_flag_list "corei7-avx")
-      list(APPEND _march_flag_list "corei7")
-      list(APPEND _march_flag_list "core2")
-      list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2" "avx")
+      _sandybridge()
+   elseif(TARGET_ARCHITECTURE STREQUAL "westmere")
+      _westmere()
+   elseif(TARGET_ARCHITECTURE STREQUAL "nehalem")
+      _nehalem()
    elseif(TARGET_ARCHITECTURE STREQUAL "atom")
       list(APPEND _march_flag_list "atom")
       list(APPEND _march_flag_list "core2")
@@ -259,100 +354,84 @@
    if(NOT TARGET_ARCHITECTURE STREQUAL "none")
       set(_disable_vector_unit_list)
       set(_enable_vector_unit_list)
-      _my_find(_available_vector_units_list "sse2" SSE2_FOUND)
-      _my_find(_available_vector_units_list "sse3" SSE3_FOUND)
-      _my_find(_available_vector_units_list "ssse3" SSSE3_FOUND)
-      _my_find(_available_vector_units_list "sse4.1" SSE4_1_FOUND)
-      _my_find(_available_vector_units_list "sse4.2" SSE4_2_FOUND)
-      _my_find(_available_vector_units_list "sse4a" SSE4a_FOUND)
       if(DEFINED Vc_AVX_INTRINSICS_BROKEN AND Vc_AVX_INTRINSICS_BROKEN)
-         UserWarning("AVX disabled per default because of old/broken compiler")
-         set(AVX_FOUND false)
-         set(XOP_FOUND false)
-         set(FMA4_FOUND false)
+         UserWarning("AVX disabled per default because of old/broken toolchain")
+         set(_avx_broken true)
+         set(_avx2_broken true)
+         set(_fma4_broken true)
+         set(_xop_broken true)
       else()
-         _my_find(_available_vector_units_list "avx" AVX_FOUND)
+         set(_avx_broken false)
          if(DEFINED Vc_FMA4_INTRINSICS_BROKEN AND Vc_FMA4_INTRINSICS_BROKEN)
-            UserWarning("FMA4 disabled per default because of old/broken compiler")
-            set(FMA4_FOUND false)
+            UserWarning("FMA4 disabled per default because of old/broken toolchain")
+            set(_fma4_broken true)
          else()
-            _my_find(_available_vector_units_list "fma4" FMA4_FOUND)
+            set(_fma4_broken false)
          endif()
          if(DEFINED Vc_XOP_INTRINSICS_BROKEN AND Vc_XOP_INTRINSICS_BROKEN)
-            UserWarning("XOP disabled per default because of old/broken compiler")
-            set(XOP_FOUND false)
+            UserWarning("XOP disabled per default because of old/broken toolchain")
+            set(_xop_broken true)
          else()
-            _my_find(_available_vector_units_list "xop" XOP_FOUND)
+            set(_xop_broken false)
+         endif()
+         if(DEFINED Vc_AVX2_INTRINSICS_BROKEN AND Vc_AVX2_INTRINSICS_BROKEN)
+            UserWarning("AVX2 disabled per default because of old/broken toolchain")
+            set(_avx2_broken true)
+         else()
+            set(_avx2_broken false)
          endif()
       endif()
-      set(USE_SSE2   ${SSE2_FOUND}   CACHE BOOL "Use SSE2. If SSE2 instructions are not enabled the SSE implementation will be disabled." ${_force})
-      set(USE_SSE3   ${SSE3_FOUND}   CACHE BOOL "Use SSE3. If SSE3 instructions are not enabled they will be emulated." ${_force})
-      set(USE_SSSE3  ${SSSE3_FOUND}  CACHE BOOL "Use SSSE3. If SSSE3 instructions are not enabled they will be emulated." ${_force})
-      set(USE_SSE4_1 ${SSE4_1_FOUND} CACHE BOOL "Use SSE4.1. If SSE4.1 instructions are not enabled they will be emulated." ${_force})
-      set(USE_SSE4_2 ${SSE4_2_FOUND} CACHE BOOL "Use SSE4.2. If SSE4.2 instructions are not enabled they will be emulated." ${_force})
-      set(USE_SSE4a  ${SSE4a_FOUND}  CACHE BOOL "Use SSE4a. If SSE4a instructions are not enabled they will be emulated." ${_force})
-      set(USE_AVX    ${AVX_FOUND}    CACHE BOOL "Use AVX. This will double some of the vector sizes relative to SSE." ${_force})
-      set(USE_XOP    ${XOP_FOUND}    CACHE BOOL "Use XOP." ${_force})
-      set(USE_FMA4   ${FMA4_FOUND}   CACHE BOOL "Use FMA4." ${_force})
-      mark_as_advanced(USE_SSE2 USE_SSE3 USE_SSSE3 USE_SSE4_1 USE_SSE4_2 USE_SSE4a USE_AVX USE_XOP USE_FMA4)
-      if(USE_SSE2)
-         list(APPEND _enable_vector_unit_list "sse2")
-      else(USE_SSE2)
-         list(APPEND _disable_vector_unit_list "sse2")
-      endif(USE_SSE2)
-      if(USE_SSE3)
-         list(APPEND _enable_vector_unit_list "sse3")
-      else(USE_SSE3)
-         list(APPEND _disable_vector_unit_list "sse3")
-      endif(USE_SSE3)
-      if(USE_SSSE3)
-         list(APPEND _enable_vector_unit_list "ssse3")
-      else(USE_SSSE3)
-         list(APPEND _disable_vector_unit_list "ssse3")
-      endif(USE_SSSE3)
-      if(USE_SSE4_1)
-         list(APPEND _enable_vector_unit_list "sse4.1")
-      else(USE_SSE4_1)
-         list(APPEND _disable_vector_unit_list "sse4.1")
-      endif(USE_SSE4_1)
-      if(USE_SSE4_2)
-         list(APPEND _enable_vector_unit_list "sse4.2")
-      else(USE_SSE4_2)
-         list(APPEND _disable_vector_unit_list "sse4.2")
-      endif(USE_SSE4_2)
-      if(USE_SSE4a)
-         list(APPEND _enable_vector_unit_list "sse4a")
-      else(USE_SSE4a)
-         list(APPEND _disable_vector_unit_list "sse4a")
-      endif(USE_SSE4a)
-      if(USE_AVX)
-         list(APPEND _enable_vector_unit_list "avx")
-         # we want SSE intrinsics to result in instructions using the VEX prefix.
-         # Otherwise integer ops (which require the older SSE intrinsics) would
-         # always have a large penalty.
-         list(APPEND _enable_vector_unit_list "sse2avx")
-      else(USE_AVX)
-         list(APPEND _disable_vector_unit_list "avx")
-      endif(USE_AVX)
-      if(USE_XOP)
-         list(APPEND _enable_vector_unit_list "xop")
-      else()
-         list(APPEND _disable_vector_unit_list "xop")
-      endif()
-      if(USE_FMA4)
-         list(APPEND _enable_vector_unit_list "fma4")
-      else()
-         list(APPEND _disable_vector_unit_list "fma4")
-      endif()
+
+      macro(_enable_or_disable _name _flag _documentation _broken)
+         if(_broken)
+            set(_found false)
+         else()
+            _my_find(_available_vector_units_list "${_flag}" _found)
+         endif()
+         set(USE_${_name} ${_found} CACHE BOOL "${documentation}" ${_force})
+         mark_as_advanced(USE_${_name})
+         if(USE_${_name})
+            list(APPEND _enable_vector_unit_list "${_flag}")
+         else()
+            list(APPEND _disable_vector_unit_list "${_flag}")
+         endif()
+      endmacro()
+      _enable_or_disable(SSE2 "sse2" "Use SSE2. If SSE2 instructions are not enabled the SSE implementation will be disabled." false)
+      _enable_or_disable(SSE3 "sse3" "Use SSE3. If SSE3 instructions are not enabled they will be emulated." false)
+      _enable_or_disable(SSSE3 "ssse3" "Use SSSE3. If SSSE3 instructions are not enabled they will be emulated." false)
+      _enable_or_disable(SSE4_1 "sse4.1" "Use SSE4.1. If SSE4.1 instructions are not enabled they will be emulated." false)
+      _enable_or_disable(SSE4_2 "sse4.2" "Use SSE4.2. If SSE4.2 instructions are not enabled they will be emulated." false)
+      _enable_or_disable(SSE4a "sse4a" "Use SSE4a. If SSE4a instructions are not enabled they will be emulated." false)
+      _enable_or_disable(AVX "avx" "Use AVX. This will all floating-point vector sizes relative to SSE." _avx_broken)
+      _enable_or_disable(FMA "fma" "Use FMA." _avx_broken)
+      _enable_or_disable(BMI2 "bmi2" "Use BMI2." _avx_broken)
+      _enable_or_disable(AVX2 "avx2" "Use AVX2. This will double all of the vector sizes relative to SSE." _avx2_broken)
+      _enable_or_disable(XOP "xop" "Use XOP." _xop_broken)
+      _enable_or_disable(FMA4 "fma4" "Use FMA4." _fma4_broken)
+      _enable_or_disable(AVX512F "avx512f" "Use AVX512F. This will double all floating-point vector sizes relative to AVX2." false)
+      _enable_or_disable(AVX512VL "avx512vl" "Use AVX512VL. This enables 128- and 256-bit vector length instructions with EVEX coding (improved write-masking & more vector registers)." _avx2_broken)
+      _enable_or_disable(AVX512PF "avx512pf" "Use AVX512PF. This enables prefetch instructions for gathers and scatters." false)
+      _enable_or_disable(AVX512ER "avx512er" "Use AVX512ER. This enables exponential and reciprocal instructions." false)
+      _enable_or_disable(AVX512CD "avx512cd" "Use AVX512CD." false)
+      _enable_or_disable(AVX512DQ "avx512dq" "Use AVX512DQ." false)
+      _enable_or_disable(AVX512BW "avx512bw" "Use AVX512BW." false)
+      _enable_or_disable(AVX512IFMA "avx512ifma" "Use AVX512IFMA." false)
+      _enable_or_disable(AVX512VBMI "avx512vbmi" "Use AVX512VBMI." false)
+
       if(MSVC)
          # MSVC on 32 bit can select /arch:SSE2 (since 2010 also /arch:AVX)
          # MSVC on 64 bit cannot select anything (should have changed with MSVC 2010)
-         _my_find(_enable_vector_unit_list "avx" _avx)
-         set(_avx_flag FALSE)
-         if(_avx)
-            AddCompilerFlag("/arch:AVX" CXX_FLAGS Vc_ARCHITECTURE_FLAGS CXX_RESULT _avx_flag)
+         _my_find(_enable_vector_unit_list "avx2" _found)
+         if(_found)
+            AddCompilerFlag("/arch:AVX2" CXX_FLAGS Vc_ARCHITECTURE_FLAGS CXX_RESULT _found)
          endif()
-         if(NOT _avx_flag)
+         if(NOT _found)
+            _my_find(_enable_vector_unit_list "avx" _found)
+            if(_found)
+               AddCompilerFlag("/arch:AVX" CXX_FLAGS Vc_ARCHITECTURE_FLAGS CXX_RESULT _found)
+            endif()
+         endif()
+         if(NOT _found)
             _my_find(_enable_vector_unit_list "sse2" _found)
             if(_found)
                AddCompilerFlag("/arch:SSE2" CXX_FLAGS Vc_ARCHITECTURE_FLAGS)
@@ -435,6 +514,8 @@
                   set(_header "ammintrin.h")
                elseif(_flag STREQUAL "avx")
                   set(_header "immintrin.h")
+               elseif(_flag STREQUAL "avx2")
+                  set(_header "immintrin.h")
                elseif(_flag STREQUAL "fma4")
                   set(_header "x86intrin.h")
                elseif(_flag STREQUAL "xop")
@@ -443,7 +524,7 @@
                set(_resultVar "HAVE_${_header}")
                string(REPLACE "." "_" _resultVar "${_resultVar}")
                if(_header)
-                  CHECK_INCLUDE_FILE("${_header}" ${_resultVar} "-m${_flag}")
+                  CHECK_INCLUDE_FILE_CXX("${_header}" ${_resultVar} "-m${_flag}")
                   if(NOT ${_resultVar})
                      set(_useVar "USE_${_flag}")
                      string(TOUPPER "${_useVar}" _useVar)
@@ -454,7 +535,7 @@
                   endif()
                endif()
                if(NOT _header OR ${_resultVar})
-                  set(Vc_ARCHITECTURE_FLAGS "${Vc_ARCHITECTURE_FLAGS} -m${_flag}")
+                  list(APPEND Vc_ARCHITECTURE_FLAGS "-m${_flag}")
                endif()
             endif()
          endforeach(_flag)
diff -Nru vc-0.7.4/cmake/VcConfig.cmake.in vc-1.3.0/cmake/VcConfig.cmake.in
--- vc-0.7.4/cmake/VcConfig.cmake.in	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/VcConfig.cmake.in	2016-10-27 02:05:02.000000000 -0500
@@ -6,13 +6,27 @@
 
 set(Vc_INSTALL_DIR "@CMAKE_INSTALL_PREFIX@")
 
-set(Vc_LIB_DIR              "@CMAKE_INSTALL_PREFIX@/lib")
-set(Vc_INCLUDE_DIR          "@CMAKE_INSTALL_PREFIX@/include")
-set(Vc_CMAKE_MODULES_DIR    "@CMAKE_INSTALL_PREFIX@/lib/cmake/Vc")
+set(Vc_LIB_DIR              "@CMAKE_INSTALL_PREFIX@/lib@LIB_SUFFIX@")
+find_path(Vc_INCLUDE_DIR       Vc/global.h HINTS "@CMAKE_INSTALL_PREFIX@/include")
+find_path(Vc_CMAKE_MODULES_DIR AddCompilerFlag.cmake HINTS "${Vc_LIB_DIR}/cmake/Vc")
+list(APPEND CMAKE_MODULE_PATH "${Vc_CMAKE_MODULES_DIR}")
 
 find_library(Vc_LIBRARIES Vc PATHS "${Vc_LIB_DIR}" NO_DEFAULT_PATH)
+find_library(Vc_MIC_LIBRARIES Vc_MIC PATHS "${Vc_LIB_DIR}" NO_DEFAULT_PATH)
 
 include("${Vc_CMAKE_MODULES_DIR}/VcMacros.cmake")
 
 set(Vc_DEFINITIONS)
+set(Vc_COMPILE_FLAGS)
+set(Vc_ARCHITECTURE_FLAGS)
 vc_set_preferred_compiler_flags()
+separate_arguments(Vc_ALL_FLAGS UNIX_COMMAND "${Vc_DEFINITIONS}")
+list(APPEND Vc_ALL_FLAGS ${Vc_COMPILE_FLAGS})
+list(APPEND Vc_ALL_FLAGS ${Vc_ARCHITECTURE_FLAGS})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Vc
+   FOUND_VAR Vc_FOUND
+   REQUIRED_VARS Vc_LIBRARIES Vc_INCLUDE_DIR Vc_CMAKE_MODULES_DIR
+   VERSION_VAR Vc_VERSION
+   )
diff -Nru vc-0.7.4/cmake/VcMacros.cmake vc-1.3.0/cmake/VcMacros.cmake
--- vc-0.7.4/cmake/VcMacros.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/cmake/VcMacros.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -5,7 +5,7 @@
 # vc_set_preferred_compiler_flags
 #
 #=============================================================================
-# Copyright 2009-2013   Matthias Kretz <kretz@kde.org>
+# Copyright 2009-2015   Matthias Kretz <kretz@kde.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -13,15 +13,12 @@
 #
 #  * Redistributions of source code must retain the above copyright notice,
 #    this list of conditions and the following disclaimer.
-#
 #  * Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
-#
-#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-#    any consortium members, or of any contributors, may not be used to
-#    endorse or promote products derived from this software without
-#    specific prior written permission.
+#  * Neither the names of contributing organizations nor the
+#    names of its contributors may be used to endorse or promote products
+#    derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -52,8 +49,13 @@
       set(Vc_COMPILER_IS_GCC false)
       if(CMAKE_CXX_COMPILER MATCHES "/(icpc|icc)$")
          set(Vc_COMPILER_IS_INTEL true)
-         exec_program(${CMAKE_C_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE Vc_ICC_VERSION)
+         exec_program(${CMAKE_CXX_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE Vc_ICC_VERSION)
          message(STATUS "Detected Compiler: Intel ${Vc_ICC_VERSION}")
+
+         # break build with too old clang as early as possible.
+         if(Vc_ICC_VERSION VERSION_LESS 15.0.3)
+            message(FATAL_ERROR "Vc 1.x requires C++11 support. This requires at least ICC 15.0.3")
+         endif()
       elseif(CMAKE_CXX_COMPILER MATCHES "(opencc|openCC)$")
          set(Vc_COMPILER_IS_OPEN64 true)
          message(STATUS "Detected Compiler: Open64")
@@ -62,43 +64,60 @@
          exec_program(${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE Vc_CLANG_VERSION)
          string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" Vc_CLANG_VERSION "${Vc_CLANG_VERSION}")
          message(STATUS "Detected Compiler: Clang ${Vc_CLANG_VERSION}")
+
+         # break build with too old clang as early as possible.
+         if(Vc_CLANG_VERSION VERSION_LESS 3.4)
+            message(FATAL_ERROR "Vc 1.x requires C++11 support. This requires at least clang 3.4")
+         endif()
       elseif(MSVC)
          set(Vc_COMPILER_IS_MSVC true)
-         message(STATUS "Detected Compiler: MSVC ${MSVC_VERSION}")
+         execute_process(COMMAND ${CMAKE_CXX_COMPILER} /nologo -EP "${_currentDir}/msvc_version.c" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE Vc_MSVC_VERSION)
+         string(STRIP "${Vc_MSVC_VERSION}" Vc_MSVC_VERSION)
+         string(REPLACE "MSVC " "" Vc_MSVC_VERSION "${Vc_MSVC_VERSION}")
+         message(STATUS "Detected Compiler: MSVC ${Vc_MSVC_VERSION}")
       elseif(CMAKE_COMPILER_IS_GNUCXX)
          set(Vc_COMPILER_IS_GCC true)
-         exec_program(${CMAKE_C_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE Vc_GCC_VERSION)
+         exec_program(${CMAKE_CXX_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE Vc_GCC_VERSION)
          message(STATUS "Detected Compiler: GCC ${Vc_GCC_VERSION}")
 
          # some distributions patch their GCC to return nothing or only major and minor version on -dumpversion.
          # In that case we must extract the version number from --version.
          if(NOT Vc_GCC_VERSION OR Vc_GCC_VERSION MATCHES "^[0-9]\\.[0-9]+$")
-            exec_program(${CMAKE_C_COMPILER} ARGS --version OUTPUT_VARIABLE Vc_GCC_VERSION)
+            exec_program(${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE Vc_GCC_VERSION)
             string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" Vc_GCC_VERSION "${Vc_GCC_VERSION}")
             message(STATUS "GCC Version from --version: ${Vc_GCC_VERSION}")
          endif()
 
          # some distributions patch their GCC to be API incompatible to what the FSF released. In
          # those cases we require a macro to identify the distribution version
-         find_program(_lsb_release lsb_release)
-         mark_as_advanced(_lsb_release)
-         if(_lsb_release)
-            execute_process(COMMAND ${_lsb_release} -is OUTPUT_VARIABLE _distributor_id OUTPUT_STRIP_TRAILING_WHITESPACE)
-            execute_process(COMMAND ${_lsb_release} -rs OUTPUT_VARIABLE _distributor_release OUTPUT_STRIP_TRAILING_WHITESPACE)
-            string(TOUPPER "${_distributor_id}" _distributor_id)
-            if(_distributor_id STREQUAL "UBUNTU")
-               execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE _gcc_version)
+         find_program(Vc_lsb_release lsb_release)
+         mark_as_advanced(Vc_lsb_release)
+         if(Vc_lsb_release)
+            if(NOT Vc_distributor_id)
+              execute_process(COMMAND ${Vc_lsb_release} -is OUTPUT_VARIABLE Vc_distributor_id OUTPUT_STRIP_TRAILING_WHITESPACE)
+              string(TOUPPER "${Vc_distributor_id}" Vc_distributor_id)
+              set(Vc_distributor_id "${Vc_distributor_id}" CACHE STRING "lsb distribution id")
+              execute_process(COMMAND ${Vc_lsb_release} -rs OUTPUT_VARIABLE Vc_distributor_release OUTPUT_STRIP_TRAILING_WHITESPACE)
+              set(Vc_distributor_release "${Vc_distributor_release}" CACHE STRING "lsb release id")
+            endif()
+            if(Vc_distributor_id STREQUAL "UBUNTU")
+               execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE _gcc_version)
                string(REGEX MATCH "\\(.* ${Vc_GCC_VERSION}-([0-9]+).*\\)" _tmp "${_gcc_version}")
                if(_tmp)
                   set(_patch ${CMAKE_MATCH_1})
-                  string(REGEX MATCH "^([0-9]+)\\.([0-9]+)$" _tmp "${_distributor_release}")
+                  string(REGEX MATCH "^([0-9]+)\\.([0-9]+)$" _tmp "${Vc_distributor_release}")
                   execute_process(COMMAND printf 0x%x%02x%02x ${CMAKE_MATCH_1} ${CMAKE_MATCH_2} ${_patch} OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE _tmp)
                   set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -D__GNUC_UBUNTU_VERSION__=${_tmp}")
                endif()
             endif()
          endif()
+
+         # break build with too old GCC as early as possible.
+         if(Vc_GCC_VERSION VERSION_LESS 4.8.1)
+            message(FATAL_ERROR "Vc 1.x requires C++11 support. This requires at least GCC 4.8.1")
+         endif()
       else()
-         message(WARNING "Untested/-supported Compiler for use with Vc.\nPlease fill out the missing parts in the CMake scripts and submit a patch to http://code.compeng.uni-frankfurt.de/projects/vc")
+         message(WARNING "Untested/-supported Compiler (${CMAKE_CXX_COMPILER}) for use with Vc.\nPlease fill out the missing parts in the CMake scripts and submit a patch to http://code.compeng.uni-frankfurt.de/projects/vc")
       endif()
    endif()
 endmacro()
@@ -128,47 +147,24 @@
 endmacro()
 
 macro(vc_check_assembler)
-   if(APPLE)
-      if(NOT Vc_COMPILER_IS_CLANG)
-         message(WARNING "Apple does not provide an assembler with AVX support. AVX will not be available. Please use Clang if you want to use AVX.")
-         set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DVC_NO_XGETBV")
+   exec_program(${CMAKE_CXX_COMPILER} ARGS -print-prog-name=as OUTPUT_VARIABLE _as)
+   mark_as_advanced(_as)
+   if(NOT _as)
+      message(WARNING "Could not find 'as', the assembler used by GCC. Hoping everything will work out...")
+   else()
+      exec_program(${_as} ARGS --version OUTPUT_VARIABLE _as_version)
+      string(REGEX REPLACE "\\([^\\)]*\\)" "" _as_version "${_as_version}")
+      string(REGEX MATCH "[1-9]\\.[0-9]+(\\.[0-9]+)?" _as_version "${_as_version}")
+      if(_as_version VERSION_LESS "2.18.93")
+         UserWarning("Your binutils is too old (${_as_version}). Some optimizations of Vc will be disabled.")
+         set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DVc_NO_XGETBV") # old assembler doesn't know the xgetbv instruction
          set(Vc_AVX_INTRINSICS_BROKEN true)
-      endif()
-   else(APPLE)
-      if(${ARGC} EQUAL 1)
-         set(_as "${ARGV1}")
-      else()
-         exec_program(${CMAKE_CXX_COMPILER} ARGS -print-prog-name=as OUTPUT_VARIABLE _as)
-         mark_as_advanced(_as)
-      endif()
-      if(NOT _as)
-         message(WARNING "Could not find 'as', the assembler used by GCC. Hoping everything will work out...")
-      else()
-         exec_program(${_as} ARGS --version OUTPUT_VARIABLE _as_version)
-         string(REGEX REPLACE "\\([^\\)]*\\)" "" _as_version "${_as_version}")
-         string(REGEX MATCH "[1-9]\\.[0-9]+(\\.[0-9]+)?" _as_version "${_as_version}")
-         if(_as_version VERSION_LESS "2.18.93")
-            UserWarning("Your binutils is too old (${_as_version}). Some optimizations of Vc will be disabled.")
-            add_definitions(-DVC_NO_XGETBV) # old assembler doesn't know the xgetbv instruction
-            set(Vc_AVX_INTRINSICS_BROKEN true)
-            set(Vc_XOP_INTRINSICS_BROKEN true)
-            set(Vc_FMA4_INTRINSICS_BROKEN true)
-         elseif(_as_version VERSION_LESS "2.21.0")
-            UserWarning("Your binutils is too old (${_as_version}) for XOP instructions. They will therefore not be provided in libVc.")
-            set(Vc_XOP_INTRINSICS_BROKEN true)
-         endif()
-      endif()
-   endif(APPLE)
-endmacro()
-
-macro(vc_check_fpmath)
-   # if compiling for 32 bit x86 we need to use the -mfpmath=sse since the x87 is broken by design
-   include (CheckCXXSourceRuns)
-   check_cxx_source_runs("int main() { return sizeof(void*) != 8; }" Vc_VOID_PTR_IS_64BIT)
-   if(NOT Vc_VOID_PTR_IS_64BIT)
-      exec_program(${CMAKE_C_COMPILER} ARGS -dumpmachine OUTPUT_VARIABLE _gcc_machine)
-      if(_gcc_machine MATCHES "[x34567]86" OR _gcc_machine STREQUAL "mingw32")
-         vc_add_compiler_flag(Vc_DEFINITIONS "-mfpmath=sse")
+         set(Vc_XOP_INTRINSICS_BROKEN true)
+         set(Vc_FMA4_INTRINSICS_BROKEN true)
+      elseif(_as_version VERSION_LESS "2.21.0")
+         UserWarning("Your binutils is too old (${_as_version}) for XOP and AVX2 instructions. They will therefore not be provided in libVc.")
+         set(Vc_XOP_INTRINSICS_BROKEN true)
+         set(Vc_AVX2_INTRINSICS_BROKEN true)
       endif()
    endif()
 endmacro()
@@ -188,6 +184,7 @@
 
    set(Vc_SSE_INTRINSICS_BROKEN false)
    set(Vc_AVX_INTRINSICS_BROKEN false)
+   set(Vc_AVX2_INTRINSICS_BROKEN false)
    set(Vc_XOP_INTRINSICS_BROKEN false)
    set(Vc_FMA4_INTRINSICS_BROKEN false)
 
@@ -208,7 +205,6 @@
          AddCompilerFlag("-Wpointer-arith")
          AddCompilerFlag("-Wcast-align")
          AddCompilerFlag("-Wreturn-type")
-         AddCompilerFlag("-ansi")
          AddCompilerFlag("-pedantic")
          AddCompilerFlag("-Wno-long-long")
          AddCompilerFlag("-Wshadow")
@@ -223,78 +219,40 @@
 
       # Open64 4.5.1 still doesn't ship immintrin.h
       set(Vc_AVX_INTRINSICS_BROKEN true)
+      set(Vc_AVX2_INTRINSICS_BROKEN true)
    elseif(Vc_COMPILER_IS_GCC)
       ##################################################################################################
       #                                              GCC                                               #
       ##################################################################################################
       if(_add_warning_flags)
-         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -W -Wall -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wcast-align -Wreturn-type -pedantic -Wno-long-long -Wshadow")
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wall -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wcast-align -Wreturn-type -pedantic -Wno-long-long -Wshadow")
-         if(NOT WIN32)
-            # the -ansi flag makes MinGW unusable, so maybe it's better to omit it
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ansi")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi")
-         endif()
-         AddCompilerFlag("-Wundef")
-         AddCompilerFlag("-Wold-style-cast")
-         AddCompilerFlag("-Wno-variadic-macros")
-         if(Vc_GCC_VERSION VERSION_GREATER "4.5.2" AND Vc_GCC_VERSION VERSION_LESS "4.6.4")
-            # GCC gives bogus "array subscript is above array bounds" warnings in math.cpp
-            AddCompilerFlag("-Wno-array-bounds")
-         endif()
+         foreach(_f -W -Wall -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wcast-align -Wreturn-type -pedantic -Wshadow -Wundef)
+            AddCompilerFlag("${_f}")
+         endforeach()
+         foreach(_f -Wold-style-cast)
+            AddCompilerFlag("${_f}" CXX_FLAGS CMAKE_CXX_FLAGS)
+         endforeach()
       endif()
-      vc_add_compiler_flag(Vc_DEFINITIONS "-Wabi")
-      vc_add_compiler_flag(Vc_DEFINITIONS "-fabi-version=0") # ABI version 4 is required to make __m128 and __m256 appear as different types. 0 should give us the latest version.
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-Wabi")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-fabi-version=0") # ABI version 4 is required to make __m128 and __m256 appear as different types. 0 should give us the latest version.
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-fabi-compat-version=0") # GCC 5 introduced this switch
+      # and defaults it to 2 if -fabi-version is 0. But in that case the bug -fabi-version=0 is
+      # supposed to fix resurfaces. For now just make sure that it compiles and links.
+      # Bug report pending.
 
       if(_add_buildtype_flags)
          vc_set_gnu_buildtype_flags()
       endif()
 
-      # GCC 4.5.[01] fail at inlining some functions, creating functions with a single instructions,
-      # thus creating a large overhead.
-      if(Vc_GCC_VERSION VERSION_LESS "4.5.2" AND NOT Vc_GCC_VERSION VERSION_LESS "4.5.0")
-         UserWarning("GCC 4.5.0 and 4.5.1 have problems with inlining correctly. Setting early-inlining-insns=12 as workaround.")
-         AddCompilerFlag("--param early-inlining-insns=12")
-      endif()
-
-      if(Vc_GCC_VERSION VERSION_LESS "4.1.99")
-         UserWarning("Your GCC is ancient and crashes on some important optimizations.  The full set of SSE2 intrinsics is not supported.  Vc will fall back to the scalar implementation.  Use of the may_alias and always_inline attributes will be disabled.  In turn all code using Vc must be compiled with -fno-strict-aliasing")
-         vc_add_compiler_flag(Vc_DEFINITIONS "-fno-strict-aliasing")
-         set(Vc_AVX_INTRINSICS_BROKEN true)
-         set(Vc_SSE_INTRINSICS_BROKEN true)
-      elseif(Vc_GCC_VERSION VERSION_LESS "4.4.6")
-         UserWarning("Your GCC is older than 4.4.6. This is known to cause problems/bugs. Please update to the latest GCC if you can.")
-         set(Vc_AVX_INTRINSICS_BROKEN true)
-         if(Vc_GCC_VERSION VERSION_LESS "4.3.0")
-            UserWarning("Your GCC is older than 4.3.0. It is unable to handle the full set of SSE2 intrinsics. All SSE code will be disabled. Please update to the latest GCC if you can.")
-            set(Vc_SSE_INTRINSICS_BROKEN true)
-         endif()
-      endif()
-
-      if(Vc_GCC_VERSION VERSION_LESS 4.5.0)
-         UserWarning("GCC 4.4.x shows false positives for -Wparentheses, thus we rather disable the warning.")
-         string(REPLACE " -Wparentheses " " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-         string(REPLACE " -Wparentheses " " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-         set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -Wno-parentheses")
-
-         UserWarning("GCC 4.4.x shows false positives for -Wstrict-aliasing, thus we rather disable the warning. Use a newer GCC for better warnings.")
-         AddCompilerFlag("-Wno-strict-aliasing")
-
-         UserWarning("GCC 4.4.x shows false positives for -Wuninitialized, thus we rather disable the warning. Use a newer GCC for better warnings.")
-         AddCompilerFlag("-Wno-uninitialized")
-      elseif(Vc_GCC_VERSION VERSION_EQUAL 4.6.0)
-         UserWarning("GCC 4.6.0 miscompiles AVX loads/stores, leading to spurious segfaults. Disabling AVX per default.")
-         set(Vc_AVX_INTRINSICS_BROKEN true)
-      elseif(Vc_GCC_VERSION VERSION_EQUAL 4.7.0)
-         UserWarning("GCC 4.7.0 miscompiles at -O3, adding -fno-predictive-commoning to the compiler flags as workaround")
-         set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -fno-predictive-commoning")
-      elseif(Vc_GCC_VERSION VERSION_EQUAL 4.8.0)
-         UserWarning("GCC 4.8.0 miscompiles at -O3, adding -fno-tree-vectorize to the compiler flags as workaround")
-         set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -fno-tree-vectorize")
+      if(APPLE)
+         # The GNU assembler (as) on Mac OS X is hopelessly outdated. The -q flag
+         # to as tells it to use the clang assembler, though, which is fine.
+         # -Wa,-q tells GCC to pass -q to as.
+         vc_add_compiler_flag(Vc_COMPILE_FLAGS "-Wa,-q")
+         # Apparently the MacOS clang assember doesn't understand XOP instructions.
+         set(Vc_XOP_INTRINSICS_BROKEN true)
+      else()
+         vc_check_assembler()
       endif()
-
-      vc_check_fpmath()
-      vc_check_assembler()
    elseif(Vc_COMPILER_IS_INTEL)
       ##################################################################################################
       #                                          Intel Compiler                                        #
@@ -305,32 +263,36 @@
          set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DNDEBUG -O3")
          set(CMAKE_C_FLAGS_RELEASE          "${CMAKE_C_FLAGS_RELEASE} -O3")
          set(CMAKE_C_FLAGS_RELWITHDEBINFO   "${CMAKE_C_FLAGS_RELWITHDEBINFO} -DNDEBUG -O3")
-
-         set(ALIAS_FLAGS "-no-ansi-alias")
-         if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-            # default ICC to -no-ansi-alias because otherwise tests/utils_sse fails. So far I suspect a miscompilation...
-            set(ENABLE_STRICT_ALIASING false CACHE BOOL "Enables strict aliasing rules for more aggressive optimizations")
-            if(ENABLE_STRICT_ALIASING)
-               set(ALIAS_FLAGS "-ansi-alias")
-            endif(ENABLE_STRICT_ALIASING)
-         endif()
-         set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   ${ALIAS_FLAGS}")
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ALIAS_FLAGS}")
       endif()
-      vc_add_compiler_flag(Vc_DEFINITIONS "-diag-disable 913")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 913")
       # Disable warning #13211 "Immediate parameter to intrinsic call too large". (sse/vector.tcc rotated(int))
-      vc_add_compiler_flag(Vc_DEFINITIONS "-diag-disable 13211")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 13211")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 61") # warning #61: integer operation result is out of range
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 173") # warning #173: floating-point value does not fit in required integral type
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 264") # warning #264: floating-point value does not fit in required floating-point type
+      if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+         set(ENABLE_STRICT_ALIASING true CACHE BOOL "Enables strict aliasing rules for more aggressive optimizations")
+         if(ENABLE_STRICT_ALIASING)
+            AddCompilerFlag(-ansi-alias CXX_FLAGS Vc_COMPILE_FLAGS)
+         else()
+            AddCompilerFlag(-no-ansi-alias CXX_FLAGS Vc_COMPILE_FLAGS)
+         endif()
+      endif()
 
       if(NOT "$ENV{DASHBOARD_TEST_FROM_CTEST}" STREQUAL "")
          # disable warning #2928: the __GXX_EXPERIMENTAL_CXX0X__ macro is disabled when using GNU version 4.6 with the c++0x option
          # this warning just adds noise about problems in the compiler - but I'm only interested in seeing problems in Vc
-         vc_add_compiler_flag(Vc_DEFINITIONS "-diag-disable 2928")
+         vc_add_compiler_flag(Vc_COMPILE_FLAGS "-diag-disable 2928")
       endif()
 
       # Intel doesn't implement the XOP or FMA4 intrinsics
       set(Vc_XOP_INTRINSICS_BROKEN true)
       set(Vc_FMA4_INTRINSICS_BROKEN true)
    elseif(Vc_COMPILER_IS_MSVC)
+      ##################################################################################################
+      #                                      Microsoft Visual Studio                                   #
+      ##################################################################################################
+
       if(_add_warning_flags)
          AddCompilerFlag("/wd4800") # Disable warning "forcing value to bool"
          AddCompilerFlag("/wd4996") # Disable warning about strdup vs. _strdup
@@ -341,116 +303,95 @@
          AddCompilerFlag("/wd4748") # Disable warning "/GS can not protect parameters and local variables from local buffer overrun because optimizations are disabled in function" (I don't get it)
          add_definitions(-D_CRT_SECURE_NO_WARNINGS)
       endif()
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "/Gv") # default to __vectorcall
 
-      # MSVC does not support inline assembly on 64 bit! :(
-      # searching the help for xgetbv doesn't turn up anything. So just fall back to not supporting AVX on Windows :(
-      # TODO: apparently MSVC 2010 SP1 added _xgetbv
-      set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DVC_NO_XGETBV")
-
-      # get rid of the min/max macros
-      set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DNOMINMAX")
-
-      # MSVC doesn't implement the XOP or FMA4 intrinsics
-      set(Vc_XOP_INTRINSICS_BROKEN true)
-      set(Vc_FMA4_INTRINSICS_BROKEN true)
-
-      if(MSVC_VERSION LESS 1700)
-         UserWarning("MSVC before 2012 has a broken std::vector::resize implementation. STL + Vc code will probably not compile.")
+      if(MSVC_VERSION LESS 1900)
+         UserWarning("MSVC before 2015 does not support enough of C++11")
       endif()
    elseif(Vc_COMPILER_IS_CLANG)
-      # for now I don't know of any arguments I want to pass. -march and stuff is tried by OptimizeForArchitecture...
-      if(Vc_CLANG_VERSION VERSION_EQUAL "3.0")
-         UserWarning("Clang 3.0 has serious issues to compile Vc code and will most likely crash when trying to do so.\nPlease update to a recent clang version.")
-      elseif(Vc_CLANG_VERSION VERSION_EQUAL "3.2" AND NOT APPLE)
-         # the LLVM assembler gets FMAs wrong (bug 15040)
-         vc_add_compiler_flag(Vc_DEFINITIONS "-no-integrated-as")
+      ##################################################################################################
+      #                                              Clang                                             #
+      ##################################################################################################
+
+      if(Vc_CLANG_VERSION VERSION_GREATER "3.5.99" AND Vc_CLANG_VERSION VERSION_LESS 3.7.0)
+         UserWarning("Clang 3.6 has serious issues with AVX code generation, frequently losing 50% of the data. AVX is therefore disabled.\nPlease update to a more recent clang version.\n")
+         set(Vc_AVX_INTRINSICS_BROKEN true)
+         set(Vc_AVX2_INTRINSICS_BROKEN true)
       endif()
 
       # disable these warnings because clang shows them for function overloads that were discarded via SFINAE
-      vc_add_compiler_flag(Vc_DEFINITIONS "-Wno-local-type-template-args")
-      vc_add_compiler_flag(Vc_DEFINITIONS "-Wno-unnamed-type-template-args")
-
-      if(NOT DEFINED Vc_INSIDE_ROOT)  # ROOT has to set this up
-         AddCompilerFlag(-stdlib=libc++)
-      endif()
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-Wno-local-type-template-args")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-Wno-unnamed-type-template-args")
    endif()
 
    if(NOT Vc_COMPILER_IS_MSVC)
-      vc_add_compiler_flag(Vc_DEFINITIONS "-ffp-contract=fast")
+      vc_add_compiler_flag(Vc_COMPILE_FLAGS "-ffp-contract=fast")
    endif()
 
    OptimizeForArchitecture()
-   set(Vc_DEFINITIONS "${Vc_ARCHITECTURE_FLAGS} ${Vc_DEFINITIONS}")
-
-   set(VC_IMPL "auto" CACHE STRING "Force the Vc implementation globally to the selected instruction set. \"auto\" lets Vc use the best available instructions.")
-   if(NOT VC_IMPL STREQUAL "auto")
-      set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DVC_IMPL=${VC_IMPL}")
-      if(NOT VC_IMPL STREQUAL "Scalar")
-         set(_use_var "USE_${VC_IMPL}")
-         if(VC_IMPL STREQUAL "SSE")
+   set(Vc_IMPL "auto" CACHE STRING "Force the Vc implementation globally to the selected instruction set. \"auto\" lets Vc use the best available instructions.")
+   if(NOT Vc_IMPL STREQUAL "auto")
+      set(Vc_DEFINITIONS "${Vc_DEFINITIONS} -DVc_IMPL=${Vc_IMPL}")
+      if(NOT Vc_IMPL STREQUAL "Scalar")
+         set(_use_var "USE_${Vc_IMPL}")
+         if(Vc_IMPL STREQUAL "SSE")
             set(_use_var "USE_SSE2")
          endif()
          if(NOT ${_use_var})
-            message(WARNING "The selected value for VC_IMPL (${VC_IMPL}) will not work because the relevant instructions are not enabled via compiler flags.")
+            message(WARNING "The selected value for Vc_IMPL (${Vc_IMPL}) will not work because the relevant instructions are not enabled via compiler flags.")
          endif()
       endif()
    endif()
 endmacro()
 
 # helper macro for vc_compile_for_all_implementations
-macro(_vc_compile_one_implementation _objs _impl)
+macro(_vc_compile_one_implementation _srcs _impl)
    list(FIND _disabled_targets "${_impl}" _disabled_index)
    list(FIND _only_targets "${_impl}" _only_index)
    if(${_disabled_index} EQUAL -1 AND (NOT _only_targets OR ${_only_index} GREATER -1))
       set(_extra_flags)
       set(_ok FALSE)
-      foreach(_flag ${ARGN})
-         if(_flag STREQUAL "NO_FLAG")
+      foreach(_flags_it ${ARGN})
+         if(_flags_it STREQUAL "NO_FLAG")
             set(_ok TRUE)
             break()
          endif()
-         string(REPLACE " " ";" _flag_list "${_flag}")
-         foreach(_flag ${_flag_list})
-            AddCompilerFlag(${_flag} CXX_RESULT _ok)
+         string(REPLACE " " ";" _flag_list "${_flags_it}")
+         foreach(_f ${_flag_list})
+            AddCompilerFlag(${_f} CXX_RESULT _ok)
             if(NOT _ok)
                break()
             endif()
          endforeach()
          if(_ok)
-            set(_extra_flags ${_flag_list})
+            set(_extra_flags ${_flags_it})
             break()
          endif()
       endforeach()
 
-      set(_outfile_flag -c -o)
       if(Vc_COMPILER_IS_MSVC)
          # MSVC for 64bit does not recognize /arch:SSE2 anymore. Therefore we set override _ok if _impl
          # says SSE
          if("${_impl}" MATCHES "SSE")
             set(_ok TRUE)
          endif()
-         set(_outfile_flag /c /Fo)
       endif()
 
       if(_ok)
          get_filename_component(_out "${_vc_compile_src}" NAME_WE)
          get_filename_component(_ext "${_vc_compile_src}" EXT)
-         if(Vc_COMPILER_IS_MSVC)
-            set(_out "${_out}_${_impl}${_ext}.obj")
-         else()
-            set(_out "${_out}_${_impl}${_ext}.o")
-         endif()
-         add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_out}
-            COMMAND ${CMAKE_CXX_COMPILER} ${_flags} ${_extra_flags}
-            -DVC_IMPL=${_impl}
-            ${_outfile_flag}${_out} ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src}
-            MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src}
-            IMPLICIT_DEPENDS CXX ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src}
-            COMMENT "Building CXX object ${_out}"
-            WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-            VERBATIM
-            )
-         list(APPEND ${_objs} "${CMAKE_CURRENT_BINARY_DIR}/${_out}")
+         set(_out "${CMAKE_CURRENT_BINARY_DIR}/${_out}_${_impl}${_ext}")
+         add_custom_command(OUTPUT "${_out}"
+            COMMAND ${CMAKE_COMMAND} -E copy "${_vc_compile_src}" "${_out}"
+            DEPENDS "${_vc_compile_src}"
+            COMMENT "Copy to ${_out}"
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            VERBATIM)
+         set_source_files_properties( "${_out}" PROPERTIES
+            COMPILE_DEFINITIONS "Vc_IMPL=${_impl}"
+            COMPILE_FLAGS "${_flags} ${_extra_flags}"
+         )
+         list(APPEND ${_srcs} "${_out}")
       endif()
    endif()
 endmacro()
@@ -461,19 +402,8 @@
 # Example:
 #   vc_compile_for_all_implementations(_objs src/trigonometric.cpp FLAGS -DCOMPILE_BLAH EXCLUDE Scalar)
 #   add_executable(executable main.cpp ${_objs})
-macro(vc_compile_for_all_implementations _objs _src)
-   set(${_objs})
-
-   # remove all -march, -msse, etc. flags from the flags we want to pass
-   string(REPLACE "${Vc_ARCHITECTURE_FLAGS}" "" _flags "${Vc_DEFINITIONS}")
-   string(REPLACE "-DVC_IMPL=[^ ]*" "" _flags "${_flags}")
-
-   # capture the -march= switch as -mtune; if there is none skip it
-   if(Vc_ARCHITECTURE_FLAGS MATCHES "-march=")
-      string(REGEX REPLACE "^.*-march=([^ ]*).*$" "-mtune=\\1" _tmp "${Vc_ARCHITECTURE_FLAGS}")
-      set(_flags "${_flags} ${_tmp}")
-   endif()
-
+macro(vc_compile_for_all_implementations _srcs _src)
+   set(_flags)
    unset(_disabled_targets)
    unset(_only_targets)
    set(_state 0)
@@ -495,49 +425,35 @@
       endif()
    endforeach()
 
-   # make a semicolon separated list of all flags
-   string(TOUPPER "${CMAKE_BUILD_TYPE}" _tmp)
-   set(_tmp "CMAKE_CXX_FLAGS_${_tmp}")
-   string(REPLACE " " ";" _tmp "${CMAKE_CXX_FLAGS} ${${_tmp}} ${_flags}")
-   set(_flags)
-   foreach(item ${_tmp})
-      if(item MATCHES "^[^']*'[^']*$")
-         if(_str)
-            list(APPEND _flags "${_str} ${item}")
-            unset(_str)
-         else()
-            set(_str "${item}")
-         endif()
-      else()
-         list(APPEND _flags "${item}")
-      endif()
-   endforeach()
-   get_directory_property(_inc INCLUDE_DIRECTORIES)
-   foreach(_i ${_inc})
-      list(APPEND _flags "-I${_i}")
-   endforeach()
-
    set(_vc_compile_src "${_src}")
 
-   _vc_compile_one_implementation(${_objs} Scalar NO_FLAG)
+   _vc_compile_one_implementation(${_srcs} Scalar NO_FLAG)
    if(NOT Vc_SSE_INTRINSICS_BROKEN)
-      _vc_compile_one_implementation(${_objs} SSE2   "-msse2"   "-xSSE2"   "/arch:SSE2")
-      _vc_compile_one_implementation(${_objs} SSE3   "-msse3"   "-xSSE3"   "/arch:SSE2")
-      _vc_compile_one_implementation(${_objs} SSSE3  "-mssse3"  "-xSSSE3"  "/arch:SSE2")
-      _vc_compile_one_implementation(${_objs} SSE4_1 "-msse4.1" "-xSSE4.1" "/arch:SSE2")
-      _vc_compile_one_implementation(${_objs} SSE4_2 "-msse4.2" "-xSSE4.2" "/arch:SSE2")
-      _vc_compile_one_implementation(${_objs} SSE3+SSE4a  "-msse4a")
+      _vc_compile_one_implementation(${_srcs} SSE2   "-xSSE2"   "-msse2"   "/arch:SSE2")
+      _vc_compile_one_implementation(${_srcs} SSE3   "-xSSE3"   "-msse3"   "/arch:SSE2")
+      _vc_compile_one_implementation(${_srcs} SSSE3  "-xSSSE3"  "-mssse3"  "/arch:SSE2")
+      _vc_compile_one_implementation(${_srcs} SSE4_1 "-xSSE4.1" "-msse4.1" "/arch:SSE2")
+      _vc_compile_one_implementation(${_srcs} SSE4_2 "-xSSE4.2" "-msse4.2" "/arch:SSE2")
+      _vc_compile_one_implementation(${_srcs} SSE3+SSE4a  "-msse4a")
    endif()
    if(NOT Vc_AVX_INTRINSICS_BROKEN)
-      _vc_compile_one_implementation(${_objs} AVX      "-mavx"    "-xAVX"    "/arch:AVX")
+      _vc_compile_one_implementation(${_srcs} AVX      "-xAVX"    "-mavx"    "/arch:AVX")
       if(NOT Vc_XOP_INTRINSICS_BROKEN)
          if(NOT Vc_FMA4_INTRINSICS_BROKEN)
-            _vc_compile_one_implementation(${_objs} SSE+XOP+FMA4 "-mxop -mfma4"        ""    "")
-            _vc_compile_one_implementation(${_objs} AVX+XOP+FMA4 "-mavx -mxop -mfma4"  ""    "")
+            _vc_compile_one_implementation(${_srcs} SSE+XOP+FMA4 "-mxop -mfma4"        ""    "")
+            _vc_compile_one_implementation(${_srcs} AVX+XOP+FMA4 "-mavx -mxop -mfma4"  ""    "")
          endif()
-         _vc_compile_one_implementation(${_objs} SSE+XOP+FMA "-mxop -mfma"        ""    "")
-         _vc_compile_one_implementation(${_objs} AVX+XOP+FMA "-mavx -mxop -mfma"  ""    "")
+         _vc_compile_one_implementation(${_srcs} SSE+XOP+FMA "-mxop -mfma"        ""    "")
+         _vc_compile_one_implementation(${_srcs} AVX+XOP+FMA "-mavx -mxop -mfma"  ""    "")
       endif()
-      _vc_compile_one_implementation(${_objs} AVX+FMA "-mavx -mfma"  ""    "")
+      _vc_compile_one_implementation(${_srcs} AVX+FMA "-mavx -mfma"  ""    "")
+   endif()
+   if(NOT Vc_AVX2_INTRINSICS_BROKEN)
+      # The necessary list is not clear to me yet. At this point I'll only consider Intel CPUs, in
+      # which case AVX2 implies the availability of FMA and BMI2
+      #_vc_compile_one_implementation(${_srcs} AVX2  "-mavx2")
+      #_vc_compile_one_implementation(${_srcs} AVX2+BMI2 "-mavx2 -mbmi2")
+      _vc_compile_one_implementation(${_srcs} AVX2+FMA+BMI2 "-xCORE-AVX2" "-mavx2 -mfma -mbmi2" "/arch:AVX2")
+      #_vc_compile_one_implementation(${_srcs} AVX2+FMA "-mavx2 -mfma")
    endif()
 endmacro()
diff -Nru vc-0.7.4/CMakeLists.txt vc-1.3.0/CMakeLists.txt
--- vc-0.7.4/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.3)
+cmake_minimum_required(VERSION 3.0)
 
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
    message(FATAL_ERROR "You don't want to configure in the source directory!")
@@ -7,9 +7,6 @@
 project(Vc)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
-set(ROOT_RELEASE FALSE CACHE BOOL "Set up for creating a Vc copy inside ROOT/AliRoot.")
-mark_as_advanced(ROOT_RELEASE)
-
 set(disabled_targets)
 
 include (VcMacros)
@@ -17,82 +14,78 @@
 include (OptimizeForArchitecture)
 
 vc_determine_compiler()
+find_package(MIC)
 
-if(ROOT_RELEASE)
-   if(EXISTS "${CMAKE_INSTALL_PREFIX}/Module.mk")
-      file(READ "${CMAKE_INSTALL_PREFIX}/Module.mk" ROOT_MODULE_MK)
-      if(NOT "${ROOT_MODULE_MK}" MATCHES "\nMODNAME *:= *vc *\n")
-         message(FATAL_ERROR "CMAKE_INSTALL_PREFIX is incorrect. It must point to the Vc subdirectory inside ROOT/AliRoot")
-      endif()
-      set(_extra_namespace "ROOT")
+option(USE_CCACHE "If enabled, ccache will be used (if it exists on the system) to speed up recompiles." OFF)
+if(USE_CCACHE)
+   find_program(CCACHE_COMMAND ccache)
+   if(CCACHE_COMMAND)
+      mark_as_advanced(CCACHE_COMMAND)
+      set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_COMMAND}")
    endif()
-   if(EXISTS "${CMAKE_INSTALL_PREFIX}/Vc.cmake")
-      file(READ "${CMAKE_INSTALL_PREFIX}/Vc.cmake" ALIROOT_VC_CMAKE)
-      if(NOT "${ALIROOT_VC_CMAKE}" MATCHES "\nmacro\\(ALICE_UseVc\\)\n")
-         message(FATAL_ERROR "CMAKE_INSTALL_PREFIX is incorrect. It must point to the Vc subdirectory inside ROOT/AliRoot")
+endif()
+
+# TODO: check that 'decltype' compiles
+# TODO: check that 'constexpr' compiles
+if(NOT Vc_COMPILER_IS_MSVC) # MSVC doesn't provide a switch to turn C++11 on/off AFAIK
+   AddCompilerFlag("-std=c++14" CXX_RESULT _ok MIC_CXX_RESULT _mic_ok CXX_FLAGS CMAKE_CXX_FLAGS MIC_CXX_FLAGS Vc_MIC_CXX_FLAGS)
+   if(MIC_NATIVE_FOUND AND NOT _mic_ok)
+      AddCompilerFlag("-std=c++1y" MIC_CXX_RESULT _mic_ok MIC_CXX_FLAGS Vc_MIC_CXX_FLAGS)
+      if(NOT _mic_ok)
+         AddCompilerFlag("-std=c++11" MIC_CXX_RESULT _mic_ok MIC_CXX_FLAGS Vc_MIC_CXX_FLAGS)
+         if(NOT _mic_ok)
+            AddCompilerFlag("-std=c++0x" MIC_CXX_RESULT _mic_ok MIC_CXX_FLAGS Vc_MIC_CXX_FLAGS)
+            if(NOT _mic_ok)
+               message(FATAL_ERROR "Vc 1.x requires C++11, better even C++14. The MIC native compiler does not support any of the C++11 language flags.")
+            endif()
+         endif()
       endif()
-      set(_extra_namespace "AliRoot")
    endif()
-else()
-   if(Vc_COMPILER_IS_GCC)
-      if(Vc_GCC_VERSION STREQUAL "4.6.0")
-         UserWarning("GCC 4.6.0 is broken. The following tests are therefore disabled:
-         gather_avx, gather_sse, gather_VC_USE_SET_GATHERS_avx, gather_VC_USE_SET_GATHERS_sse,
-         gather_sse_LOOP, scatter_avx, and scatter_sse")
-         list(APPEND disabled_targets
-            gather_avx
-            gather_sse
-            gather_VC_USE_SET_GATHERS_avx
-            gather_VC_USE_SET_GATHERS_sse
-            scatter_avx
-            scatter_sse
-            c++11_gather_avx
-            c++11_gather_sse
-            c++11_gather_VC_USE_SET_GATHERS_avx
-            c++11_gather_VC_USE_SET_GATHERS_sse
-            c++11_scatter_avx
-            c++11_scatter_sse
-            )
-      elseif(Vc_GCC_VERSION STREQUAL "4.5.0" OR Vc_GCC_VERSION STREQUAL "4.5.1")
-         UserWarning("GCC 4.5.[12] are known to generate an internal compiler error on the memory unit test.
-         (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46723)
-         The test will therefore not be compiled and executed.")
-         list(APPEND disabled_targets
-            memory_scalar
-            memory_sse
-            memory_avx
-            c++11_memory_scalar
-            c++11_memory_sse
-            c++11_memory_avx
-            )
-      elseif(Vc_GCC_VERSION STREQUAL "4.5.2")
-         UserWarning("GCC 4.5.2 generates an internal compiler error on the memory_scalar unit test. The test will not be compiled and executed.")
-         list(APPEND disabled_targets
-            memory_scalar
-            c++11_memory_scalar
-            )
+   if(NOT _ok)
+      AddCompilerFlag("-std=c++1y" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)
+      if(NOT _ok)
+         AddCompilerFlag("-std=c++11" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)
+         if(NOT _ok)
+            AddCompilerFlag("-std=c++0x" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)
+            if(NOT _ok)
+               message(FATAL_ERROR "Vc 1.x requires C++11, better even C++14. It seems this is not available. If this was incorrectly determined please notify vc-devel@compeng.uni-frankfurt.de")
+            endif()
+         endif()
       endif()
-   elseif(Vc_COMPILER_IS_CLANG)
-      if(Vc_CLANG_VERSION VERSION_EQUAL "3.0")
-         UserWarning("Clang 3.0 generates an internal compiler error on the finitediff example. The example will not be compiled.")
-         list(APPEND disabled_targets
-            example_finitediff
+   endif()
+elseif(Vc_MSVC_VERSION LESS 180021114)
+   message(FATAL_ERROR "Vc 1.x requires C++11 support. This requires at least Visual Studio 2013 with the Nov 2013 CTP.")
+endif()
+
+if(Vc_COMPILER_IS_GCC)
+   if(Vc_GCC_VERSION VERSION_GREATER "5.0.0" AND Vc_GCC_VERSION VERSION_LESS "6.0.0")
+      UserWarning("GCC 5 goes into an endless loop comiling example_scaling_scalar. Therefore, this target is disabled.")
+      list(APPEND disabled_targets
+         example_scaling_scalar
+         )
+   elseif(Vc_GCC_VERSION VERSION_GREATER "5.99")
+      AddCompilerFlag(-Wno-ignored-attributes)
+   endif()
+elseif(Vc_COMPILER_IS_MSVC)
+   if(MSVC_VERSION LESS 1700)
+      # MSVC before 2012 has a broken std::vector::resize implementation. STL + Vc code will probably not compile.
+      # UserWarning in VcMacros.cmake
+      list(APPEND disabled_targets
+         stlcontainer_sse
+         stlcontainer_avx
+         )
+   endif()
+   # Disable warning "C++ exception specification ignored except to indicate a function is not __declspec(nothrow)"
+   # MSVC emits the warning for the _UnitTest_Compare desctructor which needs the throw declaration so that it doesn't std::terminate
+   AddCompilerFlag("/wd4290")
+endif()
+if(MIC_NATIVE_FOUND)
+   if("${Vc_MIC_ICC_VERSION}" VERSION_LESS "16.1.0")
+      UserWarning("ICC for MIC uses an incompatible STL. Disabling simdize_mic.")
+      list(APPEND disabled_targets
+         simdize_mic
+         example_simdize_mic
          )
-      endif()
-   elseif(Vc_COMPILER_IS_MSVC)
-      if(MSVC_VERSION LESS 1700)
-         # MSVC before 2012 has a broken std::vector::resize implementation. STL + Vc code will probably not compile.
-         # UserWarning in VcMacros.cmake
-         list(APPEND disabled_targets
-            stlcontainer_sse
-            stlcontainer_avx
-            c++11_stlcontainer_sse
-            c++11_stlcontainer_avx
-            )
-      endif()
-      # Disable warning "C++ exception specification ignored except to indicate a function is not __declspec(nothrow)"
-      # MSVC emits the warning for the _UnitTest_Compare desctructor which needs the throw declaration so that it doesn't std::terminate
-      AddCompilerFlag("/wd4290")
    endif()
 endif()
 
@@ -103,15 +96,13 @@
 endif(NOT CMAKE_BUILD_TYPE)
 
 vc_set_preferred_compiler_flags(WARNING_FLAGS BUILDTYPE_FLAGS)
-add_definitions("${Vc_DEFINITIONS}")
-if(Vc_COMPILER_IS_GCC AND Vc_GCC_VERSION VERSION_LESS 4.3.0)
-   add_definitions(-DVC_DONT_WARN_OLD_GCC) # this warning is only interesting for external users of Vc
-endif()
+
+add_definitions(${Vc_DEFINITIONS})
+add_compile_options(${Vc_COMPILE_FLAGS})
 
 if(Vc_COMPILER_IS_INTEL)
    # per default icc is not IEEE compliant, but we need that for verification
-   set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -fp-model source")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fp-model source")
+   AddCompilerFlag("-fp-model source")
 endif()
 
 if(CMAKE_BUILD_TYPE STREQUAL "" AND NOT CMAKE_CXX_FLAGS MATCHES "-O[123]")
@@ -120,86 +111,88 @@
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-if(NOT ROOT_RELEASE)
-   add_custom_target(other VERBATIM)
-   add_custom_target(Scalar COMMENT "build Scalar code" VERBATIM)
-   add_custom_target(SSE COMMENT "build SSE code" VERBATIM)
-   add_custom_target(AVX COMMENT "build AVX code" VERBATIM)
-
-   set(libvc_compile_flags "-DVC_COMPILE_LIB")
-   AddCompilerFlag("-fPIC" CXX_FLAGS libvc_compile_flags)
-   vc_compile_for_all_implementations(_objs src/trigonometric.cpp FLAGS ${libvc_compile_flags}
-      ONLY SSE2 SSE3 SSSE3 SSE4_1 AVX SSE+XOP+FMA4 AVX+XOP+FMA4 AVX+XOP+FMA AVX+FMA)
-   set(_srcs src/const.cpp src/cpuid.cpp src/support.cpp ${_objs})
-   vc_compile_for_all_implementations(_objs src/avx_sorthelper.cpp FLAGS ${libvc_compile_flags} ONLY AVX)
-   set(_srcs ${_srcs} ${_objs})
-   add_library(Vc STATIC ${_srcs})
-   add_target_property(Vc COMPILE_FLAGS ${libvc_compile_flags})
-   add_target_property(Vc LABELS "other")
-   add_dependencies(other Vc)
-
-   install(TARGETS Vc DESTINATION lib${LIB_SUFFIX})
-   install(DIRECTORY include/Vc/ DESTINATION include/Vc)
-   install(DIRECTORY scalar sse avx common DESTINATION include/Vc FILES_MATCHING REGEX "/*.(h|tcc|def)$")
+add_custom_target(other VERBATIM)
+add_custom_target(Scalar COMMENT "build Scalar code" VERBATIM)
+add_custom_target(SSE COMMENT "build SSE code" VERBATIM)
+add_custom_target(AVX COMMENT "build AVX code" VERBATIM)
+add_custom_target(AVX2 COMMENT "build AVX2 code" VERBATIM)
+add_custom_target(MIC COMMENT "build MIC code" VERBATIM)
+
+AddCompilerFlag(-ftemplate-depth=128 CXX_FLAGS CMAKE_CXX_FLAGS MIC_CXX_FLAGS CMAKE_MIC_CXX_FLAGS)
+
+set(libvc_compile_flags "-DVc_COMPILE_LIB")
+set(libvc_mic_compile_flags "-DVc_COMPILE_LIB")
+AddCompilerFlag("-fPIC" CXX_FLAGS libvc_compile_flags MIC_CXX_FLAGS libvc_mic_compile_flags)
+
+if(MIC_FOUND)
+   mic_add_library(Vc_MIC STATIC src/mic_const.cpp src/cpuid.cpp src/support_x86.cpp src/mic_sorthelper.cpp
+      COMPILE_FLAGS ${libvc_mic_compile_flags})
+   add_target_property(Vc_MIC LABELS "MIC")
+   add_dependencies(MIC Vc_MIC)
+   get_target_property(outputName Vc_MIC OUTPUT_NAME)
+   install(FILES ${outputName} DESTINATION lib${LIB_SUFFIX})
+endif()
+
+set(_srcs src/const.cpp)
+if("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "([x3-7]86|AMD64)")
+
+   list(APPEND _srcs src/cpuid.cpp src/support_x86.cpp)
+   vc_compile_for_all_implementations(_srcs src/trigonometric.cpp ONLY SSE2 SSE3 SSSE3 SSE4_1 AVX SSE+XOP+FMA4 AVX+XOP+FMA4 AVX+XOP+FMA AVX+FMA)# AVX2+FMA+BMI2)
+   vc_compile_for_all_implementations(_srcs src/sse_sorthelper.cpp ONLY SSE2 SSE4_1 AVX AVX2+FMA+BMI2)
+   vc_compile_for_all_implementations(_srcs src/avx_sorthelper.cpp ONLY AVX AVX2+FMA+BMI2)
 else()
-   # libVc should be compiled in the ROOT/AliRoot tree, so we need to install the sources
-   #
-   # Sadly there are messed up systems where putting include/Vc in the include paths will
-   # break the standard library (e.g. MacOS X Lion with case insensitive filesystem).
-   # Thus, we modify the includes such that include/Vc never needs to be in the path.
-   file(GLOB_RECURSE _srcs RELATIVE "${CMAKE_SOURCE_DIR}" src/*.cpp examples/*.cpp examples/*.h tests/*.cpp tests/*.h)
-   foreach(_src ${_srcs})
-      message(STATUS "Processing ${CMAKE_SOURCE_DIR}/${_src} -> ${CMAKE_BINARY_DIR}/${_src}")
-      get_filename_component(_path "${CMAKE_BINARY_DIR}/${_src}" PATH)
-      file(MAKE_DIRECTORY "${_path}")
-      execute_process(
-         COMMAND sed -e "s,#include \\(.\\)\\(common\\|avx\\|sse\\|scalar\\)/,#include \\1Vc/\\2/,"
-                     -e "s,::Vc::,::${_extra_namespace}::Vc::,g"
-                     -e "s,/\\*OUTER_NAMESPACE_BEGIN\\*/,namespace ${_extra_namespace} {,"
-                     -e "s,/\\*OUTER_NAMESPACE_END\\*/,} // namespace ${_extra_namespace},"
-                     -e "s,/\\*NAMESPACE_ALIAS\\*/,namespace Vc = ${_extra_namespace}::Vc;,"
-         INPUT_FILE ${CMAKE_SOURCE_DIR}/${_src}
-         OUTPUT_FILE ${CMAKE_BINARY_DIR}/${_src}
-         )
-   endforeach()
-
-   set(includes)
-   macro(copy_and_set_outer_namespace dst)
-      foreach(_name ${ARGN})
-         set(_dst "${dst}${_name}")
-         set(_src "${CMAKE_SOURCE_DIR}/${_name}")
-         get_filename_component(_dir "${_dst}" PATH)
-         add_custom_command(OUTPUT "${_dst}"
-            COMMAND mkdir -p "${_dir}"
-            COMMAND cp  "${_src}" "${_dst}"
-            COMMAND sed -e "s,::Vc::,::${_extra_namespace}::Vc::,g"
-                        -e "s,/\\*OUTER_NAMESPACE_BEGIN\\*/,namespace ${_extra_namespace} {,"
-                        -e "s,/\\*OUTER_NAMESPACE_END\\*/,} // namespace ${_extra_namespace},"
-                        -e "s,/\\*NAMESPACE_ALIAS\\*/,namespace Vc = ${_extra_namespace}::Vc;,"
-                        -i "${_dst}"
-            MAIN_DEPENDENCY "${_src}"
-            COMMENT "Rewrite ${_dst}"
-            WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
-            VERBATIM)
-         list(APPEND includes "${_dst}")
-      endforeach()
-   endmacro()
-
-   file(GLOB_RECURSE _srcs RELATIVE "${CMAKE_SOURCE_DIR}" include/*.h include/*.tcc include/*.def)
-   file(GLOB _src2 RELATIVE "${CMAKE_SOURCE_DIR}" include/Vc/*)
-   list(APPEND _srcs ${_src2})
-   list(REMOVE_DUPLICATES _srcs)
-   copy_and_set_outer_namespace("" "${_srcs}")
-
-   foreach(_dir in scalar sse avx common)
-      file(GLOB_RECURSE _srcs RELATIVE "${CMAKE_SOURCE_DIR}" ${_dir}/*.h ${_dir}/*.tcc ${_dir}/*.def)
-      copy_and_set_outer_namespace("include/Vc/" "${_srcs}")
-   endforeach()
-   add_custom_target(rewrite ALL DEPENDS ${includes})
+   message(FATAL_ERROR "Unsupported target architecture '${CMAKE_SYSTEM_PROCESSOR}'. No support_???.cpp file exists for this architecture.")
 endif()
+add_library(Vc STATIC ${_srcs})
+set_property(TARGET Vc APPEND PROPERTY COMPILE_OPTIONS ${libvc_compile_flags})
+add_target_property(Vc LABELS "other")
+if(XCODE)
+   # TODO: document what this does and why it has no counterpart in the non-XCODE logic
+   set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_GCC_INLINES_ARE_PRIVATE_EXTERN "NO")
+   set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "YES")
+   set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x")
+   set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+elseif(UNIX AND Vc_COMPILER_IS_CLANG)
+   # On UNIX (Linux) the standard library used by default typically is libstdc++ (GCC).
+   # To get the full clang deal we rather want to build against libc++. This requires
+   # additionally the libc++abi and libsupc++ libraries in all linker invokations.
+   option(USE_LIBC++ "Use libc++ instead of the system default C++ standard library." ON)
+   if(USE_LIBC++)
+      AddCompilerFlag(-stdlib=libc++ CXX_FLAGS CMAKE_CXX_FLAGS CXX_RESULT _use_libcxx)
+      if(_use_libcxx)
+         find_library(LIBC++ABI c++abi)
+         mark_as_advanced(LIBC++ABI)
+         if(LIBC++ABI)
+            set(CMAKE_REQUIRED_LIBRARIES "${LIBC++ABI};supc++")
+            CHECK_CXX_SOURCE_COMPILES("#include <stdexcept>
+            #include <iostream>
+            void foo() {
+              std::cout << 'h' << std::flush << std::endl;
+              throw std::exception();
+            }
+            int main() {
+              try { foo(); }
+              catch (int) { return 0; }
+              return 1;
+            }" libcxx_compiles)
+            unset(CMAKE_REQUIRED_LIBRARIES)
+            if(libcxx_compiles)
+               link_libraries(${LIBC++ABI} supc++)
+            endif()
+         endif()
+      endif()
+   endif()
+endif()
+add_dependencies(other Vc)
+
+install(TARGETS Vc DESTINATION lib${LIB_SUFFIX})
+install(DIRECTORY include/Vc/ DESTINATION include/Vc)
+
+# Install all implementation headers
+install(DIRECTORY scalar sse avx mic common traits DESTINATION include/Vc FILES_MATCHING REGEX "/*.(h|tcc|def)$")
 
 # read version parts from version.h to be put into VcConfig.cmake
-file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/include/Vc/version.h _version_lines REGEX "^#define VC_VERSION_STRING ")
+file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/include/Vc/version.h _version_lines REGEX "^#define Vc_VERSION_STRING ")
 string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" _version_matches "${_version_lines}")
 set(Vc_VERSION_MAJOR ${CMAKE_MATCH_1})
 set(Vc_VERSION_MINOR ${CMAKE_MATCH_2})
@@ -210,55 +203,49 @@
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/VcConfigVersion.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/cmake/VcConfigVersion.cmake @ONLY)
 
-set(cmake_install_files
+install(FILES
    cmake/UserWarning.cmake
    cmake/VcMacros.cmake
    cmake/AddCompilerFlag.cmake
    cmake/CheckCCompilerFlag.cmake
    cmake/CheckCXXCompilerFlag.cmake
+   cmake/CheckMicCCompilerFlag.cmake
+   cmake/CheckMicCXXCompilerFlag.cmake
+   cmake/FindMIC.cmake
+   cmake/OptimizeForArchitecture.cmake
+   cmake/FindVc.cmake
+   ${CMAKE_CURRENT_BINARY_DIR}/cmake/VcConfig.cmake
+   ${CMAKE_CURRENT_BINARY_DIR}/cmake/VcConfigVersion.cmake
+   DESTINATION lib${LIB_SUFFIX}/cmake/Vc
    )
-if(ROOT_RELEASE)
-   execute_process(
-      COMMAND sed "s, \"auto\" CACHE, \"none\" CACHE,"
-      INPUT_FILE ${CMAKE_SOURCE_DIR}/cmake/OptimizeForArchitecture.cmake
-      OUTPUT_FILE ${CMAKE_BINARY_DIR}/cmake/OptimizeForArchitecture.cmake
-      )
-   install(FILES
-      ${cmake_install_files}
-      cmake/AddTargetProperty.cmake
-      ${CMAKE_BINARY_DIR}/cmake/OptimizeForArchitecture.cmake
-      DESTINATION cmake
+
+option(BUILD_TESTING "Build the testing tree." OFF)
+include (CTest)
+configure_file(${CMAKE_SOURCE_DIR}/CTestCustom.cmake ${CMAKE_BINARY_DIR}/CTestCustom.cmake COPYONLY)
+if(BUILD_TESTING)
+   add_custom_target(build_tests ALL VERBATIM)
+   add_subdirectory(tests)
+endif(BUILD_TESTING)
+
+set(BUILD_EXAMPLES FALSE CACHE BOOL "Build examples.")
+if(BUILD_EXAMPLES)
+   add_subdirectory(examples)
+endif(BUILD_EXAMPLES)
+
+# Hide Vc_IMPL as it is only meant for users of Vc
+mark_as_advanced(Vc_IMPL)
+
+find_program(BIN_CAT cat)
+mark_as_advanced(BIN_CAT)
+if(BIN_CAT)
+   file(REMOVE ${CMAKE_BINARY_DIR}/help.txt)
+   add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/help.txt
+      COMMAND ${CMAKE_MAKE_PROGRAM} help > ${CMAKE_BINARY_DIR}/help.txt
+      VERBATIM
       )
-   install(DIRECTORY ${CMAKE_BINARY_DIR}/examples/ DESTINATION examples)
-   install(DIRECTORY ${CMAKE_BINARY_DIR}/tests/ DESTINATION tests)
-   install(FILES tests/CMakeLists.txt tests/download.cmake DESTINATION tests)
-   install(DIRECTORY ${CMAKE_BINARY_DIR}/src/ DESTINATION src)
-   install(DIRECTORY ${CMAKE_BINARY_DIR}/include/Vc/ DESTINATION include/Vc)
-   install(DIRECTORY examples/ DESTINATION examples FILES_MATCHING PATTERN CMakeLists.txt)
-else()
-   install(FILES
-      ${cmake_install_files}
-      ${CMAKE_CURRENT_BINARY_DIR}/cmake/VcConfig.cmake
-      ${CMAKE_CURRENT_BINARY_DIR}/cmake/VcConfigVersion.cmake
-      cmake/OptimizeForArchitecture.cmake
-      cmake/FindVc.cmake
-      DESTINATION lib/cmake/Vc
+   add_custom_target(cached_help
+      ${BIN_CAT} ${CMAKE_BINARY_DIR}/help.txt
+      DEPENDS ${CMAKE_BINARY_DIR}/help.txt
+      VERBATIM
       )
 endif()
-
-if(NOT ROOT_RELEASE)
-   include (CTest)
-   configure_file(${CMAKE_SOURCE_DIR}/CTestCustom.cmake ${CMAKE_BINARY_DIR}/CTestCustom.cmake COPYONLY)
-   if(BUILD_TESTING)
-      add_custom_target(build_tests VERBATIM)
-      add_subdirectory(tests)
-   endif(BUILD_TESTING)
-
-   set(BUILD_EXAMPLES FALSE CACHE BOOL "Build examples.")
-   if(BUILD_EXAMPLES)
-      add_subdirectory(examples)
-   endif(BUILD_EXAMPLES)
-endif()
-
-# Hide VC_IMPL as it is only meant for users of Vc
-mark_as_advanced(VC_IMPL)
diff -Nru vc-0.7.4/common/algorithms.h vc-1.3.0/common/algorithms.h
--- vc-0.7.4/common/algorithms.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/algorithms.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,210 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_ALGORITHMS_H_
+#define VC_COMMON_ALGORITHMS_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * \ingroup Utilities
+ *
+ * \name Boolean Reductions
+ */
+//@{
+/** \ingroup Utilities
+ *  Returns whether all entries in the mask \p m are \c true.
+ */
+template<typename Mask> constexpr bool all_of(const Mask &m) { return m.isFull(); }
+/** \ingroup Utilities
+ *  Returns \p b
+ */
+constexpr bool all_of(bool b) { return b; }
+
+/** \ingroup Utilities
+ *  Returns whether at least one entry in the mask \p m is \c true.
+ */
+template<typename Mask> constexpr bool any_of(const Mask &m) { return m.isNotEmpty(); }
+/** \ingroup Utilities
+ *  Returns \p b
+ */
+constexpr bool any_of(bool b) { return b; }
+
+/** \ingroup Utilities
+ *  Returns whether all entries in the mask \p m are \c false.
+ */
+template<typename Mask> constexpr bool none_of(const Mask &m) { return m.isEmpty(); }
+/** \ingroup Utilities
+ *  Returns \p !b
+ */
+constexpr bool none_of(bool b) { return !b; }
+
+/** \ingroup Utilities
+ *  Returns whether at least one entry in \p m is \c true and at least one entry in \p m is \c
+ *  false.
+ */
+template<typename Mask> constexpr bool some_of(const Mask &m) { return m.isMix(); }
+/** \ingroup Utilities
+ *  Returns \c false
+ */
+constexpr bool some_of(bool) { return false; }
+//@}
+
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<std::is_arithmetic<typename InputIt::value_type>::value &&
+                     Traits::is_functor_argument_immutable<
+                         UnaryFunction, Vector<typename InputIt::value_type>>::value,
+                 UnaryFunction>
+simd_for_each(InputIt first, InputIt last, UnaryFunction f)
+{
+    typedef Vector<typename InputIt::value_type> V;
+    typedef Scalar::Vector<typename InputIt::value_type> V1;
+    for (; reinterpret_cast<std::uintptr_t>(std::addressof(*first)) &
+                   (V::MemoryAlignment - 1) &&
+               first != last;
+         ++first) {
+        f(V1(std::addressof(*first), Vc::Aligned));
+    }
+    const auto lastV = last - (V::Size + 1);
+    for (; first < lastV; first += V::Size) {
+        f(V(std::addressof(*first), Vc::Aligned));
+    }
+    for (; first != last; ++first) {
+        f(V1(std::addressof(*first), Vc::Aligned));
+    }
+    return std::move(f);
+}
+
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<std::is_arithmetic<typename InputIt::value_type>::value &&
+                     !Traits::is_functor_argument_immutable<
+                         UnaryFunction, Vector<typename InputIt::value_type>>::value,
+                 UnaryFunction>
+simd_for_each(InputIt first, InputIt last, UnaryFunction f)
+{
+    typedef Vector<typename InputIt::value_type> V;
+    typedef Scalar::Vector<typename InputIt::value_type> V1;
+    for (; reinterpret_cast<std::uintptr_t>(std::addressof(*first)) &
+                   (V::MemoryAlignment - 1) &&
+               first != last;
+         ++first) {
+        V1 tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    const auto lastV = last - (V::Size + 1);
+    for (; first < lastV; first += V::Size) {
+        V tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    for (; first != last; ++first) {
+        V1 tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    return std::move(f);
+}
+
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<!std::is_arithmetic<typename InputIt::value_type>::value, UnaryFunction>
+simd_for_each(InputIt first, InputIt last, UnaryFunction f)
+{
+    return std::for_each(first, last, std::move(f));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<std::is_arithmetic<typename InputIt::value_type>::value &&
+                     Traits::is_functor_argument_immutable<
+                         UnaryFunction, Vector<typename InputIt::value_type>>::value,
+                 UnaryFunction>
+simd_for_each_n(InputIt first, std::size_t count, UnaryFunction f)
+{
+    typename std::make_signed<size_t>::type len = count;
+    typedef Vector<typename InputIt::value_type> V;
+    typedef Scalar::Vector<typename InputIt::value_type> V1;
+    for (; reinterpret_cast<std::uintptr_t>(std::addressof(*first)) &
+               (V::MemoryAlignment - 1) &&
+           len != 0;
+         --len, ++first) {
+        f(V1(std::addressof(*first), Vc::Aligned));
+    }
+    for (; len >= int(V::Size); len -= V::Size, first += V::Size) {
+        f(V(std::addressof(*first), Vc::Aligned));
+    }
+    for (; len != 0; --len, ++first) {
+        f(V1(std::addressof(*first), Vc::Aligned));
+    }
+    return std::move(f);
+}
+
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<std::is_arithmetic<typename InputIt::value_type>::value &&
+                     !Traits::is_functor_argument_immutable<
+                         UnaryFunction, Vector<typename InputIt::value_type>>::value,
+                 UnaryFunction>
+simd_for_each_n(InputIt first, std::size_t count, UnaryFunction f)
+{
+    typename std::make_signed<size_t>::type len = count;
+    typedef Vector<typename InputIt::value_type> V;
+    typedef Scalar::Vector<typename InputIt::value_type> V1;
+    for (; reinterpret_cast<std::uintptr_t>(std::addressof(*first)) &
+               (V::MemoryAlignment - 1) &&
+           len != 0;
+         --len, ++first) {
+        V1 tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    for (; len >= int(V::Size); len -= V::Size, first += V::Size) {
+        V tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    for (; len != 0; --len, ++first) {
+        V1 tmp(std::addressof(*first), Vc::Aligned);
+        f(tmp);
+        tmp.store(std::addressof(*first), Vc::Aligned);
+    }
+    return std::move(f);
+}
+
+#ifdef Vc_CXX17
+template <typename InputIt, typename UnaryFunction>
+inline enable_if<!std::is_arithmetic<typename InputIt::value_type>::value, UnaryFunction>
+simd_for_each_n(InputIt first, std::size_t count, UnaryFunction f)
+{
+    return std::for_each_n(first, count, std::move(f));
+}
+#endif
+
+}  // namespace Vc
+
+#endif // VC_COMMON_ALGORITHMS_H_
diff -Nru vc-0.7.4/common/aliasingentryhelper.h vc-1.3.0/common/aliasingentryhelper.h
--- vc-0.7.4/common/aliasingentryhelper.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/aliasingentryhelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,29 +1,36 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_ALIASINGENTRYHELPER_H
-#define VC_COMMON_ALIASINGENTRYHELPER_H
+#ifndef VC_COMMON_ALIASINGENTRYHELPER_H_
+#define VC_COMMON_ALIASINGENTRYHELPER_H_
 
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace Common
 {
@@ -32,12 +39,13 @@
 {
     private:
         typedef typename StorageType::EntryType T;
-#ifdef VC_ICC
+#ifdef Vc_ICC
         StorageType *const m_storage;
         const int m_index;
     public:
         Vc_ALWAYS_INLINE AliasingEntryHelper(StorageType *d, int index) : m_storage(d), m_index(index) {}
-        Vc_ALWAYS_INLINE AliasingEntryHelper(const AliasingEntryHelper &rhs) : m_storage(rhs.m_storage), m_index(rhs.m_index) {}
+        Vc_ALWAYS_INLINE AliasingEntryHelper(const AliasingEntryHelper &) = default;
+        Vc_ALWAYS_INLINE AliasingEntryHelper(AliasingEntryHelper &&) = default;
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator=(const AliasingEntryHelper &rhs) {
             m_storage->assign(m_index, rhs);
             return *this;
@@ -54,11 +62,6 @@
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator %=(T x) { m_storage->assign(m_index, m_storage->m(m_index) % x); return *this; }
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator<<=(T x) { m_storage->assign(m_index, m_storage->m(m_index)<< x); return *this; }
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator>>=(T x) { m_storage->assign(m_index, m_storage->m(m_index)>> x); return *this; }
-
-        Vc_ALWAYS_INLINE AliasingEntryHelper &operator++() { m_storage->assign(m_index, m_storage->m(m_index) + T(1)); return *this; }
-        Vc_ALWAYS_INLINE T operator++(int) { T r = m_storage->m(m_index); m_storage->assign(m_index, m_storage->m(m_index) + T(1)); return r; }
-        Vc_ALWAYS_INLINE AliasingEntryHelper &operator--() { m_storage->assign(m_index, m_storage->m(m_index) - T(1)); return *this; }
-        Vc_ALWAYS_INLINE T operator--(int) { T r = m_storage->m(m_index); m_storage->assign(m_index, m_storage->m(m_index) - T(1)); return r; }
 #define m_data m_storage->read(m_index)
 #else
         typedef T A Vc_MAY_ALIAS;
@@ -84,11 +87,6 @@
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator%=(T x) { m_data %= x; return *this; }
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator<<=(T x) { m_data <<= x; return *this; }
         Vc_ALWAYS_INLINE AliasingEntryHelper &operator>>=(T x) { m_data >>= x; return *this; }
-
-        Vc_ALWAYS_INLINE AliasingEntryHelper &operator++() { ++m_data; return *this; }
-        Vc_ALWAYS_INLINE T operator++(int) { T r = m_data; ++m_data; return r; }
-        Vc_ALWAYS_INLINE AliasingEntryHelper &operator--() { --m_data; return *this; }
-        Vc_ALWAYS_INLINE T operator--(int) { T r = m_data; --m_data; return r; }
 #endif
 
         Vc_ALWAYS_INLINE Vc_PURE operator const T() const { return m_data; }
@@ -117,10 +115,7 @@
 #endif
 };
 
-} // namespace Common
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace Common
+}  // namespace Vc
 
-#endif // VC_COMMON_ALIASINGENTRYHELPER_H
+#endif // VC_COMMON_ALIASINGENTRYHELPER_H_
diff -Nru vc-0.7.4/common/alignedbase.h vc-1.3.0/common/alignedbase.h
--- vc-0.7.4/common/alignedbase.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/alignedbase.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,137 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_ALIGNEDBASE_H_
+#define VC_COMMON_ALIGNEDBASE_H_
+
+#include "types.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+/**\internal
+ * Break the recursion of the function below.
+ */
+template <typename T> constexpr T max(T a) { return a; }
+/**\internal
+ * \returns the maximum of all specified arguments.
+ */
+template <typename T, typename... Ts> constexpr T max(T a, T b, Ts... rest)
+{
+    return a > b ? max(a, rest...) : max(b, rest...);
+}
+}  // namespace Detail
+namespace Common
+{
+template <std::size_t> Vc_INTRINSIC void *aligned_malloc(std::size_t);
+Vc_ALWAYS_INLINE void free(void *);
+}  // namespace Common
+
+/**
+ * \ingroup Utilities
+ *
+ * Helper class to ensure a given alignment.
+ *
+ * This class reimplements the \c new and \c delete operators to align objects allocated
+ * on the heap suitably with the specified alignment \c Alignment.
+ *
+ * \see Vc::VectorAlignedBase
+ * \see Vc::MemoryAlignedBase
+ */
+template <std::size_t Alignment> struct alignas(Alignment) AlignedBase
+{
+    Vc_FREE_STORE_OPERATORS_ALIGNED(Alignment);
+};
+
+/**
+ * \ingroup Utilities
+ *
+ * Helper type to ensure suitable alignment for any Vc::Vector<T> type (using the default
+ * VectorAbi).
+ *
+ * This class reimplements the \c new and \c delete operators to align objects allocated
+ * on the heap suitably for objects of Vc::Vector<T> type. This is necessary since the
+ * standard \c new operator does not adhere to the alignment requirements of the type.
+ *
+ * \see Vc::VectorAlignedBaseT
+ * \see Vc::MemoryAlignedBase
+ * \see Vc::AlignedBase
+ */
+using VectorAlignedBase = AlignedBase<
+    Detail::max(alignof(Vector<float>), alignof(Vector<double>), alignof(Vector<ullong>),
+                alignof(Vector<llong>), alignof(Vector<ulong>), alignof(Vector<long>),
+                alignof(Vector<uint>), alignof(Vector<int>), alignof(Vector<ushort>),
+                alignof(Vector<short>), alignof(Vector<uchar>), alignof(Vector<schar>))>;
+
+/**
+ * \ingroup Utilities
+ * Variant of the above type ensuring suitable alignment only for the specified vector
+ * type \p V.
+ *
+ * \see Vc::VectorAlignedBase
+ * \see Vc::MemoryAlignedBaseT
+ */
+template <typename V> using VectorAlignedBaseT = AlignedBase<alignof(V)>;
+
+/**
+ * \ingroup Utilities
+ *
+ * Helper class to ensure suitable alignment for arrays of scalar objects for any
+ * Vc::Vector<T> type (using the default VectorAbi).
+ *
+ * This class reimplements the \c new and \c delete operators to align objects allocated
+ * on the heap suitably for arrays of type \p Vc::Vector<T>::EntryType. Subsequent load
+ * and store operations are safe to use the aligned variant.
+ *
+ * \see Vc::MemoryAlignedBaseT
+ * \see Vc::VectorAlignedBase
+ * \see Vc::AlignedBase
+ */
+using MemoryAlignedBase = AlignedBase<
+    Detail::max(Vector<float>::MemoryAlignment, Vector<double>::MemoryAlignment,
+                Vector<ullong>::MemoryAlignment, Vector<llong>::MemoryAlignment,
+                Vector<ulong>::MemoryAlignment, Vector<long>::MemoryAlignment,
+                Vector<uint>::MemoryAlignment, Vector<int>::MemoryAlignment,
+                Vector<ushort>::MemoryAlignment, Vector<short>::MemoryAlignment,
+                Vector<uchar>::MemoryAlignment, Vector<schar>::MemoryAlignment)>;
+
+/**
+ * \ingroup Utilities
+ * Variant of the above type ensuring suitable alignment only for the specified vector
+ * type \p V.
+ *
+ * \see Vc::MemoryAlignedBase
+ * \see Vc::VectorAlignedBaseT
+ */
+template <typename V> using MemoryAlignedBaseT = AlignedBase<V::MemoryAlignment>;
+}
+
+#endif  // VC_COMMON_ALIGNEDBASE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/bitscanintrinsics.h vc-1.3.0/common/bitscanintrinsics.h
--- vc-0.7.4/common/bitscanintrinsics.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/bitscanintrinsics.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,27 +1,35 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_COMMON_BITSCANINTRINSICS_H_
+#define VC_COMMON_BITSCANINTRINSICS_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_BITSCANINTRINSICS_H
-#define VC_COMMON_BITSCANINTRINSICS_H
-
-#if defined(VC_GCC) || defined(VC_CLANG)
-#  if VC_GCC >= 0x40500
+#if defined(Vc_GCC) || defined(Vc_CLANG) || defined(Vc_APPLECLANG)
+#  if Vc_GCC >= 0x40500
      // GCC 4.5.0 introduced _bit_scan_forward / _bit_scan_reverse
 #    include <x86intrin.h>
 #  else
@@ -33,30 +41,25 @@
     __asm__("bsr %1,%0" : "=r"(r) : "X"(x));
     return r;
 }
-#include "undomacros.h"
 #    define _bit_scan_reverse(x) _Vc_bit_scan_reverse_asm(x)
 #  endif
-#elif defined(VC_ICC)
-// for all I know ICC supports the _bit_scan_* intrinsics
-#elif defined(VC_OPEN64)
-// TODO
-#elif defined(VC_MSVC)
-#include "windows_fix_intrin.h"
-#pragma intrinsic(_BitScanForward)
-#pragma intrinsic(_BitScanReverse)
+#elif defined(_WIN32)
+#include "intrin.h"
 static inline __forceinline unsigned long _bit_scan_forward(unsigned long x) {
-    unsigned long index;
-    _BitScanForward(&index, x);
-    return index;
+	unsigned long index;
+	_BitScanForward(&index, x);
+	return index;
 }
 static inline __forceinline unsigned long _bit_scan_reverse(unsigned long x) {
-    unsigned long index;
-    _BitScanReverse(&index, x);
-    return index;
+	unsigned long index;
+	_BitScanReverse(&index, x);
+	return index;
 }
+#elif defined(Vc_ICC)
+// for all I know ICC supports the _bit_scan_* intrinsics
 #else
 // just assume the compiler can do it
 #endif
 
 
-#endif // VC_COMMON_BITSCANINTRINSICS_H
+#endif // VC_COMMON_BITSCANINTRINSICS_H_
diff -Nru vc-0.7.4/common/const.h vc-1.3.0/common/const.h
--- vc-0.7.4/common/const.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/const.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,92 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_CONST_H_
+#define VC_COMMON_CONST_H_
+
+#include <type_traits>
+#include <Vc/global.h>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+
+template <int exponent> constexpr double exponentToFloat(std::integral_constant<bool, true>);
+template <int exponent> constexpr double exponentToFloat(std::integral_constant<bool, false>);
+template <> constexpr double exponentToFloat<0>(std::integral_constant<bool, true>)
+{
+    return 1.;
+}
+template <> constexpr double exponentToFloat<0>(std::integral_constant<bool, false>)
+{
+    return 1.;
+}
+template <> constexpr double exponentToFloat<-32>(std::integral_constant<bool, true>)
+{
+    return 1. / (65536. * 65536.);
+}
+template <> constexpr double exponentToFloat<32>(std::integral_constant<bool, false>)
+{
+    return 65536. * 65536.;
+}
+template <> constexpr double exponentToFloat<-64>(std::integral_constant<bool, true>)
+{
+    return 1. / (65536. * 65536. * 65536. * 65536.);
+}
+template <> constexpr double exponentToFloat<64>(std::integral_constant<bool, false>)
+{
+    return 65536. * 65536. * 65536. * 65536.;
+}
+template <int exponent>
+constexpr double exponentToFloat(std::integral_constant<bool, false> negative)
+{
+    return exponentToFloat<exponent - 1>(negative) * 2.0;
+}
+template <int exponent>
+constexpr double exponentToFloat(std::integral_constant<bool, true> negative)
+{
+    return exponentToFloat<exponent + 1>(negative) * 0.5;
+}
+template <int sign, unsigned long long mantissa, int exponent> constexpr double doubleConstant()
+{
+    return (static_cast<double>((mantissa & 0x000fffffffffffffull) | 0x0010000000000000ull) /
+            0x0010000000000000ull) *
+           exponentToFloat<exponent>(std::integral_constant<bool, (exponent < 0)>()) * sign;
+}
+template <int sign, unsigned int mantissa, int exponent> constexpr float floatConstant()
+{
+    return (static_cast<float>((mantissa & 0x007fffffu) | 0x00800000u) / 0x00800000u) *
+           static_cast<float>(
+               exponentToFloat<exponent>(std::integral_constant<bool, (exponent < 0)>())) *
+           sign;
+}
+
+}  // namespace Detail
+}  // namespace Vc
+
+#endif // VC_COMMON_CONST_H_
diff -Nru vc-0.7.4/common/data.h vc-1.3.0/common/data.h
--- vc-0.7.4/common/data.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/data.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,43 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_CONST_DATA_H_
+#define VC_COMMON_CONST_DATA_H_
+
+#include "macros.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+alignas(64) extern unsigned int RandomState[];
+alignas(32) extern const unsigned int AllBitsSet[8];
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_CONST_DATA_H_
diff -Nru vc-0.7.4/common/deinterleave.h vc-1.3.0/common/deinterleave.h
--- vc-0.7.4/common/deinterleave.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/deinterleave.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,34 +1,43 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_DEINTERLEAVE_H
-#define VC_COMMON_DEINTERLEAVE_H
+#ifndef VC_COMMON_DEINTERLEAVE_H_
+#define VC_COMMON_DEINTERLEAVE_H_
 
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 
 /**
  * \ingroup Vectors
  *
+ * \deprecated Turn to InterleavedMemoryWrapper for a more flexible and complete solution.
+ *
  * Loads two vectors of values from an interleaved array.
  *
  * \param a, b The vectors to load the values from memory into.
@@ -53,8 +62,6 @@
 =========|=======|========|========|=======|======|=====
  float_v |   X   |        |    X   |   X   |      |
 ---------|-------|--------|--------|-------|------|-----
-sfloat_v |   X   |        |    X   |   X   |      |
----------|-------|--------|--------|-------|------|-----
 double_v |       |    X   |        |       |      |
 ---------|-------|--------|--------|-------|------|-----
    int_v |       |        |        |   X   |      |  X
@@ -69,19 +76,16 @@
 template<typename V, typename M, typename A> Vc_ALWAYS_INLINE void deinterleave(V *a, V *b,
         const M *memory, A align)
 {
-    Internal::Helper::deinterleave(*a, *b, memory, align);
+    Detail::deinterleave(*a, *b, memory, align);
 }
 
 // documented as default for align above
 template<typename V, typename M> Vc_ALWAYS_INLINE void deinterleave(V *a, V *b,
         const M *memory)
 {
-    Internal::Helper::deinterleave(*a, *b, memory, Aligned);
+    Detail::deinterleave(*a, *b, memory, Aligned);
 }
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace Vc
 
-#endif // VC_COMMON_DEINTERLEAVE_H
+#endif // VC_COMMON_DEINTERLEAVE_H_
diff -Nru vc-0.7.4/common/elementreference.h vc-1.3.0/common/elementreference.h
--- vc-0.7.4/common/elementreference.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/elementreference.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,140 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_ELEMENTREFERENCE_H_
+#define VC_COMMON_ELEMENTREFERENCE_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+template <typename U, typename Accessor = U> class ElementReference
+{
+    using value_type = typename U::value_type;
+    friend U;
+    friend Accessor;
+    Vc_INTRINSIC ElementReference(U &o, int i) noexcept : index(i), obj(o) {}
+
+    static constexpr bool get_noexcept =
+        noexcept(Accessor::get(std::declval<U &>(), int()));
+    template <typename T> static constexpr bool set_noexcept()
+    {
+        return noexcept(Accessor::set(std::declval<U &>(), int(), std::declval<T>()));
+    }
+
+public:
+    Vc_INTRINSIC ElementReference(const ElementReference &) = delete;
+
+    Vc_INTRINSIC operator value_type() const noexcept(get_noexcept)
+    {
+        return Accessor::get(obj, index);
+    }
+
+    template <typename T>
+        Vc_INTRINSIC ElementReference &operator=(T &&x) &&
+        noexcept(noexcept(Accessor::set(std::declval<U &>(), int(), std::declval<T>())))
+    {
+        Accessor::set(obj, index, std::forward<T>(x));
+        return *this;
+    }
+
+// TODO: improve with operator.()
+
+#define Vc_OP_(op_)                                                                      \
+    template <typename T, typename R = decltype(std::declval<const value_type &>()       \
+                                                    op_ std::declval<T>())>              \
+        Vc_INTRINSIC ElementReference &operator op_##=(T &&x) &&                         \
+        noexcept(get_noexcept && noexcept(Accessor::set(std::declval<U &>(), int(),      \
+                                                        std::declval<R &&>())))          \
+    {                                                                                    \
+        const value_type &lhs = Accessor::get(obj, index);                               \
+        Accessor::set(obj, index, lhs op_ std::forward<T>(x));                           \
+        return *this;                                                                    \
+    }
+    Vc_ALL_ARITHMETICS(Vc_OP_);
+    Vc_ALL_SHIFTS(Vc_OP_);
+    Vc_ALL_BINARY(Vc_OP_);
+#undef Vc_OP_
+
+    template <typename = void>
+        Vc_INTRINSIC ElementReference &operator++() &&
+        noexcept(noexcept(std::declval<value_type &>() =
+                              Accessor::get(std::declval<U &>(), int())) &&
+                 set_noexcept<decltype(++std::declval<value_type &>())>())
+    {
+        value_type x = Accessor::get(obj, index);
+        Accessor::set(obj, index, ++x);
+        return *this;
+    }
+
+    template <typename = void>
+        Vc_INTRINSIC value_type operator++(int) &&
+        noexcept(noexcept(std::declval<value_type &>() =
+                              Accessor::get(std::declval<U &>(), int())) &&
+                 set_noexcept<decltype(std::declval<value_type &>()++)>())
+    {
+        const value_type r = Accessor::get(obj, index);
+        value_type x = r;
+        Accessor::set(obj, index, ++x);
+        return r;
+    }
+
+    template <typename = void>
+        Vc_INTRINSIC ElementReference &operator--() &&
+        noexcept(noexcept(std::declval<value_type &>() =
+                              Accessor::get(std::declval<U &>(), int())) &&
+                 set_noexcept<decltype(--std::declval<value_type &>())>())
+    {
+        value_type x = Accessor::get(obj, index);
+        Accessor::set(obj, index, --x);
+        return *this;
+    }
+
+    template <typename = void>
+        Vc_INTRINSIC value_type operator--(int) &&
+        noexcept(noexcept(std::declval<value_type &>() =
+                              Accessor::get(std::declval<U &>(), int())) &&
+                 set_noexcept<decltype(std::declval<value_type &>()--)>())
+    {
+        const value_type r = Accessor::get(obj, index);
+        value_type x = r;
+        Accessor::set(obj, index, --x);
+        return r;
+    }
+
+private:
+    int index;
+    U &obj;
+};
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_COMMON_ELEMENTREFERENCE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/exponential.h vc-1.3.0/common/exponential.h
--- vc-0.7.4/common/exponential.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/exponential.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,62 +1,53 @@
-#ifndef COMMON_EXPONENTIAL_H
-#define COMMON_EXPONENTIAL_H
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-    -------------------------------------------------------------------
-
-    The exp implementation is derived from Cephes, which carries the
-    following Copyright notice:
-
-    Cephes Math Library Release 2.2:  June, 1992
-    Copyright 1984, 1987, 1989 by Stephen L. Moshier
-    Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------
+
+The exp implementation is derived from Cephes, which carries the
+following Copyright notice:
+
+Cephes Math Library Release 2.2:  June, 1992
+Copyright 1984, 1987, 1989 by Stephen L. Moshier
+Direct inquiries to 30 Frost Street, Cambridge, MA 02140
 
 }}}*/
 
-#ifndef VC_COMMON_EXPONENTIAL_H
-#define VC_COMMON_EXPONENTIAL_H
+#ifdef Vc_COMMON_MATH_H_INTERNAL
 
-#include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+constexpr float log2_e = 1.44269504088896341f;
+constexpr float MAXLOGF = 88.72283905206835f;
+constexpr float MINLOGF = -103.278929903431851103f; /* log(2^-149) */
+constexpr float MAXNUMF = 3.4028234663852885981170418348451692544e38f;
+
+template <typename Abi, typename = enable_if<std::is_same<Abi, VectorAbi::Sse>::value ||
+                                             std::is_same<Abi, VectorAbi::Avx>::value>>
+inline Vector<float, Abi> exp(Vector<float, Abi> x)
 {
-namespace Common
-{
-    using Vc::VC__USE_NAMESPACE::c_log;
-    using Vc::VC__USE_NAMESPACE::Vector;
-    using Vc::VC__USE_NAMESPACE::floor;
-    using Vc::VC__USE_NAMESPACE::ldexp;
-
-    static const float log2_e = 1.44269504088896341f;
-    static const float MAXLOGF = 88.72283905206835f;
-    static const float MINLOGF = -103.278929903431851103f; /* log(2^-149) */
-    static const float MAXNUMF = 3.4028234663852885981170418348451692544e38f;
-
-    template<typename T> struct TypenameForLdexp { typedef Vector<int> Type; };
-    template<> struct TypenameForLdexp<Vc::sfloat> { typedef Vector<short> Type; };
-
-    template<typename T> static inline Vector<T> exp(VC_ALIGNED_PARAMETER(Vector<T>) _x) {
-        typedef Vector<T> V;
-        typedef typename V::Mask M;
-        typedef typename TypenameForLdexp<T>::Type I;
-        typedef Const<T> C;
-
-        V x(_x);
+    using V = Vector<float, Abi>;
+    typedef typename V::Mask M;
+    typedef Detail::Const<float, Abi> C;
 
         const M overflow  = x > MAXLOGF;
         const M underflow = x < MINLOGF;
@@ -68,7 +59,7 @@
         // => y  = x - n * ln(2)       | recall that: ln(2) * log₂(e) == 1
         // <=> eˣ = 2ⁿ * eʸ
         V z = floor(C::log2_e() * x + 0.5f);
-        I n = static_cast<I>(z);
+        const auto n = static_cast<Vc::SimdArray<int, V::Size>>(z);
         x -= z * C::ln2_large();
         x -= z * C::ln2_small();
 
@@ -89,57 +80,5 @@
 
         return x;
     }
-    static inline Vector<double> exp(Vector<double>::AsArg _x) {
-        Vector<double> x = _x;
-        typedef Vector<double> V;
-        typedef V::Mask M;
-        typedef Const<double> C;
-
-        const M overflow  = x > Vc_buildDouble( 1, 0x0006232bdd7abcd2ull, 9); // max log
-        const M underflow = x < Vc_buildDouble(-1, 0x0006232bdd7abcd2ull, 9); // min log
-
-        V px = floor(C::log2_e() * x + 0.5);
-#ifdef VC_IMPL_SSE
-        Vector<int> n(px);
-        n.data() = Mem::permute<X0, X2, X1, X3>(n.data());
-#elif defined(VC_IMPL_AVX)
-        __m128i tmp = _mm256_cvttpd_epi32(px.data());
-        Vector<int> n = AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp));
-#endif
-        x -= px * C::ln2_large(); //Vc_buildDouble(1, 0x00062e4000000000ull, -1);  // ln2
-        x -= px * C::ln2_small(); //Vc_buildDouble(1, 0x0007f7d1cf79abcaull, -20); // ln2
-
-        const double P[] = {
-            Vc_buildDouble(1, 0x000089cdd5e44be8ull, -13),
-            Vc_buildDouble(1, 0x000f06d10cca2c7eull,  -6),
-            Vc_buildDouble(1, 0x0000000000000000ull,   0)
-        };
-        const double Q[] = {
-            Vc_buildDouble(1, 0x00092eb6bc365fa0ull, -19),
-            Vc_buildDouble(1, 0x0004ae39b508b6c0ull,  -9),
-            Vc_buildDouble(1, 0x000d17099887e074ull,  -3),
-            Vc_buildDouble(1, 0x0000000000000000ull,   1)
-        };
-        const V x2 = x * x;
-        px = x * ((P[0] * x2 + P[1]) * x2 + P[2]);
-        x =  px / ((((Q[0] * x2 + Q[1]) * x2 + Q[2]) * x2 + Q[3]) - px);
-        x = V::One() + 2.0 * x;
-
-        x = ldexp(x, n); // == x * 2ⁿ
-
-        x(overflow) = std::numeric_limits<double>::infinity();
-        x.setZero(underflow);
-
-        return x;
-    }
-} // namespace Common
-namespace VC__USE_NAMESPACE
-{
-    using Vc::Common::exp;
-} // namespace VC__USE_NAMESPACE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
 
-#endif // VC_COMMON_EXPONENTIAL_H
-#endif // COMMON_EXPONENTIAL_H
+#endif // Vc_COMMON_MATH_H_INTERNAL
diff -Nru vc-0.7.4/common/fix_clang_emmintrin.h vc-1.3.0/common/fix_clang_emmintrin.h
--- vc-0.7.4/common/fix_clang_emmintrin.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/fix_clang_emmintrin.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*{{{
-    Copyright (C) 2013 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2013-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -21,12 +21,12 @@
 
 }}}*/
 
-#ifndef VC_COMMON_FIX_CLANG_EMMINTRIN_H
-#define VC_COMMON_FIX_CLANG_EMMINTRIN_H
+#ifndef VC_COMMON_FIX_CLANG_EMMINTRIN_H_
+#define VC_COMMON_FIX_CLANG_EMMINTRIN_H_
 
 #include <Vc/global.h>
 
-#ifdef VC_CLANG
+#if (defined Vc_CLANG && Vc_CLANG < 0x30700) || (defined Vc_APPLECLANG && Vc_APPLECLANG < 0x70000)
 
 #ifdef _mm_slli_si128
 #undef _mm_slli_si128
@@ -74,6 +74,6 @@
   __builtin_shufflevector((__m128d)(a), (__m128d)(b), (i) & 1, (((i) & 2) >> 1) + 2); })
 #endif
 
-#endif // VC_CLANG
+#endif // Vc_CLANG || Vc_APPLECLANG
 
-#endif // VC_COMMON_FIX_CLANG_EMMINTRIN_H
+#endif // VC_COMMON_FIX_CLANG_EMMINTRIN_H_
diff -Nru vc-0.7.4/common/gatherimplementation.h vc-1.3.0/common/gatherimplementation.h
--- vc-0.7.4/common/gatherimplementation.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/gatherimplementation.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,282 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_GATHERIMPLEMENTATION_H_
+#define VC_COMMON_GATHERIMPLEMENTATION_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+enum class GatherScatterImplementation : int {
+    SimpleLoop,
+    SetIndexZero,
+    BitScanLoop,
+    PopcntSwitch
+};
+
+using SimpleLoopT   = std::integral_constant<GatherScatterImplementation, GatherScatterImplementation::SimpleLoop>;
+using SetIndexZeroT = std::integral_constant<GatherScatterImplementation, GatherScatterImplementation::SetIndexZero>;
+using BitScanLoopT  = std::integral_constant<GatherScatterImplementation, GatherScatterImplementation::BitScanLoop>;
+using PopcntSwitchT = std::integral_constant<GatherScatterImplementation, GatherScatterImplementation::PopcntSwitch>;
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(SetIndexZeroT,
+                                    V &v,
+                                    const MT *mem,
+                                    IT &&indexes_,
+                                    typename V::MaskArgument mask)
+{
+    auto indexes = std::forward<IT>(indexes_);
+    indexes.setZeroInverted(static_cast<decltype(!indexes)>(mask));
+    const V tmp(mem, indexes);
+    where(mask) | v = tmp;
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(SimpleLoopT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask)
+{
+    if (Vc_IS_UNLIKELY(mask.isEmpty())) {
+        return;
+    }
+    Common::unrolled_loop<std::size_t, 0, V::Size>([&](std::size_t i) {
+        if (mask[i])
+            v[i] = mem[indexes[i]];
+    });
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(BitScanLoopT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask)
+{
+#ifdef Vc_GNU_ASM
+    size_t bits = mask.toInt();
+    while (Vc_IS_LIKELY(bits > 0)) {
+        size_t i, j;
+        asm("bsf %[bits],%[i]\n\t"
+            "bsr %[bits],%[j]\n\t"
+            "btr %[i],%[bits]\n\t"
+            "btr %[j],%[bits]\n\t"
+            : [i] "=r"(i), [j] "=r"(j), [bits] "+r"(bits));
+        v[i] = mem[indexes[i]];
+        v[j] = mem[indexes[j]];
+    }
+#else
+    // Alternative from Vc::SSE (0.7)
+    int bits = mask.toInt();
+    while (bits) {
+        const int i = _bit_scan_forward(bits);
+	bits &= bits - 1;
+	v[i] = mem[indexes[i]];
+    }
+#endif  // Vc_GNU_ASM
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(PopcntSwitchT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 16> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt16(bits)) {
+    case 16:
+        v.gather(mem, indexes);
+        break;
+    case 15:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        v[low] = mem[indexes[low]];
+    case 14:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 13:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 12:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 11:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 10:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 9:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 8:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 7:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 6:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 5:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 4:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+    case 1:
+        low = _bit_scan_forward(bits);
+        v[low] = mem[indexes[low]];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(PopcntSwitchT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 8> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt8(bits)) {
+    case 8:
+        v.gather(mem, indexes);
+        break;
+    case 7:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        v[low] = mem[indexes[low]];
+    case 6:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 5:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 4:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+        high = (1 << high);
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        v[low] = mem[indexes[low]];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+    case 1:
+        low = _bit_scan_forward(bits);
+        v[low] = mem[indexes[low]];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(PopcntSwitchT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 4> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt4(bits)) {
+    case 4:
+        v.gather(mem, indexes);
+        break;
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        v[low] = mem[indexes[low]];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        v[high] = mem[indexes[high]];
+    case 1:
+        low = _bit_scan_forward(bits);
+        v[low] = mem[indexes[low]];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeGather(PopcntSwitchT,
+                                    V &v,
+                                    const MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 2> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low;
+    switch (Vc::Detail::popcnt4(bits)) {
+    case 2:
+        v.gather(mem, indexes);
+        break;
+    case 1:
+        low = _bit_scan_forward(bits);
+        v[low] = mem[indexes[low]];
+    case 0:
+        break;
+    }
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_GATHERIMPLEMENTATION_H_
diff -Nru vc-0.7.4/common/gatherinterface.h vc-1.3.0/common/gatherinterface.h
--- vc-0.7.4/common/gatherinterface.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/gatherinterface.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,539 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef Vc_CURRENT_CLASS_NAME
+#error "incorrect use of common/gatherinterface.h: Vc_CURRENT_CLASS_NAME must be defined to the current class name for declaring constructors."
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// gathers
+// A gather takes the following arguments:
+// 1. A const pointer to memory of any type that can convert to EntryType
+// 2. An indexes “vector”. The requirement is that the type implements the subscript operator,
+//    stores «Size» valid index values, and each offset to the pointer above yields a valid
+//    memory location for reading.
+// 3. Optionally the third argument may be a mask. The mask disables several memory reads and
+//    thus removes the requirements in (2.) for the disabled entries.
+
+private:
+    /**\internal
+     * This function implements a gather given a pointer to memory \p mem and some
+     * container object storing the gather \p indexes.
+     *
+     * \param mem This pointer must be aligned correctly for the type \p MT. This is the
+     * natural behavior of C++, so this is typically the case.
+     * \param indexes This object contains at least \VSize{T} indexes that denote the
+     * offset in \p mem where the components for the current vector should be copied from.
+     * The offset is not in Bytes, but in multiples of `sizeof(MT)`.
+     */
+    // enable_if<std::can_convert<MT, EntryType>::value &&
+    // has_subscript_operator<IT>::value>
+    template <typename MT, typename IT>
+    inline void gatherImplementation(const MT *mem, IT &&indexes);
+
+    /**\internal
+     * This overload of the above function adds a \p mask argument to disable memory
+     * accesses at the \p indexes offsets where \p mask is \c false.
+     */
+    template <typename MT, typename IT>
+    inline void gatherImplementation(const MT *mem, IT &&indexes, MaskArgument mask);
+
+    /**\internal
+     * Overload for the case of C-arrays or %Vc vector objects.
+     *
+     * In this case the \p indexes parameter is usable without adjustment.
+     *
+     * \param indexes An object to be used for gather or scatter.
+     * \returns Forwards the \p indexes parameter.
+     */
+    template <typename IT, typename = enable_if<std::is_pointer<IT>::value ||
+                                                Traits::is_simd_vector<IT>::value>>
+    static Vc_INTRINSIC IT adjustIndexParameter(IT &&indexes)
+    {
+        return std::forward<IT>(indexes);
+    }
+
+    /**\internal
+     * Overload for the case of a container that returns an lvalue reference from its
+     * subscript operator.
+     *
+     * In this case the container is assumed to use contiguous storage and therefore the
+     * \p indexes object is converted to a C-array interface.
+     *
+     * \param indexes An object to be used for gather or scatter.
+     * \returns A pointer to the first object in the \p indexes container.
+     */
+    template <typename IT,
+              typename = enable_if<
+                  !std::is_pointer<IT>::value && !Traits::is_simd_vector<IT>::value &&
+                  std::is_lvalue_reference<decltype(std::declval<IT>()[0])>::value>>
+    static Vc_INTRINSIC decltype(std::addressof(std::declval<IT>()[0]))
+        adjustIndexParameter(IT &&i)
+    {
+        return std::addressof(i[0]);
+    }
+
+    /**\internal
+     * Overload for the case of a container that returns an rvalue from its
+     * subscript operator.
+     *
+     * \param indexes An object to be used for gather or scatter.
+     * \returns Forwards the \p indexes parameter.
+     */
+    template <typename IT>
+    static Vc_INTRINSIC
+        enable_if<!std::is_pointer<IT>::value && !Traits::is_simd_vector<IT>::value &&
+                      !std::is_lvalue_reference<decltype(std::declval<IT>()[0])>::value,
+                  IT>
+            adjustIndexParameter(IT &&i)
+    {
+        return std::forward<IT>(i);
+    }
+
+public:
+#define Vc_ASSERT_GATHER_PARAMETER_TYPES_                                                \
+    static_assert(                                                                       \
+        std::is_convertible<MT, EntryType>::value,                                       \
+        "The memory pointer needs to point to a type that can be converted to the "      \
+        "EntryType of this SIMD vector type.");                                          \
+    static_assert(                                                                       \
+        Vc::Traits::has_subscript_operator<IT>::value,                                   \
+        "The indexes argument must be a type that implements the subscript operator.");  \
+    static_assert(                                                                       \
+        !Traits::is_simd_vector<IT>::value ||                                            \
+            Traits::simd_vector_size<IT>::value >= Size,                                 \
+        "If you use a SIMD vector for the indexes parameter, the index vector must "     \
+        "have at least as many entries as this SIMD vector.");                           \
+    static_assert(                                                                       \
+        !std::is_array<T>::value ||                                                      \
+            (std::rank<T>::value == 1 &&                                                 \
+             (std::extent<T>::value == 0 || std::extent<T>::value >= Size)),             \
+        "If you use a simple array for the indexes parameter, the array must have "      \
+        "at least as many entries as this SIMD vector.")
+
+    /**
+     * \name Gather constructors and member functions
+     *
+     * Constructs or loads a vector from the objects at `mem[indexes[0]]`,
+     * `mem[indexes[1]]`, `mem[indexes[2]]`, ...
+     *
+     * All gather functions optionally take a mask as last argument. In that case only the
+     * entries that are selected in the mask are accessed in memory and copied to the
+     * vector. This enables invalid indexes in the \p indexes vector if those are masked
+     * off in \p mask.
+     *
+     * Gathers from structured data (AoS: arrays of struct) are possible via a special
+     * subscript operator of the container (array). You can use \ref Vc::array and \ref
+     * Vc::vector as drop-in replacements for \c std::array and \c std::vector. These
+     * container classes contain the necessary subscript operator overload. Example:
+     * \code
+     * Vc::vector<float> data(100);
+     * std::iota(data.begin(), data.end(), 0.f);  // fill with values 0, 1, 2, ...
+     * auto indexes = float_v::IndexType::IndexesFromZero();
+     * float_v gathered = data[indexes];  // gathered == [0, 1, 2, ...]
+     * \endcode
+     *
+     * Alternatively, you can use Vc::Common::AdaptSubscriptOperator to extend a given
+     * container class with the necessary subscript operator. Example:
+     * \code
+     * template <typename T, typename Allocator = std::allocator<T>>
+     * using my_vector = Vc::Common::AdaptSubscriptOperator<std::vector<T, Allocator>>;
+     * \endcode
+     *
+     * \param mem A pointer to memory which contains objects of type \p MT at the offsets
+     *            given by \p indexes.
+     * \param indexes A container/vector of offsets into \p mem.
+     *                The type of \p indexes (\p IT) may either be a pointer to integers
+     *                (C-array) or a vector of integers (preferrably IndexType).
+     * \param mask If a mask is given, only the active entries will be copied from memory.
+     *
+     * \note If you use a masked gather constructor the masked-off entries of the vector
+     * are zero-initilized.
+     */
+    ///@{
+
+    /// Gather constructor
+    template <typename MT, typename IT,
+              typename = enable_if<Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const MT *mem, IT &&indexes)
+    {
+        Vc_ASSERT_GATHER_PARAMETER_TYPES_;
+        gatherImplementation(mem, adjustIndexParameter(std::forward<IT>(indexes)));
+    }
+
+    /// Masked gather constructor
+    template <typename MT, typename IT,
+              typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const MT *mem, IT &&indexes, MaskArgument mask)
+    {
+        Vc_ASSERT_GATHER_PARAMETER_TYPES_;
+        gatherImplementation(mem, adjustIndexParameter(std::forward<IT>(indexes)), mask);
+    }
+
+    /// Gather function
+    template <typename MT,
+              typename IT,
+              typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC void gather(const MT *mem, IT &&indexes)
+    {
+        Vc_ASSERT_GATHER_PARAMETER_TYPES_;
+        gatherImplementation(mem, adjustIndexParameter(std::forward<IT>(indexes)));
+    }
+
+    /// Masked gather function
+    template <typename MT,
+              typename IT,
+              typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC void gather(const MT *mem, IT &&indexes, MaskArgument mask)
+    {
+        Vc_ASSERT_GATHER_PARAMETER_TYPES_;
+        gatherImplementation(mem, adjustIndexParameter(std::forward<IT>(indexes)), mask);
+    }
+    ///@}
+
+    /// \name Deprecated Members
+    ///@{
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                           const EntryType S1::*member1,
+                                                           IT indexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                           const EntryType S1::*member1,
+                                                           IT indexes, MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1]
+                   .gatherArguments(),
+               mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                           const S2 S1::*member1,
+                                                           const EntryType S2::*member2,
+                                                           IT indexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1][member2]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                           const S2 S1::*member1,
+                                                           const EntryType S2::*member2,
+                                                           IT indexes, MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1][member2]
+                   .gatherArguments(),
+               mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED(
+        "use the subscript operator to Vc::array or Vc::vector "
+        "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                 const EntryType *const S1::*ptrMember1,
+                                                 IT1 outerIndexes, IT2 innerIndexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                   array, outerIndexes)[ptrMember1][innerIndexes]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED(
+        "use the subscript operator to Vc::array or Vc::vector "
+        "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
+                                                 const EntryType *const S1::*ptrMember1,
+                                                 IT1 outerIndexes, IT2 innerIndexes,
+                                                 MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                   array, outerIndexes)[ptrMember1][innerIndexes]
+                   .gatherArguments(),
+               mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array,
+                                                 const EntryType S1::*member1, IT indexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array,
+                                                 const EntryType S1::*member1,
+                                                 IT indexes,
+                                                 MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1]
+                   .gatherArguments(),
+               mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array, const S2 S1::*member1,
+                                                 const EntryType S2::*member2, IT indexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1][member2]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array, const S2 S1::*member1,
+                                                 const EntryType S2::*member2, IT indexes,
+                                                 MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                   array, indexes)[member1][member2]
+                   .gatherArguments(),
+               mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array,
+                                                 const EntryType *const S1::*ptrMember1,
+                                                 IT1 outerIndexes, IT2 innerIndexes)
+    {
+        gather(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                   array, outerIndexes)[ptrMember1][innerIndexes]
+                   .gatherArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void gather(const S1 *array,
+                                                 const EntryType *const S1::*ptrMember1,
+                                                 IT1 outerIndexes, IT2 innerIndexes,
+                                                 MaskArgument mask)
+    {
+        gather(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                   array, outerIndexes)[ptrMember1][innerIndexes]
+                   .gatherArguments(),
+               mask);
+    }
+    ///@}
+
+    /**\internal
+     * \name Gather function to use from Vc::Common::subscript_operator
+     *
+     * \param args
+     * \param mask
+     */
+    ///@{
+    template <typename MT, typename IT>
+    Vc_INTRINSIC void gather(const Common::GatherArguments<MT, IT> &args)
+    {
+        gather(args.address, adjustIndexParameter(args.indexes));
+    }
+
+    template <typename MT, typename IT>
+    Vc_INTRINSIC void gather(const Common::GatherArguments<MT, IT> &args, MaskArgument mask)
+    {
+        gather(args.address, adjustIndexParameter(args.indexes), mask);
+    }
+    ///@}
+
+#undef Vc_ASSERT_GATHER_PARAMETER_TYPES_
diff -Nru vc-0.7.4/common/generalinterface.h vc-1.3.0/common/generalinterface.h
--- vc-0.7.4/common/generalinterface.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/generalinterface.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,52 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+public:
+    ///////////////////////////////////////////////////////////////////////////
+    // init to zero
+    Vector() = default;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // types
+
+    ///////////////////////////////////////////////////////////////////////////
+    // constants
+    static constexpr std::size_t size() { return Size; }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // constant Vectors
+    explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerZero) Vc_INTRINSIC_R;
+    explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerOne) Vc_INTRINSIC_R;
+    explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerIndexesFromZero) Vc_INTRINSIC_R;
+    static Vc_INTRINSIC Vc_CONST Vector Zero() { return Vector(Vc::Zero); }
+    static Vc_INTRINSIC Vc_CONST Vector One() { return Vector(Vc::One); }
+    static Vc_INTRINSIC Vc_CONST Vector IndexesFromZero()
+    {
+        return Vector(Vc::IndexesFromZero);
+    }
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/iif.h vc-1.3.0/common/iif.h
--- vc-0.7.4/common/iif.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/iif.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,32 +1,42 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_COMMON_IIF_H
-#define VC_COMMON_IIF_H
+#ifndef VC_COMMON_IIF_H_
+#define VC_COMMON_IIF_H_
 
+#include <Vc/type_traits>
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 /**
- * Function to mimic the ternary operator '?:'.
+ * \ingroup Utilities
+ *
+ * Function to mimic the ternary operator '?:' (inline-if).
  *
  * \param condition  Determines which values are returned. This is analog to the first argument to
  *                   the ternary operator.
@@ -42,21 +52,46 @@
  * \code
  * float_v x = Vc::iif (a > 1.f, b, b + c);
  * \endcode
+ *
+ * Assuming \c a has the values [0, 3, 5, 1], \c b is [1, 1, 1, 1], and \c c is [1, 2, 3, 4], then x
+ * will be [2, 2, 3, 5].
  */
-#ifndef VC_MSVC
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> iif (typename Vector<T>::Mask condition, Vector<T> trueValue, Vector<T> falseValue)
+template <typename Mask, typename T>
+Vc_ALWAYS_INLINE enable_if<is_simd_mask<Mask>::value && is_simd_vector<T>::value, T> iif(
+    const Mask &condition, const T &trueValue, const T &falseValue)
 {
-#else
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> iif (const typename Vector<T>::Mask &condition, const Vector<T> &trueValue, const Vector<T> &_falseValue)
+    T result(falseValue);
+    Vc::where(condition) | result = trueValue;
+    return result;
+}
+
+/**\internal
+ * The following declaration makes it explicit that `iif (Mask, non-vector, non-vector)`
+ * is not supposed to work. Doing the same thing with \c static_assert would break SFINAE.
+ */
+template <typename Mask, typename T>
+enable_if<is_simd_mask<Mask>::value && !is_simd_vector<T>::value, T> iif(
+    const Mask &, const T &, const T &) = delete;
+
+/**
+ * \ingroup Utilities
+ *
+ * Overload of the above for boolean conditions.
+ *
+ * This typically results in direct use of the ternary operator. This function makes it easier to
+ * switch from a Vc type to a builtin type.
+ *
+ * \param condition  Determines which value is returned. This is analog to the first argument to
+ *                   the ternary operator.
+ * \param trueValue  The value to return if \p condition is \c true.
+ * \param falseValue The value to return if \p condition is \c false.
+ * \return Either \p trueValue or \p falseValue, depending on \p condition.
+ */
+template<typename T> constexpr T iif (bool condition, const T &trueValue, const T &falseValue)
 {
-    Vector<T> falseValue(_falseValue);
-#endif
-    falseValue(condition) = trueValue;
-    return falseValue;
+    return condition ? trueValue : falseValue;
 }
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
 
-#include "undomacros.h"
+}  // namespace Vc
 
-#endif // VC_COMMON_IIF_H
+#endif // VC_COMMON_IIF_H_
diff -Nru vc-0.7.4/common/indexsequence.h vc-1.3.0/common/indexsequence.h
--- vc-0.7.4/common/indexsequence.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/indexsequence.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,79 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_INDEXSEQUENCE_H_
+#define VC_COMMON_INDEXSEQUENCE_H_
+
+#include <Vc/global.h>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/** \internal
+ * Helper class for a sequence of size_t values from 0 to N. This type will be included in
+ * C++14.
+ */
+template <std::size_t... I> struct index_sequence
+{
+    static constexpr std::size_t size() noexcept { return sizeof...(I); }
+};
+
+/** \internal
+ * This struct builds an index_sequence type from a given upper bound \p N.
+ * It does so recursively via concatenation of to index sequences of length N/2.
+ */
+template <std::size_t N> struct make_index_sequence_impl {
+    template <std::size_t Offset, std::size_t... Ns>
+    static index_sequence<Ns..., (Ns + Offset)...> join(std::false_type,
+                                                        index_sequence<Ns...>);
+    template <std::size_t Offset, std::size_t... Ns>
+    static index_sequence<Ns..., Offset - 1, (Ns + Offset)...> join(
+        std::true_type, index_sequence<Ns...>);
+
+    using is_odd = std::integral_constant<bool, N & 1>;
+    using half = typename make_index_sequence_impl<N / 2>::type;
+    using type = decltype(join<(N + 1) / 2>(is_odd(), half()));
+};
+template <> struct make_index_sequence_impl<0> {
+    using type = index_sequence<>;
+};
+template <> struct make_index_sequence_impl<1> {
+    using type = index_sequence<0>;
+};
+template <> struct make_index_sequence_impl<2> {
+    using type = index_sequence<0, 1>;
+};
+
+/** \internal
+ * Creates an index_sequence type for the upper bound \p N.
+ */
+template <std::size_t N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
+}
+
+#endif  // VC_COMMON_INDEXSEQUENCE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/interleavedmemory.h vc-1.3.0/common/interleavedmemory.h
--- vc-0.7.4/common/interleavedmemory.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/interleavedmemory.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,49 +1,50 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_COMMON_INTERLEAVEDMEMORY_H
-#define VC_COMMON_INTERLEAVEDMEMORY_H
+#ifndef VC_COMMON_INTERLEAVEDMEMORY_H_
+#define VC_COMMON_INTERLEAVEDMEMORY_H_
 
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace Common
 {
-
-namespace Internal
-{
-template<typename A, typename B> struct CopyConst { typedef B Type; };
-template<typename A, typename B> struct CopyConst<const A, B> { typedef const B Type; };
-
-template<typename S, typename X, typename R> struct EnableInterleaves { typedef R Type; };
-template<typename S, typename X, typename R> struct EnableInterleaves<const S, X, R>;
-}  // namespace Internal
-
 /**
  * \internal
  */
-template<typename V> struct InterleavedMemoryAccessBase
+template<typename V, typename I, bool Readonly> struct InterleavedMemoryAccessBase
 {
-    typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
+    // Partial specialization doesn't work for functions without partial specialization of the whole
+    // class. Therefore we capture the contents of InterleavedMemoryAccessBase in a macro to easily
+    // copy it into its specializations.
+    typedef typename std::conditional<
+        Readonly, typename std::add_const<typename V::EntryType>::type,
+        typename V::EntryType>::type T;
     typedef typename V::AsArg VArg;
     typedef T Ta Vc_MAY_ALIAS;
     const I m_indexes;
@@ -54,93 +55,114 @@
     {
     }
 
-    // implementations of the following are in {scalar,sse,avx}/interleavedmemory.tcc
-    void deinterleave(V &v0, V &v1) const;
-    void deinterleave(V &v0, V &v1, V &v2) const;
-    void deinterleave(V &v0, V &v1, V &v2, V &v3) const;
-    void deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4) const;
-    void deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5) const;
-    void deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6) const;
-    void deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7) const;
-
-    void interleave(VArg v0, VArg v1);
-    void interleave(VArg v0, VArg v1, VArg v2);
-    void interleave(VArg v0, VArg v1, VArg v2, VArg v3);
-    void interleave(VArg v0, VArg v1, VArg v2, VArg v3, VArg v4);
-    void interleave(VArg v0, VArg v1, VArg v2, VArg v3, VArg v4, VArg v5);
-    void interleave(VArg v0, VArg v1, VArg v2, VArg v3, VArg v4, VArg v5, VArg v6);
-    void interleave(VArg v0, VArg v1, VArg v2, VArg v3, VArg v4, VArg v5, VArg v6, VArg v7);
+    // implementations of the following are in {scalar,sse,avx}/detail.h
+    template <typename... Vs> Vc_INTRINSIC void deinterleave(Vs &&... vs) const
+    {
+        Impl::deinterleave(m_data, m_indexes, std::forward<Vs>(vs)...);
+    }
+
+protected:
+    using Impl = Vc::Detail::InterleaveImpl<V, V::Size, sizeof(V)>;
+
+    template <typename T, std::size_t... Indexes>
+    Vc_INTRINSIC void callInterleave(T &&a, index_sequence<Indexes...>)
+    {
+        Impl::interleave(m_data, m_indexes, a[Indexes]...);
+    }
 };
 
 /**
  * \internal
  */
 // delay execution of the deinterleaving gather until operator=
-template<size_t StructSize, typename V> struct InterleavedMemoryReadAccess : public InterleavedMemoryAccessBase<V>
+template <size_t StructSize, typename V, typename I = typename V::IndexType,
+          bool Readonly>
+struct InterleavedMemoryReadAccess : public InterleavedMemoryAccessBase<V, I, Readonly>
 {
-    typedef InterleavedMemoryAccessBase<V> Base;
+    typedef InterleavedMemoryAccessBase<V, I, Readonly> Base;
     typedef typename Base::Ta Ta;
-    typedef typename Base::I I;
 
-    Vc_ALWAYS_INLINE InterleavedMemoryReadAccess(const Ta *data, typename I::AsArg indexes)
-        : Base(indexes * I(StructSize), const_cast<Ta *>(data)) // this needs to be refactored to properly keep the constness
+    Vc_ALWAYS_INLINE InterleavedMemoryReadAccess(Ta *data, typename I::AsArg indexes)
+        : Base(StructSize == 1u
+                   ? indexes
+                   : StructSize == 2u
+                         ? indexes << 1
+                         : StructSize == 4u
+                               ? indexes << 2
+                               : StructSize == 8u
+                                     ? indexes << 3
+                                     : StructSize == 16u ? indexes << 4
+                                                         : indexes * I(int(StructSize)),
+               data)
     {
     }
+
+    template <typename T, std::size_t... Indexes>
+    Vc_ALWAYS_INLINE T deinterleave_unpack(index_sequence<Indexes...>) const
+    {
+        T r;
+        Base::Impl::deinterleave(this->m_data, this->m_indexes, std::get<Indexes>(r)...);
+        return r;
+    }
+
+    template <typename T,
+              typename = enable_if<(std::is_default_constructible<T>::value &&
+                                    std::is_same<V, Traits::decay<decltype(std::get<0>(
+                                                        std::declval<T &>()))>>::value)>>
+    Vc_ALWAYS_INLINE operator T() const
+    {
+        return deinterleave_unpack<T>(make_index_sequence<std::tuple_size<T>::value>());
+    }
+};
+
+///\internal Runtime check (NDEBUG) for asserting unique indexes.
+template<typename I> struct CheckIndexesUnique
+{
+#ifdef NDEBUG
+    static Vc_INTRINSIC void test(const I &) {}
+#else
+    static void test(const I &indexes)
+    {
+        const I test = indexes.sorted();
+        Vc_ASSERT(I::Size == 1 || (test == test.rotated(1)).isEmpty())
+    }
+#endif
+};
+///\internal For SuccessiveEntries there can never be a problem.
+template<size_t S> struct CheckIndexesUnique<SuccessiveEntries<S> >
+{
+    static Vc_INTRINSIC void test(const SuccessiveEntries<S> &) {}
 };
 
 /**
  * \internal
  */
-template<size_t StructSize, typename V> struct InterleavedMemoryAccess : public InterleavedMemoryReadAccess<StructSize, V>
+template <size_t StructSize, typename V, typename I = typename V::IndexType>
+struct InterleavedMemoryAccess : public InterleavedMemoryReadAccess<StructSize, V, I, false>
 {
-    typedef InterleavedMemoryAccessBase<V> Base;
+    typedef InterleavedMemoryAccessBase<V, I, false> Base;
     typedef typename Base::Ta Ta;
-    typedef typename Base::I I;
 
     Vc_ALWAYS_INLINE InterleavedMemoryAccess(Ta *data, typename I::AsArg indexes)
-        : InterleavedMemoryReadAccess<StructSize, V>(data, indexes)
+        : InterleavedMemoryReadAccess<StructSize, V, I, false>(data, indexes)
     {
+        CheckIndexesUnique<I>::test(indexes);
     }
 
-#define _VC_SCATTER_ASSIGNMENT(LENGTH, parameters) \
-    Vc_ALWAYS_INLINE void operator=(const VectorTuple<LENGTH, V> &rhs) \
-    { \
-        VC_STATIC_ASSERT(LENGTH <= StructSize, You_are_trying_to_scatter_more_data_into_the_struct_than_it_has); \
-        this->interleave parameters ; \
-    } \
-    Vc_ALWAYS_INLINE void operator=(const VectorTuple<LENGTH, const V> &rhs) \
-    { \
-        VC_STATIC_ASSERT(LENGTH <= StructSize, You_are_trying_to_scatter_more_data_into_the_struct_than_it_has); \
-        checkIndexesUnique(); \
-        this->interleave parameters ; \
-    }
-    _VC_SCATTER_ASSIGNMENT(2, (rhs.l, rhs.r))
-    _VC_SCATTER_ASSIGNMENT(3, (rhs.l.l, rhs.l.r, rhs.r));
-    _VC_SCATTER_ASSIGNMENT(4, (rhs.l.l.l, rhs.l.l.r, rhs.l.r, rhs.r));
-    _VC_SCATTER_ASSIGNMENT(5, (rhs.l.l.l.l, rhs.l.l.l.r, rhs.l.l.r, rhs.l.r, rhs.r));
-    _VC_SCATTER_ASSIGNMENT(6, (rhs.l.l.l.l.l, rhs.l.l.l.l.r, rhs.l.l.l.r, rhs.l.l.r, rhs.l.r, rhs.r));
-    _VC_SCATTER_ASSIGNMENT(7, (rhs.l.l.l.l.l.l, rhs.l.l.l.l.l.r, rhs.l.l.l.l.r, rhs.l.l.l.r, rhs.l.l.r, rhs.l.r, rhs.r));
-    _VC_SCATTER_ASSIGNMENT(8, (rhs.l.l.l.l.l.l.l, rhs.l.l.l.l.l.l.r, rhs.l.l.l.l.l.r, rhs.l.l.l.l.r, rhs.l.l.l.r, rhs.l.l.r, rhs.l.r, rhs.r));
-#undef _VC_SCATTER_ASSIGNMENT
-
-private:
-#ifdef NDEBUG
-    Vc_ALWAYS_INLINE void checkIndexesUnique() const {}
-#else
-    void checkIndexesUnique() const
+    template <int N> Vc_ALWAYS_INLINE void operator=(VectorReferenceArray<N, V> &&rhs)
     {
-        const I test = Base::m_indexes.sorted();
-        VC_ASSERT(I::Size == 1 || (test == test.rotated(1)).isEmpty())
+        static_assert(N <= StructSize,
+                      "You_are_trying_to_scatter_more_data_into_the_struct_than_it_has");
+        this->callInterleave(std::move(rhs), make_index_sequence<N>());
+    }
+    template <int N> Vc_ALWAYS_INLINE void operator=(VectorReferenceArray<N, const V> &&rhs)
+    {
+        static_assert(N <= StructSize,
+                      "You_are_trying_to_scatter_more_data_into_the_struct_than_it_has");
+        this->callInterleave(std::move(rhs), make_index_sequence<N>());
     }
-#endif
 };
 
-#ifdef DOXYGEN
-} // namespace Common
-// in doxygen InterleavedMemoryWrapper should appear in the Vc namespace (see the using statement
-// below)
-#endif
-
 /**
  * Wraps a pointer to memory with convenience functions to access it via vectors.
  *
@@ -154,16 +176,22 @@
  */
 template<typename S, typename V> class InterleavedMemoryWrapper
 {
-    typedef typename V::EntryType T;
+    typedef typename std::conditional<std::is_const<S>::value,
+                                      const typename V::EntryType,
+                                      typename V::EntryType>::type T;
     typedef typename V::IndexType I;
     typedef typename V::AsArg VArg;
-    typedef typename I::AsArg IndexType;
-    typedef InterleavedMemoryAccess<sizeof(S) / sizeof(T), V> Access;
-    typedef InterleavedMemoryReadAccess<sizeof(S) / sizeof(T), V> ReadAccess;
-    typedef typename Internal::CopyConst<S, T>::Type Ta Vc_MAY_ALIAS;
+    typedef const I &IndexType;
+    static constexpr std::size_t StructSize = sizeof(S) / sizeof(T);
+    typedef InterleavedMemoryAccess<StructSize, V> Access;
+    typedef InterleavedMemoryReadAccess<StructSize, V> ReadAccess;
+    typedef InterleavedMemoryAccess<StructSize, V, SuccessiveEntries<StructSize> > AccessSuccessiveEntries;
+    typedef InterleavedMemoryReadAccess<StructSize, V, SuccessiveEntries<StructSize> > ReadSuccessiveEntries;
+    typedef T Ta Vc_MAY_ALIAS;
     Ta *const m_data;
 
-    VC_STATIC_ASSERT((sizeof(S) / sizeof(T)) * sizeof(T) == sizeof(S), InterleavedMemoryAccess_does_not_support_packed_structs);
+    static_assert(StructSize * sizeof(T) == sizeof(S),
+                  "InterleavedMemoryAccess_does_not_support_packed_structs");
 
 public:
     /**
@@ -228,41 +256,77 @@
      * \warning If \p indexes contains non-unique entries on scatter, the result is undefined. If
      * \c NDEBUG is not defined the implementation will assert that the \p indexes entries are unique.
      */
-#ifdef DOXYGEN
-    Vc_ALWAYS_INLINE Access operator[](IndexType indexes)
-#else
-    // need to SFINAE disable this for objects that wrap constant data
-    template <typename U>
-    Vc_ALWAYS_INLINE typename Internal::EnableInterleaves<S, U, Access>::Type operator[](
-        VC_ALIGNED_PARAMETER(U) indexes)
-#endif
+    template <typename IT>
+    Vc_ALWAYS_INLINE enable_if<
+        std::is_convertible<IT, IndexType>::value && !std::is_const<S>::value, Access>
+        operator[](IT indexes)
     {
         return Access(m_data, indexes);
     }
 
     /// const overload (gathers only) of the above function
-    Vc_ALWAYS_INLINE ReadAccess operator[](VC_ALIGNED_PARAMETER(IndexType) indexes) const
+    Vc_ALWAYS_INLINE ReadAccess operator[](IndexType indexes) const
     {
         return ReadAccess(m_data, indexes);
     }
 
     /// alias of the above function
-    Vc_ALWAYS_INLINE ReadAccess gather(VC_ALIGNED_PARAMETER(IndexType) indexes) const
+    Vc_ALWAYS_INLINE ReadAccess gather(IndexType indexes) const { return operator[](indexes); }
+
+    /**
+     * Interleaved access.
+     *
+     * This function is an optimization of the function above, for cases where the index vector
+     * contains consecutive values. It will load \p V::Size consecutive entries from memory and
+     * deinterleave them into Vc vectors.
+     *
+     * \param first The first of \p V::Size indizes to be accessed.
+     *
+     * \return A special (magic) object that executes the loads and deinterleave on assignment to a
+     * vector tuple.
+     *
+     * Example:
+     * \code
+     * struct Foo {
+     *   float x, y, z;
+     * };
+     *
+     * void foo(Foo *_data)
+     * {
+     *   Vc::InterleavedMemoryWrapper<Foo, float_v> data(_data);
+     *   for (size_t i = 0; i < 32U; i += float_v::Size) {
+     *     float_v x, y, z;
+     *     (x, y, z) = data[i];
+     *     // now:
+     *     // x = { _data[i].x, _data[i + 1].x, _data[i + 2].x, ... }
+     *     // y = { _data[i].y, _data[i + 1].y, _data[i + 2].y, ... }
+     *     // z = { _data[i].z, _data[i + 1].z, _data[i + 2].z, ... }
+     *     ...
+     *   }
+     * }
+     * \endcode
+     */
+    Vc_ALWAYS_INLINE ReadSuccessiveEntries operator[](size_t first) const
+    {
+        return ReadSuccessiveEntries(m_data, first);
+    }
+
+    Vc_ALWAYS_INLINE AccessSuccessiveEntries operator[](size_t first)
     {
-        return operator[](indexes);
+        return AccessSuccessiveEntries(m_data, first);
     }
 
     //Vc_ALWAYS_INLINE Access scatter(I indexes, VArg v0, VArg v1);
 };
-#ifndef DOXYGEN
-} // namespace Common
+}  // namespace Common
 
 using Common::InterleavedMemoryWrapper;
-#endif
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+template <typename V, typename S>
+inline Common::InterleavedMemoryWrapper<S, V> make_interleave_wrapper(S *s)
+{
+    return Common::InterleavedMemoryWrapper<S, V>(s);
+}
+}  // namespace Vc
 
-#endif // VC_COMMON_INTERLEAVEDMEMORY_H
+#endif // VC_COMMON_INTERLEAVEDMEMORY_H_
diff -Nru vc-0.7.4/common/interleave.h vc-1.3.0/common/interleave.h
--- vc-0.7.4/common/interleave.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/interleave.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,63 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_INTERLEAVE_H_
+#define VC_COMMON_INTERLEAVE_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/** \ingroup Utilities
+ Interleaves the entries from \p a and \p b into two vectors of the same type. The order
+ in the returned vector contains the elements `a[0], b[0], a[1], b[1], a[2], b[2], a[3],
+ b[3], ...`.
+
+Example:
+\code
+Vc::SimdArray<int, 4> a = { 1, 2, 3, 4 };
+Vc::SimdArray<int, 4> b = { 9, 8, 7, 6 };
+std::tie(a, b) = Vc::interleave(a, b);
+std::cout << a << b;
+// prints:
+// <1 9 2 8><3 7 4 6>
+\endcode
+
+ \param a input vector whose data will appear at even indexes in the output
+ \param b input vector whose data will appear at odd indexes in the output
+ \return two vectors with data from \p a and \p b interleaved
+ */
+template <typename V, typename = enable_if<Traits::is_simd_vector<V>::value>>
+std::pair<V, V> interleave(const V &a, const V &b)
+{
+    return {a.interleaveLow(b), a.interleaveHigh(b)};
+}
+}  // namespace Vc
+
+#endif  // VC_COMMON_INTERLEAVE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/iterators.h vc-1.3.0/common/iterators.h
--- vc-0.7.4/common/iterators.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/iterators.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,307 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_ITERATORS_H_
+#define VC_COMMON_ITERATORS_H_
+
+#include <array>
+#include <iterator>
+#include "where.h"
+#include "elementreference.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+template<typename _V, typename Flags> class MemoryVector;
+template<typename _V, typename Flags> class MemoryVectorIterator;
+
+template <typename V> class Iterator;
+template <typename V, bool> class IteratorBase;
+template <typename V> class IteratorBase<V, true>
+{
+public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename V::value_type;
+    using difference_type = int;
+    using reference = value_type;
+    Vc_ALWAYS_INLINE reference operator*() const { return v()[i()]; }
+    Vc_ALWAYS_INLINE reference operator[](difference_type i2) const { return v()[i2]; }
+
+private:
+    Vc_INTRINSIC V &v() const { return *static_cast<const Iterator<V> *>(this)->v; }
+    Vc_INTRINSIC difference_type i() const
+    {
+        return static_cast<const Iterator<V> *>(this)->i;
+    }
+};
+
+template <typename V> class IteratorBase<V, false>
+{
+public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename V::value_type;
+    using difference_type = int;
+    using reference = Vc::Detail::ElementReference<V, IteratorBase>;
+    Vc_ALWAYS_INLINE reference operator*() const { return {*v(), i()}; }
+    Vc_ALWAYS_INLINE reference operator[](difference_type i2) const { return {*v(), i2}; }
+
+private:
+    Vc_INTRINSIC V *v() const { return static_cast<const Iterator<V> *>(this)->v; }
+    Vc_INTRINSIC difference_type i() const
+    {
+        return static_cast<const Iterator<V> *>(this)->i;
+    }
+
+    friend reference;
+    static Vc_INTRINSIC value_type get(const V &o, int i)
+    {
+        return o[i];
+    }
+    template <typename T> static Vc_INTRINSIC void set(V &o, int i, T &&v)
+    {
+        o[i] = std::forward<T>(v);
+    }
+};
+
+// class Iterator {{{
+template <typename V> class Iterator : public IteratorBase<V, std::is_const<V>::value>
+{
+    using Base = IteratorBase<V, std::is_const<V>::value>;
+    friend Base;
+
+public:
+    using typename Base::iterator_category;
+    using typename Base::value_type;
+    using typename Base::difference_type;
+    using pointer = const Iterator *;
+    using typename Base::reference;
+
+    constexpr Iterator() = default;
+    constexpr Iterator(V &_v, difference_type _i) : v(&_v), i(_i) {}
+    // rely on implicit copy constructor/assignment
+
+    Vc_ALWAYS_INLINE pointer operator->() const { return this; }
+    using Base::operator*;
+
+    Vc_ALWAYS_INLINE Iterator &operator++()    { ++i; return *this; }
+    Vc_ALWAYS_INLINE Iterator  operator++(int) { Iterator tmp = *this; ++i; return tmp; }
+
+    // bidirectional iteration is supported
+    Vc_ALWAYS_INLINE Iterator &operator--()    { --i; return *this; }
+    Vc_ALWAYS_INLINE Iterator  operator--(int) { Iterator tmp = *this; --i; return tmp; }
+
+    // RandomAccessIterator:
+    using Base::operator[];
+    Vc_ALWAYS_INLINE Iterator &operator+=(difference_type d) { i += d; return *this; }
+    Vc_ALWAYS_INLINE Iterator &operator-=(difference_type d) { i -= d; return *this; }
+    Vc_ALWAYS_INLINE Iterator operator+(difference_type d) const { return {*v, i + d}; }
+    Vc_ALWAYS_INLINE Iterator operator-(difference_type d) const { return {*v, i - d}; }
+    Vc_ALWAYS_INLINE difference_type operator-(const Iterator &rhs) const { return i - rhs.i; }
+    friend Vc_ALWAYS_INLINE Iterator operator+(difference_type d, const Iterator &rhs)
+    {
+        return {*rhs.v, rhs.i + d};
+    }
+
+    // InputIterator would not need to test v == rhs.v, but except for `reference` this
+    // class implements a complete RandomAccessIterator
+    Vc_ALWAYS_INLINE bool operator==(const Iterator<V> &rhs) const { return v == rhs.v && i == rhs.i; }
+    Vc_ALWAYS_INLINE bool operator!=(const Iterator<V> &rhs) const { return v == rhs.v && i != rhs.i; }
+    Vc_ALWAYS_INLINE bool operator< (const Iterator<V> &rhs) const { return v == rhs.v && i <  rhs.i; }
+    Vc_ALWAYS_INLINE bool operator<=(const Iterator<V> &rhs) const { return v == rhs.v && i <= rhs.i; }
+    Vc_ALWAYS_INLINE bool operator> (const Iterator<V> &rhs) const { return v == rhs.v && i >  rhs.i; }
+    Vc_ALWAYS_INLINE bool operator>=(const Iterator<V> &rhs) const { return v == rhs.v && i >= rhs.i; }
+
+private:
+    V *v = nullptr;
+    difference_type i = 0;
+};/*}}}*/
+
+template <typename V> using ConstIterator = Iterator<const V>;
+
+#ifdef Vc_IMPL_MIC
+    class BitmaskIterator/*{{{*/
+    {
+        const int mask;
+        int bit;
+    public:
+        Vc_ALWAYS_INLINE BitmaskIterator(int m) : mask(m), bit(_mm_tzcnt_32(mask)) {}
+        Vc_ALWAYS_INLINE BitmaskIterator(const BitmaskIterator &) = default;
+        Vc_ALWAYS_INLINE BitmaskIterator(BitmaskIterator &&) = default;
+
+        Vc_ALWAYS_INLINE size_t operator->() const { return bit; }
+        Vc_ALWAYS_INLINE size_t operator*() const { return bit; }
+
+        Vc_ALWAYS_INLINE BitmaskIterator &operator++()    {
+            bit = _mm_tzcnti_32(bit, mask);
+            return *this;
+        }
+        Vc_ALWAYS_INLINE BitmaskIterator  operator++(int) {
+            BitmaskIterator tmp = *this;
+            bit = _mm_tzcnti_32(bit, mask);
+            return tmp;
+        }
+
+        Vc_ALWAYS_INLINE bool operator==(const BitmaskIterator &rhs) const { return bit == rhs.bit; }
+        Vc_ALWAYS_INLINE bool operator!=(const BitmaskIterator &rhs) const { return bit != rhs.bit; }
+    };/*}}}*/
+#else
+    class BitmaskIterator/*{{{*/
+    {
+#ifdef Vc_MSVC
+        unsigned long mask;
+        unsigned long bit;
+#else
+        size_t mask;
+        size_t bit;
+#endif
+
+        void nextBit()
+        {
+#ifdef Vc_GNU_ASM
+            bit = __builtin_ctzl(mask);
+#elif defined(Vc_MSVC)
+            _BitScanForward(&bit, mask);
+#else
+#error "Not implemented yet. Please contact vc-devel@compeng.uni-frankfurt.de"
+#endif
+        }
+        void resetLsb()
+        {
+            // 01100100 - 1 = 01100011
+            mask &= (mask - 1);
+            /*
+#ifdef Vc_GNU_ASM
+            __asm__("btr %1,%0" : "+r"(mask) : "r"(bit));
+#elif defined(_WIN64)
+            _bittestandreset64(&mask, bit);
+#elif defined(_WIN32)
+            _bittestandreset(&mask, bit);
+#else
+#error "Not implemented yet. Please contact vc-devel@compeng.uni-frankfurt.de"
+#endif
+            */
+        }
+    public:
+        BitmaskIterator(decltype(mask) m) : mask(m) { nextBit(); }
+        BitmaskIterator(const BitmaskIterator &) = default;
+        BitmaskIterator(BitmaskIterator &&) = default;
+
+        Vc_ALWAYS_INLINE size_t operator->() const { return bit; }
+        Vc_ALWAYS_INLINE size_t operator*() const { return bit; }
+
+        Vc_ALWAYS_INLINE BitmaskIterator &operator++()    { resetLsb(); nextBit(); return *this; }
+        Vc_ALWAYS_INLINE BitmaskIterator  operator++(int) { BitmaskIterator tmp = *this; resetLsb(); nextBit(); return tmp; }
+
+        Vc_ALWAYS_INLINE bool operator==(const BitmaskIterator &rhs) const { return mask == rhs.mask; }
+        Vc_ALWAYS_INLINE bool operator!=(const BitmaskIterator &rhs) const { return mask != rhs.mask; }
+    };/*}}}*/
+#endif
+
+template <typename T>
+Vc_ALWAYS_INLINE
+    enable_if<Traits::is_simd_vector<T>::value || Traits::is_simd_mask<T>::value,
+              Iterator<typename std::remove_reference<T>::type>>
+    begin(T &&x)
+{
+    return {std::forward<T>(x), 0};
+}
+
+template <typename T>
+Vc_ALWAYS_INLINE
+    enable_if<Traits::is_simd_vector<T>::value || Traits::is_simd_mask<T>::value,
+              Iterator<typename std::remove_reference<T>::type>>
+    end(T &&x)
+{
+    using TT = typename std::decay<T>::type;
+    return {std::forward<T>(x), int(TT::size())};
+}
+
+template <typename T>
+Vc_ALWAYS_INLINE enable_if<
+    Traits::is_simd_mask<T>::value || Traits::is_simd_vector<T>::value, ConstIterator<T>>
+cbegin(const T &v)
+{
+    return {v, 0};
+}
+
+template <typename T>
+Vc_ALWAYS_INLINE enable_if<
+    Traits::is_simd_mask<T>::value || Traits::is_simd_vector<T>::value, ConstIterator<T>>
+cend(const T &v)
+{
+    return {v, int(T::size())};
+}
+
+template<typename M> Vc_ALWAYS_INLINE BitmaskIterator begin(const WhereImpl::WhereMask<M> &w)
+{
+    return w.mask.toInt();
+}
+
+template<typename M> Vc_ALWAYS_INLINE BitmaskIterator end(const WhereImpl::WhereMask<M> &)
+{
+    return 0;
+}
+
+template<typename V, typename Flags, typename T> Vc_ALWAYS_INLINE MemoryVectorIterator<V, Flags>
+    makeIterator(T *mem, Flags)
+{
+    return new(mem) MemoryVector<V, Flags>;
+}
+
+template<typename V, typename Flags, typename T> Vc_ALWAYS_INLINE MemoryVectorIterator<const V, Flags>
+    makeIterator(const T *mem, Flags)
+{
+    return new(const_cast<T *>(mem)) MemoryVector<const V, Flags>;
+}
+
+template<typename V, typename Flags, typename FlagsX> Vc_ALWAYS_INLINE MemoryVectorIterator<V, Flags>
+    makeIterator(MemoryVector<V, FlagsX> &mv, Flags)
+{
+    return new(&mv) MemoryVector<V, Flags>;
+}
+
+template<typename V, typename Flags, typename FlagsX> Vc_ALWAYS_INLINE MemoryVectorIterator<const V, Flags>
+    makeIterator(MemoryVector<const V, FlagsX> &mv, Flags)
+{
+    return new(&mv) MemoryVector<const V, Flags>;
+}
+
+}  // namespace Common
+
+using Common::begin;
+using Common::end;
+using Common::cbegin;
+using Common::cend;
+using Common::makeIterator;
+}  // namespace Vc
+
+#endif // VC_COMMON_ITERATORS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/loadinterface.h vc-1.3.0/common/loadinterface.h
--- vc-0.7.4/common/loadinterface.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/loadinterface.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,105 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+// load ctors{{{1
+/**
+ * Construct a vector from loading its entries from the array at \p mem.
+ *
+ * \param mem A pointer to data. The pointer must not be aligned on a
+ *            MemoryAlignment boundary unless you add the Vc::Aligned flag as a second
+ *            argument.
+ */
+explicit Vc_INTRINSIC Vector(const EntryType *mem)
+{
+    load(mem);
+}
+/**
+ * Construct a vector from loading its entries from the array at \p mem.
+ *
+ * \param mem A pointer to data. If \p flags contains the Vc::Aligned flag, the pointer
+ *            must be aligned on a MemoryAlignment boundary.
+ * \param flags A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming,
+ *              Vc::Unaligned, and/or Vc::PrefetchDefault.
+ */
+template <typename Flags, typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+explicit Vc_INTRINSIC Vector(const EntryType *mem, Flags flags)
+{
+    load(mem, flags);
+}
+
+template <typename U, typename Flags = DefaultLoadTag,
+          typename = enable_if<
+              (!std::is_integral<U>::value || !std::is_integral<EntryType>::value ||
+               sizeof(EntryType) >= sizeof(U)) &&
+              std::is_arithmetic<U>::value &&Traits::is_load_store_flag<Flags>::value>>
+explicit Vc_INTRINSIC Vector(const U *x, Flags flags = Flags())
+{
+    load<U, Flags>(x, flags);
+}
+
+// load member functions{{{1
+/**
+ * Load the vector entries from \p mem, overwriting the previous values.
+ *
+ * \param mem
+ * A pointer to data. The pointer must not be aligned on a MemoryAlignment boundary unless
+ * you add the Vc::Aligned flag as a second argument.
+ */
+Vc_INTRINSIC void load(const EntryType *mem)
+{
+    load(mem, DefaultLoadTag());
+}
+/**
+ * Load the vector entries from \p mem, overwriting the previous values.
+ *
+ * \param mem
+ * A pointer to data. If \p flags contains the Vc::Aligned flag, the pointer must be
+ * aligned on a MemoryAlignment boundary.
+ * \param flags
+ * A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming, Vc::Unaligned,
+ * and/or Vc::PrefetchDefault.
+ */
+template <typename Flags>
+Vc_INTRINSIC enable_if<Traits::is_load_store_flag<Flags>::value, void>
+load(const EntryType *mem, Flags flags)
+{
+    load<EntryType, Flags>(mem, flags);
+}
+private:
+template <typename U, typename Flags>
+struct load_concept : public std::enable_if<
+              (!std::is_integral<U>::value || !std::is_integral<EntryType>::value ||
+               sizeof(EntryType) >= sizeof(U)) &&
+              std::is_arithmetic<U>::value && Traits::is_load_store_flag<Flags>::value, void>
+{};
+
+public:
+template <typename U, typename Flags = DefaultLoadTag>
+Vc_INTRINSIC_L typename load_concept<U, Flags>::type load(const U *mem, Flags = Flags()) Vc_INTRINSIC_R;
+//}}}1
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/loadstoreflags.h vc-1.3.0/common/loadstoreflags.h
--- vc-0.7.4/common/loadstoreflags.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/loadstoreflags.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,248 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_LOADSTOREFLAGS_H_
+#define VC_COMMON_LOADSTOREFLAGS_H_
+
+#include "../traits/type_traits.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+/**
+ * Hint for \ref Prefetch to select prefetches that mark the memory as exclusive.
+ *
+ * This hint may optimize the prefetch if the memory will subsequently be written to.
+ */
+struct Exclusive {};
+/**
+ * Hint for \ref Prefetch to select prefetches that mark the memory as shared.
+ */
+struct Shared {};
+
+namespace LoadStoreFlags
+{
+
+struct StreamingFlag {};
+struct UnalignedFlag {};
+struct PrefetchFlagBase {};
+#ifdef Vc_IMPL_MIC
+template<size_t L1 = 8 * 64, size_t L2 = 64 * 64,
+#else
+// TODO: determine a good default for typical CPU use
+template<size_t L1 = 16 * 64, size_t L2 = 128 * 64,
+#endif
+    typename ExclusiveOrShared_ = void> struct PrefetchFlag : public PrefetchFlagBase
+{
+    typedef ExclusiveOrShared_ ExclusiveOrShared;
+    static constexpr size_t L1Stride = L1;
+    static constexpr size_t L2Stride = L2;
+    static constexpr bool IsExclusive = std::is_same<ExclusiveOrShared, Exclusive>::value;
+    static constexpr bool IsShared = std::is_same<ExclusiveOrShared, Shared>::value;
+};
+
+template<typename Base, typename Default, typename... LoadStoreFlags> struct ExtractType
+{
+    typedef Default type;
+};
+template<typename Base, typename Default, typename T, typename... LoadStoreFlags> struct ExtractType<Base, Default, T, LoadStoreFlags...>
+{
+    typedef typename std::conditional<std::is_base_of<Base, T>::value, T, typename ExtractType<Base, Default, LoadStoreFlags...>::type>::type type;
+};
+
+// ICC warns about the constexpr members in LoadStoreFlags: member "LoadStoreFlags<Flags...>::IsAligned" was declared but never referenced
+// who needs that warning, especially if it was referenced...
+// The warning cannot be reenabled because it gets emitted whenever the LoadStoreFlags is instantiated
+// somewhere, so it could be anywhere.
+#ifdef Vc_ICC
+#pragma warning(disable: 177)
+#endif
+/**\internal
+ * Implementation of the load/store flags mechanism. This is internal API. Only some
+ * concrete aliases are API-relevant types.
+ */
+template<typename... Flags> struct LoadStoreFlags
+{
+private:
+    // ICC doesn't grok this line:
+    //template<typename Test> using TestFlag = std::is_same<typename ExtractType<StreamingFlag, void, Flags...>::type, void>;
+    typedef typename ExtractType<PrefetchFlagBase, PrefetchFlag<0, 0>, Flags...>::type Prefetch;
+
+public:
+    constexpr LoadStoreFlags() {}
+
+    static constexpr bool IsStreaming = !std::is_same<typename ExtractType<StreamingFlag, void, Flags...>::type, void>::value;
+    static constexpr bool IsUnaligned = !std::is_same<typename ExtractType<UnalignedFlag, void, Flags...>::type, void>::value;
+    static constexpr bool IsAligned = !IsUnaligned;
+    static constexpr bool IsPrefetch = !std::is_same<typename ExtractType<PrefetchFlagBase, void, Flags...>::type, void>::value;
+    static constexpr bool IsExclusivePrefetch = Prefetch::IsExclusive;
+    static constexpr bool IsSharedPrefetch = Prefetch::IsShared;
+    static constexpr size_t L1Stride = Prefetch::L1Stride;
+    static constexpr size_t L2Stride = Prefetch::L2Stride;
+
+    typedef LoadStoreFlags<typename std::conditional<std::is_same<Flags, UnalignedFlag>::value, void, Flags>::type...> UnalignedRemoved;
+
+    // The following EnableIf* convenience types cannot use enable_if because then no LoadStoreFlags type
+    // could ever be instantiated. Instead these types are defined either as void* or void. The
+    // function that does SFINAE then assigns "= nullptr" to this type. Thus, the ones with just
+    // void result in substitution failure.
+    typedef typename std::conditional<IsAligned   && !IsStreaming, void *, void>::type EnableIfAligned;
+    typedef typename std::conditional<IsAligned   &&  IsStreaming, void *, void>::type EnableIfStreaming;
+    typedef typename std::conditional<IsUnaligned && !IsStreaming, void *, void>::type EnableIfUnalignedNotStreaming;
+    typedef typename std::conditional<IsUnaligned &&  IsStreaming, void *, void>::type EnableIfUnalignedAndStreaming;
+    typedef typename std::conditional<IsUnaligned                , void *, void>::type EnableIfUnaligned;
+    typedef typename std::conditional<!IsUnaligned               , void *, void>::type EnableIfNotUnaligned;
+    typedef typename std::conditional<IsPrefetch                 , void *, void>::type EnableIfPrefetch;
+    typedef typename std::conditional<!IsPrefetch                , void *, void>::type EnableIfNotPrefetch;
+};
+
+/**\internal
+ * Specialization for no flags (i.e aligned, non-streaming, no prefetching)
+ */
+template<> struct LoadStoreFlags<>
+{
+    constexpr LoadStoreFlags() {}
+
+    static constexpr bool IsStreaming = false;
+    static constexpr bool IsUnaligned = false;
+    static constexpr bool IsAligned = !IsUnaligned;
+    static constexpr bool IsPrefetch = false;
+    static constexpr bool IsExclusivePrefetch = false;
+    static constexpr bool IsSharedPrefetch = false;
+    static constexpr size_t L1Stride = 0;
+    static constexpr size_t L2Stride = 0;
+    typedef void* EnableIfAligned;
+    typedef void* EnableIfNotUnaligned;
+    typedef void* EnableIfNotPrefetch;
+};
+
+/**
+ * Operator for concatenation of LoadStoreFlags.
+ *
+ * Example:
+ * \code
+ * float_v x(mem, Vc::Aligned | Vc::Streaming);
+ * \endcode
+ */
+template<typename... LFlags, typename... RFlags>
+constexpr LoadStoreFlags<LFlags..., RFlags...> operator|(LoadStoreFlags<LFlags...>, LoadStoreFlags<RFlags...>)
+{
+    return LoadStoreFlags<LFlags..., RFlags...>();
+}
+
+} // LoadStoreFlags namespace
+
+using LoadStoreFlags::PrefetchFlag;
+
+typedef LoadStoreFlags::LoadStoreFlags<> AlignedTag;
+typedef LoadStoreFlags::LoadStoreFlags<LoadStoreFlags::StreamingFlag> StreamingTag;
+typedef LoadStoreFlags::LoadStoreFlags<LoadStoreFlags::UnalignedFlag> UnalignedTag;
+
+/// The default load tag type uses unaligned (non-streaming) loads.
+typedef UnalignedTag DefaultLoadTag;
+/// The default store tag type uses unaligned (non-streaming) stores.
+typedef UnalignedTag DefaultStoreTag;
+
+/**\addtogroup Utilities
+ * @{
+ */
+/**
+ * Use this object for a \p flags parameter to request aligned loads and stores.
+ *
+ * It specifies that a load/store can expect a memory address that is aligned on
+ * the correct boundary. (i.e. \p MemoryAlignment)
+ *
+ * \warning
+ * If you specify Aligned, but the memory address is not aligned the program
+ * will most likely crash.
+ */
+constexpr AlignedTag Aligned;
+
+/**
+ * Use this object for a \p flags parameter to request unaligned loads and stores.
+ *
+ * It specifies that a load/store can \em not expect a memory address that is
+ * aligned on the correct boundary. (i.e. alignment is less than
+ * \p MemoryAlignment)
+ *
+ * \note
+ * If you specify Unaligned, but the memory address is aligned the load/store
+ * will execute slightly slower than necessary.
+ */
+constexpr UnalignedTag Unaligned;
+
+/**
+ * Use this object for a \p flags parameter to request streaming loads and stores.
+ *
+ * It specifies that the cache should be bypassed for the given load/store.
+ * Whether this will actually be done depends on the target system's capabilities.
+ *
+ * Streaming stores can be interesting when the code calculates values that, after being
+ * written to memory, will not be used for a long time or used by a different thread.
+ *
+ * \note
+ * Expect that most target systems do not support unaligned streaming loads or stores.
+ * Therefore, make sure that you also specify Aligned.
+ */
+constexpr StreamingTag Streaming;
+
+/**
+ * Use this object for a \p flags parameter to request default software prefetches to be
+ * emitted.
+ */
+constexpr LoadStoreFlags::LoadStoreFlags<PrefetchFlag<>> PrefetchDefault;
+///@}
+
+/**
+ * \tparam L1
+ * \tparam L2
+ * \tparam ExclusiveOrShared
+ */
+template <size_t L1 = PrefetchFlag<>::L1Stride,
+          size_t L2 = PrefetchFlag<>::L2Stride,
+          typename ExclusiveOrShared = PrefetchFlag<>::ExclusiveOrShared>
+struct Prefetch : public LoadStoreFlags::LoadStoreFlags<PrefetchFlag<L1, L2, ExclusiveOrShared>>
+{
+};
+
+namespace Traits
+{
+///\internal partial specialization for detecting LoadStoreFlags types
+template <typename... Ts>
+struct is_loadstoreflag_internal<LoadStoreFlags::LoadStoreFlags<Ts...>> : public std::true_type
+{
+};
+///\internal partial specialization for detecting the derived Prefetch type as a
+/// load/store flag.
+template <size_t L1, size_t L2, typename ExclusiveOrShared>
+struct is_loadstoreflag_internal<Prefetch<L1, L2, ExclusiveOrShared>> : public std::true_type
+{
+};
+}  // namespace Traits
+}  // namespace Vc
+
+#endif // VC_COMMON_LOADSTOREFLAGS_H_
diff -Nru vc-0.7.4/common/logarithm.h vc-1.3.0/common/logarithm.h
--- vc-0.7.4/common/logarithm.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/logarithm.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,21 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 /* The log implementations are based on code from Julien Pommier which carries the following
    copyright information:
@@ -45,33 +53,24 @@
   (this is the zlib license)
 */
 
-#ifndef VC_COMMON_LOGARITHM_H
-#define VC_COMMON_LOGARITHM_H
+#ifdef Vc_COMMON_MATH_H_INTERNAL
 
-#include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Common
-{
-#ifdef VC__USE_NAMESPACE
-using Vc::VC__USE_NAMESPACE::Const;
-using Vc::VC__USE_NAMESPACE::Vector;
-namespace Internal
-{
-    using namespace Vc::VC__USE_NAMESPACE::Internal;
-} // namespace Internal
-#endif
 enum LogarithmBase {
     BaseE, Base10, Base2
 };
 
+namespace Detail
+{
+template <typename T, typename Abi>
+using Const = typename std::conditional<std::is_same<Abi, VectorAbi::Avx>::value,
+                                        AVX::Const<T>, SSE::Const<T>>::type;
+
 template<LogarithmBase Base>
 struct LogImpl
 {
-    template<typename T> static Vc_ALWAYS_INLINE void log_series(Vector<T> &VC_RESTRICT x, typename Vector<T>::AsArg exponent) {
-        typedef Vector<T> V;
-        typedef Const<T> C;
+    template<typename T, typename Abi> static Vc_ALWAYS_INLINE void log_series(Vector<T, Abi> &Vc_RESTRICT x, typename Vector<T, Abi>::AsArg exponent) {
+        typedef Vector<T, Abi> V;
+        typedef Detail::Const<T, Abi> C;
         // Taylor series around x = 2^exponent
         //   f(x) = ln(x)   → exponent * ln(2) → C::ln2_small + C::ln2_large
         //  f'(x) =    x⁻¹  →  x               → 1
@@ -85,7 +84,7 @@
         // P(0) is the smallest term and |x| < 1 ⇒ |xⁿ| > |xⁿ⁺¹|
         // The order of additions must go from smallest to largest terms
         const V x2 = x * x; // 0 → 4
-#ifdef VC_LOG_ILP
+#ifdef Vc_LOG_ILP
         V y2 = (C::P(6) * /*4 →  8*/ x2 + /* 8 → 11*/ C::P(7) * /*1 → 5*/ x) + /*11 → 14*/ C::P(8);
         V y0 = (C::P(0) * /*5 →  9*/ x2 + /* 9 → 12*/ C::P(1) * /*2 → 6*/ x) + /*12 → 15*/ C::P(2);
         V y1 = (C::P(3) * /*6 → 10*/ x2 + /*10 → 13*/ C::P(4) * /*3 → 7*/ x) + /*13 → 16*/ C::P(5);
@@ -93,7 +92,7 @@
         const V x6 = x3 * x3; // 11 → 15
         const V x9 = x6 * x3; // 15 → 19
         V y = (y0 * /*19 → 23*/ x9 + /*23 → 26*/ y1 * /*16 → 20*/ x6) + /*26 → 29*/ y2 * /*14 → 18*/ x3;
-#elif defined VC_LOG_ILP2
+#elif defined Vc_LOG_ILP2
         /*
          *                            name start done
          *  movaps %xmm0, %xmm1     ; x     0     1
@@ -138,9 +137,7 @@
             + C::P(5) * x6  + C::P(6) * x5  + C::P(7) * x4 + C::P(8) * x3;
 #else
         V y = C::P(0);
-        unrolled_loop16(i, 1, 9,
-                y = y * x + C::P(i);
-                );
+        Vc::Common::unrolled_loop<int, 1, 9>([&](int i) { y = y * x + C::P(i); });
         y *= x * x2;
 #endif
         switch (Base) {
@@ -171,16 +168,19 @@
         }
     }
 
-    static Vc_ALWAYS_INLINE void log_series(Vector<double> &VC_RESTRICT x, Vector<double>::AsArg exponent) {
-        typedef Vector<double> V;
-        typedef Const<double> C;
+template <typename Abi>
+static Vc_ALWAYS_INLINE void log_series(Vector<double, Abi> &Vc_RESTRICT x,
+                                        typename Vector<double, Abi>::AsArg exponent)
+{
+    typedef Vector<double, Abi> V;
+    typedef Detail::Const<double, Abi> C;
         const V x2 = x * x;
         V y = C::P(0);
         V y2 = C::Q(0) + x;
-        unrolled_loop16(i, 1, 5,
-                y = y * x + C::P(i);
-                y2 = y2 * x + C::Q(i);
-                );
+        Vc::Common::unrolled_loop<int, 1, 5>([&](int i) {
+            y = y * x + C::P(i);
+            y2 = y2 * x + C::Q(i);
+        });
         y2 = x / y2;
         y = y * x + C::P(5);
         y = x2 * y * y2;
@@ -213,10 +213,11 @@
         }
     }
 
-    template<typename T> static inline Vector<T> calc(VC_ALIGNED_PARAMETER(Vector<T>) _x) {
-        typedef Vector<T> V;
+template <typename T, typename Abi, typename V = Vector<T, Abi>>
+static inline Vector<T, Abi> calc(V _x)
+{
         typedef typename V::Mask M;
-        typedef Const<T> C;
+    typedef Detail::Const<T, Abi> C;
 
         V x(_x);
 
@@ -224,12 +225,13 @@
         const M infinityMask = x == V::Zero();
         const M denormal = x <= C::min();
 
-        x(denormal) *= V(Vc_buildDouble(1, 0, 54)); // 2²⁵
-        V exponent = Internal::exponent(x.data()); // = ⎣log₂(x)⎦
+        x(denormal) *= V(Vc::Detail::doubleConstant<1, 0, 54>()); // 2²⁵
+        V exponent = Detail::exponent(x.data());                    // = ⎣log₂(x)⎦
         exponent(denormal) -= 54;
 
         x.setZero(C::exponentMask()); // keep only the fractional part ⇒ x ∈ [1, 2[
-        x |= C::_1_2();               // and set the exponent to 2⁻¹   ⇒ x ∈ [½, 1[
+        x = Detail::operator|(x,
+                              C::_1_2());  // and set the exponent to 2⁻¹   ⇒ x ∈ [½, 1[
 
         // split calculation in two cases:
         // A: x ∈ [½, √½[
@@ -250,28 +252,22 @@
         return x;
     }
 };
+}  // namespace Detail
 
-template<typename T> static Vc_ALWAYS_INLINE Vc_CONST Vector<T> log(VC_ALIGNED_PARAMETER(Vector<T>) x) {
-    return LogImpl<BaseE>::calc(x);
-}
-template<typename T> static Vc_ALWAYS_INLINE Vc_CONST Vector<T> log10(VC_ALIGNED_PARAMETER(Vector<T>) x) {
-    return LogImpl<Base10>::calc(x);
+template <typename T, typename Abi>
+Vc_INTRINSIC Vc_CONST Vector<T, Abi> log(const Vector<T, Abi> &x)
+{
+    return Detail::LogImpl<BaseE>::calc<T, Abi>(x);
 }
-template<typename T> static Vc_ALWAYS_INLINE Vc_CONST Vector<T> log2(VC_ALIGNED_PARAMETER(Vector<T>) x) {
-    return LogImpl<Base2>::calc(x);
+template <typename T, typename Abi>
+Vc_INTRINSIC Vc_CONST Vector<T, Abi> log10(const Vector<T, Abi> &x)
+{
+    return Detail::LogImpl<Base10>::calc<T, Abi>(x);
 }
-} // namespace Common
-#ifdef VC__USE_NAMESPACE
-namespace VC__USE_NAMESPACE
+template <typename T, typename Abi>
+Vc_INTRINSIC Vc_CONST Vector<T, Abi> log2(const Vector<T, Abi> &x)
 {
-    using Vc::Common::log;
-    using Vc::Common::log10;
-    using Vc::Common::log2;
-} // namespace VC__USE_NAMESPACE
-#undef VC__USE_NAMESPACE
-#endif
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
+    return Detail::LogImpl<Base2>::calc<T, Abi>(x);
+}
 
-#endif // VC_COMMON_LOGARITHM_H
+#endif // Vc_COMMON_MATH_H_INTERNAL
diff -Nru vc-0.7.4/common/macros.h vc-1.3.0/common/macros.h
--- vc-0.7.4/common/macros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/macros.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,56 +1,77 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_MACROS_H
-#define VC_COMMON_MACROS_H
-#undef VC_COMMON_UNDOMACROS_H
+#ifndef VC_COMMON_MACROS_H_
+#define VC_COMMON_MACROS_H_
 
 #include <Vc/global.h>
 
-#if defined(VC_GCC) && !defined(__OPTIMIZE__)
-#  if VC_GCC >= 0x40500
-#    pragma GCC diagnostic push
-#    define Vc_POP_GCC_DIAGNOSTIC__ 1
-#  endif
-// GCC uses lots of old-style-casts in macros that disguise as intrinsics
-#  pragma GCC diagnostic ignored "-Wold-style-cast"
-#endif
-
-#ifdef VC_MSVC
-# define ALIGN(n) __declspec(align(n))
-# define STRUCT_ALIGN1(n) ALIGN(n)
-# define STRUCT_ALIGN2(n)
-# define ALIGNED_TYPEDEF(n, _type_, _newType_) typedef ALIGN(n) _type_ _newType_
-#else
-# define ALIGN(n) __attribute__((aligned(n)))
-# define STRUCT_ALIGN1(n)
-# define STRUCT_ALIGN2(n) ALIGN(n)
-# define ALIGNED_TYPEDEF(n, _type_, _newType_) typedef _type_ _newType_ ALIGN(n)
-#endif
-
-#ifdef VC_CXX11
-#define Vc_ALIGNOF(_TYPE_) alignof(_TYPE_)
-#else
-#define Vc_ALIGNOF(_TYPE_) __alignof(_TYPE_)
-#endif
 
-#ifdef VC_CLANG
+#ifdef Vc_MSVC
+#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_)                                      \
+    typedef __declspec(align(n_)) type_ new_type_
+#elif __GNUC__
+#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_)                                      \
+    typedef type_ new_type_[[gnu::aligned(n_)]]
+#else  // the following is actually ill-formed according to C++1[14]
+#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_)                                      \
+    using new_type_ alignas(sizeof(n_)) = type_
+#endif
+
+// On Windows (WIN32) we might see macros called min and max. Just undefine them and hope
+// noone (re)defines them (NOMINMAX should help).
+#ifdef WIN32
+#define NOMINMAX 1
+#if defined min
+#undef min
+#endif
+#if defined max
+#undef max
+#endif
+#endif  // WIN32
+
+#if defined Vc_GCC && Vc_GCC >= 0x60000
+// GCC 6 drops all attributes on types passed as template arguments. This is important
+// if a may_alias gets lost and therefore needs to be readded in the implementation of
+// the class template.
+#define Vc_TEMPLATES_DROP_ATTRIBUTES 1
+#endif
+
+#if Vc_IS_VERSION_2 || (defined Vc_GCC && Vc_GCC >= 0x60000)
+// GCC 6 optimizes the RowMemory::fromRawData hack away (common/memorybase.h). Therefore
+// the 2D Memory class is implemented recursively using 1D Memory members. Since this is
+// an ABI break this is only enabled for GCC 6. With Vc 2.x all implementations should do
+// this.
+#define Vc_RECURSIVE_MEMORY 1
+#endif
+
+#if defined Vc_CLANG || defined Vc_APPLECLANG
+#  define Vc_UNREACHABLE __builtin_unreachable
+#  define Vc_NEVER_INLINE [[gnu::noinline]]
 #  define Vc_INTRINSIC_L inline
 #  define Vc_INTRINSIC_R __attribute__((always_inline))
 #  define Vc_INTRINSIC Vc_INTRINSIC_L Vc_INTRINSIC_R
@@ -65,37 +86,33 @@
 #  define Vc_ALWAYS_INLINE_L inline
 #  define Vc_ALWAYS_INLINE_R __attribute__((always_inline))
 #  define Vc_ALWAYS_INLINE Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE_R
-#  define VC_IS_UNLIKELY(x) __builtin_expect(x, 0)
-#  define VC_IS_LIKELY(x) __builtin_expect(x, 1)
-#  define VC_RESTRICT __restrict__
-#  define VC_DEPRECATED(msg)
+#  define Vc_IS_UNLIKELY(x) __builtin_expect(x, 0)
+#  define Vc_IS_LIKELY(x) __builtin_expect(x, 1)
+#  define Vc_RESTRICT __restrict__
+#  define Vc_DEPRECATED(msg)
+#  define Vc_DEPRECATED_ALIAS(msg)
+#  define Vc_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
 #elif defined(__GNUC__)
-#  if (defined(VC_GCC) && VC_GCC < 0x40300) || defined(VC_OPEN64)
-// GCC 4.1 and 4.2 ICE on may_alias. Since Open64 uses the GCC 4.2 frontend it has the same problem.
+#  define Vc_UNREACHABLE __builtin_unreachable
+#  if defined Vc_GCC && !defined __OPTIMIZE__
 #    define Vc_MAY_ALIAS
 #  else
 #    define Vc_MAY_ALIAS __attribute__((__may_alias__))
 #  endif
-#  if (defined(VC_GCC) && VC_GCC < 0x40300)
-// GCC 4.1 fails with "sorry unimplemented: inlining failed"
-#    define Vc_INTRINSIC_R __attribute__((__flatten__))
-#  elif defined(VC_OPEN64)
-// the GCC 4.2 frontend doesn't know the __artificial__ attribute
-#    define Vc_INTRINSIC_R __attribute__((__flatten__, __always_inline__))
-#  else
-#    define Vc_INTRINSIC_R __attribute__((__flatten__, __always_inline__, __artificial__))
-#  endif
+#  define Vc_INTRINSIC_R __attribute__((__always_inline__, __artificial__))
 #  define Vc_INTRINSIC_L inline
 #  define Vc_INTRINSIC Vc_INTRINSIC_L Vc_INTRINSIC_R
 #  define Vc_FLATTEN __attribute__((__flatten__))
 #  define Vc_ALWAYS_INLINE_L inline
 #  define Vc_ALWAYS_INLINE_R __attribute__((__always_inline__))
 #  define Vc_ALWAYS_INLINE Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE_R
-#  ifdef VC_ICC
-     // ICC miscompiles if there are functions marked as pure or const
+#  ifdef Vc_ICC
+// ICC miscompiles if there are functions marked as pure or const
 #    define Vc_PURE
 #    define Vc_CONST
+#    define Vc_NEVER_INLINE
 #  else
+#    define Vc_NEVER_INLINE [[gnu::noinline]]
 #    define Vc_PURE __attribute__((__pure__))
 #    define Vc_CONST __attribute__((__const__))
 #  endif
@@ -103,17 +120,25 @@
 #  define Vc_CONST_R Vc_CONST
 #  define Vc_PURE_L
 #  define Vc_PURE_R Vc_PURE
-#  define VC_IS_UNLIKELY(x) __builtin_expect(x, 0)
-#  define VC_IS_LIKELY(x) __builtin_expect(x, 1)
-#  define VC_RESTRICT __restrict__
-#  define VC_DEPRECATED(msg) __attribute__((__deprecated__(msg)))
+#  define Vc_IS_UNLIKELY(x) __builtin_expect(x, 0)
+#  define Vc_IS_LIKELY(x) __builtin_expect(x, 1)
+#  define Vc_RESTRICT __restrict__
+#  ifdef Vc_ICC
+#    define Vc_DEPRECATED(msg)
+#    define Vc_DEPRECATED_ALIAS(msg)
+#  else
+#    define Vc_DEPRECATED(msg) __attribute__((__deprecated__(msg)))
+#    define Vc_DEPRECATED_ALIAS(msg) __attribute__((__deprecated__(msg)))
+#  endif
+#  define Vc_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
 #else
+#  define Vc_NEVER_INLINE
 #  define Vc_FLATTEN
 #  ifdef Vc_PURE
 #    undef Vc_PURE
 #  endif
 #  define Vc_MAY_ALIAS
-#  ifdef VC_MSVC
+#  ifdef Vc_MSVC
 #    define Vc_ALWAYS_INLINE inline __forceinline
 #    define Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE
 #    define Vc_ALWAYS_INLINE_R
@@ -126,6 +151,13 @@
 #    define Vc_INTRINSIC inline __forceinline
 #    define Vc_INTRINSIC_L Vc_INTRINSIC
 #    define Vc_INTRINSIC_R
+namespace Vc_VERSIONED_NAMESPACE {
+namespace detail
+{
+static Vc_INTRINSIC void unreachable() { __assume(0); }
+}  // namespace detail
+}
+#    define Vc_UNREACHABLE Vc::detail::unreachable
 #  else
 #    define Vc_ALWAYS_INLINE
 #    define Vc_ALWAYS_INLINE_L
@@ -139,246 +171,162 @@
 #    define Vc_INTRINSIC
 #    define Vc_INTRINSIC_L
 #    define Vc_INTRINSIC_R
+#    define Vc_UNREACHABLE std::abort
 #  endif
-#  define VC_IS_UNLIKELY(x) x
-#  define VC_IS_LIKELY(x) x
-#  define VC_RESTRICT __restrict
-#  define VC_DEPRECATED(msg) __declspec(deprecated(msg))
-#endif
+#  define Vc_IS_UNLIKELY(x) x
+#  define Vc_IS_LIKELY(x) x
+#  define Vc_RESTRICT __restrict
+#  define Vc_DEPRECATED(msg) __declspec(deprecated(msg))
+#  define Vc_DEPRECATED_ALIAS(msg)
+#  define Vc_WARN_UNUSED_RESULT
+#endif
+
+#ifdef Vc_CXX14
+#undef Vc_DEPRECATED
+#define Vc_DEPRECATED(msg_) [[deprecated(msg_)]]
+#endif
+
+#define Vc_NOTHING_EXPECTING_SEMICOLON static_assert(true, "")
+
+#define Vc_FREE_STORE_OPERATORS_ALIGNED(align_)                                          \
+    /**\name new/delete overloads for correct alignment */                               \
+    /**@{*/                                                                              \
+    /*!\brief Allocates correctly aligned memory */                                      \
+    Vc_ALWAYS_INLINE void *operator new(size_t size)                                     \
+    {                                                                                    \
+        return Vc::Common::aligned_malloc<align_>(size);                                 \
+    }                                                                                    \
+    /*!\brief Returns \p p. */                                                           \
+    Vc_ALWAYS_INLINE void *operator new(size_t, void *p) { return p; }                   \
+    /*!\brief Allocates correctly aligned memory */                                      \
+    Vc_ALWAYS_INLINE void *operator new[](size_t size)                                   \
+    {                                                                                    \
+        return Vc::Common::aligned_malloc<align_>(size);                                 \
+    }                                                                                    \
+    /*!\brief Returns \p p. */                                                           \
+    Vc_ALWAYS_INLINE void *operator new[](size_t, void *p) { return p; }                 \
+    /*!\brief Frees aligned memory. */                                                   \
+    Vc_ALWAYS_INLINE void operator delete(void *ptr, size_t) { Vc::Common::free(ptr); }  \
+    /*!\brief Does nothing. */                                                           \
+    Vc_ALWAYS_INLINE void operator delete(void *, void *) {}                             \
+    /*!\brief Frees aligned memory. */                                                   \
+    Vc_ALWAYS_INLINE void operator delete[](void *ptr, size_t)                           \
+    {                                                                                    \
+        Vc::Common::free(ptr);                                                           \
+    }                                                                                    \
+    /*!\brief Does nothing. */                                                           \
+    Vc_ALWAYS_INLINE void operator delete[](void *, void *) {}                           \
+    /**@}*/                                                                              \
+    Vc_NOTHING_EXPECTING_SEMICOLON
 
-#if __cplusplus >= 201103 /*C++11*/
-#define _VC_CONSTEXPR constexpr
-#define _VC_CONSTEXPR_L _VC_CONSTEXPR
-#define _VC_CONSTEXPR_R
-#else
-#define _VC_CONSTEXPR Vc_INTRINSIC Vc_CONST
-#define _VC_CONSTEXPR_L Vc_INTRINSIC_L Vc_CONST_L
-#define _VC_CONSTEXPR_R Vc_INTRINSIC_R Vc_CONST_R
-#endif
-
-#ifdef VC_CXX11
-# define _VC_NOEXCEPT noexcept
-#else
-# define _VC_NOEXCEPT throw()
-#endif
-
-#define FREE_STORE_OPERATORS_ALIGNED(alignment) \
-        Vc_ALWAYS_INLINE void *operator new(size_t size) { return _mm_malloc(size, alignment); } \
-        Vc_ALWAYS_INLINE void *operator new(size_t, void *p) { return p; } \
-        Vc_ALWAYS_INLINE void *operator new[](size_t size) { return _mm_malloc(size, alignment); } \
-        Vc_ALWAYS_INLINE void *operator new[](size_t , void *p) { return p; } \
-        Vc_ALWAYS_INLINE void operator delete(void *ptr, size_t) { _mm_free(ptr); } \
-        Vc_ALWAYS_INLINE void operator delete(void *, void *) {} \
-        Vc_ALWAYS_INLINE void operator delete[](void *ptr, size_t) { _mm_free(ptr); } \
-        Vc_ALWAYS_INLINE void operator delete[](void *, void *) {}
-
-#ifdef VC_GCC
-# define VC_WARN_INLINE
-# define VC_WARN(msg) __attribute__((warning("\n\t" msg)))
-#else
-# define VC_WARN_INLINE inline
-# define VC_WARN(msg)
-#endif
-
-#define unrolled_loop16(_it_, _start_, _end_, _code_) \
-if (_start_ +  0 < _end_) { enum { _it_ = (_start_ +  0) < _end_ ? (_start_ +  0) : _start_ }; _code_ } \
-if (_start_ +  1 < _end_) { enum { _it_ = (_start_ +  1) < _end_ ? (_start_ +  1) : _start_ }; _code_ } \
-if (_start_ +  2 < _end_) { enum { _it_ = (_start_ +  2) < _end_ ? (_start_ +  2) : _start_ }; _code_ } \
-if (_start_ +  3 < _end_) { enum { _it_ = (_start_ +  3) < _end_ ? (_start_ +  3) : _start_ }; _code_ } \
-if (_start_ +  4 < _end_) { enum { _it_ = (_start_ +  4) < _end_ ? (_start_ +  4) : _start_ }; _code_ } \
-if (_start_ +  5 < _end_) { enum { _it_ = (_start_ +  5) < _end_ ? (_start_ +  5) : _start_ }; _code_ } \
-if (_start_ +  6 < _end_) { enum { _it_ = (_start_ +  6) < _end_ ? (_start_ +  6) : _start_ }; _code_ } \
-if (_start_ +  7 < _end_) { enum { _it_ = (_start_ +  7) < _end_ ? (_start_ +  7) : _start_ }; _code_ } \
-if (_start_ +  8 < _end_) { enum { _it_ = (_start_ +  8) < _end_ ? (_start_ +  8) : _start_ }; _code_ } \
-if (_start_ +  9 < _end_) { enum { _it_ = (_start_ +  9) < _end_ ? (_start_ +  9) : _start_ }; _code_ } \
-if (_start_ + 10 < _end_) { enum { _it_ = (_start_ + 10) < _end_ ? (_start_ + 10) : _start_ }; _code_ } \
-if (_start_ + 11 < _end_) { enum { _it_ = (_start_ + 11) < _end_ ? (_start_ + 11) : _start_ }; _code_ } \
-if (_start_ + 12 < _end_) { enum { _it_ = (_start_ + 12) < _end_ ? (_start_ + 12) : _start_ }; _code_ } \
-if (_start_ + 13 < _end_) { enum { _it_ = (_start_ + 13) < _end_ ? (_start_ + 13) : _start_ }; _code_ } \
-if (_start_ + 14 < _end_) { enum { _it_ = (_start_ + 14) < _end_ ? (_start_ + 14) : _start_ }; _code_ } \
-if (_start_ + 15 < _end_) { enum { _it_ = (_start_ + 15) < _end_ ? (_start_ + 15) : _start_ }; _code_ } \
-do {} while ( false )
-
-#define for_all_vector_entries(_it_, _code_) \
-  unrolled_loop16(_it_, 0, Size, _code_)
-
-#ifdef VC_ASSERT
-#define VC_EXTERNAL_ASSERT 1
+#ifdef Vc_ASSERT
+#define Vc_EXTERNAL_ASSERT 1
 #else
 #ifdef NDEBUG
-#define VC_ASSERT(x)
+#define Vc_ASSERT(x)
 #else
 #include <assert.h>
-#define VC_ASSERT(x) assert(x);
+#define Vc_ASSERT(x) assert(x);
 #endif
 #endif
 
-#ifdef VC_CLANG
-#define VC_HAS_BUILTIN(x) __has_builtin(x)
+#if defined Vc_CLANG || defined Vc_APPLECLANG
+#define Vc_HAS_BUILTIN(x) __has_builtin(x)
 #else
-#define VC_HAS_BUILTIN(x) 0
+#define Vc_HAS_BUILTIN(x) 0
 #endif
 
-#ifndef VC_COMMON_MACROS_H_ONCE
-#define VC_COMMON_MACROS_H_ONCE
+#define Vc_CAT_HELPER_(a, b, c, d) a##b##c##d
+#define Vc_CAT(a, b, c, d) Vc_CAT_HELPER_(a, b, c, d)
 
-#define _VC_CAT_HELPER(a, b, c, d) a##b##c##d
-#define _VC_CAT(a, b, c, d) _VC_CAT_HELPER(a, b, c, d)
+#define Vc_CAT_IMPL(a, b) a##b
+#define Vc_CAT2(a, b) Vc_CAT_IMPL(a, b)
 
-#if __cplusplus >= 201103 /*C++11*/ || (defined(VC_MSVC) && VC_MSVC >= 160000000)
-#define VC_STATIC_ASSERT_NC(cond, msg) \
-    static_assert(cond, #msg)
-#define VC_STATIC_ASSERT(cond, msg) VC_STATIC_ASSERT_NC(cond, msg)
-#else // C++98
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc {
-    namespace {
-        template<bool> struct STATIC_ASSERT_FAILURE;
-        template<> struct STATIC_ASSERT_FAILURE<true> {};
-}}
-/*OUTER_NAMESPACE_END*/
-
-#define VC_STATIC_ASSERT_NC(cond, msg) \
-    typedef STATIC_ASSERT_FAILURE<cond> _VC_CAT(static_assert_failed_on_line_,__LINE__,_,msg); \
-    enum { \
-        _VC_CAT(static_assert_failed__on_line_,__LINE__,_,msg) = sizeof(_VC_CAT(static_assert_failed_on_line_,__LINE__,_,msg)) \
-    }
-#define VC_STATIC_ASSERT(cond, msg) VC_STATIC_ASSERT_NC(cond, msg)
-#endif // C++11/98
-
-    template<int e, int center> struct exponentToMultiplier { enum Values__ {
-        X = exponentToMultiplier<e - 1, center>::X * ((e - center < 31) ? 2 : 1),
-        Value = (X == 0 ? 1 : X)
-    }; };
-    template<int center> struct exponentToMultiplier<center,center> { enum Values__ { X = 1, Value = X }; };
-    template<int center> struct exponentToMultiplier<   -1, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -128, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -256, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -384, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -512, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -640, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -768, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier< -896, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToMultiplier<-1024, center> { enum Values__ { X = 0, Value = 1 }; };
-
-    template<int e, int center> struct exponentToDivisor { enum Values__ {
-        X = exponentToDivisor<e + 1, center>::X * ((center - e < 31) ? 2 : 1),
-        Value = (X == 0 ? 1 : X)
-    }; };
-    template<int center> struct exponentToDivisor<center, center> { enum Values__ { X = 1, Value = X }; };
-    template<int center> struct exponentToDivisor<     1, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   128, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   256, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   384, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   512, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   640, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   768, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<   896, center> { enum Values__ { X = 0, Value = 1 }; };
-    template<int center> struct exponentToDivisor<  1024, center> { enum Values__ { X = 0, Value = 1 }; };
-#endif // VC_COMMON_MACROS_H_ONCE
-
-#define _CAT_IMPL(a, b) a##b
-#define CAT(a, b) _CAT_IMPL(a, b)
-
-#define Vc_buildDouble(sign, mantissa, exponent) \
-    ((static_cast<double>((mantissa & 0x000fffffffffffffull) | 0x0010000000000000ull) / 0x0010000000000000ull) \
-    * exponentToMultiplier<exponent,  0>::Value \
-    * exponentToMultiplier<exponent, 30>::Value \
-    * exponentToMultiplier<exponent, 60>::Value \
-    * exponentToMultiplier<exponent, 90>::Value \
-    / exponentToDivisor<exponent,   0>::Value \
-    / exponentToDivisor<exponent, -30>::Value \
-    / exponentToDivisor<exponent, -60>::Value \
-    / exponentToDivisor<exponent, -90>::Value \
-    * static_cast<double>(sign))
-#define Vc_buildFloat(sign, mantissa, exponent) \
-    ((static_cast<float>((mantissa & 0x007fffffu) | 0x00800000) / 0x00800000) \
-    * exponentToMultiplier<exponent,  0>::Value \
-    * exponentToMultiplier<exponent, 30>::Value \
-    * exponentToMultiplier<exponent, 60>::Value \
-    * exponentToMultiplier<exponent, 90>::Value \
-    / exponentToDivisor<exponent,   0>::Value \
-    / exponentToDivisor<exponent, -30>::Value \
-    / exponentToDivisor<exponent, -60>::Value \
-    / exponentToDivisor<exponent, -90>::Value \
-    * static_cast<float>(sign))
-
-#define _VC_APPLY_IMPL_1(macro, a, b, c, d, e) macro(a)
-#define _VC_APPLY_IMPL_2(macro, a, b, c, d, e) macro(a, b)
-#define _VC_APPLY_IMPL_3(macro, a, b, c, d, e) macro(a, b, c)
-#define _VC_APPLY_IMPL_4(macro, a, b, c, d, e) macro(a, b, c, d)
-#define _VC_APPLY_IMPL_5(macro, a, b, c, d, e) macro(a, b, c, d, e)
+#define Vc_APPLY_IMPL_1_(macro, a, b, c, d, e) macro(a)
+#define Vc_APPLY_IMPL_2_(macro, a, b, c, d, e) macro(a, b)
+#define Vc_APPLY_IMPL_3_(macro, a, b, c, d, e) macro(a, b, c)
+#define Vc_APPLY_IMPL_4_(macro, a, b, c, d, e) macro(a, b, c, d)
+#define Vc_APPLY_IMPL_5_(macro, a, b, c, d, e) macro(a, b, c, d, e)
 
-#define VC_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \
+#define Vc_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \
     size(macro, double_v, a, b, c, d) \
-    size(macro,  float_v, a, b, c, d) \
-    size(macro, sfloat_v, a, b, c, d)
-#define VC_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d) \
+    size(macro,  float_v, a, b, c, d)
+#define Vc_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d) \
     size(macro,    int_v, a, b, c, d) \
     size(macro,   uint_v, a, b, c, d) \
     size(macro,  short_v, a, b, c, d) \
     size(macro, ushort_v, a, b, c, d)
-#define VC_LIST_VECTOR_TYPES(size, macro, a, b, c, d) \
-    VC_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \
-    VC_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d)
-#define VC_LIST_COMPARES(size, macro, a, b, c, d) \
+#define Vc_LIST_VECTOR_TYPES(size, macro, a, b, c, d) \
+    Vc_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \
+    Vc_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d)
+#define Vc_LIST_COMPARES(size, macro, a, b, c, d) \
     size(macro, ==, a, b, c, d) \
     size(macro, !=, a, b, c, d) \
     size(macro, <=, a, b, c, d) \
     size(macro, >=, a, b, c, d) \
     size(macro, < , a, b, c, d) \
     size(macro, > , a, b, c, d)
-#define VC_LIST_LOGICAL(size, macro, a, b, c, d) \
+#define Vc_LIST_LOGICAL(size, macro, a, b, c, d) \
     size(macro, &&, a, b, c, d) \
     size(macro, ||, a, b, c, d)
-#define VC_LIST_BINARY(size, macro, a, b, c, d) \
+#define Vc_LIST_BINARY(size, macro, a, b, c, d) \
     size(macro, |, a, b, c, d) \
     size(macro, &, a, b, c, d) \
     size(macro, ^, a, b, c, d)
-#define VC_LIST_SHIFTS(size, macro, a, b, c, d) \
+#define Vc_LIST_SHIFTS(size, macro, a, b, c, d) \
     size(macro, <<, a, b, c, d) \
     size(macro, >>, a, b, c, d)
-#define VC_LIST_ARITHMETICS(size, macro, a, b, c, d) \
+#define Vc_LIST_ARITHMETICS(size, macro, a, b, c, d) \
     size(macro, +, a, b, c, d) \
     size(macro, -, a, b, c, d) \
     size(macro, *, a, b, c, d) \
     size(macro, /, a, b, c, d) \
     size(macro, %, a, b, c, d)
 
-#define VC_APPLY_0(_list, macro)             _list(_VC_APPLY_IMPL_1, macro, 0, 0, 0, 0)
-#define VC_APPLY_1(_list, macro, a)          _list(_VC_APPLY_IMPL_2, macro, a, 0, 0, 0)
-#define VC_APPLY_2(_list, macro, a, b)       _list(_VC_APPLY_IMPL_3, macro, a, b, 0, 0)
-#define VC_APPLY_3(_list, macro, a, b, c)    _list(_VC_APPLY_IMPL_4, macro, a, b, c, 0)
-#define VC_APPLY_4(_list, macro, a, b, c, d) _list(_VC_APPLY_IMPL_5, macro, a, b, c, d)
-
-#define VC_ALL_COMPARES(macro)     VC_APPLY_0(VC_LIST_COMPARES, macro)
-#define VC_ALL_LOGICAL(macro)      VC_APPLY_0(VC_LIST_LOGICAL, macro)
-#define VC_ALL_BINARY(macro)       VC_APPLY_0(VC_LIST_BINARY, macro)
-#define VC_ALL_SHIFTS(macro)       VC_APPLY_0(VC_LIST_SHIFTS, macro)
-#define VC_ALL_ARITHMETICS(macro)  VC_APPLY_0(VC_LIST_ARITHMETICS, macro)
-#define VC_ALL_FLOAT_VECTOR_TYPES(macro) VC_APPLY_0(VC_LIST_FLOAT_VECTOR_TYPES, macro)
-#define VC_ALL_VECTOR_TYPES(macro) VC_APPLY_0(VC_LIST_VECTOR_TYPES, macro)
+#define Vc_APPLY_0(_list, macro)             _list(Vc_APPLY_IMPL_1_, macro, 0, 0, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON
+#define Vc_APPLY_1(_list, macro, a)          _list(Vc_APPLY_IMPL_2_, macro, a, 0, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON
+#define Vc_APPLY_2(_list, macro, a, b)       _list(Vc_APPLY_IMPL_3_, macro, a, b, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON
+#define Vc_APPLY_3(_list, macro, a, b, c)    _list(Vc_APPLY_IMPL_4_, macro, a, b, c, 0) Vc_NOTHING_EXPECTING_SEMICOLON
+#define Vc_APPLY_4(_list, macro, a, b, c, d) _list(Vc_APPLY_IMPL_5_, macro, a, b, c, d) Vc_NOTHING_EXPECTING_SEMICOLON
 
-#define VC_EXACT_TYPE(_test, _reference, _type) \
-    typename EnableIf<IsEqualType<_test, _reference>::Value, _type>::Value
+#define Vc_ALL_COMPARES(macro)     Vc_APPLY_0(Vc_LIST_COMPARES, macro)
+#define Vc_ALL_LOGICAL(macro)      Vc_APPLY_0(Vc_LIST_LOGICAL, macro)
+#define Vc_ALL_BINARY(macro)       Vc_APPLY_0(Vc_LIST_BINARY, macro)
+#define Vc_ALL_SHIFTS(macro)       Vc_APPLY_0(Vc_LIST_SHIFTS, macro)
+#define Vc_ALL_ARITHMETICS(macro)  Vc_APPLY_0(Vc_LIST_ARITHMETICS, macro)
+#define Vc_ALL_FLOAT_VECTOR_TYPES(macro) Vc_APPLY_0(Vc_LIST_FLOAT_VECTOR_TYPES, macro)
+#define Vc_ALL_VECTOR_TYPES(macro) Vc_APPLY_0(Vc_LIST_VECTOR_TYPES, macro)
 
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-#define VC_ALIGNED_PARAMETER(_Type) const _Type &
-#else
-#define VC_ALIGNED_PARAMETER(_Type) const _Type
-#endif
+#define Vc_EXACT_TYPE(_test, _reference, _type) \
+    typename std::enable_if<std::is_same<_test, _reference>::value, _type>::type
+
+#define Vc_make_unique(name) Vc_CAT(Vc_,name,_,__LINE__)
 
-#ifndef Vc__make_unique
-#define Vc__make_unique(name) _VC_CAT(Vc__,name,_,__LINE__)
+#if defined(Vc_ICC) || defined(Vc_CLANG) || defined Vc_APPLECLANG
+#define Vc_OFFSETOF(Type, member) (reinterpret_cast<const char *>(&reinterpret_cast<const Type *>(0)->member) - reinterpret_cast<const char *>(0))
+#else
+#define Vc_OFFSETOF(Type, member) offsetof(Type, member)
 #endif
 
-#if defined(VC_ICC) || defined(VC_CLANG)
-#define VC_OFFSETOF(Type, member) (reinterpret_cast<const char *>(&reinterpret_cast<const Type *>(0)->member) - reinterpret_cast<const char *>(0))
-#elif defined(VC_GCC) && VC_GCC < 0x40500
-#define VC_OFFSETOF(Type, member) (reinterpret_cast<const char *>(&reinterpret_cast<const Type *>(0x1000)->member) - reinterpret_cast<const char *>(0x1000))
+#if defined(Vc_NO_NOEXCEPT)
+#define Vc_NOEXCEPT throw()
 #else
-#define VC_OFFSETOF(Type, member) offsetof(Type, member)
+#define Vc_NOEXCEPT noexcept
 #endif
 
+#ifdef Vc_NO_ALWAYS_INLINE
+#undef Vc_ALWAYS_INLINE
+#undef Vc_ALWAYS_INLINE_L
+#undef Vc_ALWAYS_INLINE_R
+#define Vc_ALWAYS_INLINE inline
+#define Vc_ALWAYS_INLINE_L inline
+#define Vc_ALWAYS_INLINE_R
+#undef Vc_INTRINSIC
+#undef Vc_INTRINSIC_L
+#undef Vc_INTRINSIC_R
+#define Vc_INTRINSIC inline
+#define Vc_INTRINSIC_L inline
+#define Vc_INTRINSIC_R
+#endif
 
-#endif // VC_COMMON_MACROS_H
+#endif // VC_COMMON_MACROS_H_
diff -Nru vc-0.7.4/common/makeContainer.h vc-1.3.0/common/makeContainer.h
--- vc-0.7.4/common/makeContainer.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/makeContainer.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,151 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MAKECONTAINER_H_
+#define VC_COMMON_MAKECONTAINER_H_
+
+#include <Vc/vector.h>
+#include <initializer_list>
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+    namespace
+    {
+        template<typename Container, typename T> struct make_container_helper
+        {
+            static constexpr Container help(std::initializer_list<T> list) { return { list }; }
+        };
+
+        template <typename T_, typename Abi, typename Alloc,
+                  template <class, class> class Container>
+        struct make_container_helper<Container<Vector<T_, Abi>, Alloc>,
+                                     typename Vector<T_, Abi>::EntryType> {
+            typedef Vector<T_, Abi> V;
+            typedef typename V::EntryType T;
+            typedef Container<V, Alloc> C;
+            static inline C help(std::initializer_list<T> list) {
+                const std::size_t size = (list.size() + (V::Size - 1)) / V::Size;
+                C v(size);
+                auto containerIt = v.begin();
+                auto init = std::begin(list);
+                const auto initEnd = std::end(list);
+                for (std::size_t i = 0; i < size - 1; ++i) {
+                    *containerIt++ = V(init, Vc::Unaligned);
+                    init += V::Size;
+                }
+                Vc_ASSERT(all_of(*containerIt == V::Zero()));
+                int j = 0;
+                while (init != initEnd) {
+                    (*containerIt)[j++] = *init++;
+                }
+                return v;
+            }
+        };
+
+        template <typename T_, typename Abi, std::size_t N,
+                  template <class, std::size_t> class Container>
+        struct make_container_helper<Container<Vector<T_, Abi>, N>,
+                                     typename Vector<T_, Abi>::EntryType> {
+            typedef Vector<T_, Abi> V;
+            typedef typename V::EntryType T;
+            static constexpr std::size_t size = (N + (V::Size - 1)) / V::Size;
+            typedef Container<
+                V,
+#if defined Vc_CLANG && Vc_CLANG < 0x30700 // TODO: when did Vc_APPLECLANG fix it?
+                // clang before 3.7.0 has a bug when returning std::array<__m256x, 1>. So
+                // increase it to std::array<__m256x, 2> and fill it with zeros. Better
+                // than returning garbage.
+                (size == 1 && std::is_same<Abi, VectorAbi::Avx>::value) ? 2 :
+#endif
+                                                                        size> C;
+            static inline C help(std::initializer_list<T> list) {
+                Vc_ASSERT(N == list.size())
+                Vc_ASSERT(size == (list.size() + (V::Size - 1)) / V::Size)
+                C v;
+                auto containerIt = v.begin();
+                auto init = std::begin(list);
+                const auto initEnd = std::end(list);
+                for (std::size_t i = 0; i < size - 1; ++i) {
+                    *containerIt++ = V(init, Vc::Unaligned);
+                    init += V::Size;
+                }
+                Vc_ASSERT(all_of(*containerIt == V::Zero()));
+                int j = 0;
+                while (init != initEnd) {
+                    (*containerIt)[j++] = *init++;
+                }
+                return v;
+            }
+        };
+    } // anonymous namespace
+
+    /**
+     * \ingroup Utilities
+     * \headerfile Utils
+     *
+     * Construct a container of Vc vectors from a std::initializer_list of scalar entries.
+     *
+     * \tparam Container The container type to construct.
+     * \tparam T The scalar type to use for the initializer_list.
+     *
+     * \param list An initializer list of arbitrary size. The type of the entries is important!
+     * If you pass a list of integers you will get a container filled with Vc::int_v objects.
+     * If, instead, you want to have a container of Vc::float_v objects, be sure the include a
+     * period (.) and the 'f' postfix in the literals. Alternatively, you can pass the
+     * type as second template argument to makeContainer.
+     *
+     * \return Returns a container of the requested class filled with the minimum number of SIMD
+     * vectors to hold the values in the initializer list.
+     * If the number of values in \p list does not match the number of values in the
+     * returned container object, the remaining values in the returned object will be
+     * zero-initialized.
+     *
+     * Example:
+     * \code
+     * auto data = Vc::makeContainer<std::vector<float_v>>({ 1.f, 2.f, 3.f, 4.f, 5.f });
+     * // data.size() == 5 if float_v::Size == 1 (i.e. Vc_IMPL=Scalar)
+     * // data.size() == 2 if float_v::Size == 4 (i.e. Vc_IMPL=SSE)
+     * // data.size() == 1 if float_v::Size == 8 (i.e. Vc_IMPL=AVX)
+     * \endcode
+     */
+    template<typename Container, typename T>
+    constexpr auto makeContainer(std::initializer_list<T> list) -> decltype(make_container_helper<Container, T>::help(list))
+    {
+        return make_container_helper<Container, T>::help(list);
+    }
+
+    template<typename Container, typename T>
+    constexpr auto make_container(std::initializer_list<T> list) -> decltype(makeContainer<Container, T>(list))
+    {
+        return makeContainer<Container, T>(list);
+    }
+
+}  // namespace Vc
+
+#endif // VC_COMMON_MAKECONTAINER_H_
diff -Nru vc-0.7.4/common/make_unique.h vc-1.3.0/common/make_unique.h
--- vc-0.7.4/common/make_unique.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/make_unique.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,57 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MAKE_UNIQUE_H_
+#define VC_COMMON_MAKE_UNIQUE_H_
+
+#include <memory>
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+template<typename T> struct Deleter
+{
+    Vc_ALWAYS_INLINE void operator()(T *ptr) {
+        ptr->~T();
+        Vc::free(ptr);
+    }
+};
+
+template<class T, MallocAlignment A = Vc::AlignOnVector, class... Args>
+inline std::unique_ptr<T, Deleter<T>> make_unique(Args&&... args)
+{
+    return std::unique_ptr<T, Deleter<T>>(new(Vc::malloc<T, A>(1)) T(std::forward<Args>(args)...));
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_MAKE_UNIQUE_H_
diff -Nru vc-0.7.4/common/malloc.h vc-1.3.0/common/malloc.h
--- vc-0.7.4/common/malloc.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/malloc.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,106 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MALLOC_H_
+#define VC_COMMON_MALLOC_H_
+
+#ifndef Vc_VECTOR_DECLARED_
+#error "Incorrect inclusion order. This header must be included from Vc/vector.h only."
+#endif
+
+#if defined _WIN32 || defined _WIN64
+#include <malloc.h>
+#else
+#include <cstdlib>
+#endif
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+template <size_t X> static constexpr size_t nextMultipleOf(size_t value)
+{
+    return (value % X) > 0 ? value + X - (value % X) : value;
+}
+
+template <std::size_t alignment> Vc_INTRINSIC void *aligned_malloc(std::size_t n)
+{
+#ifdef __MIC__
+    return _mm_malloc(nextMultipleOf<alignment>(n), alignment);
+#elif defined(_WIN32)
+# ifdef __GNUC__
+    return __mingw_aligned_malloc(nextMultipleOf<alignment>(n), alignment);
+# else
+    return _aligned_malloc(nextMultipleOf<alignment>(n), alignment);
+# endif
+#else
+    void *ptr = nullptr;
+    if (0 == posix_memalign(&ptr, alignment < sizeof(void *) ? sizeof(void *) : alignment,
+                            nextMultipleOf<alignment>(n))) {
+        return ptr;
+    }
+    return ptr;
+#endif
+}
+
+template <Vc::MallocAlignment A> Vc_ALWAYS_INLINE void *malloc(size_t n)
+{
+    switch (A) {
+    case Vc::AlignOnVector:
+        return aligned_malloc<Vc::VectorAlignment>(n);
+    case Vc::AlignOnCacheline:
+        // TODO: hardcoding 64 is not such a great idea
+        return aligned_malloc<64>(n);
+    case Vc::AlignOnPage:
+        // TODO: hardcoding 4096 is not such a great idea
+        return aligned_malloc<4096>(n);
+    }
+    return nullptr;
+}
+
+Vc_ALWAYS_INLINE void free(void *p)
+{
+#ifdef __MIC__
+    _mm_free(p);
+#elif defined(_WIN32)
+# ifdef __GNUC__
+    return __mingw_aligned_free(p);
+# else
+    return _aligned_free(p);
+# endif
+#else
+    std::free(p);
+#endif
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_MALLOC_H_
diff -Nru vc-0.7.4/common/maskbool.h vc-1.3.0/common/maskbool.h
--- vc-0.7.4/common/maskbool.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/maskbool.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,102 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MASKENTRY_H_
+#define VC_COMMON_MASKENTRY_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+namespace
+{
+    template<size_t Bytes> struct MaskBoolStorage;
+    // the following for typedefs must use std::intN_t and NOT! Vc::intN_t. The latter
+    // segfaults ICC 15.0.3.
+    template<> struct MaskBoolStorage<1> { typedef std::int8_t  type; };
+    template<> struct MaskBoolStorage<2> { typedef std::int16_t type; };
+    template<> struct MaskBoolStorage<4> { typedef std::int32_t type; };
+    template<> struct MaskBoolStorage<8> { typedef std::int64_t type; };
+} // anonymous namespace
+
+template<size_t Bytes> class MaskBool
+{
+    typedef typename MaskBoolStorage<Bytes>::type storage_type Vc_MAY_ALIAS;
+    storage_type data;
+public:
+    constexpr MaskBool(bool x) noexcept : data(x ? -1 : 0) {}
+    Vc_ALWAYS_INLINE MaskBool &operator=(bool x) noexcept { data = x ? -1 : 0; return *this; }
+    template <typename T, typename = enable_if<(!std::is_same<T, bool>::value &&
+                                                std::is_fundamental<T>::value)>>
+    Vc_ALWAYS_INLINE MaskBool &operator=(T x) noexcept
+    {
+        data = reinterpret_cast<const storage_type &>(x);
+        return *this;
+    }
+
+    Vc_ALWAYS_INLINE MaskBool(const MaskBool &) noexcept = default;
+    Vc_ALWAYS_INLINE MaskBool &operator=(const MaskBool &) noexcept = default;
+
+    template <typename T, typename = enable_if<(std::is_same<T, bool>::value ||
+                                                (std::is_fundamental<T>::value &&
+                                                 sizeof(storage_type) == sizeof(T)))>>
+    constexpr operator T() const noexcept
+    {
+        return std::is_same<T, bool>::value ? T((data & 1) != 0)
+                                            : reinterpret_cast<const MayAlias<T> &>(data);
+    }
+} Vc_MAY_ALIAS;
+
+template <typename A,
+          typename B,
+          typename std::enable_if<
+              std::is_convertible<A, bool>::value &&std::is_convertible<B, bool>::value,
+              int>::type = 0>
+constexpr bool operator==(A &&a, B &&b)
+{
+    return static_cast<bool>(a) == static_cast<bool>(b);
+}
+template <typename A,
+          typename B,
+          typename std::enable_if<
+              std::is_convertible<A, bool>::value &&std::is_convertible<B, bool>::value,
+              int>::type = 0>
+constexpr bool operator!=(A &&a, B &&b)
+{
+    return static_cast<bool>(a) != static_cast<bool>(b);
+}
+
+static_assert(true == MaskBool<4>(true), "true == MaskBool<4>(true)");
+static_assert(true != MaskBool<4>(false), "true != MaskBool<4>(false)");
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_MASKENTRY_H_
diff -Nru vc-0.7.4/common/mask.h vc-1.3.0/common/mask.h
--- vc-0.7.4/common/mask.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/mask.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,392 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MASK_H_
+#define VC_COMMON_MASK_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * \class Mask mask.h <Vc/vector.h>
+ * \ingroup Masks
+ *
+ * The main SIMD mask class.
+ */
+template <typename T, typename Abi = VectorAbi::Best<T>> class Mask
+{
+public:
+    /**
+     * Returns the number of boolean components (\VSize{T}) in a mask of this type.
+     *
+     * The size of the mask. I.e. the number of boolean entries in the mask. Do not
+     * make any assumptions about the size of masks.
+     *
+     * In addition, you can easily use if clauses that compare sizes. The compiler can
+     * statically evaluate and fully optimize dead code away (very much like \#ifdef, but
+     * with syntax checking).
+     *
+     * \returns The number of components (i.e. \VSize{T}) objects of this mask type store
+     * and manipulate.
+     */
+    static constexpr size_t size() { return VectorTraits<T, Abi>::size(); }
+    ///\copydoc size
+    ///\deprecated Use Vc::Mask::size instead.
+    static constexpr size_t Size = VectorTraits<T, Abi>::size();
+
+    /**
+     * Specifies the alignment requirement for aligned load and store calls for objects of
+     * this mask type.
+     */
+    static constexpr size_t MemoryAlignment = VectorTraits<T, Abi>::maskMemoryAlignment();
+
+    /// The ABI tag type of the current template instantiation.
+    using abi = Abi;
+
+    /**
+     * The \c EntryType of masks is always \c bool, independent of \c T.
+     */
+    using EntryType = bool;
+    /// \copydoc EntryType
+    using value_type = EntryType;
+
+    /// The reference wrapper type used for accessing individual mask components.
+    using EntryReference = typename VectorTraits<T, Abi>::EntryReference;
+    /// \copydoc EntryReference
+    using value_reference = EntryReference;
+
+    /**
+     * The \c VectorEntryType, in contrast to \c EntryType, reveals information about the SIMD
+     * implementation.
+     * This type is useful for the \c sizeof operator in generic functions.
+     */
+    using VectorEntryType = typename VectorTraits<T, Abi>::VectorEntryType;
+
+    /**\internal
+     * The \c VectorType reveals the implementation-specific internal type used for the SIMD type.
+     */
+    using VectorType = typename VectorTraits<T, Abi>::VectorType;
+    /**\internal
+     * \copydoc VectorType
+     */
+    using vector_type = VectorType;
+
+    /*
+     * The associated Vector<T> type.
+     */
+    //using Vector = Vector<T, Abi>;
+
+    /// \name Generators
+    ///@{
+    /**
+     * Creates a new mask object initialized to zero/\c false.
+     *
+     * \returns A mask object with zero-initialized components.
+     */
+    Vc_INTRINSIC static Mask Zero();
+
+    /**
+     * Creates a mask object initialized to one/\c true.
+     *
+     * \returns A mask object with components initialized to \c true.
+     */
+    Vc_INTRINSIC static Mask One();
+
+    /// Generate a mask object from booleans returned from the function \p gen.
+    template <typename G> static Vc_INTRINSIC Mask generate(G &&gen);
+    ///@}
+
+    /// \name Compile-Time Constant Initialization
+    ///@{
+    /**
+     * Construct a zero-initialized vector object.
+     *
+     * This constructor follows the behavior of the underlying \c bool type in that the
+     * expression `bool()` zero-initializes the object (to \c false). On the other hand
+     * the variable \c x in `bool x;` is uninitialized.
+     * Since, for class types, both expressions call the default constructor `Mask<T> x`
+     * must zero-initialize \c x as well.
+     */
+    Vc_INTRINSIC Mask() = default;
+
+    /// Zero-initialize the new mask object (\c false).
+    /// \see Vc::Zero, Zero()
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero);
+
+    /// Initialize the new mask object to one (\c true).
+    /// \see Vc::One, One()
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne);
+    ///@}
+
+    /// \name Conversion/Broadcast Constructors
+    ///@{
+    /**
+     * Broadcast constructor.
+     *
+     * Set all components of the new mask object to \p b.
+     *
+     * \param b Determines the initial state of the mask.
+     */
+    Vc_INTRINSIC explicit Mask(bool b);
+
+    /**
+     * Implicit conversion from a compatible (equal \VSize{T} on every platform) mask
+     * object.
+     *
+     * \param otherMask The mask to be converted.
+     */
+    template <typename U>
+    Vc_INTRINSIC Mask(U &&otherMask,
+                      Common::enable_if_mask_converts_implicitly<T, U> = nullarg);
+
+#if Vc_IS_VERSION_1
+    /**
+     * Explicit conversion (static_cast) from a mask object that potentially has a
+     * different \VSize{T}.
+     *
+     * \param otherMask The mask to be converted.
+     *
+     * \internal This is implemented via simd_cast in scalar/simd_cast_caller.h
+     */
+    template <typename U>
+    Vc_DEPRECATED(
+        "use simd_cast instead of explicit type casting to convert between mask types")
+        Vc_INTRINSIC_L
+        explicit Mask(U &&otherMask, Common::enable_if_mask_converts_explicitly<T, U> =
+                                         nullarg) Vc_INTRINSIC_R;
+    ///@}
+#endif
+
+    /**
+     * \name Loads & Stores
+     */
+    ///@{
+    /**
+     * Load constructor from an array of \c bool.
+     *
+     * This constructor implements an explicit conversion from an array of booleans to a
+     * mask object. It corresponds to a Vector load constructor.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \see Mask(const bool *, Flags), load(const bool *)
+     */
+    Vc_ALWAYS_INLINE explicit Mask(const bool *mem);
+    /**
+     * Overload of the above with a load/store flag argument.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,
+     * Vc::Unaligned, Vc::PrefetchDefault, ...
+     * \see load(const bool *, Flags)
+     */
+    template <typename Flags> Vc_ALWAYS_INLINE explicit Mask(const bool *mem, Flags flags);
+
+    /**
+     * Load the components of the mask from an array of \c bool.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \see load(const bool *, Flags), Mask(const bool *)
+     */
+    Vc_ALWAYS_INLINE void load(const bool *mem);
+    /**
+     * Overload of the above with a load/store flag argument.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,
+     * Vc::Unaligned, Vc::PrefetchDefault, ...
+     * \see Mask(const bool *, Flags)
+     */
+    template <typename Flags> Vc_ALWAYS_INLINE void load(const bool *mem, Flags flags);
+
+    /**
+     * Store the values of the mask to an array of \c bool.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \see store(bool *, Flags)
+     */
+    Vc_ALWAYS_INLINE void store(bool *mem) const;
+    /**
+     * Overload of the above with a load/store flag argument.
+     *
+     * \param mem A pointer to the start of the array of booleans.
+     * \param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,
+     * Vc::Unaligned, Vc::PrefetchDefault, ...
+     */
+    template <typename Flags> Vc_ALWAYS_INLINE void store(bool *mem, Flags flags) const;
+    ///@}
+
+    /// \name Comparison Operators
+    ///@{
+    /**
+     * Returns whether the two masks are equal in all components.
+     *
+     * \param mask The other mask to compare against.
+     * \returns A scalar boolean value that says whether all components of the two masks
+     * are equal.
+     *
+     * \note If you expected a behavior similar to the compare operator of Vc::Vector,
+     * consider that the bitwise operators already implement such functionality. There is
+     * little use, typically, in having `a == b` return the same as `a ^ b`. In general,
+     * it is more useful to query `all_of(a ^ b)` which is the same as this equality
+     * operator.
+     */
+    Vc_ALWAYS_INLINE bool operator==(const Mask &mask) const;
+
+    /**
+     * Returns whether the two masks are different in at least one component.
+     *
+     * \param mask The other mask to compare against.
+     * \returns A scalar boolean value that says whether at least one component of the two masks is different.
+     *
+     * \note `(a == b) == !(a != b)` holds
+     * \see Mask::operator==(const Mask &)
+     */
+    Vc_ALWAYS_INLINE bool operator!=(const Mask &mask) const;
+    ///@}
+
+    /**
+     * \name Logical and Binary Operators
+     *
+     * \brief Component-wise logical/binary operations on mask objects.
+     *
+     * The effect of logical and binary \c AND and \c OR is equivalent for mask types (as
+     * it is for \c bool).
+     */
+    ///@{
+
+    /// Returns the component-wise application of a logical \c AND to \p mask.
+    Vc_ALWAYS_INLINE Mask operator&&(const Mask &mask) const;
+    /// Returns the component-wise application of a binary \c AND to \p mask.
+    Vc_ALWAYS_INLINE Mask operator&(const Mask &mask) const;
+    /// Returns the component-wise application of a logical \c OR to \p mask.
+    Vc_ALWAYS_INLINE Mask operator||(const Mask &mask) const;
+    /// Returns the component-wise application of a binary \c OR to \p mask.
+    Vc_ALWAYS_INLINE Mask operator|(const Mask &mask) const;
+    /// Returns the component-wise application of a binary \c XOR to \p mask.
+    Vc_ALWAYS_INLINE Mask operator^(const Mask &mask) const;
+    /// Returns a mask with inverted components.
+    Vc_ALWAYS_INLINE Mask operator!() const;
+
+    /// Modifies the mask using an \c AND operation with \p mask.
+    Vc_ALWAYS_INLINE Mask &operator&=(const Mask &mask);
+    /// Modifies the mask using an \c OR operation with \p mask.
+    Vc_ALWAYS_INLINE Mask &operator|=(const Mask &mask);
+    /// Modifies the mask using an \c XOR operation with \p mask.
+    Vc_ALWAYS_INLINE Mask &operator^=(const Mask &mask);
+    ///@}
+
+    /**
+     * \name Reductions
+     *
+     * \see any_of, all_of, none_of, some_of
+     */
+    ///@{
+
+    /// Returns a logical \c AND of all components.
+    Vc_ALWAYS_INLINE bool isFull() const;
+    /// Returns a logical \c OR of all components.
+    Vc_ALWAYS_INLINE bool isNotEmpty() const;
+    /// Returns \c true if components are \c false, \c false otherwise.
+    Vc_ALWAYS_INLINE bool isEmpty() const;
+    /// Returns `!isFull() && !isEmpty()`.
+    Vc_ALWAYS_INLINE bool isMix() const;
+    ///@}
+
+    /**\internal
+     * \name Internal Data Access
+     */
+    ///@{
+    Vc_ALWAYS_INLINE bool data() const;
+    Vc_ALWAYS_INLINE bool dataI() const;
+    Vc_ALWAYS_INLINE bool dataD() const;
+    ///@}
+
+    /// \name Scalar Subscript Operators
+    ///@{
+    /**
+     * Lvalue-reference-like access to mask entries.
+     *
+     * \param index Determines the boolean to be accessed.
+     * \return a temporary proxy object referencing the \p index th entry of the mask.
+     *
+     * \warning This operator does not return an lvalue reference (to \c bool), but rather
+     * a temporary (rvalue) object that mimics an lvalue reference (as much as is possible
+     * with C++11/14).
+     */
+    Vc_ALWAYS_INLINE EntryReference operator[](size_t index);
+
+    /**
+     * Read-only access to mask entries.
+     *
+     * \param index Determines the boolean to be accessed.
+     * \return The \p index th entry of the mask as a \c bool (rvalue).
+     *
+     * \warning This operator does not return an lvalue reference (to `const bool`), but
+     * rather a temporary (rvalue) \c bool.
+     */
+    Vc_ALWAYS_INLINE EntryType operator[](size_t index) const;
+    ///@}
+
+    /// Returns how many components of the mask are \c true.
+    Vc_ALWAYS_INLINE int count() const;
+
+    /**
+     * Returns the index of the first one in the mask.
+     *
+     * \returns the index of the first component that is \c true.
+     *
+     * \warning The return value is undefined if the mask is empty.
+     *
+     * Thus, unless `none_of(mask)`, `mask[mask.firstOne()] == true` holds and `mask[i] ==
+     * false` for all `i < mask.firstOne()`.
+     */
+    Vc_ALWAYS_INLINE int firstOne() const;
+
+    /**
+     * Convert the boolean components of the mask into bits of an integer.
+     *
+     * \return An \c int where each bit corresponds to the boolean value in the mask.
+     *
+     * For example, the mask `[true, false, false, true]` results in a `9` (in binary: `1001`).
+     */
+    Vc_ALWAYS_INLINE int toInt() const;
+
+    /// Returns a mask with components shifted by \p amount places.
+    Vc_INTRINSIC Vc_PURE Mask shifted(int amount) const;
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(Mask));
+
+private:
+    VectorType d;
+};
+
+}  // namespace Vc
+
+#endif  // VC_COMMON_MASK_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/math.h vc-1.3.0/common/math.h
--- vc-0.7.4/common/math.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/math.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,130 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_MATH_H_
+#define VC_COMMON_MATH_H_
+
+#define Vc_COMMON_MATH_H_INTERNAL 1
+
+#include "trigonometric.h"
+
+#include "const.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#ifdef Vc_IMPL_SSE
+// for SSE, AVX, and AVX2
+#include "logarithm.h"
+#include "exponential.h"
+#ifdef Vc_IMPL_AVX
+inline AVX::double_v exp(AVX::double_v _x)
+{
+    AVX::Vector<double> x = _x;
+    typedef AVX::Vector<double> V;
+        typedef V::Mask M;
+    typedef AVX::Const<double> C;
+
+        const M overflow  = x > Vc::Detail::doubleConstant< 1, 0x0006232bdd7abcd2ull, 9>(); // max log
+        const M underflow = x < Vc::Detail::doubleConstant<-1, 0x0006232bdd7abcd2ull, 9>(); // min log
+
+        V px = floor(C::log2_e() * x + 0.5);
+        __m128i tmp = _mm256_cvttpd_epi32(px.data());
+    const SimdArray<int, V::Size> n = SSE::int_v{tmp};
+        x -= px * C::ln2_large(); //Vc::Detail::doubleConstant<1, 0x00062e4000000000ull, -1>();  // ln2
+        x -= px * C::ln2_small(); //Vc::Detail::doubleConstant<1, 0x0007f7d1cf79abcaull, -20>(); // ln2
+
+        const double P[] = {
+            Vc::Detail::doubleConstant<1, 0x000089cdd5e44be8ull, -13>(),
+            Vc::Detail::doubleConstant<1, 0x000f06d10cca2c7eull,  -6>(),
+            Vc::Detail::doubleConstant<1, 0x0000000000000000ull,   0>()
+        };
+        const double Q[] = {
+            Vc::Detail::doubleConstant<1, 0x00092eb6bc365fa0ull, -19>(),
+            Vc::Detail::doubleConstant<1, 0x0004ae39b508b6c0ull,  -9>(),
+            Vc::Detail::doubleConstant<1, 0x000d17099887e074ull,  -3>(),
+            Vc::Detail::doubleConstant<1, 0x0000000000000000ull,   1>()
+        };
+        const V x2 = x * x;
+        px = x * ((P[0] * x2 + P[1]) * x2 + P[2]);
+        x =  px / ((((Q[0] * x2 + Q[1]) * x2 + Q[2]) * x2 + Q[3]) - px);
+        x = V::One() + 2.0 * x;
+
+        x = ldexp(x, n); // == x * 2ⁿ
+
+        x(overflow) = std::numeric_limits<double>::infinity();
+        x.setZero(underflow);
+
+        return x;
+    }
+#endif  // Vc_IMPL_AVX
+
+inline SSE::double_v exp(SSE::double_v::AsArg _x) {
+    SSE::Vector<double> x = _x;
+    typedef SSE::Vector<double> V;
+        typedef V::Mask M;
+    typedef SSE::Const<double> C;
+
+        const M overflow  = x > Vc::Detail::doubleConstant< 1, 0x0006232bdd7abcd2ull, 9>(); // max log
+        const M underflow = x < Vc::Detail::doubleConstant<-1, 0x0006232bdd7abcd2ull, 9>(); // min log
+
+        V px = floor(C::log2_e() * x + 0.5);
+    SimdArray<int, V::Size> n;
+        _mm_storel_epi64(reinterpret_cast<__m128i *>(&n), _mm_cvttpd_epi32(px.data()));
+        x -= px * C::ln2_large(); //Vc::Detail::doubleConstant<1, 0x00062e4000000000ull, -1>();  // ln2
+        x -= px * C::ln2_small(); //Vc::Detail::doubleConstant<1, 0x0007f7d1cf79abcaull, -20>(); // ln2
+
+        const double P[] = {
+            Vc::Detail::doubleConstant<1, 0x000089cdd5e44be8ull, -13>(),
+            Vc::Detail::doubleConstant<1, 0x000f06d10cca2c7eull,  -6>(),
+            Vc::Detail::doubleConstant<1, 0x0000000000000000ull,   0>()
+        };
+        const double Q[] = {
+            Vc::Detail::doubleConstant<1, 0x00092eb6bc365fa0ull, -19>(),
+            Vc::Detail::doubleConstant<1, 0x0004ae39b508b6c0ull,  -9>(),
+            Vc::Detail::doubleConstant<1, 0x000d17099887e074ull,  -3>(),
+            Vc::Detail::doubleConstant<1, 0x0000000000000000ull,   1>()
+        };
+        const V x2 = x * x;
+        px = x * ((P[0] * x2 + P[1]) * x2 + P[2]);
+        x =  px / ((((Q[0] * x2 + Q[1]) * x2 + Q[2]) * x2 + Q[3]) - px);
+        x = V::One() + 2.0 * x;
+
+        x = ldexp(x, n); // == x * 2ⁿ
+
+        x(overflow) = std::numeric_limits<double>::infinity();
+        x.setZero(underflow);
+
+        return x;
+    }
+
+#endif
+}  // namespace Vc
+
+#undef Vc_COMMON_MATH_H_INTERNAL
+
+#endif // VC_COMMON_MATH_H_
diff -Nru vc-0.7.4/common/memorybase.h vc-1.3.0/common/memorybase.h
--- vc-0.7.4/common/memorybase.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/memorybase.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,77 +1,51 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_MEMORYBASE_H
-#define VC_COMMON_MEMORYBASE_H
+#ifndef VC_COMMON_MEMORYBASE_H_
+#define VC_COMMON_MEMORYBASE_H_
 
 #include <assert.h>
+#include <type_traits>
+#include <iterator>
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-
-#if __cplusplus >= 201103 || defined(VC_MSVC)
-#define VC_DECLTYPE(T1, op, T2) decltype(T1() op T2())
-#elif defined(VC_OPEN64) || (defined(VC_GCC) && VC_GCC < 0x40300)
-#define VC_DECLTYPE(T1, op, T2) T1
-#else
-namespace
+namespace Common
 {
-    struct one { char x; };
-    struct two { one x, y; };
-    template<typename T1, typename T2> struct DecltypeHelper
-    {
-        static one test(const T1 &) { return one(); }
-        static two test(const T2 &) { return two(); }
-        //static void test(...) {}
-    };
-    template<typename T1> struct DecltypeHelper<T1, T1>
-    {
-        static one test(const T1 &) { return one(); }
-        //static void test(...) {}
-    };
-    template<typename T1, typename T2, size_t ToSelect> struct Decltype { typedef T1 Value; };
-    template<typename T1, typename T2> struct Decltype<T1, T2, sizeof(one)> { typedef T1 Value; };
-    template<typename T1, typename T2> struct Decltype<T1, T2, sizeof(two)> { typedef T2 Value; };
-#ifdef VC_CLANG
-    // this special case is only necessary to silence a warning (which is rather a note that clang
-    // did the expected optimization):
-    // warning: variable 'SOME_PTR' is not needed and will not be emitted [-Wunneeded-internal-declaration]
-    // Then again, I don't remember why the SOME_PTR hack was necessary in the first place - some
-    // strange compiler quirk...
-#define VC_DECLTYPE(T1, op, T2) typename Decltype<T1, T2, sizeof(DecltypeHelper<T1, T2>::test(T1() op T2()))>::Value
-#else
-    static const void *SOME_PTR;
-#define VC_DECLTYPE(T1, op, T2) typename Decltype<T1, T2, sizeof(DecltypeHelper<T1, T2>::test(*static_cast<const T1*>(SOME_PTR) op *static_cast<const T2*>(SOME_PTR)))>::Value
-#endif
-} // anonymous namespace
-#endif
 
-#define VC_MEM_OPERATOR_EQ(op) \
+#define Vc_MEM_OPERATOR_EQ(op) \
         template<typename T> \
-        Vc_ALWAYS_INLINE VectorPointerHelper<V, A> &operator op##=(const T &x) { \
-            const V result = V(m_ptr, Internal::FlagObject<A>::the()) op x; \
-            result.store(m_ptr, Internal::FlagObject<A>::the()); \
+        Vc_ALWAYS_INLINE enable_if_mutable<T, MemoryVector &> operator op##=(const T &x) { \
+            const V v = value() op x; \
+            v.store(&m_data[0], Flags()); \
             return *this; \
         }
-
+/*dox{{{*/
 /**
  * Helper class for the Memory::vector(size_t) class of functions.
  *
@@ -79,71 +53,149 @@
  * Memory API.
  *
  * \headerfile memorybase.h <Vc/Memory>
- */
-template<typename V, typename A> class VectorPointerHelperConst
+ *//*}}}*/
+template<typename _V, typename Flags> class MemoryVector/*{{{*/
 {
-    typedef typename V::EntryType EntryType;
-    typedef typename V::Mask Mask;
-    public:
-        const EntryType *const m_ptr;
+    typedef typename std::remove_cv<_V>::type V;
 
-        explicit VectorPointerHelperConst(const EntryType *ptr) : m_ptr(ptr) {}
-
-        /**
-         * Cast to \p V operator.
-         *
-         * This function allows to assign this object to any object of type \p V.
-         */
-        Vc_ALWAYS_INLINE Vc_PURE operator const V() const { return V(m_ptr, Internal::FlagObject<A>::the()); }
-};
+    template<typename T, typename R> using enable_if_mutable =
+        typename std::enable_if<std::is_same<T, T>::value && !std::is_const<_V>::value, R>::type;
 
-/**
- * Helper class for the Memory::vector(size_t) class of functions.
- *
- * You will never need to directly make use of this class. It is an implementation detail of the
- * Memory API.
- *
- * \headerfile memorybase.h <Vc/Memory>
- */
-template<typename V, typename A> class VectorPointerHelper
-{
     typedef typename V::EntryType EntryType;
     typedef typename V::Mask Mask;
-    public:
-        EntryType *const m_ptr;
 
-        explicit VectorPointerHelper(EntryType *ptr) : m_ptr(ptr) {}
+    EntryType m_data[V::Size];
+public:
+        // It is important that neither initialization nor cleanup is done as MemoryVector aliases
+        // other memory
+        Vc_ALWAYS_INLINE MemoryVector() {}
+
+        // disable copies because this type is supposed to alias the data in a Memory object,
+        // nothing else
+        MemoryVector(const MemoryVector &) = delete;
+        MemoryVector(MemoryVector &&) = delete;
+        // Do not disable MemoryVector &operator=(const MemoryVector &) = delete; because it is
+        // covered nicely by the operator= below.
+
+        //! \internal
+        Vc_ALWAYS_INLINE Vc_PURE V value() const { return V(&m_data[0], Flags()); }
 
         /**
          * Cast to \p V operator.
          *
          * This function allows to assign this object to any object of type \p V.
          */
-        Vc_ALWAYS_INLINE Vc_PURE operator const V() const { return V(m_ptr, Internal::FlagObject<A>::the()); }
+        Vc_ALWAYS_INLINE Vc_PURE operator V() const { return value(); }
 
         template<typename T>
-        Vc_ALWAYS_INLINE VectorPointerHelper &operator=(const T &x) {
+        Vc_ALWAYS_INLINE enable_if_mutable<T, MemoryVector &> operator=(const T &x) {
             V v;
             v = x;
-            v.store(m_ptr, Internal::FlagObject<A>::the());
+            v.store(&m_data[0], Flags());
             return *this;
         }
 
-        VC_ALL_BINARY(VC_MEM_OPERATOR_EQ)
-        VC_ALL_ARITHMETICS(VC_MEM_OPERATOR_EQ)
+        Vc_ALL_BINARY(Vc_MEM_OPERATOR_EQ);
+        Vc_ALL_ARITHMETICS(Vc_MEM_OPERATOR_EQ);
+};
+
+template<typename _V, typename Flags> class MemoryVectorIterator
+{
+    typedef typename std::remove_cv<_V>::type V;
+
+    template<typename T, typename R> using enable_if_mutable =
+        typename std::enable_if<std::is_same<T, T>::value && !std::is_const<_V>::value, R>::type;
+
+    using iterator_traits = std::iterator_traits<MemoryVector<_V, Flags> *>;
+
+    MemoryVector<_V, Flags> *d;
+public:
+    typedef typename iterator_traits::difference_type difference_type;
+    typedef typename iterator_traits::value_type value_type;
+    typedef typename iterator_traits::pointer pointer;
+    typedef typename iterator_traits::reference reference;
+    typedef typename iterator_traits::iterator_category iterator_category;
+
+    constexpr MemoryVectorIterator(MemoryVector<_V, Flags> *dd) : d(dd) {}
+    constexpr MemoryVectorIterator(const MemoryVectorIterator &) = default;
+    constexpr MemoryVectorIterator(MemoryVectorIterator &&) = default;
+    Vc_ALWAYS_INLINE MemoryVectorIterator &operator=(const MemoryVectorIterator &) = default;
+
+    Vc_ALWAYS_INLINE void *orderBy() const { return d; }
+
+    Vc_ALWAYS_INLINE difference_type operator-(const MemoryVectorIterator &rhs) const { return d - rhs.d; }
+    Vc_ALWAYS_INLINE reference operator[](size_t i) const { return d[i]; }
+    Vc_ALWAYS_INLINE reference operator*() const { return *d; }
+    Vc_ALWAYS_INLINE pointer operator->() const { return d; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator &operator++() { ++d; return *this; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator operator++(int) { MemoryVectorIterator r(*this); ++d; return r; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator &operator--() { --d; return *this; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator operator--(int) { MemoryVectorIterator r(*this); --d; return r; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator &operator+=(size_t n) { d += n; return *this; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator &operator-=(size_t n) { d -= n; return *this; }
+    Vc_ALWAYS_INLINE MemoryVectorIterator operator+(size_t n) const { return MemoryVectorIterator(d + n); }
+    Vc_ALWAYS_INLINE MemoryVectorIterator operator-(size_t n) const { return MemoryVectorIterator(d - n); }
 };
-#undef VC_MEM_OPERATOR_EQ
 
-#define VC_VPH_OPERATOR(op) \
-template<typename V1, typename A1, typename V2, typename A2> \
-VC_DECLTYPE(V1, op, V2) operator op(const VectorPointerHelper<V1, A1> &x, const VectorPointerHelper<V2, A2> &y) { \
-    return V1(x.m_ptr, Internal::FlagObject<A1>::the()) op V2(y.m_ptr, Internal::FlagObject<A2>::the()); \
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator==(const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() == r.orderBy();
 }
-VC_ALL_ARITHMETICS(VC_VPH_OPERATOR)
-VC_ALL_BINARY     (VC_VPH_OPERATOR)
-VC_ALL_COMPARES   (VC_VPH_OPERATOR)
-#undef VC_VPH_OPERATOR
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator!=(const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() != r.orderBy();
+}
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator>=(const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() >= r.orderBy();
+}
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator<=(const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() <= r.orderBy();
+}
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator> (const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() >  r.orderBy();
+}
+template<typename V, typename FlagsL, typename FlagsR>
+Vc_ALWAYS_INLINE bool operator< (const MemoryVectorIterator<V, FlagsL> &l, const MemoryVectorIterator<V, FlagsR> &r)
+{
+    return l.orderBy() <  r.orderBy();
+}
+/*}}}*/
+#undef Vc_MEM_OPERATOR_EQ
+
+#define Vc_VPH_OPERATOR(op)                                                              \
+    template <typename V1, typename Flags1, typename V2, typename Flags2>                \
+    decltype(std::declval<V1>() op std::declval<V2>()) operator op(                      \
+        const MemoryVector<V1, Flags1> &x, const MemoryVector<V2, Flags2> &y)            \
+    {                                                                                    \
+        return x.value() op y.value();                                                   \
+    }
+Vc_ALL_ARITHMETICS(Vc_VPH_OPERATOR);
+Vc_ALL_BINARY     (Vc_VPH_OPERATOR);
+Vc_ALL_COMPARES   (Vc_VPH_OPERATOR);
+#undef Vc_VPH_OPERATOR
 
+template<typename V, typename Parent, typename Flags = Prefetch<>> class MemoryRange/*{{{*/
+{
+    Parent *m_parent;
+    size_t m_first;
+    size_t m_last;
+
+public:
+    MemoryRange(Parent *p, size_t firstIndex, size_t lastIndex)
+        : m_parent(p), m_first(firstIndex), m_last(lastIndex)
+    {}
+
+    MemoryVectorIterator<V, Flags> begin() const { return &m_parent->vector(m_first   , Flags()); }
+    MemoryVectorIterator<V, Flags> end() const   { return &m_parent->vector(m_last + 1, Flags()); }
+};/*}}}*/
 template<typename V, typename Parent, int Dimension, typename RowMemory> class MemoryDimensionBase;
 template<typename V, typename Parent, typename RowMemory> class MemoryDimensionBase<V, Parent, 1, RowMemory> // {{{1
 {
@@ -170,6 +222,7 @@
         /// Const overload of the above function.
         Vc_ALWAYS_INLINE Vc_PURE const EntryType scalar(size_t i) const { return entries()[i]; }
 
+#ifdef DOXYGEN
         /**
          * Cast operator to the scalar type. This allows to use the object very much like a standard
          * C array.
@@ -177,17 +230,52 @@
         Vc_ALWAYS_INLINE Vc_PURE operator       EntryType*()       { return entries(); }
         /// Const overload of the above function.
         Vc_ALWAYS_INLINE Vc_PURE operator const EntryType*() const { return entries(); }
+#else
+        // The above conversion operator allows implicit conversion to bool. To prohibit this
+        // conversion we use SFINAE to allow only conversion to EntryType* and void*.
+        template <typename T,
+                  typename std::enable_if<
+                      std::is_same<typename std::remove_const<T>::type, EntryType *>::value ||
+                          std::is_same<typename std::remove_const<T>::type, void *>::value,
+                      int>::type = 0>
+        Vc_ALWAYS_INLINE Vc_PURE operator T()
+        {
+            return entries();
+        }
+        template <typename T,
+                  typename std::enable_if<std::is_same<T, const EntryType *>::value ||
+                                              std::is_same<T, const void *>::value,
+                                          int>::type = 0>
+        Vc_ALWAYS_INLINE Vc_PURE operator T() const
+        {
+            return entries();
+        }
+#endif
+
+        /**
+         *
+         */
+        template<typename Flags>
+        Vc_ALWAYS_INLINE MemoryRange<V, Parent, Flags> range(size_t firstIndex, size_t lastIndex, Flags) {
+            return MemoryRange<V, Parent, Flags>(p(), firstIndex, lastIndex);
+        }
+        Vc_ALWAYS_INLINE MemoryRange<V, Parent> range(size_t firstIndex, size_t lastIndex) {
+            return MemoryRange<V, Parent>(p(), firstIndex, lastIndex);
+        }
+        template<typename Flags>
+        Vc_ALWAYS_INLINE MemoryRange<const V, Parent, Flags> range(size_t firstIndex, size_t lastIndex, Flags) const {
+            return MemoryRange<const V, Parent, Flags>(p(), firstIndex, lastIndex);
+        }
+        Vc_ALWAYS_INLINE MemoryRange<const V, Parent> range(size_t firstIndex, size_t lastIndex) const {
+            return MemoryRange<const V, Parent>(p(), firstIndex, lastIndex);
+        }
 
-        // omit operator[] because the EntryType* cast operator suffices, for dox it makes sense to
-        // show it, though because it helps API discoverability.
-#ifdef DOXYGEN
         /**
          * Returns the \p i-th scalar value in the memory.
          */
-        inline EntryType &operator[](size_t i);
+        Vc_ALWAYS_INLINE EntryType &operator[](size_t i) { return entries()[i]; }
         /// Const overload of the above function.
-        inline const EntryType &operator[](size_t i) const;
-#endif
+        Vc_ALWAYS_INLINE const EntryType &operator[](size_t i) const { return entries()[i]; }
 
         /**
          * Uses a vector gather to combine the entries at the indexes in \p i into the returned
@@ -216,7 +304,7 @@
          */
         typedef typename V::EntryType EntryType;
 
-        static _VC_CONSTEXPR size_t rowCount() { return Parent::RowCount; }
+        static constexpr size_t rowCount() { return Parent::RowCount; }
 
         /**
          * Returns a pointer to the start of the allocated memory.
@@ -236,11 +324,19 @@
          * Returns the \p i-th row in the memory.
          */
         Vc_ALWAYS_INLINE Vc_PURE RowMemory &operator[](size_t i) {
+#ifdef Vc_RECURSIVE_MEMORY
+            return p()->m_mem[i];
+#else
             return RowMemory::fromRawData(entries(i));
+#endif
         }
         /// Const overload of the above function.
         Vc_ALWAYS_INLINE Vc_PURE const RowMemory &operator[](size_t i) const {
+#ifdef Vc_RECURSIVE_MEMORY
+            return p()->m_mem[i];
+#else
             return RowMemory::fromRawData(const_cast<EntryType *>(entries(i)));
+#endif
         }
 
         /**
@@ -251,7 +347,7 @@
         Vc_ALWAYS_INLINE Vc_PURE size_t rowsCount() const { return p()->rowsCount(); }
 };
 
-//{{{1
+//dox{{{1
 /**
  * \headerfile memorybase.h <Vc/Memory>
  *
@@ -264,6 +360,10 @@
  */
 template<typename V, typename Parent, int Dimension, typename RowMemory> class MemoryBase : public MemoryDimensionBase<V, Parent, Dimension, RowMemory> //{{{1
 {
+    static_assert((V::size() * sizeof(typename V::EntryType)) % V::MemoryAlignment == 0,
+                  "Vc::Memory can only be used for data-parallel types storing a number "
+                  "of values that's a multiple of the memory alignment.");
+
     private:
         Parent *p() { return static_cast<Parent *>(this); }
         const Parent *p() const { return static_cast<const Parent *>(this); }
@@ -288,6 +388,24 @@
         using MemoryDimensionBase<V, Parent, Dimension, RowMemory>::scalar;
 
         /**
+         * Return a (vectorized) iterator to the start of this memory object.
+         */
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE MemoryVectorIterator<      V, Flags> begin(Flags flags = Flags())       { return &firstVector(flags); }
+        //! const overload of the above
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE MemoryVectorIterator<const V, Flags> begin(Flags flags = Flags()) const { return &firstVector(flags); }
+
+        /**
+         * Return a (vectorized) iterator to the end of this memory object.
+         */
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE MemoryVectorIterator<      V, Flags>   end(Flags flags = Flags())       { return &lastVector(flags) + 1; }
+        //! const overload of the above
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE MemoryVectorIterator<const V, Flags>   end(Flags flags = Flags()) const { return &lastVector(flags) + 1; }
+
+        /**
          * \param i Selects the offset, where the vector should be read.
          *
          * \return a smart object to wrap the \p i-th vector in the memory.
@@ -307,8 +425,9 @@
          * access memory at fixed strides. If access to known offsets from the aligned vectors is
          * needed the vector(size_t, int) function can be used.
          */
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, AlignedFlag> vector(size_t i) {
-            return VectorPointerHelper<V, AlignedFlag>(&entries()[i * V::Size]);
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<!std::is_convertible<Flags, int>::value, MemoryVector<V, Flags>>::type &vector(size_t i, Flags = Flags()) {
+            return *new(&entries()[i * V::Size]) MemoryVector<V, Flags>;
         }
         /** \brief Const overload of the above function
          *
@@ -316,8 +435,9 @@
          *
          * \return a smart object to wrap the \p i-th vector in the memory.
          */
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, AlignedFlag> vector(size_t i) const {
-            return VectorPointerHelperConst<V, AlignedFlag>(&entries()[i * V::Size]);
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<!std::is_convertible<Flags, int>::value, MemoryVector<const V, Flags>>::type &vector(size_t i, Flags = Flags()) const {
+            return *new(const_cast<EntryType *>(&entries()[i * V::Size])) MemoryVector<const V, Flags>;
         }
 
         /**
@@ -335,12 +455,14 @@
          * \param i      Specifies the scalar entry from where the vector will be loaded/stored. I.e. the
          * values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.
          *
-         * \param align  You must take care to determine whether an unaligned load/store is
-         * required. Per default an aligned load/store is used. If \p i is not a multiple of \c V::Size
-         * you must pass Vc::Unaligned here.
-         */
-#ifdef DOXYGEN
-        template<typename A> inline VectorPointerHelper<V, A> vectorAt(size_t i, A align = Vc::Aligned);
+         * \param flags  You must take care to determine whether an unaligned load/store is
+         * required. Per default an unaligned load/store is used. If \p i is a multiple of \c V::Size
+         * you may want to pass Vc::Aligned here.
+         */
+        template<typename Flags = UnalignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<V, Flags> &vectorAt(size_t i, Flags flags = Flags()) {
+            return *new(&entries()[i]) MemoryVector<V, Flags>;
+        }
         /** \brief Const overload of the above function
          *
          * \return a smart object to wrap the vector starting from the \p i-th scalar entry in the memory.
@@ -348,28 +470,14 @@
          * \param i      Specifies the scalar entry from where the vector will be loaded/stored. I.e. the
          * values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.
          *
-         * \param align  You must take care to determine whether an unaligned load/store is
-         * required. Per default an aligned load/store is used. If \p i is not a multiple of \c V::Size
-         * you must pass Vc::Unaligned here.
-         */
-        template<typename A> inline const VectorPointerHelperConst<V, A> vectorAt(size_t i, A align = Vc::Aligned) const;
-#else
-        template<typename A>
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, A> vectorAt(size_t i, A) {
-            return VectorPointerHelper<V, A>(&entries()[i]);
-        }
-        template<typename A>
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, A> vectorAt(size_t i, A) const {
-            return VectorPointerHelperConst<V, A>(&entries()[i]);
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, AlignedFlag> vectorAt(size_t i) {
-            return VectorPointerHelper<V, AlignedFlag>(&entries()[i]);
-        }
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, AlignedFlag> vectorAt(size_t i) const {
-            return VectorPointerHelperConst<V, AlignedFlag>(&entries()[i]);
+         * \param flags  You must take care to determine whether an unaligned load/store is
+         * required. Per default an unaligned load/store is used. If \p i is a multiple of \c V::Size
+         * you may want to pass Vc::Aligned here.
+         */
+        template<typename Flags = UnalignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<const V, Flags> &vectorAt(size_t i, Flags flags = Flags()) const {
+            return *new(const_cast<EntryType *>(&entries()[i])) MemoryVector<const V, Flags>;
         }
-#endif
 
         /**
          * \return a smart object to wrap the \p i-th vector + \p shift in the memory.
@@ -398,12 +506,24 @@
          * mem.vector(0, i) += 1;
          * \endcode
          */
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, UnalignedFlag> vector(size_t i, int shift) {
-            return VectorPointerHelper<V, UnalignedFlag>(&entries()[i * V::Size + shift]);
+        template <typename ShiftT, typename Flags = decltype(Unaligned)>
+        Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<
+            std::is_convertible<ShiftT, int>::value,
+            MemoryVector<V, decltype(std::declval<Flags>() | Unaligned)>>::type &
+        vector(size_t i, ShiftT shift, Flags = Flags())
+        {
+            return *new (&entries()[i * V::Size + shift])
+                MemoryVector<V, decltype(std::declval<Flags>() | Unaligned)>;
         }
         /// Const overload of the above function.
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, UnalignedFlag> vector(size_t i, int shift) const {
-            return VectorPointerHelperConst<V, UnalignedFlag>(&entries()[i * V::Size + shift]);
+        template <typename ShiftT, typename Flags = decltype(Unaligned)>
+        Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<
+            std::is_convertible<ShiftT, int>::value,
+            MemoryVector<const V, decltype(std::declval<Flags>() | Unaligned)>>::type &
+        vector(size_t i, ShiftT shift, Flags = Flags()) const
+        {
+            return *new (const_cast<EntryType *>(&entries()[i * V::Size + shift]))
+                MemoryVector<const V, decltype(std::declval<Flags>() | Unaligned)>;
         }
 
         /**
@@ -411,12 +531,14 @@
          *
          * This function is simply a shorthand for vector(0).
          */
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, AlignedFlag> firstVector() {
-            return VectorPointerHelper<V, AlignedFlag>(entries());
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<V, Flags> &firstVector(Flags = Flags()) {
+            return *new(entries()) MemoryVector<V, Flags>;
         }
         /// Const overload of the above function.
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, AlignedFlag> firstVector() const {
-            return VectorPointerHelperConst<V, AlignedFlag>(entries());
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<const V, Flags> &firstVector(Flags = Flags()) const {
+            return *new(const_cast<EntryType *>(entries())) MemoryVector<const V, Flags>;
         }
 
         /**
@@ -424,12 +546,14 @@
          *
          * This function is simply a shorthand for vector(vectorsCount() - 1).
          */
-        Vc_ALWAYS_INLINE Vc_PURE VectorPointerHelper<V, AlignedFlag> lastVector() {
-            return VectorPointerHelper<V, AlignedFlag>(&entries()[vectorsCount() * V::Size - V::Size]);
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<V, Flags> &lastVector(Flags = Flags()) {
+            return *new(&entries()[vectorsCount() * V::Size - V::Size]) MemoryVector<V, Flags>;
         }
         /// Const overload of the above function.
-        Vc_ALWAYS_INLINE Vc_PURE const VectorPointerHelperConst<V, AlignedFlag> lastVector() const {
-            return VectorPointerHelperConst<V, AlignedFlag>(&entries()[vectorsCount() * V::Size - V::Size]);
+        template<typename Flags = AlignedTag>
+        Vc_ALWAYS_INLINE Vc_PURE MemoryVector<const V, Flags> &lastVector(Flags = Flags()) const {
+            return *new(const_cast<EntryType *>(&entries()[vectorsCount() * V::Size - V::Size])) MemoryVector<const V, Flags>;
         }
 
         Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned char  *indexes) const { return V(entries(), indexes); }
@@ -437,6 +561,9 @@
         Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned int   *indexes) const { return V(entries(), indexes); }
         Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned long  *indexes) const { return V(entries(), indexes); }
 
+        /**
+         * Zero the whole memory area.
+         */
         Vc_ALWAYS_INLINE void setZero() {
             V zero(Vc::Zero);
             for (size_t i = 0; i < vectorsCount(); ++i) {
@@ -444,6 +571,19 @@
             }
         }
 
+        /**
+         * Assign a value to all vectors in the array.
+         */
+        template<typename U>
+        Vc_ALWAYS_INLINE Parent &operator=(U &&x) {
+            for (size_t i = 0; i < vectorsCount(); ++i) {
+                vector(i) = std::forward<U>(x);
+            }
+        }
+
+        /**
+         * (Inefficient) shorthand to add up two arrays.
+         */
         template<typename P2, typename RM>
         inline Parent &operator+=(const MemoryBase<V, P2, Dimension, RM> &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -452,6 +592,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to subtract two arrays.
+         */
         template<typename P2, typename RM>
         inline Parent &operator-=(const MemoryBase<V, P2, Dimension, RM> &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -460,6 +604,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to multiply two arrays.
+         */
         template<typename P2, typename RM>
         inline Parent &operator*=(const MemoryBase<V, P2, Dimension, RM> &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -468,6 +616,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to divide two arrays.
+         */
         template<typename P2, typename RM>
         inline Parent &operator/=(const MemoryBase<V, P2, Dimension, RM> &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -476,6 +628,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to add a value to an array.
+         */
         inline Parent &operator+=(EntryType rhs) {
             V v(rhs);
             for (size_t i = 0; i < vectorsCount(); ++i) {
@@ -483,6 +639,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to subtract a value from an array.
+         */
         inline Parent &operator-=(EntryType rhs) {
             V v(rhs);
             for (size_t i = 0; i < vectorsCount(); ++i) {
@@ -490,6 +650,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to multiply a value to an array.
+         */
         inline Parent &operator*=(EntryType rhs) {
             V v(rhs);
             for (size_t i = 0; i < vectorsCount(); ++i) {
@@ -497,6 +661,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand to divide an array with a value.
+         */
         inline Parent &operator/=(EntryType rhs) {
             V v(rhs);
             for (size_t i = 0; i < vectorsCount(); ++i) {
@@ -504,6 +672,10 @@
             }
             return static_cast<Parent &>(*this);
         }
+
+        /**
+         * (Inefficient) shorthand compare equality of two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator==(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -514,6 +686,10 @@
             }
             return true;
         }
+
+        /**
+         * (Inefficient) shorthand compare two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator!=(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -524,6 +700,10 @@
             }
             return true;
         }
+
+        /**
+         * (Inefficient) shorthand compare two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator<(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -534,6 +714,10 @@
             }
             return true;
         }
+
+        /**
+         * (Inefficient) shorthand compare two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator<=(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -544,6 +728,10 @@
             }
             return true;
         }
+
+        /**
+         * (Inefficient) shorthand compare two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator>(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -554,6 +742,10 @@
             }
             return true;
         }
+
+        /**
+         * (Inefficient) shorthand compare two arrays.
+         */
         template<typename P2, typename RM>
         inline bool operator>=(const MemoryBase<V, P2, Dimension, RM> &rhs) const {
             assert(vectorsCount() == rhs.vectorsCount());
@@ -566,7 +758,7 @@
         }
 };
 
-namespace Internal
+namespace Detail
 {
 template <typename V,
           typename ParentL,
@@ -593,11 +785,11 @@
         dst.vector(i) = src.vector(i);
     }
 }
-} // namespace Internal
+} // namespace Detail
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Common
+}  // namespace Vc
 
-#include "undomacros.h"
+#endif // VC_COMMON_MEMORYBASE_H_
 
-#endif // VC_COMMON_MEMORYBASE_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/memoryfwd.h vc-1.3.0/common/memoryfwd.h
--- vc-0.7.4/common/memoryfwd.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/memoryfwd.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,30 +1,46 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_COMMON_MEMORYFWD_H_
+#define VC_COMMON_MEMORYFWD_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_MEMORYFWD_H
-#define VC_COMMON_MEMORYFWD_H
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-    template<typename V, size_t Size1 = 0, size_t Size2 = 0> class Memory;
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+namespace Common
+{
+template <typename V, std::size_t Size1 = 0, std::size_t Size2 = 0,
+          bool InitPadding = true>
+class Memory;
+
+template <typename V, typename Parent, int Dimension, typename RowMemory>
+class MemoryBase;
+}  // namespace Common
+
+using Common::Memory;
+}  // namespace Vc
 
-#endif // VC_COMMON_MEMORYFWD_H
+#endif // VC_COMMON_MEMORYFWD_H_
diff -Nru vc-0.7.4/common/memory.h vc-1.3.0/common/memory.h
--- vc-0.7.4/common/memory.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/memory.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,37 +1,45 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_MEMORY_H
-#define VC_COMMON_MEMORY_H
+#ifndef VC_COMMON_MEMORY_H_
+#define VC_COMMON_MEMORY_H_
 
 #include "memorybase.h"
 #include <assert.h>
 #include <algorithm>
 #include <cstring>
 #include <cstddef>
+#include <initializer_list>
 #include "memoryfwd.h"
+#include "malloc.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-
 /**
  * Allocates memory on the Heap with alignment and padding suitable for vectorized access.
  *
@@ -64,9 +72,9 @@
  * \headerfile memory.h <Vc/Memory>
  */
 template<typename T, Vc::MallocAlignment A>
-Vc_ALWAYS_INLINE_L T *Vc_ALWAYS_INLINE_R malloc(size_t n)
+Vc_ALWAYS_INLINE T *malloc(size_t n)
 {
-    return static_cast<T *>(Internal::Helper::malloc<A>(n * sizeof(T)));
+    return static_cast<T *>(Common::malloc<A>(n * sizeof(T)));
 }
 
 /**
@@ -93,9 +101,11 @@
 template<typename T>
 Vc_ALWAYS_INLINE void free(T *p)
 {
-    Internal::Helper::free(p);
+    Common::free(p);
 }
 
+namespace Common
+{
 template<typename V, size_t Size> struct _MemorySizeCalculation
 {
     enum AlignmentCalculations {
@@ -117,28 +127,42 @@
  * \param Size1 Number of rows
  * \param Size2 Number of columns
  */
-template<typename V, size_t Size1, size_t Size2> class Memory : public VectorAlignedBaseT<V>, public MemoryBase<V, Memory<V, Size1, Size2>, 2, Memory<V, Size2> >
+template <typename V, size_t Size1, size_t Size2, bool InitPadding>
+#ifdef Vc_RECURSIVE_MEMORY
+class Memory : public MemoryBase<V, Memory<V, Size1, Size2, InitPadding>, 2,
+                                 Memory<V, Size2, 0, InitPadding>>
+#else
+class Memory : public AlignedBase<V::MemoryAlignment>,
+               public MemoryBase<V, Memory<V, Size1, Size2, InitPadding>, 2,
+                                 Memory<V, Size2, 0, false>>
+#endif
 {
-    public:
-        typedef typename V::EntryType EntryType;
-    private:
-        typedef MemoryBase<V, Memory<V, Size1, Size2>, 2, Memory<V, Size2> > Base;
-            friend class MemoryBase<V, Memory<V, Size1, Size2>, 2, Memory<V, Size2> >;
-            friend class MemoryDimensionBase<V, Memory<V, Size1, Size2>, 2, Memory<V, Size2> >;
-            enum InternalConstants {
-                PaddedSize2 = _MemorySizeCalculation<V, Size2>::PaddedSize
-            };
-#if defined(VC_ICC) && defined(_WIN32)
-            __declspec(align(__alignof(VectorAlignedBaseT<V>)))
-#elif defined(VC_CLANG)
-            __attribute__((aligned(__alignof(VectorAlignedBaseT<V>))))
-#elif defined(VC_MSVC)
-	    VectorAlignedBaseT<V> _force_alignment;
-            // __declspec(align(#)) accepts only numbers not __alignof nor just VectorAlignment
-	    // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly.
-	    // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :(
+public:
+    typedef typename V::EntryType EntryType;
+
+private:
+#ifdef Vc_RECURSIVE_MEMORY
+    using RowMemory = Memory<V, Size2, 0, InitPadding>;
+#else
+    using RowMemory = Memory<V, Size2, 0, false>;
 #endif
-            EntryType m_mem[Size1][PaddedSize2];
+    typedef MemoryBase<V, Memory<V, Size1, Size2, InitPadding>, 2, RowMemory> Base;
+    friend class MemoryBase<V, Memory<V, Size1, Size2, InitPadding>, 2, RowMemory>;
+    friend class MemoryDimensionBase<V, Memory<V, Size1, Size2, InitPadding>, 2,
+                                     RowMemory>;
+    enum : size_t {
+        Alignment = V::MemoryAlignment,
+        PaddedSize2 = _MemorySizeCalculation<V, Size2>::PaddedSize
+    };
+    alignas(static_cast<size_t>(Alignment))  // GCC complains about 'is not an
+                                             // integer constant' unless the
+                                             // static_cast is present
+#ifdef Vc_RECURSIVE_MEMORY
+        RowMemory m_mem[Size1];
+#else
+        EntryType m_mem[Size1][PaddedSize2];
+#endif
+
         public:
             using Base::vector;
             enum Constants {
@@ -146,12 +170,26 @@
                 VectorsCount = PaddedSize2 / V::Size
             };
 
+#ifdef Vc_RECURSIVE_MEMORY
+            Memory() = default;
+#else
+            Memory()
+            {
+                if (InitPadding) {
+                    if (Size1 > 32)
+                    for (size_t i = 0; i < Size1; ++i) {
+                        V::Zero().store(&m_mem[i][PaddedSize2 - V::Size], Vc::Streaming);
+                    }
+                }
+            }
+#endif
+
             /**
              * \return the number of rows in the array.
              *
              * \note This function can be eliminated by an optimizing compiler.
              */
-            _VC_CONSTEXPR size_t rowsCount() const { return RowCount; }
+            static constexpr size_t rowsCount() { return RowCount; }
             /**
              * \return the number of scalar entries in the whole array.
              *
@@ -160,13 +198,13 @@
              *
              * \note This function can be optimized into a compile-time constant.
              */
-            _VC_CONSTEXPR size_t entriesCount() const { return Size1 * Size2; }
+            static constexpr size_t entriesCount() { return Size1 * Size2; }
             /**
              * \return the number of vectors in the whole array.
              *
              * \note This function can be optimized into a compile-time constant.
              */
-            _VC_CONSTEXPR size_t vectorsCount() const { return VectorsCount * Size1; }
+            static constexpr size_t vectorsCount() { return VectorsCount * Size1; }
 
             /**
              * Copies the data from a different object.
@@ -180,12 +218,12 @@
             template<typename Parent, typename RM>
             Vc_ALWAYS_INLINE Memory &operator=(const MemoryBase<V, Parent, 2, RM> &rhs) {
                 assert(vectorsCount() == rhs.vectorsCount());
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
                 return *this;
             }
 
             Vc_ALWAYS_INLINE Memory &operator=(const Memory &rhs) {
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
                 return *this;
             }
 
@@ -202,11 +240,7 @@
                 }
                 return *this;
             }
-    }
-#if defined(VC_ICC) && VC_ICC < 20120212 && !defined(_WIN32)
-    __attribute__((__aligned__(__alignof(VectorAlignedBaseT<V>))))
-#endif
-    ;
+};
 
     /**
      * A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and
@@ -251,32 +285,31 @@
      * \ingroup Utilities
      * \headerfile memory.h <Vc/Memory>
      */
-    template<typename V, size_t Size> class Memory<V, Size, 0u> : public VectorAlignedBaseT<V>, public MemoryBase<V, Memory<V, Size, 0u>, 1, void>
+template <typename V, size_t Size, bool InitPadding>
+class Memory<V, Size, 0u, InitPadding> :
+#ifndef Vc_RECURSIVE_MEMORY
+    public AlignedBase<V::MemoryAlignment>,
+#endif
+    public MemoryBase<V, Memory<V, Size, 0u, InitPadding>, 1, void>
     {
         public:
             typedef typename V::EntryType EntryType;
         private:
-            typedef MemoryBase<V, Memory<V, Size, 0u>, 1, void> Base;
-            friend class MemoryBase<V, Memory<V, Size, 0u>, 1, void>;
-            friend class MemoryDimensionBase<V, Memory<V, Size, 0u>, 1, void>;
-            enum InternalConstants {
-                Alignment = V::Size,
-                AlignmentMask = Alignment - 1,
-                MaskedSize = Size & AlignmentMask,
-                Padding = Alignment - MaskedSize,
+            typedef MemoryBase<V, Memory<V, Size, 0u, InitPadding>, 1, void> Base;
+            friend class MemoryBase<V, Memory<V, Size, 0u, InitPadding>, 1, void>;
+            friend class MemoryDimensionBase<V, Memory<V, Size, 0u, InitPadding>, 1, void>;
+            enum : size_t {
+                Alignment = V::MemoryAlignment,     // in Bytes
+                MaskedSize = Size & (V::Size - 1),  // the fraction of Size that exceeds
+                                                    // an integral multiple of V::Size
+                Padding = V::Size - MaskedSize,
                 PaddedSize = MaskedSize == 0 ? Size : Size + Padding
             };
-#if defined(VC_ICC) && defined(_WIN32)
-            __declspec(align(__alignof(VectorAlignedBaseT<V>)))
-#elif defined(VC_CLANG)
-            __attribute__((aligned(__alignof(VectorAlignedBaseT<V>))))
-#elif defined(VC_MSVC)
-	    VectorAlignedBaseT<V> _force_alignment;
-            // __declspec(align(#)) accepts only numbers not __alignof nor just VectorAlignment
-	    // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly.
-	    // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :(
-#endif
-            EntryType m_mem[PaddedSize];
+            alignas(static_cast<size_t>(Alignment))  // GCC complains about 'is not an
+                                                     // integer constant' unless the
+                                                     // static_cast is present
+                EntryType m_mem[PaddedSize];
+
         public:
             using Base::vector;
             enum Constants {
@@ -284,6 +317,20 @@
                 VectorsCount = PaddedSize / V::Size
             };
 
+            Memory()
+            {
+                if (InitPadding) {
+                    Base::lastVector() = V::Zero();
+                }
+            }
+
+            Memory(std::initializer_list<EntryType> init)
+            {
+                Vc_ASSERT(init.size() <= Size);
+                Base::lastVector() = V::Zero();
+                std::copy(init.begin(), init.end(), &m_mem[0]);
+            }
+
             /**
              * Wrap existing data with the Memory convenience class.
              *
@@ -306,14 +353,14 @@
              * (not too early/not leaked). This function simply adds convenience functions to \em
              * access the memory.
              */
-            static Vc_ALWAYS_INLINE Vc_CONST Memory<V, Size, 0u> &fromRawData(EntryType *ptr)
+            static Vc_ALWAYS_INLINE Vc_CONST Memory<V, Size, 0u, false> &fromRawData(EntryType *ptr)
             {
                 // DANGER! This placement new has to use the right address. If the compiler decides
                 // RowMemory requires padding before the actual data then the address has to be adjusted
                 // accordingly
                 char *addr = reinterpret_cast<char *>(ptr);
-                typedef Memory<V, Size, 0u> MM;
-                addr -= VC_OFFSETOF(MM, m_mem);
+                typedef Memory<V, Size, 0u, false> MM;
+                addr -= Vc_OFFSETOF(MM, m_mem);
                 return *new(addr) MM;
             }
 
@@ -322,42 +369,36 @@
              *
              * \note This function can be optimized into a compile-time constant.
              */
-            _VC_CONSTEXPR size_t entriesCount() const { return EntriesCount; }
+            static constexpr size_t entriesCount() { return EntriesCount; }
 
             /**
              * \return the number of vectors in the whole array.
              *
              * \note This function can be optimized into a compile-time constant.
              */
-            _VC_CONSTEXPR size_t vectorsCount() const { return VectorsCount; }
-
-#ifdef VC_CXX11
-            Vc_ALWAYS_INLINE Memory() = default;
-#else
-            Vc_ALWAYS_INLINE Memory() {}
-#endif
+            static constexpr size_t vectorsCount() { return VectorsCount; }
 
             inline Memory(const Memory &rhs)
             {
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
             }
 
             template <size_t S> inline Memory(const Memory<V, S> &rhs)
             {
                 assert(vectorsCount() == rhs.vectorsCount());
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
             }
 
             inline Memory &operator=(const Memory &rhs)
             {
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
                 return *this;
             }
 
             template <size_t S> inline Memory &operator=(const Memory<V, S> &rhs)
             {
                 assert(vectorsCount() == rhs.vectorsCount());
-                Internal::copyVectors(*this, rhs);
+                Detail::copyVectors(*this, rhs);
                 return *this;
             }
 
@@ -371,11 +412,7 @@
                 }
                 return *this;
             }
-    }
-#if defined(VC_ICC) && VC_ICC < 20120212 && !defined(_WIN32)
-    __attribute__((__aligned__(__alignof(VectorAlignedBaseT<V>)) ))
-#endif
-    ;
+    };
 
     /**
      * A helper class that is very similar to Memory<V, Size> but with dynamically allocated memory and
@@ -417,7 +454,7 @@
      * \ingroup Utilities
      * \headerfile memory.h <Vc/Memory>
      */
-    template<typename V> class Memory<V, 0u, 0u> : public MemoryBase<V, Memory<V, 0u, 0u>, 1, void>
+    template<typename V> class Memory<V, 0u, 0u, true> : public MemoryBase<V, Memory<V, 0u, 0u, true>, 1, void>
     {
         public:
             typedef typename V::EntryType EntryType;
@@ -453,6 +490,7 @@
             m_mem(Vc::malloc<EntryType, Vc::AlignOnVector>(m_vectorsCount))
         {
             m_vectorsCount /= V::Size;
+            Base::lastVector() = V::Zero();
         }
 
         /**
@@ -468,7 +506,7 @@
             m_vectorsCount(rhs.vectorsCount()),
             m_mem(Vc::malloc<EntryType, Vc::AlignOnVector>(m_vectorsCount * V::Size))
         {
-            Internal::copyVectors(*this, rhs);
+            Detail::copyVectors(*this, rhs);
         }
 
         /**
@@ -483,7 +521,7 @@
             m_vectorsCount(rhs.vectorsCount()),
             m_mem(Vc::malloc<EntryType, Vc::AlignOnVector>(m_vectorsCount * V::Size))
         {
-            Internal::copyVectors(*this, rhs);
+            Detail::copyVectors(*this, rhs);
         }
 
         /**
@@ -527,13 +565,13 @@
         template<typename Parent, typename RM>
         Vc_ALWAYS_INLINE Memory &operator=(const MemoryBase<V, Parent, 1, RM> &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
-            Internal::copyVectors(*this, rhs);
+            Detail::copyVectors(*this, rhs);
             return *this;
         }
 
         Vc_ALWAYS_INLINE Memory &operator=(const Memory &rhs) {
             assert(vectorsCount() == rhs.vectorsCount());
-            Internal::copyVectors(*this, rhs);
+            Detail::copyVectors(*this, rhs);
             return *this;
         }
 
@@ -564,7 +602,7 @@
  */
 Vc_ALWAYS_INLINE void prefetchForOneRead(const void *addr)
 {
-    Internal::Helper::prefetchForOneRead(addr);
+    Vc::Detail::prefetchForOneRead(addr, VectorAbi::Best<float>());
 }
 
 /**
@@ -581,7 +619,7 @@
  */
 Vc_ALWAYS_INLINE void prefetchForModify(const void *addr)
 {
-    Internal::Helper::prefetchForModify(addr);
+    Vc::Detail::prefetchForModify(addr, VectorAbi::Best<float>());
 }
 
 /**
@@ -596,7 +634,7 @@
  */
 Vc_ALWAYS_INLINE void prefetchClose(const void *addr)
 {
-    Internal::Helper::prefetchClose(addr);
+    Vc::Detail::prefetchClose(addr, VectorAbi::Best<float>());
 }
 
 /**
@@ -611,7 +649,7 @@
  */
 Vc_ALWAYS_INLINE void prefetchMid(const void *addr)
 {
-    Internal::Helper::prefetchMid(addr);
+    Vc::Detail::prefetchMid(addr, VectorAbi::Best<float>());
 }
 
 /**
@@ -626,17 +664,21 @@
  */
 Vc_ALWAYS_INLINE void prefetchFar(const void *addr)
 {
-    Internal::Helper::prefetchFar(addr);
+    Vc::Detail::prefetchFar(addr, VectorAbi::Best<float>());
 }
+}  // namespace Common
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+using Common::Memory;
+using Common::prefetchForOneRead;
+using Common::prefetchForModify;
+using Common::prefetchClose;
+using Common::prefetchMid;
+using Common::prefetchFar;
+}  // namespace Vc
 
 namespace std
 {
     template<typename V> Vc_ALWAYS_INLINE void swap(Vc::Memory<V> &a, Vc::Memory<V> &b) { a.swap(b); }
 } // namespace std
 
-#include "undomacros.h"
-
-#endif // VC_COMMON_MEMORY_H
+#endif // VC_COMMON_MEMORY_H_
diff -Nru vc-0.7.4/common/operators.h vc-1.3.0/common/operators.h
--- vc-0.7.4/common/operators.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/operators.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,209 +1,257 @@
-#ifndef VC_ICC
-// ICC ICEs if the following type-traits are in the anonymous namespace
-namespace
-{
-#endif
-template<typename Cond, typename T> struct EnableIfNeitherIntegerNorVector : public EnableIf<!CanConvertToInt<Cond>::Value, T> {};
-template<typename Cond, typename T> struct EnableIfNeitherIntegerNorVector<Vector<Cond>, T>;
+/*  This file is part of the Vc library. {{{
+Copyright © 2012-2016 Matthias Kretz <kretz@kde.org>
 
-template<typename T> struct IsVector             { enum { Value = false }; };
-template<typename T> struct IsVector<Vector<T> > { enum { Value =  true }; };
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef COMMON_OPERATORS_H_
+#define COMMON_OPERATORS_H_
+#include "macros.h"
 
-template<typename T0, typename T1, typename V0, typename V1> struct IsTypeCombinationOf
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
 {
-    enum {
-        Value = IsVector<V0>::Value ? (IsVector<V1>::Value ? ( // Vec × Vec
-                    (    IsEqualType<T0, V0>::Value && HasImplicitCast<T1, V1>::Value && !HasImplicitCast<T1, int>::Value) ||
-                    (HasImplicitCast<T0, V0>::Value &&     IsEqualType<T1, V1>::Value && !HasImplicitCast<T0, int>::Value) ||
-                    (    IsEqualType<T0, V1>::Value && HasImplicitCast<T1, V0>::Value && !HasImplicitCast<T1, int>::Value) ||
-                    (HasImplicitCast<T0, V1>::Value &&     IsEqualType<T1, V0>::Value && !HasImplicitCast<T0, int>::Value)
-                ) : ( // Vec × Scalar
-                    (HasImplicitCast<T0, V0>::Value &&     IsEqualType<T1, V1>::Value && !HasImplicitCast<T0, int>::Value) ||
-                    (    IsEqualType<T0, V1>::Value && HasImplicitCast<T1, V0>::Value && !HasImplicitCast<T1, int>::Value)
-            )) : (IsVector<V1>::Value ? ( // Scalar × Vec
-                    (    IsEqualType<T0, V0>::Value && HasImplicitCast<T1, V1>::Value && !HasImplicitCast<T1, int>::Value) ||
-                    (HasImplicitCast<T0, V1>::Value &&     IsEqualType<T1, V0>::Value && !HasImplicitCast<T0, int>::Value)
-                ) : ( // Scalar × Scalar
-                    (    IsEqualType<T0, V0>::Value &&     IsEqualType<T1, V1>::Value) ||
-                    (    IsEqualType<T0, V1>::Value &&     IsEqualType<T1, V0>::Value)
-                    ))
-    };
+template <typename T, typename Abi, typename U>
+enable_if<!std::is_same<T, U>::value, U> is_convertible_to_any_vector(Vector<U, Abi>);
+template <typename T, typename Abi> T is_convertible_to_any_vector(Vector<T, Abi>);
+template <typename T, typename Abi> void is_convertible_to_any_vector(...);
+
+template <typename T, typename U, bool = std::is_integral<T>::value,
+          bool = std::is_integral<U>::value>
+struct FundamentalReturnType;
+template <typename T, typename U> struct FundamentalReturnType<T, U, false, false> {
+    using type = typename std::conditional<
+        std::is_arithmetic<U>::value,
+        typename std::conditional<(sizeof(T) < sizeof(U)), U, T>::type,
+        // U is not arithmetic, e.g. an enum or a type with e.g. operator int()
+        T>::type;
+};
+template <typename T, typename U> struct FundamentalReturnType<T, U, true, false> {
+    using type = typename std::conditional<
+        std::is_arithmetic<U>::value, U,
+        // U is not arithmetic, e.g. an enum or a type with e.g. operator int()
+        T>::type;
+};
+template <typename T, typename U> struct FundamentalReturnType<T, U, false, true> {
+    using type = T;
 };
 
-template<typename T0, typename T1, typename V> struct IsVectorOperands
-{
-    enum {
-        Value = (HasImplicitCast<T0, V>::Value && !HasImplicitCast<T0, int>::Value && !IsEqualType<T0, V>::Value && IsEqualType<T1, V>::Value)
-            ||  (HasImplicitCast<T1, V>::Value && !HasImplicitCast<T1, int>::Value && !IsEqualType<T1, V>::Value && IsEqualType<T0, V>::Value)
-    };
+template <typename T> struct my_make_signed : public std::make_signed<T> {
+};
+template <> struct my_make_signed<bool> {
+    using type = bool;
+};
+
+template <typename TT, typename UU>
+struct higher_conversion_rank {
+    template <typename A>
+    using fix_sign =
+        typename std::conditional<(std::is_unsigned<TT>::value ||
+                                   std::is_unsigned<UU>::value),
+                                  typename std::make_unsigned<A>::type, A>::type;
+    using T = typename my_make_signed<TT>::type;
+    using U = typename my_make_signed<UU>::type;
+    template <typename Test, typename Otherwise>
+    using c = typename std::conditional<std::is_same<T, Test>::value ||
+                                            std::is_same<U, Test>::value,
+                                        Test, Otherwise>::type;
+
+    using type = fix_sign<c<long long, c<long, c<int, c<short, c<signed char, void>>>>>>;
+};
+
+template <typename T, typename U> struct FundamentalReturnType<T, U, true, true> {
+    template <bool B, class Then, class E>
+    using c = typename std::conditional<B, Then, E>::type;
+    using type =
+        c<(sizeof(T) > sizeof(U)), T,
+          c<(sizeof(T) < sizeof(U)), U, typename higher_conversion_rank<T, U>::type>>;
+};
+static_assert(std::is_same<long, typename FundamentalReturnType<int, long>::type>::value, "");
+
+template <typename V, typename T, bool, typename, bool> struct ReturnTypeImpl {
+    // no type => SFINAE
+};
+template <typename T, typename U, typename Abi, typename Deduced>
+struct ReturnTypeImpl<Vector<T, Abi>, Vector<U, Abi>, false, Deduced, false> {
+    using type = Vc::Vector<typename FundamentalReturnType<T, U>::type, Abi>;
+};
+template <typename T, typename Abi>
+struct ReturnTypeImpl<Vector<T, Abi>, int, true, T, true> {
+    using type = Vc::Vector<T, Abi>;
+};
+template <typename T, typename Abi>
+struct ReturnTypeImpl<Vector<T, Abi>, unsigned int, true, T, true> {
+    using type = Vc::Vector<typename std::make_unsigned<T>::type, Abi>;
+};
+template <typename T, typename U, typename Abi, bool Integral>
+struct ReturnTypeImpl<Vector<T, Abi>, U, true, T, Integral> {
+    using type = Vc::Vector<typename FundamentalReturnType<T, U>::type, Abi>;
+};
+template <typename T, typename U, typename Abi, bool Integral>
+struct ReturnTypeImpl<Vector<T, Abi>, U, false, void, Integral> {
+    // no type => SFINAE
+};
+template <typename T, typename U, typename Abi, typename V, bool Integral>
+struct ReturnTypeImpl<Vector<T, Abi>, U, false, V, Integral> {
+    using type = Vc::Vector<typename FundamentalReturnType<T, V>::type, Abi>;
+};
+template <typename V, typename T>
+using ReturnType = ReturnTypeImpl<
+    V, T, std::is_arithmetic<T>::value || std::is_convertible<T, int>::value,
+    decltype(is_convertible_to_any_vector<typename V::value_type, typename V::abi>(
+        std::declval<const T &>())),
+    std::is_integral<typename V::value_type>::value>;
+
+template <typename T> struct is_a_type : public std::true_type {
 };
-#ifndef VC_ICC
-}
-#endif
 
-// float-int arithmetic operators //{{{1
-// These operators must be very picky about the exact types they want to handle. Once (uncontrolled)
-// implicit type conversions get involved, ambiguous overloads will occur. E.g. a simple int × enum
-// will become ambiguous because it can convert both to a vector type, which then can execute the
-// operator. We can't argue that such code should not be used - it could break existing code, not
-// under control of the developer, just by putting the Vc header somewhere on top.
-//
-// The following type combinations are safe (always symmetric):
-// 1. Vector × Vector
-// 2. Vector × Scalar (int, float, enum value, ...)
-// 3. Some object that has a vector cast operator × Vector
-// 4. Some object that has a vector cast operator × Scalar
-//
-// Additionally there are restrictions on which types combine to what resulting type:
-// 1.a.        float × double_v -> double_v
-// 1.b.      any int × double_v -> double_v
-// 2.a.     (u)int_v ×  float_v ->  float_v
-// 2.b.     (u)int_v ×    float ->  float_v
-// 2.c.      any int ×  float_v ->  float_v
-// 3.a.   (u)short_v × sfloat_v -> sfloat_v
-// 3.b.   (u)short_v ×    float -> sfloat_v
-// 3.c.        short × sfloat_v -> sfloat_v
-// 4.a.        int_v ×   uint_v ->   uint_v
-// 4.b.      any int ×   uint_v ->   uint_v
-// 4.c. unsigned int ×    int_v ->   uint_v
-// 4.d.   signed int ×    int_v ->    int_v
-// 5.              shorts like ints
-
-#define VC_OPERATOR_FORWARD_(ret, op) \
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, double_v>::Value || \
-    ((IsEqualType<T0, float>::Value || IsLikeInteger<T0>::Value) && HasImplicitCast<T1, double_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    ((IsEqualType<T1, float>::Value || IsLikeInteger<T1>::Value) && HasImplicitCast<T0, double_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, double_##ret>::Value operator op(const T0 &x, const T1 &y) { return double_v(x) op double_v(y); } \
-\
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, float_v>::Value || \
-    IsTypeCombinationOf<T0, T1,  int_v, float_v>::Value || \
-    IsTypeCombinationOf<T0, T1, uint_v, float_v>::Value || \
-    IsTypeCombinationOf<T0, T1,  int_v,   float>::Value || \
-    IsTypeCombinationOf<T0, T1, uint_v,   float>::Value || \
-    (IsLikeInteger<T0>::Value && HasImplicitCast<T1, float_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeInteger<T1>::Value && HasImplicitCast<T0, float_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, float_##ret>::Value operator op(const T0 &x, const T1 &y) { return float_v(x) op float_v(y); } \
-\
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, sfloat_v>::Value || \
-    IsTypeCombinationOf<T0, T1,  short_v, sfloat_v>::Value || \
-    IsTypeCombinationOf<T0, T1, ushort_v, sfloat_v>::Value || \
-    IsTypeCombinationOf<T0, T1,  short_v,    float>::Value || \
-    IsTypeCombinationOf<T0, T1, ushort_v,    float>::Value || \
-    (IsLikeInteger<T0>::Value && HasImplicitCast<T1, sfloat_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeInteger<T1>::Value && HasImplicitCast<T0, sfloat_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, sfloat_##ret>::Value operator op(const T0 &x, const T1 &y) { return sfloat_v(x) op sfloat_v(y); } \
-\
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, uint_v>::Value || \
-    IsTypeCombinationOf<T0, T1, int_v, uint_v>::Value || \
-    (IsUnsignedInteger<T0>::Value && HasImplicitCast<T1, int_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsUnsignedInteger<T1>::Value && HasImplicitCast<T0, int_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    (IsLikeInteger<T0>::Value && !IsEqualType<T0, unsigned int>::Value && HasImplicitCast<T1, uint_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeInteger<T1>::Value && !IsEqualType<T1, unsigned int>::Value && HasImplicitCast<T0, uint_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, uint_##ret>::Value operator op(const T0 &x, const T1 &y) { return uint_v(x) op uint_v(y); } \
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, int_v>::Value || \
-    (IsLikeSignedInteger<T0>::Value && !IsEqualType<T0, int>::Value && HasImplicitCast<T1, int_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeSignedInteger<T1>::Value && !IsEqualType<T1, int>::Value && HasImplicitCast<T0, int_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, int_##ret>::Value operator op(const T0 &x, const T1 &y) { return  int_v(x) op  int_v(y); } \
-\
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, ushort_v>::Value || \
-    IsTypeCombinationOf<T0, T1, short_v, ushort_v>::Value || \
-    (IsUnsignedInteger<T0>::Value && HasImplicitCast<T1, short_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsUnsignedInteger<T1>::Value && HasImplicitCast<T0, short_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    (IsLikeInteger<T0>::Value && !IsEqualType<T0, unsigned short>::Value && HasImplicitCast<T1, ushort_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeInteger<T1>::Value && !IsEqualType<T1, unsigned short>::Value && HasImplicitCast<T0, ushort_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, ushort_##ret>::Value operator op(const T0 &x, const T1 &y) { return ushort_v(x) op ushort_v(y); } \
-template<typename T0, typename T1> static Vc_ALWAYS_INLINE typename EnableIf< \
-    IsVectorOperands<T0, T1, short_v>::Value || \
-    (IsLikeSignedInteger<T0>::Value && !IsEqualType<T0, short>::Value && HasImplicitCast<T1, short_v>::Value && !HasImplicitCast<T1, int>::Value) || \
-    (IsLikeSignedInteger<T1>::Value && !IsEqualType<T1, short>::Value && HasImplicitCast<T0, short_v>::Value && !HasImplicitCast<T0, int>::Value) || \
-    false, short_##ret>::Value operator op(const T0 &x, const T1 &y) { return  short_v(x) op  short_v(y); }
-
-
-// break incorrect combinations
-#define VC_OPERATOR_INTENTIONAL_ERROR_1(V, op) \
-template<typename T> static inline typename EnableIfNeitherIntegerNorVector<T, Vc::Error::invalid_operands_of_types<V, T> >::Value operator op(const V &, const T &) { return Vc::Error::invalid_operands_of_types<V, T>(); } \
-template<typename T> static inline typename EnableIfNeitherIntegerNorVector<T, Vc::Error::invalid_operands_of_types<T, V> >::Value operator op(const T &, const V &) { return Vc::Error::invalid_operands_of_types<T, V>(); }
-
-#define VC_OPERATOR_INTENTIONAL_ERROR_2(V1, V2, op) \
-static inline Vc::Error::invalid_operands_of_types<V1, V2> operator op(V1::AsArg, V2::AsArg) { return Vc::Error::invalid_operands_of_types<V1, V2>(); } \
-static inline Vc::Error::invalid_operands_of_types<V2, V1> operator op(V2::AsArg, V1::AsArg) { return Vc::Error::invalid_operands_of_types<V2, V1>(); }
-
-#define VC_OPERATOR_INTENTIONAL_ERROR_3(V, _T, op) \
-template<typename T> static inline typename EnableIf<IsEqualType<T, _T>::Value, Vc::Error::invalid_operands_of_types<V, T> >::Value operator op(const V &, const T &) { return Vc::Error::invalid_operands_of_types<V, T>(); } \
-template<typename T> static inline typename EnableIf<IsEqualType<T, _T>::Value, Vc::Error::invalid_operands_of_types<T, V> >::Value operator op(const T &, const V &) { return Vc::Error::invalid_operands_of_types<T, V>(); }
-
-//#define VC_EXTRA_CHECKING
-#ifdef VC_EXTRA_CHECKING
-#define VC_OPERATOR_INTENTIONAL_ERROR(op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v, sfloat_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v,  float_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v,    int_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v,   uint_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v,  short_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(double_v, ushort_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(   int_v,  short_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(  uint_v,  short_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(   int_v, ushort_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(  uint_v, ushort_v, op) \
-    VC_APPLY_1(VC_LIST_VECTOR_TYPES, VC_OPERATOR_INTENTIONAL_ERROR_1, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2( float_v,  short_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2( float_v, ushort_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(sfloat_v,  float_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(sfloat_v,    int_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_2(sfloat_v,   uint_v, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_3( float_v,   double, op) \
-    VC_OPERATOR_INTENTIONAL_ERROR_3(sfloat_v,   double, op)
+#ifdef Vc_ENABLE_FLOAT_BIT_OPERATORS
+#define Vc_TEST_FOR_BUILTIN_OPERATOR(op_) true
 #else
-#define VC_OPERATOR_INTENTIONAL_ERROR(op)
+#define Vc_TEST_FOR_BUILTIN_OPERATOR(op_)                                                \
+    Detail::is_a_type<decltype(                                                          \
+        std::declval<typename Detail::ReturnType<Vector<T, Abi>, U>::type::EntryType>()  \
+            op_ std::declval<typename Detail::ReturnType<Vector<T, Abi>,                 \
+                                                         U>::type::EntryType>())>::value
 #endif
+}  // namespace Detail
 
-#define VC_OPERATOR_FORWARD_COMMUTATIVE(ret, op, op2) \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,         double, double_##ret) operator op(T x, double_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          float, sfloat_##ret) operator op(T x, sfloat_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          float,  float_##ret) operator op(T x,  float_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,            int,    int_##ret) operator op(T x,    int_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,   unsigned int,   uint_##ret) operator op(T x,   uint_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          short,  short_##ret) operator op(T x,  short_v::AsArg y) { return y op2 x; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T, unsigned short, ushort_##ret) operator op(T x, ushort_v::AsArg y) { return y op2 x; } \
-VC_OPERATOR_FORWARD_(ret, op) \
-VC_OPERATOR_INTENTIONAL_ERROR(op)
-
-#define VC_OPERATOR_FORWARD(ret, op) \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,         double, double_##ret) operator op(T x, double_v::AsArg y) { return double_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          float, sfloat_##ret) operator op(T x, sfloat_v::AsArg y) { return sfloat_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          float,  float_##ret) operator op(T x,  float_v::AsArg y) { return  float_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,            int,    int_##ret) operator op(T x,    int_v::AsArg y) { return    int_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,   unsigned int,   uint_##ret) operator op(T x,   uint_v::AsArg y) { return   uint_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T,          short,  short_##ret) operator op(T x,  short_v::AsArg y) { return  short_v(x) op y; } \
-template<typename T> static Vc_ALWAYS_INLINE VC_EXACT_TYPE(T, unsigned short, ushort_##ret) operator op(T x, ushort_v::AsArg y) { return ushort_v(x) op y; } \
-VC_OPERATOR_FORWARD_(ret, op) \
-VC_OPERATOR_INTENTIONAL_ERROR(op)
-
-VC_OPERATOR_FORWARD_COMMUTATIVE(v, *, *)
-VC_OPERATOR_FORWARD(v, /)
-VC_OPERATOR_FORWARD_COMMUTATIVE(v, +, +)
-VC_OPERATOR_FORWARD(v, -)
-VC_OPERATOR_FORWARD_COMMUTATIVE(v, |, |)
-VC_OPERATOR_FORWARD_COMMUTATIVE(v, &, &)
-VC_OPERATOR_FORWARD_COMMUTATIVE(v, ^, ^)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, <, >)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, >, <)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, <=, >=)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, >=, <=)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, ==, ==)
-VC_OPERATOR_FORWARD_COMMUTATIVE(m, !=, !=)
-
-#undef VC_OPERATOR_FORWARD_
-#undef VC_OPERATOR_INTENTIONAL_ERROR_1
-#undef VC_OPERATOR_INTENTIONAL_ERROR_2
-#undef VC_OPERATOR_INTENTIONAL_ERROR
-#undef VC_OPERATOR_FORWARD_COMMUTATIVE
-#undef VC_OPERATOR_FORWARD
+#define Vc_GENERIC_OPERATOR(op_)                                                         \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        Vc_TEST_FOR_BUILTIN_OPERATOR(op_) &&                                             \
+            std::is_convertible<Vector<T, Abi>, typename Detail::ReturnType<             \
+                                                    Vector<T, Abi>, U>::type>::value &&  \
+            std::is_convertible<                                                         \
+                U, typename Detail::ReturnType<Vector<T, Abi>, U>::type>::value,         \
+        typename Detail::ReturnType<Vector<T, Abi>, U>::type>                            \
+    operator op_(Vector<T, Abi> x, const U &y)                                           \
+    {                                                                                    \
+        using V = typename Detail::ReturnType<Vector<T, Abi>, U>::type;                  \
+        return Detail::operator op_(V(x), V(y));                                         \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        Vc_TEST_FOR_BUILTIN_OPERATOR(op_) &&                                             \
+            !Traits::is_simd_vector_internal<U>::value &&                                \
+            std::is_convertible<Vector<T, Abi>, typename Detail::ReturnType<             \
+                                                    Vector<T, Abi>, U>::type>::value &&  \
+            std::is_convertible<                                                         \
+                U, typename Detail::ReturnType<Vector<T, Abi>, U>::type>::value,         \
+        typename Detail::ReturnType<Vector<T, Abi>, U>::type>                            \
+    operator op_(const U &x, Vector<T, Abi> y)                                           \
+    {                                                                                    \
+        using V = typename Detail::ReturnType<Vector<T, Abi>, U>::type;                  \
+        return Detail::operator op_(V(x), V(y));                                         \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        Vc_TEST_FOR_BUILTIN_OPERATOR(op_) &&                                             \
+            std::is_convertible<Vector<T, Abi>, typename Detail::ReturnType<             \
+                                                    Vector<T, Abi>, U>::type>::value &&  \
+            std::is_convertible<                                                         \
+                U, typename Detail::ReturnType<Vector<T, Abi>, U>::type>::value,         \
+        Vector<T, Abi> &>                                                                \
+    operator op_##=(Vector<T, Abi> &x, const U &y)                                       \
+    {                                                                                    \
+        using V = typename Detail::ReturnType<Vector<T, Abi>, U>::type;                  \
+        x = Detail::operator op_(V(x), V(y));                                            \
+        return x;                                                                        \
+    }
+
+#define Vc_LOGICAL_OPERATOR(op_)                                                         \
+    template <typename T, typename Abi>                                                  \
+    Vc_ALWAYS_INLINE typename Vector<T, Abi>::Mask operator op_(Vector<T, Abi> x,        \
+                                                                Vector<T, Abi> y)        \
+    {                                                                                    \
+        return !!x op_ !!y;                                                              \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        std::is_convertible<Vector<T, Abi>, Vector<U, Abi>>::value &&                    \
+            std::is_convertible<Vector<U, Abi>, Vector<T, Abi>>::value,                  \
+        typename Detail::ReturnType<Vector<T, Abi>, Vector<U, Abi>>::type::Mask>         \
+    operator op_(Vector<T, Abi> x, Vector<U, Abi> y)                                     \
+    {                                                                                    \
+        return !!x op_ !!y;                                                              \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE                                                                     \
+        enable_if<std::is_same<bool, decltype(!std::declval<const U &>())>::value,       \
+                  typename Vector<T, Abi>::Mask>                                         \
+        operator op_(Vector<T, Abi> x, const U &y)                                       \
+    {                                                                                    \
+        using M = typename Vector<T, Abi>::Mask;                                         \
+        return !!x op_ M(!!y);                                                           \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE                                                                     \
+        enable_if<std::is_same<bool, decltype(!std::declval<const U &>())>::value,       \
+                  typename Vector<T, Abi>::Mask>                                         \
+        operator op_(const U &x, Vector<T, Abi> y)                                       \
+    {                                                                                    \
+        using M = typename Vector<T, Abi>::Mask;                                         \
+        return M(!!x) op_ !!y;                                                           \
+    }
+
+#define Vc_COMPARE_OPERATOR(op_)                                                         \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        std::is_convertible<Vector<T, Abi>, typename Detail::ReturnType<                 \
+                                                Vector<T, Abi>, U>::type>::value &&      \
+            std::is_convertible<                                                         \
+                U, typename Detail::ReturnType<Vector<T, Abi>, U>::type>::value,         \
+        typename Detail::ReturnType<Vector<T, Abi>, U>::type::Mask>                      \
+    operator op_(Vector<T, Abi> x, const U &y)                                           \
+    {                                                                                    \
+        using V = typename Detail::ReturnType<Vector<T, Abi>, U>::type;                  \
+        return Detail::operator op_(V(x), V(y));                                         \
+    }                                                                                    \
+    template <typename T, typename Abi, typename U>                                      \
+    Vc_ALWAYS_INLINE enable_if<                                                          \
+        !Traits::is_simd_vector_internal<U>::value &&                                    \
+            std::is_convertible<Vector<T, Abi>, typename Detail::ReturnType<             \
+                                                    Vector<T, Abi>, U>::type>::value &&  \
+            std::is_convertible<                                                         \
+                U, typename Detail::ReturnType<Vector<T, Abi>, U>::type>::value,         \
+        typename Detail::ReturnType<Vector<T, Abi>, U>::type::Mask>                      \
+    operator op_(const U &x, Vector<T, Abi> y)                                           \
+    {                                                                                    \
+        using V = typename Detail::ReturnType<Vector<T, Abi>, U>::type;                  \
+        return Detail::operator op_(V(x), V(y));                                         \
+    }
+
+Vc_ALL_LOGICAL    (Vc_LOGICAL_OPERATOR);
+Vc_ALL_BINARY     (Vc_GENERIC_OPERATOR);
+Vc_ALL_ARITHMETICS(Vc_GENERIC_OPERATOR);
+Vc_ALL_COMPARES   (Vc_COMPARE_OPERATOR);
+
+#undef Vc_LOGICAL_OPERATOR
+#undef Vc_GENERIC_OPERATOR
+#undef Vc_COMPARE_OPERATOR
+#undef Vc_INVALID_OPERATOR
 
-// }}}1
+}  // namespace Vc
+#endif  // COMMON_OPERATORS_H_
diff -Nru vc-0.7.4/common/permutation.h vc-1.3.0/common/permutation.h
--- vc-0.7.4/common/permutation.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/permutation.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,44 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_PERMUTATION_H_
+#define VC_COMMON_PERMUTATION_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Permutation
+{
+struct ReversedTag {};
+constexpr ReversedTag Reversed{};
+}  // namespace Permutation
+}
+
+#endif  // VC_COMMON_PERMUTATION_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/scatterimplementation.h vc-1.3.0/common/scatterimplementation.h
--- vc-0.7.4/common/scatterimplementation.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/scatterimplementation.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,270 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SCATTERIMPLEMENTATION_H_
+#define VC_COMMON_SCATTERIMPLEMENTATION_H_
+
+#include "gatherimplementation.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(SetIndexZeroT,
+                                    V &v,
+                                    MT *mem,
+                                    IT indexes,
+                                    typename V::MaskArgument mask)
+{
+    indexes.setZeroInverted(static_cast<typename IT::Mask>(mask));
+    // Huh?
+    const V tmp(mem, indexes);
+    where(mask) | v = tmp;
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(SimpleLoopT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask)
+{
+    if (Vc_IS_UNLIKELY(mask.isEmpty())) {
+        return;
+    }
+    Common::unrolled_loop<std::size_t, 0, V::Size>([&](std::size_t i) {
+        if (mask[i])
+            mem[indexes[i]] = v[i];
+    });
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(BitScanLoopT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask)
+{
+    size_t bits = mask.toInt();
+    while (Vc_IS_LIKELY(bits > 0)) {
+        size_t i, j;
+        asm("bsf %[bits],%[i]\n\t"
+            "bsr %[bits],%[j]\n\t"
+            "btr %[i],%[bits]\n\t"
+            "btr %[j],%[bits]\n\t"
+            : [i] "=r"(i), [j] "=r"(j), [bits] "+r"(bits));
+        mem[indexes[i]] = v[i];
+        mem[indexes[j]] = v[j];
+    }
+
+    /* Alternative from Vc::SSE (0.7)
+    int bits = mask.toInt();
+    while (bits) {
+        const int i = _bit_scan_forward(bits);
+        bits ^= (1 << i); // btr?
+        mem[indexes[i]] = v[i];
+    }
+    */
+}
+
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 16> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt16(bits)) {
+    case 16:
+        v.scatter(mem, indexes);
+        break;
+    case 15:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        mem[indexes[low]] = v[low];
+    case 14:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 13:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 12:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 11:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 10:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 9:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 8:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 7:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 6:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 5:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 4:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+    case 1:
+        low = _bit_scan_forward(bits);
+        mem[indexes[low]] = v[low];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 8> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt8(bits)) {
+    case 8:
+        v.scatter(mem, indexes);
+        break;
+    case 7:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        mem[indexes[low]] = v[low];
+    case 6:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 5:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 4:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+        high = (1 << high);
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= high | (1 << low);
+        mem[indexes[low]] = v[low];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+    case 1:
+        low = _bit_scan_forward(bits);
+        mem[indexes[low]] = v[low];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 4> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low, high = 0;
+    switch (Vc::Detail::popcnt4(bits)) {
+    case 4:
+        v.scatter(mem, indexes);
+        break;
+    case 3:
+        low = _bit_scan_forward(bits);
+        bits ^= 1 << low;
+        mem[indexes[low]] = v[low];
+    case 2:
+        high = _bit_scan_reverse(bits);
+        mem[indexes[high]] = v[high];
+    case 1:
+        low = _bit_scan_forward(bits);
+        mem[indexes[low]] = v[low];
+    case 0:
+        break;
+    }
+}
+template <typename V, typename MT, typename IT>
+Vc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,
+                                    V &v,
+                                    MT *mem,
+                                    const IT &indexes,
+                                    typename V::MaskArgument mask,
+                                    enable_if<V::Size == 2> = nullarg)
+{
+    unsigned int bits = mask.toInt();
+    unsigned int low;
+    switch (Vc::Detail::popcnt4(bits)) {
+    case 2:
+        v.scatter(mem, indexes);
+        break;
+    case 1:
+        low = _bit_scan_forward(bits);
+        mem[indexes[low]] = v[low];
+    case 0:
+        break;
+    }
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_SCATTERIMPLEMENTATION_H_
diff -Nru vc-0.7.4/common/scatterinterface.h vc-1.3.0/common/scatterinterface.h
--- vc-0.7.4/common/scatterinterface.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/scatterinterface.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,282 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// scatters
+// A scatter takes the following arguments:
+// 1. A pointer to memory of any type that EntryType can convert to.
+// 2. An indexes “vector”. The requirement is that the type implements the subscript operator,
+//    stores «Size» valid index values, and each offset to the pointer above yields a valid
+//    memory location for reading.
+// 3. Optionally the third argument may be a mask. The mask disables several memory stores and
+//    thus removes the requirements in (2.) for the disabled entries.
+
+private:
+    /**\internal
+     * This function implements a scatter given a pointer to memory \p mem and some
+     * container object storing the scatter \p indexes.
+     *
+     * \param mem This pointer must be aligned correctly for the type \p MT. This is the
+     * natural behavior of C++, so this is typically the case.
+     * \param indexes This object contains at least \VSize{T} indexes that denote the
+     * offset in \p mem where the components for the current vector should be copied to.
+     * The offset is not in Bytes, but in multiples of `sizeof(MT)`.
+     */
+    // enable_if<std::can_convert<MT, EntryType>::value && has_subscript_operator<IT>::value>
+    template <typename MT, typename IT>
+    inline void scatterImplementation(MT *mem, IT &&indexes) const;
+
+    /**\internal
+     * This overload of the above function adds a \p mask argument to disable memory
+     * accesses at the \p indexes offsets where \p mask is \c false.
+     */
+    template <typename MT, typename IT>
+    inline void scatterImplementation(MT *mem, IT &&indexes, MaskArgument mask) const;
+
+public:
+#define Vc_ASSERT_SCATTER_PARAMETER_TYPES_                                               \
+    static_assert(                                                                       \
+        std::is_convertible<EntryType, MT>::value,                                       \
+        "The memory pointer needs to point to a type that the EntryType of this "        \
+        "SIMD vector type can be converted to.");                                        \
+    static_assert(                                                                       \
+        Vc::Traits::has_subscript_operator<IT>::value,                                   \
+        "The indexes argument must be a type that implements the subscript operator.");  \
+    static_assert(                                                                       \
+        !Traits::is_simd_vector<IT>::value ||                                            \
+            Traits::simd_vector_size<IT>::value >= Size,                                 \
+        "If you use a SIMD vector for the indexes parameter, the index vector must "     \
+        "have at least as many entries as this SIMD vector.");                           \
+    static_assert(                                                                       \
+        !std::is_array<T>::value ||                                                      \
+            (std::rank<T>::value == 1 &&                                                 \
+             (std::extent<T>::value == 0 || std::extent<T>::value >= Size)),             \
+        "If you use a simple array for the indexes parameter, the array must have "      \
+        "at least as many entries as this SIMD vector.")
+
+    /**
+     * \name Scatter functions
+     *
+     * Stores a vector to the objects at `mem[indexes[0]]`, `mem[indexes[1]]`,
+     * `mem[indexes[2]]`, ...
+     *
+     * \param mem A pointer to memory which contains objects of type \p MT at the offsets
+     *            given by \p indexes.
+     * \param indexes
+     * \param mask
+     */
+    ///@{
+
+    /// Scatter function
+    template <typename MT,
+              typename IT,
+              typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC void scatter(MT *mem, IT &&indexes) const
+    {
+        Vc_ASSERT_SCATTER_PARAMETER_TYPES_;
+        scatterImplementation(mem, std::forward<IT>(indexes));
+    }
+
+    /// Masked scatter function
+    template <typename MT,
+              typename IT,
+              typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>
+    Vc_INTRINSIC void scatter(MT *mem, IT &&indexes, MaskArgument mask) const
+    {
+        Vc_ASSERT_SCATTER_PARAMETER_TYPES_;
+        scatterImplementation(mem, std::forward<IT>(indexes), mask);
+    }
+    ///@}
+
+    /// \name Deprecated Members
+    ///@{
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, EntryType S1::*member1,
+                                                  IT indexes) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                    array, indexes)[member1]
+                    .scatterArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, EntryType S1::*member1,
+                                                  IT indexes, MaskArgument mask) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                    array, indexes)[member1]
+                    .scatterArguments(),
+                mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, S2 S1::*member1,
+                                                  EntryType S2::*member2,
+                                                  IT indexes) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                    array, indexes)[member1][member2]
+                    .scatterArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
+     *                struct (i.e. array[i].*member1.*member2 is read).
+     * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
+     *                to. The type of indexes can either be an integer vector or a type that supports
+     *                operator[] access.
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename S2, typename IT>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, S2 S1::*member1,
+                                                  EntryType S2::*member2, IT indexes,
+                                                  MaskArgument mask) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
+                    array, indexes)[member1][member2]
+                    .scatterArguments(),
+                mask);
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,
+                                                  IT1 outerIndexes,
+                                                  IT2 innerIndexes) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                    array, outerIndexes)[ptrMember1][innerIndexes]
+                    .scatterArguments());
+    }
+
+    /**
+     * \deprecated Use Vc::array or Vc::vector subscripting instead.
+     *
+     * \param array   A pointer into memory (without alignment restrictions).
+     * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
+     *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
+     *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
+     *                (&(array->*member1))[i])
+     * \param outerIndexes
+     * \param innerIndexes
+     * \param mask    If a mask is given only the active entries will be gathered/scattered.
+     */
+    template <typename S1, typename IT1, typename IT2>
+    Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
+                  "instead.") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,
+                                                  IT1 outerIndexes, IT2 innerIndexes,
+                                                  MaskArgument mask) const
+    {
+        scatter(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
+                    array, outerIndexes)[ptrMember1][innerIndexes]
+                    .scatterArguments(),
+                mask);
+    }
+    ///@}
+
+    /**\internal
+     * \name Scatter function to use from Vc::Common::subscript_operator
+     *
+     * \param args
+     * \param mask
+     */
+    ///@{
+    template <typename MT, typename IT>
+    Vc_INTRINSIC void scatter(const Common::ScatterArguments<MT, IT> &args) const
+    {
+        scatter(args.address, args.indexes);
+    }
+
+    template <typename MT, typename IT>
+    Vc_INTRINSIC void scatter(const Common::ScatterArguments<MT, IT> &args, MaskArgument mask) const
+    {
+        scatter(args.address, args.indexes, mask);
+    }
+    ///@}
+#undef Vc_ASSERT_SCATTER_PARAMETER_TYPES_
diff -Nru vc-0.7.4/common/set.h vc-1.3.0/common/set.h
--- vc-0.7.4/common/set.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/set.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,92 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SET_H_
+#define VC_COMMON_SET_H_
+
+#include "macros.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace
+{
+    static Vc_INTRINSIC Vc_CONST __m128i set(unsigned short x0, unsigned short x1, unsigned short x2, unsigned short x3,
+            unsigned short x4, unsigned short x5, unsigned short x6, unsigned short x7)
+    {
+#if defined(Vc_GNU_ASM)
+#if 0 // defined(__x86_64__)
+        // it appears that the 32bit variant is always faster
+        __m128i r;
+        unsigned long long tmp0 = x3; tmp0 = (tmp0 << 16) | x2;
+        unsigned long long tmp1 = x1; tmp1 = (tmp1 << 16) | x0;
+        asm("vmovq %1,%0" : "=x"(r) : "r"((tmp0 << 32) | tmp1));
+        unsigned long long tmp2 = x7; tmp2 = (tmp2 << 16) | x6;
+        unsigned long long tmp3 = x5; tmp3 = (tmp3 << 16) | x4;
+        asm("vpinsrq $1,%1,%0,%0" : "+x"(r) : "r"((tmp2 << 32) | tmp3));
+        return r;
+#elif defined(Vc_USE_VEX_CODING)
+        __m128i r0, r1;
+        unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;
+        unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;
+        unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;
+        unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;
+        asm("vmovd %1,%0" : "=x"(r0) : "r"(tmp0));
+        asm("vpinsrd $1,%1,%0,%0" : "+x"(r0) : "r"(tmp1));
+        asm("vmovd %1,%0" : "=x"(r1) : "r"(tmp2));
+        asm("vpinsrd $1,%1,%0,%0" : "+x"(r1) : "r"(tmp3));
+        asm("vpunpcklqdq %1,%0,%0" : "+x"(r0) : "x"(r1));
+        return r0;
+#else
+        __m128i r0, r1;
+        unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;
+        unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;
+        unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;
+        unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;
+        asm("movd %1,%0" : "=x"(r0) : "r"(tmp0));
+        asm("pinsrd $1,%1,%0" : "+x"(r0) : "r"(tmp1));
+        asm("movd %1,%0" : "=x"(r1) : "r"(tmp2));
+        asm("pinsrd $1,%1,%0" : "+x"(r1) : "r"(tmp3));
+        asm("punpcklqdq %1,%0" : "+x"(r0) : "x"(r1));
+        return r0;
+#endif
+#else
+        unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;
+        unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;
+        unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;
+        unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;
+        return _mm_setr_epi32(tmp0, tmp1, tmp2, tmp3);
+#endif
+    }
+    static Vc_INTRINSIC Vc_CONST __m128i set(short x0, short x1, short x2, short x3, short x4, short x5, short x6, short x7)
+    {
+        return set(static_cast<unsigned short>(x0), static_cast<unsigned short>(x1), static_cast<unsigned short>(x2),
+                static_cast<unsigned short>(x3), static_cast<unsigned short>(x4), static_cast<unsigned short>(x5),
+                static_cast<unsigned short>(x6), static_cast<unsigned short>(x7));
+    }
+}  // anonymous namespace
+}  // namespace Vc
+
+#endif // VC_COMMON_SET_H_
diff -Nru vc-0.7.4/common/simdarrayfwd.h vc-1.3.0/common/simdarrayfwd.h
--- vc-0.7.4/common/simdarrayfwd.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simdarrayfwd.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,172 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMDARRAYFWD_H_
+#define VC_COMMON_SIMDARRAYFWD_H_
+
+#include "../scalar/types.h"
+#include "../sse/types.h"
+#include "../avx/types.h"
+#include "../mic/types.h"
+
+#include "utility.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+/// \addtogroup SimdArray
+/// @{
+/*select_best_vector_type{{{*/
+/**
+ * \internal
+ * Selects the best SIMD type out of a typelist to store N scalar values.
+ */
+template<std::size_t N, typename... Typelist> struct select_best_vector_type_impl;
+
+template<std::size_t N, typename T> struct select_best_vector_type_impl<N, T>
+{
+    using type = T;
+};
+template<std::size_t N, typename T, typename... Typelist> struct select_best_vector_type_impl<N, T, Typelist...>
+{
+    using type = typename std::conditional<
+        (N < T::Size), typename select_best_vector_type_impl<N, Typelist...>::type,
+        T>::type;
+};
+template <typename T, std::size_t N>
+using select_best_vector_type =
+    typename select_best_vector_type_impl<N,
+#ifdef Vc_IMPL_AVX2
+                                          Vc::AVX2::Vector<T>,
+                                          Vc::SSE::Vector<T>,
+                                          Vc::Scalar::Vector<T>
+#elif defined(Vc_IMPL_AVX)
+                                          Vc::AVX::Vector<T>,
+                                          Vc::SSE::Vector<T>,
+                                          Vc::Scalar::Vector<T>
+#elif defined(Vc_IMPL_Scalar)
+                                          Vc::Scalar::Vector<T>
+#elif defined(Vc_IMPL_SSE)
+                                          Vc::SSE::Vector<T>,
+                                          Vc::Scalar::Vector<T>
+#elif defined(Vc_IMPL_MIC)
+                                          Vc::MIC::Vector<T>,
+                                          Vc::Scalar::Vector<T>
+#endif
+                                          >::type;
+//}}}
+/// @}
+}  // namespace Common
+
+// === having SimdArray<T, N> in the Vc namespace leads to a ABI bug ===
+//
+// SimdArray<double, 4> can be { double[4] }, { __m128d[2] }, or { __m256d } even though the type
+// is the same.
+// The question is, what should SimdArray focus on?
+// a) A type that makes interfacing between different implementations possible?
+// b) Or a type that makes fixed size SIMD easier and efficient?
+//
+// a) can be achieved by using a union with T[N] as one member. But this may have more serious
+// performance implications than only less efficient parameter passing (because compilers have a
+// much harder time wrt. aliasing issues). Also alignment would need to be set to the sizeof in
+// order to be compatible with targets with larger alignment requirements.
+// But, the in-memory representation of masks is not portable. Thus, at the latest with AVX-512,
+// there would be a problem with requiring SimdMaskArray<T, N> to be an ABI compatible type.
+// AVX-512 uses one bit per boolean, whereas SSE/AVX use sizeof(T) Bytes per boolean. Conversion
+// between the two representations is not a trivial operation. Therefore choosing one or the other
+// representation will have a considerable impact for the targets that do not use this
+// representation. Since the future probably belongs to one bit per boolean representation, I would
+// go with that choice.
+//
+// b) requires that SimdArray<T, N> != SimdArray<T, N> if
+// SimdArray<T, N>::vector_type != SimdArray<T, N>::vector_type
+//
+// Therefore use SimdArray<T, N, V>, where V follows from the above.
+template <typename T, size_t N, typename V = Common::select_best_vector_type<T, N>,
+          size_t Wt = V::Size  // this last parameter is only used for specialization of N
+                               // == VectorSize
+          >
+class SimdArray;
+
+template <typename T, size_t N, typename V = Common::select_best_vector_type<T, N>,
+          size_t Wt = V::Size  // this last parameter is only used for specialization of N
+                               // == VectorSize
+          >
+class SimdMaskArray;
+
+/** \internal
+ * Simple traits for SimdArray to easily access internal types of non-atomic SimdArray
+ * types.
+ */
+template <typename T, std::size_t N> struct SimdArrayTraits {
+    static constexpr std::size_t N0 = Common::left_size<N>();
+    static constexpr std::size_t N1 = Common::right_size<N>();
+
+    using storage_type0 = SimdArray<T, N0>;
+    using storage_type1 = SimdArray<T, N1>;
+};
+
+template <typename T, std::size_t N, typename VectorType, std::size_t VectorSize>
+Vc_INTRINSIC_L typename SimdArrayTraits<T, N>::storage_type0 &internal_data0(
+    SimdArray<T, N, VectorType, VectorSize> &x) Vc_INTRINSIC_R;
+template <typename T, std::size_t N, typename VectorType, std::size_t VectorSize>
+Vc_INTRINSIC_L typename SimdArrayTraits<T, N>::storage_type1 &internal_data1(
+    SimdArray<T, N, VectorType, VectorSize> &x) Vc_INTRINSIC_R;
+template <typename T, std::size_t N, typename VectorType, std::size_t VectorSize>
+Vc_INTRINSIC_L const typename SimdArrayTraits<T, N>::storage_type0 &internal_data0(
+    const SimdArray<T, N, VectorType, VectorSize> &x) Vc_INTRINSIC_R;
+template <typename T, std::size_t N, typename VectorType, std::size_t VectorSize>
+Vc_INTRINSIC_L const typename SimdArrayTraits<T, N>::storage_type1 &internal_data1(
+    const SimdArray<T, N, VectorType, VectorSize> &x) Vc_INTRINSIC_R;
+
+template <typename T, std::size_t N, typename V>
+Vc_INTRINSIC_L V &internal_data(SimdArray<T, N, V, N> &x) Vc_INTRINSIC_R;
+template <typename T, std::size_t N, typename V>
+Vc_INTRINSIC_L const V &internal_data(const SimdArray<T, N, V, N> &x) Vc_INTRINSIC_R;
+
+namespace Traits
+{
+template <typename T, std::size_t N, typename V> struct is_atomic_simdarray_internal<SimdArray<T, N, V, N>> : public std::true_type {};
+template <typename T, std::size_t N, typename V> struct is_atomic_simd_mask_array_internal<SimdMaskArray<T, N, V, N>> : public std::true_type {};
+
+template <typename T, std::size_t N, typename VectorType, std::size_t M> struct is_simdarray_internal<SimdArray<T, N, VectorType, M>> : public std::true_type {};
+template <typename T, std::size_t N, typename VectorType, std::size_t M> struct is_simd_mask_array_internal<SimdMaskArray<T, N, VectorType, M>> : public std::true_type {};
+template <typename T, std::size_t N, typename V, std::size_t M> struct is_integral_internal      <SimdArray<T, N, V, M>, false> : public std::is_integral<T> {};
+template <typename T, std::size_t N, typename V, std::size_t M> struct is_floating_point_internal<SimdArray<T, N, V, M>, false> : public std::is_floating_point<T> {};
+template <typename T, std::size_t N, typename V, std::size_t M> struct is_signed_internal        <SimdArray<T, N, V, M>, false> : public std::is_signed<T> {};
+template <typename T, std::size_t N, typename V, std::size_t M> struct is_unsigned_internal      <SimdArray<T, N, V, M>, false> : public std::is_unsigned<T> {};
+
+template<typename T, std::size_t N> struct has_no_allocated_data_impl<Vc::SimdArray<T, N>> : public std::true_type {};
+}  // namespace Traits
+
+}  // namespace Vc
+
+#endif  // VC_COMMON_SIMDARRAYFWD_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/simdarray.h vc-1.3.0/common/simdarray.h
--- vc-0.7.4/common/simdarray.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simdarray.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,2608 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMDARRAY_H_
+#define VC_COMMON_SIMDARRAY_H_
+
+//#define Vc_DEBUG_SIMD_CAST 1
+//#define Vc_DEBUG_SORTED 1
+#if defined Vc_DEBUG_SIMD_CAST || defined Vc_DEBUG_SORTED
+#include <Vc/IO>
+#endif
+
+#include <array>
+
+#include "writemaskedvector.h"
+#include "simdarrayhelper.h"
+#include "simdmaskarray.h"
+#include "utility.h"
+#include "interleave.h"
+#include "indexsequence.h"
+#include "transpose.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+// internal namespace (product & sum helper) {{{1
+namespace internal
+{
+template <typename T> T Vc_INTRINSIC Vc_PURE product_helper_(const T &l, const T &r) { return l * r; }
+template <typename T> T Vc_INTRINSIC Vc_PURE sum_helper_(const T &l, const T &r) { return l + r; }
+}  // namespace internal
+
+// min & max declarations {{{1
+template <typename T, std::size_t N, typename V, std::size_t M>
+inline SimdArray<T, N, V, M> min(const SimdArray<T, N, V, M> &x,
+                                 const SimdArray<T, N, V, M> &y);
+template <typename T, std::size_t N, typename V, std::size_t M>
+inline SimdArray<T, N, V, M> max(const SimdArray<T, N, V, M> &x,
+                                 const SimdArray<T, N, V, M> &y);
+
+// SimdArray class {{{1
+/// \addtogroup SimdArray
+/// @{
+
+// atomic SimdArray {{{1
+#define Vc_CURRENT_CLASS_NAME SimdArray
+/**\internal
+ * Specialization of `SimdArray<T, N, VectorType, VectorSize>` for the case where `N ==
+ * VectorSize`.
+ *
+ * This is specialized for implementation purposes: Since the general implementation uses
+ * two SimdArray data members it recurses over different SimdArray instantiations. The
+ * recursion is ended by this specialization, which has a single \p VectorType_ data
+ * member to which all functions are forwarded more or less directly.
+ */
+template <typename T, std::size_t N, typename VectorType_>
+class SimdArray<T, N, VectorType_, N>
+{
+    static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value ||
+                      std::is_same<T, int32_t>::value ||
+                      std::is_same<T, uint32_t>::value ||
+                      std::is_same<T, int16_t>::value ||
+                      std::is_same<T, uint16_t>::value,
+                  "SimdArray<T, N> may only be used with T = { double, float, int32_t, uint32_t, "
+                  "int16_t, uint16_t }");
+
+public:
+    using VectorType = VectorType_;
+    using vector_type = VectorType;
+    using storage_type = vector_type;
+    using vectorentry_type = typename vector_type::VectorEntryType;
+    using value_type = T;
+    using mask_type = SimdMaskArray<T, N, vector_type>;
+    using index_type = SimdArray<int, N>;
+    static constexpr std::size_t size() { return N; }
+    using Mask = mask_type;
+    using MaskType = Mask;
+    using MaskArgument = const MaskType &;
+    using VectorEntryType = vectorentry_type;
+    using EntryType = value_type;
+    using IndexType = index_type;
+    using AsArg = const SimdArray &;
+    using reference = Detail::ElementReference<SimdArray>;
+    static constexpr std::size_t Size = size();
+    static constexpr std::size_t MemoryAlignment = storage_type::MemoryAlignment;
+
+    // zero init
+#ifndef Vc_MSVC  // bogus error C2580
+    Vc_INTRINSIC SimdArray() = default;
+#endif
+
+    // default copy ctor/operator
+    Vc_INTRINSIC SimdArray(const SimdArray &) = default;
+    Vc_INTRINSIC SimdArray(SimdArray &&) = default;
+    Vc_INTRINSIC SimdArray &operator=(const SimdArray &) = default;
+
+    // broadcast
+    Vc_INTRINSIC SimdArray(const value_type &a) : data(a) {}
+    Vc_INTRINSIC SimdArray(value_type &a) : data(a) {}
+    Vc_INTRINSIC SimdArray(value_type &&a) : data(a) {}
+    template <
+        typename U,
+        typename = enable_if<std::is_same<U, int>::value && !std::is_same<int, value_type>::value>>
+    Vc_INTRINSIC SimdArray(U a)
+        : SimdArray(static_cast<value_type>(a))
+    {
+    }
+
+    // implicit casts
+    template <typename U, typename V>
+    Vc_INTRINSIC SimdArray(const SimdArray<U, N, V> &x, enable_if<N == V::Size> = nullarg)
+        : data(simd_cast<vector_type>(internal_data(x)))
+    {
+    }
+    template <typename U, typename V>
+    Vc_INTRINSIC SimdArray(const SimdArray<U, N, V> &x,
+                            enable_if<(N > V::Size && N <= 2 * V::Size)> = nullarg)
+        : data(simd_cast<vector_type>(internal_data(internal_data0(x)), internal_data(internal_data1(x))))
+    {
+    }
+    template <typename U, typename V>
+    Vc_INTRINSIC SimdArray(const SimdArray<U, N, V> &x,
+                            enable_if<(N > 2 * V::Size && N <= 4 * V::Size)> = nullarg)
+        : data(simd_cast<vector_type>(internal_data(internal_data0(internal_data0(x))),
+                                      internal_data(internal_data1(internal_data0(x))),
+                                      internal_data(internal_data0(internal_data1(x))),
+                                      internal_data(internal_data1(internal_data1(x)))))
+    {
+    }
+
+    template <typename V, std::size_t Pieces, std::size_t Index>
+    Vc_INTRINSIC SimdArray(Common::Segment<V, Pieces, Index> &&x)
+        : data(simd_cast<vector_type, Index>(x.data))
+    {
+    }
+
+    Vc_INTRINSIC SimdArray(const std::initializer_list<value_type> &init)
+        : data(init.begin(), Vc::Unaligned)
+    {
+#if defined Vc_CXX14 && 0  // doesn't compile yet
+        static_assert(init.size() == size(), "The initializer_list argument to "
+                                             "SimdArray<T, N> must contain exactly N "
+                                             "values.");
+#else
+        Vc_ASSERT(init.size() == size());
+#endif
+    }
+
+    // implicit conversion from underlying vector_type
+    template <
+        typename V,
+        typename = enable_if<Traits::is_simd_vector<V>::value && !Traits::isSimdArray<V>::value>>
+    explicit Vc_INTRINSIC SimdArray(const V &x)
+        : data(simd_cast<vector_type>(x))
+    {
+    }
+
+    // implicit conversion to Vector<U, AnyAbi> for if Vector<U, AnyAbi>::size() == N and
+    // T implicitly convertible to U
+    template <
+        typename U, typename A,
+        typename = enable_if<std::is_convertible<T, U>::value && Vector<U, A>::Size == N>>
+    Vc_INTRINSIC operator Vector<U, A>() const
+    {
+        return simd_cast<Vector<U, A>>(data);
+    }
+
+#include "gatherinterface.h"
+#include "scatterinterface.h"
+
+    // forward all remaining ctors
+    template <typename... Args,
+              typename = enable_if<!Traits::is_cast_arguments<Args...>::value &&
+                                   !Traits::is_gather_signature<Args...>::value &&
+                                   !Traits::is_initializer_list<Args...>::value>>
+    explicit Vc_INTRINSIC SimdArray(Args &&... args)
+        : data(std::forward<Args>(args)...)
+    {
+    }
+
+    template <std::size_t Offset>
+    explicit Vc_INTRINSIC SimdArray(
+        Common::AddOffset<VectorSpecialInitializerIndexesFromZero, Offset>)
+        : data(Vc::IndexesFromZero)
+    {
+        data += value_type(Offset);
+    }
+
+    Vc_INTRINSIC void setZero() { data.setZero(); }
+    Vc_INTRINSIC void setZero(mask_type k) { data.setZero(internal_data(k)); }
+    Vc_INTRINSIC void setZeroInverted() { data.setZeroInverted(); }
+    Vc_INTRINSIC void setZeroInverted(mask_type k) { data.setZeroInverted(internal_data(k)); }
+
+    Vc_INTRINSIC void setQnan() { data.setQnan(); }
+    Vc_INTRINSIC void setQnan(mask_type m) { data.setQnan(internal_data(m)); }
+
+    // internal: execute specified Operation
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC SimdArray fromOperation(Op op, Args &&... args)
+    {
+        SimdArray r;
+        Common::unpackArgumentsAuto(op, r.data, std::forward<Args>(args)...);
+        return r;
+    }
+
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC void callOperation(Op op, Args &&... args)
+    {
+        Common::unpackArgumentsAuto(op, nullptr, std::forward<Args>(args)...);
+    }
+
+    static Vc_INTRINSIC SimdArray Zero()
+    {
+        return SimdArray(Vc::Zero);
+    }
+    static Vc_INTRINSIC SimdArray One()
+    {
+        return SimdArray(Vc::One);
+    }
+    static Vc_INTRINSIC SimdArray IndexesFromZero()
+    {
+        return SimdArray(Vc::IndexesFromZero);
+    }
+    static Vc_INTRINSIC SimdArray Random()
+    {
+        return fromOperation(Common::Operations::random());
+    }
+
+    template <typename... Args> Vc_INTRINSIC void load(Args &&... args)
+    {
+        data.load(std::forward<Args>(args)...);
+    }
+
+    template <typename... Args> Vc_INTRINSIC void store(Args &&... args) const
+    {
+        data.store(std::forward<Args>(args)...);
+    }
+
+    Vc_INTRINSIC mask_type operator!() const
+    {
+        return {!data};
+    }
+
+    Vc_INTRINSIC SimdArray operator-() const
+    {
+        return {-data};
+    }
+
+    /// Returns a copy of itself
+    Vc_INTRINSIC SimdArray operator+() const { return *this; }
+
+    Vc_INTRINSIC SimdArray operator~() const
+    {
+        return {~data};
+    }
+
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC Vc_CONST SimdArray operator<<(U x) const
+    {
+        return {data << x};
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC SimdArray &operator<<=(U x)
+    {
+        data <<= x;
+        return *this;
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC Vc_CONST SimdArray operator>>(U x) const
+    {
+        return {data >> x};
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC SimdArray &operator>>=(U x)
+    {
+        data >>= x;
+        return *this;
+    }
+
+#define Vc_BINARY_OPERATOR_(op)                                                          \
+    Vc_INTRINSIC Vc_CONST SimdArray operator op(const SimdArray &rhs) const              \
+    {                                                                                    \
+        return {data op rhs.data};                                                       \
+    }                                                                                    \
+    Vc_INTRINSIC SimdArray &operator op##=(const SimdArray &rhs)                         \
+    {                                                                                    \
+        data op## = rhs.data;                                                            \
+        return *this;                                                                    \
+    }
+    Vc_ALL_ARITHMETICS(Vc_BINARY_OPERATOR_);
+    Vc_ALL_BINARY(Vc_BINARY_OPERATOR_);
+    Vc_ALL_SHIFTS(Vc_BINARY_OPERATOR_);
+#undef Vc_BINARY_OPERATOR_
+
+#define Vc_COMPARES(op)                                                                  \
+    Vc_INTRINSIC mask_type operator op(const SimdArray &rhs) const                       \
+    {                                                                                    \
+        return {data op rhs.data};                                                       \
+    }
+    Vc_ALL_COMPARES(Vc_COMPARES);
+#undef Vc_COMPARES
+
+    /// \copydoc Vector::isNegative
+    Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC MaskType isNegative() const
+    {
+        return {isnegative(data)};
+    }
+
+private:
+    friend reference;
+    Vc_INTRINSIC static value_type get(const SimdArray &o, int i) noexcept
+    {
+        return o.data[i];
+    }
+    template <typename U>
+    Vc_INTRINSIC static void set(SimdArray &o, int i, U &&v) noexcept(
+        noexcept(std::declval<value_type &>() = v))
+    {
+        o.data[i] = v;
+    }
+
+public:
+    Vc_INTRINSIC reference operator[](size_t i) noexcept
+    {
+        static_assert(noexcept(reference{std::declval<SimdArray &>(), int()}), "");
+        return {*this, int(i)};
+    }
+    Vc_INTRINSIC value_type operator[](size_t i) const noexcept
+    {
+        return get(*this, int(i));
+    }
+
+    Vc_INTRINSIC Common::WriteMaskedVector<SimdArray, mask_type> operator()(const mask_type &k)
+    {
+        return {*this, k};
+    }
+
+    Vc_INTRINSIC void assign(const SimdArray &v, const mask_type &k)
+    {
+        data.assign(v.data, internal_data(k));
+    }
+
+    // reductions ////////////////////////////////////////////////////////
+#define Vc_REDUCTION_FUNCTION_(name_)                                                    \
+    Vc_INTRINSIC Vc_PURE value_type name_() const { return data.name_(); }               \
+    Vc_INTRINSIC Vc_PURE value_type name_(mask_type mask) const                          \
+    {                                                                                    \
+        return data.name_(internal_data(mask));                                          \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+    Vc_REDUCTION_FUNCTION_(min);
+    Vc_REDUCTION_FUNCTION_(max);
+    Vc_REDUCTION_FUNCTION_(product);
+    Vc_REDUCTION_FUNCTION_(sum);
+#undef Vc_REDUCTION_FUNCTION_
+    Vc_INTRINSIC Vc_PURE SimdArray partialSum() const { return data.partialSum(); }
+
+    template <typename F> Vc_INTRINSIC SimdArray apply(F &&f) const
+    {
+        return {data.apply(std::forward<F>(f))};
+    }
+    template <typename F> Vc_INTRINSIC SimdArray apply(F &&f, const mask_type &k) const
+    {
+        return {data.apply(std::forward<F>(f), k)};
+    }
+
+    Vc_INTRINSIC SimdArray shifted(int amount) const
+    {
+        return {data.shifted(amount)};
+    }
+
+    template <std::size_t NN>
+    Vc_INTRINSIC SimdArray shifted(int amount, const SimdArray<value_type, NN> &shiftIn)
+        const
+    {
+        return {data.shifted(amount, simd_cast<VectorType>(shiftIn))};
+    }
+
+    Vc_INTRINSIC SimdArray rotated(int amount) const
+    {
+        return {data.rotated(amount)};
+    }
+
+    /// \copydoc Vector::exponent
+    Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC SimdArray exponent() const
+    {
+        return {exponent(data)};
+    }
+
+    Vc_INTRINSIC SimdArray interleaveLow(SimdArray x) const
+    {
+        return {data.interleaveLow(x.data)};
+    }
+    Vc_INTRINSIC SimdArray interleaveHigh(SimdArray x) const
+    {
+        return {data.interleaveHigh(x.data)};
+    }
+
+    Vc_INTRINSIC SimdArray reversed() const
+    {
+        return {data.reversed()};
+    }
+
+    Vc_INTRINSIC SimdArray sorted() const
+    {
+        return {data.sorted()};
+    }
+
+    template <typename G> static Vc_INTRINSIC SimdArray generate(const G &gen)
+    {
+        return {VectorType::generate(gen)};
+    }
+
+    Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC SimdArray
+        copySign(const SimdArray &reference) const
+    {
+        return {Vc::copysign(data, reference.data)};
+    }
+
+    friend VectorType &internal_data<>(SimdArray &x);
+    friend const VectorType &internal_data<>(const SimdArray &x);
+
+    /// \internal
+    Vc_INTRINSIC SimdArray(VectorType &&x) : data(std::move(x)) {}
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(storage_type));
+
+private:
+    // The alignas attribute attached to the class declaration above is ignored by ICC
+    // 17.0.0 (at least). So just move the alignas attribute down here where it works for
+    // all compilers.
+    alignas(static_cast<std::size_t>(
+        Common::BoundedAlignment<Common::NextPowerOfTwo<N>::value * sizeof(VectorType_) /
+                                 VectorType_::size()>::value)) storage_type data;
+};
+template <typename T, std::size_t N, typename VectorType> constexpr std::size_t SimdArray<T, N, VectorType, N>::Size;
+template <typename T, std::size_t N, typename VectorType>
+constexpr std::size_t SimdArray<T, N, VectorType, N>::MemoryAlignment;
+template <typename T, std::size_t N, typename VectorType>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+VectorType &internal_data(SimdArray<T, N, VectorType, N> &x)
+{
+    return x.data;
+}
+template <typename T, std::size_t N, typename VectorType>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+const VectorType &internal_data(const SimdArray<T, N, VectorType, N> &x)
+{
+    return x.data;
+}
+
+// unpackIfSegment {{{2
+template <typename T> T unpackIfSegment(T &&x) { return std::forward<T>(x); }
+template <typename T, size_t Pieces, size_t Index>
+auto unpackIfSegment(Common::Segment<T, Pieces, Index> &&x) -> decltype(x.asSimdArray())
+{
+    return x.asSimdArray();
+}
+
+// gatherImplementation {{{2
+template <typename T, std::size_t N, typename VectorType>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, N>::gatherImplementation(const MT *mem,
+                                                                 IT &&indexes)
+{
+    data.gather(mem, unpackIfSegment(std::forward<IT>(indexes)));
+}
+template <typename T, std::size_t N, typename VectorType>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, N>::gatherImplementation(const MT *mem,
+                                                                 IT &&indexes,
+                                                                 MaskArgument mask)
+{
+    data.gather(mem, unpackIfSegment(std::forward<IT>(indexes)), mask);
+}
+
+// scatterImplementation {{{2
+template <typename T, std::size_t N, typename VectorType>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, N>::scatterImplementation(MT *mem,
+                                                                 IT &&indexes) const
+{
+    data.scatter(mem, unpackIfSegment(std::forward<IT>(indexes)));
+}
+template <typename T, std::size_t N, typename VectorType>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, N>::scatterImplementation(MT *mem,
+                                                                 IT &&indexes,
+                                                                 MaskArgument mask) const
+{
+    data.scatter(mem, unpackIfSegment(std::forward<IT>(indexes)), mask);
+}
+
+// generic SimdArray {{{1
+/**
+ * Data-parallel arithmetic type with user-defined number of elements.
+ *
+ * \tparam T The type of the vector's elements. The supported types currently are limited
+ *           to the types supported by Vc::Vector<T>.
+ *
+ * \tparam N The number of elements to store and process concurrently. You can choose an
+ *           arbitrary number, though not every number is a good idea.
+ *           Generally, a power of two value or the sum of two power of two values might
+ *           work efficiently, though this depends a lot on the target system.
+ *
+ * \tparam V Don't change the default value unless you really know what you are doing.
+ *           This type is set to the underlying native Vc::Vector type used in the
+ *           implementation of the type.
+ *           Having it as part of the type name guards against some cases of ODR
+ *           violations (i.e. linking incompatible translation units / libraries).
+ *
+ * \tparam Wt Don't ever change the default value.
+ *           This parameter is an unfortunate implementation detail shining through.
+ *
+ * \warning Choosing \p N too large (what “too large” means depends on the target) will
+ *          result in excessive compilation times and high (or too high) register
+ *          pressure, thus potentially negating the improvement from concurrent execution.
+ *          As a rule of thumb, keep \p N less or equal to `2 * float_v::size()`.
+ *
+ * \warning A special portability concern arises from a current limitation in the MIC
+ *          implementation (Intel Knights Corner), where SimdArray types with \p T = \p
+ *          (u)short require an \p N either less than short_v::size() or a multiple of
+ *          short_v::size().
+ *
+ * \headerfile simdarray.h <Vc/SimdArray>
+ */
+template <typename T, size_t N, typename V, size_t Wt> class SimdArray
+{
+    static_assert(std::is_same<T,   double>::value ||
+                  std::is_same<T,    float>::value ||
+                  std::is_same<T,  int32_t>::value ||
+                  std::is_same<T, uint32_t>::value ||
+                  std::is_same<T,  int16_t>::value ||
+                  std::is_same<T, uint16_t>::value, "SimdArray<T, N> may only be used with T = { double, float, int32_t, uint32_t, int16_t, uint16_t }");
+    static_assert(
+        // either the EntryType and VectorEntryType of the main V are equal
+        std::is_same<typename V::EntryType, typename V::VectorEntryType>::value ||
+            // or N is a multiple of V::size()
+            (N % V::size() == 0),
+        "SimdArray<(un)signed short, N> on MIC only works correctly for N = k * "
+        "MIC::(u)short_v::size(), i.e. k * 16.");
+
+    using my_traits = SimdArrayTraits<T, N>;
+    static constexpr std::size_t N0 = my_traits::N0;
+    static constexpr std::size_t N1 = my_traits::N1;
+    using Split = Common::Split<N0>;
+    template <typename U, std::size_t K> using CArray = U[K];
+
+public:
+    using storage_type0 = typename my_traits::storage_type0;
+    using storage_type1 = typename my_traits::storage_type1;
+    static_assert(storage_type0::size() == N0, "");
+
+    /**\internal
+     * This type reveals the implementation-specific type used for the data member.
+     */
+    using vector_type = V;
+    using vectorentry_type = typename storage_type0::vectorentry_type;
+    typedef vectorentry_type alias_type Vc_MAY_ALIAS;
+
+    /// The type of the elements (i.e.\ \p T)
+    using value_type = T;
+
+    /// The type of the mask used for masked operations and returned from comparisons.
+    using mask_type = SimdMaskArray<T, N, vector_type>;
+
+    /// The type of the vector used for indexes in gather and scatter operations.
+    using index_type = SimdArray<int, N>;
+
+    /**
+     * Returns \p N, the number of scalar components in an object of this type.
+     *
+     * The size of the SimdArray, i.e. the number of scalar elements in the vector. In
+     * contrast to Vector::size() you have control over this value via the \p N template
+     * parameter of the SimdArray class template.
+     *
+     * \returns The number of scalar values stored and manipulated concurrently by objects
+     * of this type.
+     */
+    static constexpr std::size_t size() { return N; }
+
+    /// \copydoc mask_type
+    using Mask = mask_type;
+    /// \copydoc mask_type
+    using MaskType = Mask;
+    using MaskArgument = const MaskType &;
+    using VectorEntryType = vectorentry_type;
+    /// \copydoc value_type
+    using EntryType = value_type;
+    /// \copydoc index_type
+    using IndexType = index_type;
+    using AsArg = const SimdArray &;
+
+    using reference = Detail::ElementReference<SimdArray>;
+
+    ///\copydoc Vector::MemoryAlignment
+    static constexpr std::size_t MemoryAlignment =
+        storage_type0::MemoryAlignment > storage_type1::MemoryAlignment
+            ? storage_type0::MemoryAlignment
+            : storage_type1::MemoryAlignment;
+
+    /// \name Generators
+    ///@{
+
+    ///\copybrief Vector::Zero
+    static Vc_INTRINSIC SimdArray Zero()
+    {
+        return SimdArray(Vc::Zero);
+    }
+
+    ///\copybrief Vector::One
+    static Vc_INTRINSIC SimdArray One()
+    {
+        return SimdArray(Vc::One);
+    }
+
+    ///\copybrief Vector::IndexesFromZero
+    static Vc_INTRINSIC SimdArray IndexesFromZero()
+    {
+        return SimdArray(Vc::IndexesFromZero);
+    }
+
+    ///\copydoc Vector::Random
+    static Vc_INTRINSIC SimdArray Random()
+    {
+        return fromOperation(Common::Operations::random());
+    }
+
+    ///\copybrief Vector::generate
+    template <typename G> static Vc_INTRINSIC SimdArray generate(const G &gen) // {{{2
+    {
+        auto tmp = storage_type0::generate(gen);  // GCC bug: the order of evaluation in
+                                                  // an initializer list is well-defined
+                                                  // (front to back), but GCC 4.8 doesn't
+                                                  // implement this correctly. Therefore
+                                                  // we enforce correct order.
+        return {std::move(tmp),
+                storage_type1::generate([&](std::size_t i) { return gen(i + N0); })};
+    }
+    ///@}
+
+    /// \name Compile-Time Constant Initialization
+    ///@{
+
+    ///\copydoc Vector::Vector()
+#ifndef Vc_MSVC  // bogus error C2580
+    SimdArray() = default;
+#endif
+    ///@}
+
+    /// \name Conversion/Broadcast Constructors
+    ///@{
+
+    ///\copydoc Vector::Vector(EntryType)
+    Vc_INTRINSIC SimdArray(value_type a) : data0(a), data1(a) {}
+    template <
+        typename U,
+        typename = enable_if<std::is_same<U, int>::value && !std::is_same<int, value_type>::value>>
+    SimdArray(U a)
+        : SimdArray(static_cast<value_type>(a))
+    {
+    }
+    ///@}
+
+    // default copy ctor/operator
+    SimdArray(const SimdArray &) = default;
+    SimdArray(SimdArray &&) = default;
+    SimdArray &operator=(const SimdArray &) = default;
+
+    // load ctor
+    template <typename U,
+              typename Flags = DefaultLoadTag,
+              typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+    explicit Vc_INTRINSIC SimdArray(const U *mem, Flags f = Flags())
+        : data0(mem, f), data1(mem + storage_type0::size(), f)
+    {
+    }
+
+// MSVC does overload resolution differently and takes the const U *mem overload (I hope)
+#ifndef Vc_MSVC
+    /**\internal
+     * Load from a C-array. This is basically the same function as the load constructor
+     * above, except that the forwarding reference overload would steal the deal and the
+     * constructor above doesn't get called. This overload is required to enable loads
+     * from C-arrays.
+     */
+    template <typename U, std::size_t Extent, typename Flags = DefaultLoadTag,
+              typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+    explicit Vc_INTRINSIC SimdArray(CArray<U, Extent> &mem, Flags f = Flags())
+        : data0(&mem[0], f), data1(&mem[storage_type0::size()], f)
+    {
+    }
+    /**\internal
+     * Const overload of the above.
+     */
+    template <typename U, std::size_t Extent, typename Flags = DefaultLoadTag,
+              typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+    explicit Vc_INTRINSIC SimdArray(const CArray<U, Extent> &mem, Flags f = Flags())
+        : data0(&mem[0], f), data1(&mem[storage_type0::size()], f)
+    {
+    }
+#endif
+
+    // initializer list
+    Vc_INTRINSIC SimdArray(const std::initializer_list<value_type> &init)
+        : data0(init.begin(), Vc::Unaligned)
+        , data1(init.begin() + storage_type0::size(), Vc::Unaligned)
+    {
+#if defined Vc_CXX14 && 0  // doesn't compile yet
+        static_assert(init.size() == size(), "The initializer_list argument to "
+                                             "SimdArray<T, N> must contain exactly N "
+                                             "values.");
+#else
+        Vc_ASSERT(init.size() == size());
+#endif
+    }
+
+#include "gatherinterface.h"
+#include "scatterinterface.h"
+
+    // forward all remaining ctors
+    template <typename... Args,
+              typename = enable_if<!Traits::is_cast_arguments<Args...>::value &&
+                                   !Traits::is_initializer_list<Args...>::value &&
+                                   !Traits::is_gather_signature<Args...>::value &&
+                                   !Traits::is_load_arguments<Args...>::value>>
+    explicit Vc_INTRINSIC SimdArray(Args &&... args)
+        : data0(Split::lo(args)...)  // no forward here - it could move and thus
+                                     // break the next line
+        , data1(Split::hi(std::forward<Args>(args))...)
+    {
+    }
+
+    // explicit casts
+    template <typename W>
+    Vc_INTRINSIC explicit SimdArray(
+        W &&x,
+        enable_if<(Traits::is_simd_vector<W>::value && Traits::simd_vector_size<W>::value == N &&
+                   !(std::is_convertible<Traits::entry_type_of<W>, T>::value &&
+                     Traits::isSimdArray<W>::value))> = nullarg)
+        : data0(Split::lo(x)), data1(Split::hi(x))
+    {
+    }
+
+    // implicit casts
+    template <typename W>
+    Vc_INTRINSIC SimdArray(
+        W &&x,
+        enable_if<(Traits::isSimdArray<W>::value && Traits::simd_vector_size<W>::value == N &&
+                   std::is_convertible<Traits::entry_type_of<W>, T>::value)> = nullarg)
+        : data0(Split::lo(x)), data1(Split::hi(x))
+    {
+    }
+
+    // implicit conversion to Vector<U, AnyAbi> for if Vector<U, AnyAbi>::size() == N and
+    // T implicitly convertible to U
+    template <
+        typename U, typename A,
+        typename = enable_if<std::is_convertible<T, U>::value && Vector<U, A>::Size == N>>
+    operator Vector<U, A>() const
+    {
+        return simd_cast<Vector<U, A>>(data0, data1);
+    }
+
+    //////////////////// other functions ///////////////
+
+    Vc_INTRINSIC void setZero()
+    {
+        data0.setZero();
+        data1.setZero();
+    }
+    Vc_INTRINSIC void setZero(const mask_type &k)
+    {
+        data0.setZero(Split::lo(k));
+        data1.setZero(Split::hi(k));
+    }
+    Vc_INTRINSIC void setZeroInverted()
+    {
+        data0.setZeroInverted();
+        data1.setZeroInverted();
+    }
+    Vc_INTRINSIC void setZeroInverted(const mask_type &k)
+    {
+        data0.setZeroInverted(Split::lo(k));
+        data1.setZeroInverted(Split::hi(k));
+    }
+
+
+    Vc_INTRINSIC void setQnan() {
+        data0.setQnan();
+        data1.setQnan();
+    }
+    Vc_INTRINSIC void setQnan(const mask_type &m) {
+        data0.setQnan(Split::lo(m));
+        data1.setQnan(Split::hi(m));
+    }
+
+    ///\internal execute specified Operation
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC SimdArray fromOperation(Op op, Args &&... args)
+    {
+        SimdArray r = {
+            storage_type0::fromOperation(op, Split::lo(args)...),  // no forward here - it
+                                                                   // could move and thus
+                                                                   // break the next line
+            storage_type1::fromOperation(op, Split::hi(std::forward<Args>(args))...)};
+        return r;
+    }
+
+    ///\internal
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC void callOperation(Op op, Args &&... args)
+    {
+        storage_type0::callOperation(op, Split::lo(args)...);
+        storage_type1::callOperation(op, Split::hi(std::forward<Args>(args))...);
+    }
+
+
+    template <typename U, typename... Args> Vc_INTRINSIC void load(const U *mem, Args &&... args)
+    {
+        data0.load(mem, Split::lo(args)...);  // no forward here - it could move and thus
+                                              // break the next line
+        data1.load(mem + storage_type0::size(), Split::hi(std::forward<Args>(args))...);
+    }
+
+    template <typename U, typename... Args> Vc_INTRINSIC void store(U *mem, Args &&... args) const
+    {
+        data0.store(mem, Split::lo(args)...);  // no forward here - it could move and thus
+                                               // break the next line
+        data1.store(mem + storage_type0::size(), Split::hi(std::forward<Args>(args))...);
+    }
+
+    Vc_INTRINSIC mask_type operator!() const
+    {
+        return {!data0, !data1};
+    }
+
+    Vc_INTRINSIC SimdArray operator-() const
+    {
+        return {-data0, -data1};
+    }
+
+    /// Returns a copy of itself
+    Vc_INTRINSIC SimdArray operator+() const { return *this; }
+
+    Vc_INTRINSIC SimdArray operator~() const
+    {
+        return {~data0, ~data1};
+    }
+
+    // left/right shift operators {{{2
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC Vc_CONST SimdArray operator<<(U x) const
+    {
+        return {data0 << x, data1 << x};
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC SimdArray &operator<<=(U x)
+    {
+        data0 <<= x;
+        data1 <<= x;
+        return *this;
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC Vc_CONST SimdArray operator>>(U x) const
+    {
+        return {data0 >> x, data1 >> x};
+    }
+    template <typename U,
+              typename = enable_if<std::is_integral<T>::value && std::is_integral<U>::value>>
+    Vc_INTRINSIC SimdArray &operator>>=(U x)
+    {
+        data0 >>= x;
+        data1 >>= x;
+        return *this;
+    }
+
+    // binary operators {{{2
+#define Vc_BINARY_OPERATOR_(op)                                                          \
+    Vc_INTRINSIC Vc_CONST SimdArray operator op(const SimdArray &rhs) const              \
+    {                                                                                    \
+        return {data0 op rhs.data0, data1 op rhs.data1};                                 \
+    }                                                                                    \
+    Vc_INTRINSIC SimdArray &operator op##=(const SimdArray &rhs)                         \
+    {                                                                                    \
+        data0 op## = rhs.data0;                                                          \
+        data1 op## = rhs.data1;                                                          \
+        return *this;                                                                    \
+    }
+    Vc_ALL_ARITHMETICS(Vc_BINARY_OPERATOR_);
+    Vc_ALL_BINARY(Vc_BINARY_OPERATOR_);
+    Vc_ALL_SHIFTS(Vc_BINARY_OPERATOR_);
+#undef Vc_BINARY_OPERATOR_
+
+#define Vc_COMPARES(op)                                                                  \
+    Vc_INTRINSIC mask_type operator op(const SimdArray &rhs) const                       \
+    {                                                                                    \
+        return {data0 op rhs.data0, data1 op rhs.data1};                                 \
+    }
+    Vc_ALL_COMPARES(Vc_COMPARES);
+#undef Vc_COMPARES
+
+    // operator[] {{{2
+    /// \name Scalar Subscript Operators
+    ///@{
+
+private:
+    friend reference;
+    Vc_INTRINSIC static value_type get(const SimdArray &o, int i) noexcept
+    {
+        return reinterpret_cast<const alias_type *>(&o)[i];
+    }
+    template <typename U>
+    Vc_INTRINSIC static void set(SimdArray &o, int i, U &&v) noexcept(
+        noexcept(std::declval<value_type &>() = v))
+    {
+        reinterpret_cast<alias_type *>(&o)[i] = v;
+    }
+
+public:
+    ///\copydoc Vector::operator[](size_t)
+    Vc_INTRINSIC reference operator[](size_t i) noexcept
+    {
+        static_assert(noexcept(reference{std::declval<SimdArray &>(), int()}), "");
+        return {*this, int(i)};
+    }
+
+    ///\copydoc Vector::operator[](size_t) const
+    Vc_INTRINSIC value_type operator[](size_t index) const noexcept
+    {
+        return get(*this, int(index));
+    }
+    ///@}
+
+    // operator(){{{2
+    ///\copydoc Vector::operator()(MaskType)
+    Vc_INTRINSIC Common::WriteMaskedVector<SimdArray, mask_type> operator()(
+        const mask_type &mask)
+    {
+        return {*this, mask};
+    }
+
+    ///\internal
+    Vc_INTRINSIC void assign(const SimdArray &v, const mask_type &k) //{{{2
+    {
+        data0.assign(v.data0, internal_data0(k));
+        data1.assign(v.data1, internal_data1(k));
+    }
+
+    // reductions {{{2
+#define Vc_REDUCTION_FUNCTION_(name_, binary_fun_, scalar_fun_)                          \
+private:                                                                                 \
+    template <typename ForSfinae = void>                                                 \
+    Vc_INTRINSIC enable_if<std::is_same<ForSfinae, void>::value &&                       \
+                               storage_type0::Size == storage_type1::Size,           \
+                           value_type> name_##_impl() const                              \
+    {                                                                                    \
+        return binary_fun_(data0, data1).name_();                                        \
+    }                                                                                    \
+                                                                                         \
+    template <typename ForSfinae = void>                                                 \
+    Vc_INTRINSIC enable_if<std::is_same<ForSfinae, void>::value &&                       \
+                               storage_type0::Size != storage_type1::Size,           \
+                           value_type> name_##_impl() const                              \
+    {                                                                                    \
+        return scalar_fun_(data0.name_(), data1.name_());                                \
+    }                                                                                    \
+                                                                                         \
+public:                                                                                  \
+    /**\copybrief Vector::##name_ */                                                     \
+    Vc_INTRINSIC value_type name_() const { return name_##_impl(); }                     \
+    /**\copybrief Vector::##name_ */                                                     \
+    Vc_INTRINSIC value_type name_(const mask_type &mask) const                           \
+    {                                                                                    \
+        if (Vc_IS_UNLIKELY(Split::lo(mask).isEmpty())) {                                 \
+            return data1.name_(Split::hi(mask));                                         \
+        } else if (Vc_IS_UNLIKELY(Split::hi(mask).isEmpty())) {                          \
+            return data0.name_(Split::lo(mask));                                         \
+        } else {                                                                         \
+            return scalar_fun_(data0.name_(Split::lo(mask)),                             \
+                               data1.name_(Split::hi(mask)));                            \
+        }                                                                                \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+    Vc_REDUCTION_FUNCTION_(min, Vc::min, std::min);
+    Vc_REDUCTION_FUNCTION_(max, Vc::max, std::max);
+    Vc_REDUCTION_FUNCTION_(product, internal::product_helper_, internal::product_helper_);
+    Vc_REDUCTION_FUNCTION_(sum, internal::sum_helper_, internal::sum_helper_);
+#undef Vc_REDUCTION_FUNCTION_
+    ///\copybrief Vector::partialSum
+    Vc_INTRINSIC Vc_PURE SimdArray partialSum() const //{{{2
+    {
+        auto ps0 = data0.partialSum();
+        auto tmp = data1;
+        tmp[0] += ps0[data0.size() - 1];
+        return {std::move(ps0), tmp.partialSum()};
+    }
+
+    // apply {{{2
+    ///\copybrief Vector::apply(F &&) const
+    template <typename F> inline SimdArray apply(F &&f) const
+    {
+        return {data0.apply(f), data1.apply(f)};
+    }
+    ///\copybrief Vector::apply(F &&, MaskType) const
+    template <typename F> inline SimdArray apply(F &&f, const mask_type &k) const
+    {
+        return {data0.apply(f, Split::lo(k)), data1.apply(f, Split::hi(k))};
+    }
+
+    // shifted {{{2
+    ///\copybrief Vector::shifted(int) const
+    inline SimdArray shifted(int amount) const
+    {
+        constexpr int SSize = Size;
+        constexpr int SSize0 = storage_type0::Size;
+        constexpr int SSize1 = storage_type1::Size;
+        if (amount == 0) {
+            return *this;
+        }
+        if (amount < 0) {
+            if (amount > -SSize0) {
+                return {data0.shifted(amount), data1.shifted(amount, data0)};
+            }
+            if (amount == -SSize0) {
+                return {storage_type0::Zero(), simd_cast<storage_type1>(data0)};
+            }
+            if (amount < -SSize0) {
+                return {storage_type0::Zero(), simd_cast<storage_type1>(data0.shifted(
+                                                   amount + SSize0))};
+            }
+            return Zero();
+        } else {
+            if (amount >= SSize) {
+                return Zero();
+            } else if (amount >= SSize0) {
+                return {
+                    simd_cast<storage_type0>(data1).shifted(amount - SSize0),
+                    storage_type1::Zero()};
+            } else if (amount >= SSize1) {
+                return {data0.shifted(amount, data1), storage_type1::Zero()};
+            } else {
+                return {data0.shifted(amount, data1), data1.shifted(amount)};
+            }
+        }
+    }
+
+    template <std::size_t NN>
+    inline enable_if<
+        !(std::is_same<storage_type0, storage_type1>::value &&  // not bisectable
+          N == NN),
+        SimdArray>
+        shifted(int amount, const SimdArray<value_type, NN> &shiftIn) const
+    {
+        constexpr int SSize = Size;
+        if (amount < 0) {
+            return SimdArray::generate([&](int i) -> value_type {
+                i += amount;
+                if (i >= 0) {
+                    return operator[](i);
+                } else if (i >= -SSize) {
+                    return shiftIn[i + SSize];
+                }
+                return 0;
+            });
+        }
+        return SimdArray::generate([&](int i) -> value_type {
+            i += amount;
+            if (i < SSize) {
+                return operator[](i);
+            } else if (i < 2 * SSize) {
+                return shiftIn[i - SSize];
+            }
+            return 0;
+        });
+    }
+
+private:
+    // workaround for MSVC not understanding the simpler and shorter expression of the boolean
+    // expression directly in the enable_if below
+    template <std::size_t NN> struct bisectable_shift
+        : public std::integral_constant<bool,
+                                        std::is_same<storage_type0, storage_type1>::value &&  // bisectable
+                                        N == NN>
+    {
+    };
+
+public:
+    template <std::size_t NN>
+    inline SimdArray shifted(enable_if<bisectable_shift<NN>::value, int> amount,
+            const SimdArray<value_type, NN> &shiftIn) const
+    {
+        constexpr int SSize = Size;
+        if (amount < 0) {
+            if (amount > -static_cast<int>(storage_type0::Size)) {
+                return {data0.shifted(amount, internal_data1(shiftIn)),
+                        data1.shifted(amount, data0)};
+            }
+            if (amount == -static_cast<int>(storage_type0::Size)) {
+                return {storage_type0(internal_data1(shiftIn)), storage_type1(data0)};
+            }
+            if (amount > -SSize) {
+                return {
+                    internal_data1(shiftIn)
+                        .shifted(amount + static_cast<int>(storage_type0::Size), internal_data0(shiftIn)),
+                    data0.shifted(amount + static_cast<int>(storage_type0::Size), internal_data1(shiftIn))};
+            }
+            if (amount == -SSize) {
+                return shiftIn;
+            }
+            if (amount > -2 * SSize) {
+                return shiftIn.shifted(amount + SSize);
+            }
+        }
+        if (amount == 0) {
+            return *this;
+        }
+        if (amount < static_cast<int>(storage_type0::Size)) {
+            return {data0.shifted(amount, data1),
+                    data1.shifted(amount, internal_data0(shiftIn))};
+        }
+        if (amount == static_cast<int>(storage_type0::Size)) {
+            return {storage_type0(data1), storage_type1(internal_data0(shiftIn))};
+        }
+        if (amount < SSize) {
+            return {data1.shifted(amount - static_cast<int>(storage_type0::Size), internal_data0(shiftIn)),
+                    internal_data0(shiftIn)
+                        .shifted(amount - static_cast<int>(storage_type0::Size), internal_data1(shiftIn))};
+        }
+        if (amount == SSize) {
+            return shiftIn;
+        }
+        if (amount < 2 * SSize) {
+            return shiftIn.shifted(amount - SSize);
+        }
+        return Zero();
+    }
+
+    // rotated {{{2
+    ///\copybrief Vector::rotated
+    Vc_INTRINSIC SimdArray rotated(int amount) const
+    {
+        amount %= int(size());
+        if (amount == 0) {
+            return *this;
+        } else if (amount < 0) {
+            amount += size();
+        }
+
+#ifdef Vc_MSVC
+        // MSVC fails to find a SimdArray::shifted function with 2 arguments. So use store
+        // ->
+        // load to implement the function instead.
+        alignas(MemoryAlignment) T tmp[N + data0.size()];
+        data0.store(&tmp[0], Vc::Aligned);
+        data1.store(&tmp[data0.size()], Vc::Aligned);
+        data0.store(&tmp[N], Vc::Unaligned);
+        SimdArray r;
+        r.data0.load(&tmp[amount], Vc::Unaligned);
+        r.data1.load(&tmp[(amount + data0.size()) % size()], Vc::Unaligned);
+        return r;
+#else
+        auto &&d0cvtd = simd_cast<storage_type1>(data0);
+        auto &&d1cvtd = simd_cast<storage_type0>(data1);
+        constexpr int size0 = storage_type0::size();
+        constexpr int size1 = storage_type1::size();
+
+        if (amount == size0 && std::is_same<storage_type0, storage_type1>::value) {
+            return {std::move(d1cvtd), std::move(d0cvtd)};
+        } else if (amount < size1) {
+            return {data0.shifted(amount, d1cvtd), data1.shifted(amount, d0cvtd)};
+        } else if (amount == size1) {
+            return {data0.shifted(amount, d1cvtd), std::move(d0cvtd)};
+        } else if (int(size()) - amount < size1) {
+            return {data0.shifted(amount - int(size()), d1cvtd.shifted(size1 - size0)),
+                    data1.shifted(amount - int(size()), data0.shifted(size0 - size1))};
+        } else if (int(size()) - amount == size1) {
+            return {data0.shifted(-size1, d1cvtd.shifted(size1 - size0)),
+                    simd_cast<storage_type1>(data0.shifted(size0 - size1))};
+        } else if (amount <= size0) {
+            return {data0.shifted(size1, d1cvtd).shifted(amount - size1, data0),
+                    simd_cast<storage_type1>(data0.shifted(amount - size1))};
+        } else {
+            return {data0.shifted(size1, d1cvtd).shifted(amount - size1, data0),
+                    simd_cast<storage_type1>(data0.shifted(amount - size1, d1cvtd))};
+        }
+        return *this;
+#endif
+    }
+
+    // interleaveLow/-High {{{2
+    ///\internal \copydoc Vector::interleaveLow
+    Vc_INTRINSIC SimdArray interleaveLow(const SimdArray &x) const
+    {
+        // return data0[0], x.data0[0], data0[1], x.data0[1], ...
+        return {data0.interleaveLow(x.data0),
+                simd_cast<storage_type1>(data0.interleaveHigh(x.data0))};
+    }
+    ///\internal \copydoc Vector::interleaveHigh
+    Vc_INTRINSIC SimdArray interleaveHigh(const SimdArray &x) const
+    {
+        return interleaveHighImpl(
+            x,
+            std::integral_constant<bool, storage_type0::Size == storage_type1::Size>());
+    }
+
+private:
+    ///\internal
+    Vc_INTRINSIC SimdArray interleaveHighImpl(const SimdArray &x, std::true_type) const
+    {
+        return {data1.interleaveLow(x.data1), data1.interleaveHigh(x.data1)};
+    }
+    ///\internal
+    inline SimdArray interleaveHighImpl(const SimdArray &x, std::false_type) const
+    {
+        return {data0.interleaveHigh(x.data0)
+                    .shifted(storage_type1::Size,
+                             simd_cast<storage_type0>(data1.interleaveLow(x.data1))),
+                data1.interleaveHigh(x.data1)};
+    }
+
+public:
+    ///\copybrief Vector::reversed
+    inline SimdArray reversed() const //{{{2
+    {
+        if (std::is_same<storage_type0, storage_type1>::value) {
+            return {simd_cast<storage_type0>(data1).reversed(),
+                    simd_cast<storage_type1>(data0).reversed()};
+        } else {
+#ifdef Vc_MSVC
+            // MSVC fails to find a SimdArray::shifted function with 2 arguments. So use
+            // store
+            // -> load to implement the function instead.
+            alignas(MemoryAlignment) T tmp[N];
+            data1.reversed().store(&tmp[0], Vc::Aligned);
+            data0.reversed().store(&tmp[data1.size()], Vc::Unaligned);
+            return SimdArray{&tmp[0], Vc::Aligned};
+#else
+            return {data0.shifted(storage_type1::Size, data1).reversed(),
+                    simd_cast<storage_type1>(data0.reversed().shifted(
+                        storage_type0::Size - storage_type1::Size))};
+#endif
+        }
+    }
+    ///\copydoc Vector::sorted
+    inline SimdArray sorted() const  //{{{2
+    {
+        return sortedImpl(
+            std::integral_constant<bool, storage_type0::Size == storage_type1::Size>());
+    }
+
+    ///\internal
+    Vc_INTRINSIC SimdArray sortedImpl(std::true_type) const
+    {
+#ifdef Vc_DEBUG_SORTED
+        std::cerr << "-- " << data0 << data1 << '\n';
+#endif
+        const auto a = data0.sorted();
+        const auto b = data1.sorted().reversed();
+        const auto lo = Vc::min(a, b);
+        const auto hi = Vc::max(a, b);
+        return {lo.sorted(), hi.sorted()};
+    }
+
+    ///\internal
+    Vc_INTRINSIC SimdArray sortedImpl(std::false_type) const
+    {
+        using SortableArray =
+            SimdArray<value_type, Common::NextPowerOfTwo<size()>::value>;
+        auto sortable = simd_cast<SortableArray>(*this);
+        for (std::size_t i = Size; i < SortableArray::Size; ++i) {
+            using limits = std::numeric_limits<value_type>;
+            if (limits::has_infinity) {
+                sortable[i] = limits::infinity();
+            } else {
+                sortable[i] = std::numeric_limits<value_type>::max();
+            }
+        }
+        return simd_cast<SimdArray>(sortable.sorted());
+
+        /* The following implementation appears to be less efficient. But this may need further
+         * work.
+        const auto a = data0.sorted();
+        const auto b = data1.sorted();
+#ifdef Vc_DEBUG_SORTED
+        std::cerr << "== " << a << b << '\n';
+#endif
+        auto aIt = Vc::begin(a);
+        auto bIt = Vc::begin(b);
+        const auto aEnd = Vc::end(a);
+        const auto bEnd = Vc::end(b);
+        return SimdArray::generate([&](std::size_t) {
+            if (aIt == aEnd) {
+                return *(bIt++);
+            }
+            if (bIt == bEnd) {
+                return *(aIt++);
+            }
+            if (*aIt < *bIt) {
+                return *(aIt++);
+            } else {
+                return *(bIt++);
+            }
+        });
+        */
+    }
+
+    /// \name Deprecated Members
+    ///@{
+
+    ///\copydoc size
+    ///\deprecated Use size() instead.
+    static constexpr std::size_t Size = size();
+
+    /// \copydoc Vector::exponent
+    Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC SimdArray exponent() const
+    {
+        return {exponent(data0), exponent(data1)};
+    }
+
+    /// \copydoc Vector::isNegative
+    Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC MaskType isNegative() const
+    {
+        return {isnegative(data0), isnegative(data1)};
+    }
+
+    ///\copydoc Vector::copySign
+    Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC SimdArray
+        copySign(const SimdArray &reference) const
+    {
+        return {Vc::copysign(data0, reference.data0),
+                Vc::copysign(data1, reference.data1)};
+    }
+    ///@}
+
+    // internal_data0/1 {{{2
+    friend storage_type0 &internal_data0<>(SimdArray &x);
+    friend storage_type1 &internal_data1<>(SimdArray &x);
+    friend const storage_type0 &internal_data0<>(const SimdArray &x);
+    friend const storage_type1 &internal_data1<>(const SimdArray &x);
+
+    /// \internal
+    Vc_INTRINSIC SimdArray(storage_type0 &&x, storage_type1 &&y) //{{{2
+        : data0(std::move(x)), data1(std::move(y))
+    {
+    }
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(storage_type0));
+
+private: //{{{2
+    // The alignas attribute attached to the class declaration above is ignored by ICC
+    // 17.0.0 (at least). So just move the alignas attribute down here where it works for
+    // all compilers.
+    alignas(static_cast<std::size_t>(
+        Common::BoundedAlignment<Common::NextPowerOfTwo<N>::value * sizeof(V) /
+                                 V::size()>::value)) storage_type0 data0;
+    storage_type1 data1;
+};
+#undef Vc_CURRENT_CLASS_NAME
+template <typename T, std::size_t N, typename V, std::size_t M>
+constexpr std::size_t SimdArray<T, N, V, M>::Size;
+template <typename T, std::size_t N, typename V, std::size_t M>
+constexpr std::size_t SimdArray<T, N, V, M>::MemoryAlignment;
+
+// gatherImplementation {{{2
+template <typename T, std::size_t N, typename VectorType, std::size_t M>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, M>::gatherImplementation(const MT *mem,
+                                                                 IT &&indexes)
+{
+    data0.gather(mem, Split::lo(Common::Operations::gather(),
+                                indexes));  // don't forward indexes - it could move and
+                                            // thus break the next line
+    data1.gather(mem, Split::hi(Common::Operations::gather(), std::forward<IT>(indexes)));
+}
+template <typename T, std::size_t N, typename VectorType, std::size_t M>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, M>::gatherImplementation(const MT *mem,
+                                                                 IT &&indexes, MaskArgument mask)
+{
+    data0.gather(mem, Split::lo(Common::Operations::gather(), indexes),
+                 Split::lo(mask));  // don't forward indexes - it could move and
+                                    // thus break the next line
+    data1.gather(mem, Split::hi(Common::Operations::gather(), std::forward<IT>(indexes)),
+                 Split::hi(mask));
+}
+
+// scatterImplementation {{{2
+template <typename T, std::size_t N, typename VectorType, std::size_t M>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, M>::scatterImplementation(MT *mem,
+                                                                 IT &&indexes) const
+{
+    data0.scatter(mem, Split::lo(Common::Operations::gather(),
+                                indexes));  // don't forward indexes - it could move and
+                                            // thus break the next line
+    data1.scatter(mem, Split::hi(Common::Operations::gather(), std::forward<IT>(indexes)));
+}
+template <typename T, std::size_t N, typename VectorType, std::size_t M>
+template <typename MT, typename IT>
+inline void SimdArray<T, N, VectorType, M>::scatterImplementation(MT *mem,
+                                                                 IT &&indexes, MaskArgument mask) const
+{
+    data0.scatter(mem, Split::lo(Common::Operations::gather(), indexes),
+                 Split::lo(mask));  // don't forward indexes - it could move and
+                                    // thus break the next line
+    data1.scatter(mem, Split::hi(Common::Operations::gather(), std::forward<IT>(indexes)),
+                 Split::hi(mask));
+}
+
+// internal_data0/1 (SimdArray) {{{1
+///\internal Returns the first data member of a generic SimdArray
+template <typename T, std::size_t N, typename V, std::size_t M>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+typename SimdArrayTraits<T, N>::storage_type0 &internal_data0(
+    SimdArray<T, N, V, M> &x)
+{
+    return x.data0;
+}
+///\internal Returns the second data member of a generic SimdArray
+template <typename T, std::size_t N, typename V, std::size_t M>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+typename SimdArrayTraits<T, N>::storage_type1 &internal_data1(
+    SimdArray<T, N, V, M> &x)
+{
+    return x.data1;
+}
+///\internal Returns the first data member of a generic SimdArray (const overload)
+template <typename T, std::size_t N, typename V, std::size_t M>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+const typename SimdArrayTraits<T, N>::storage_type0 &internal_data0(
+    const SimdArray<T, N, V, M> &x)
+{
+    return x.data0;
+}
+///\internal Returns the second data member of a generic SimdArray (const overload)
+template <typename T, std::size_t N, typename V, std::size_t M>
+#ifndef Vc_MSVC
+Vc_INTRINSIC
+#endif
+const typename SimdArrayTraits<T, N>::storage_type1 &internal_data1(
+    const SimdArray<T, N, V, M> &x)
+{
+    return x.data1;
+}
+
+// MSVC workaround for SimdArray(storage_type0, storage_type1) ctor{{{1
+// MSVC sometimes stores x to data1. By first broadcasting 0 and then assigning y
+// in the body the bug is supressed.
+#if defined Vc_MSVC && defined Vc_IMPL_SSE
+template <>
+Vc_INTRINSIC SimdArray<double, 8, SSE::Vector<double>, 2>::SimdArray(
+    SimdArray<double, 4> &&x, SimdArray<double, 4> &&y)
+    : data0(x), data1(0)
+{
+    data1 = y;
+}
+#endif
+
+// binary operators {{{1
+namespace result_vector_type_internal
+{
+template <typename T>
+using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+template <typename T>
+using is_integer_larger_than_int = std::integral_constant<
+    bool, std::is_integral<T>::value &&(sizeof(T) > sizeof(int) ||
+                                        std::is_same<T, long>::value ||
+                                        std::is_same<T, unsigned long>::value)>;
+
+template <
+    typename L, typename R,
+    std::size_t N = Traits::isSimdArray<L>::value ? Traits::simd_vector_size<L>::value
+                                                  : Traits::simd_vector_size<R>::value,
+    bool =
+        (Traits::isSimdArray<L>::value ||
+         Traits::isSimdArray<R>::value)  // one of the operands must be a SimdArray
+        && !std::is_same<type<L>, type<R>>::value  // if the operands are of the same type
+                                                   // use the member function
+        &&
+        ((std::is_arithmetic<type<L>>::value &&
+          !is_integer_larger_than_int<type<L>>::value) ||
+         (std::is_arithmetic<type<R>>::value &&
+          !is_integer_larger_than_int<type<R>>::value)  // one of the operands is a scalar
+                                                        // type
+         ||
+         (  // or one of the operands is Vector<T> with Vector<T>::size() ==
+            // SimdArray::size()
+             Traits::simd_vector_size<L>::value == Traits::simd_vector_size<R>::value &&
+             ((Traits::is_simd_vector<L>::value && !Traits::isSimdArray<L>::value) ||
+              (Traits::is_simd_vector<R>::value && !Traits::isSimdArray<R>::value))))>
+struct evaluate;
+
+template <typename L, typename R, std::size_t N> struct evaluate<L, R, N, true>
+{
+private:
+    using LScalar = Traits::entry_type_of<L>;
+    using RScalar = Traits::entry_type_of<R>;
+
+    template <bool B, typename True, typename False>
+    using conditional = typename std::conditional<B, True, False>::type;
+
+public:
+    // In principle we want the exact same rules for SimdArray<T> ⨉ SimdArray<U> as the standard
+    // defines for T ⨉ U. BUT: short ⨉ short returns int (because all integral types smaller than
+    // int are promoted to int before any operation). This would imply that SIMD types with integral
+    // types smaller than int are more or less useless - and you could use SimdArray<int> from the
+    // start. Therefore we special-case those operations where the scalar type of both operands is
+    // integral and smaller than int.
+    // In addition to that there is no generic support for 64-bit int SIMD types. Therefore
+    // promotion to a 64-bit integral type (including `long` because it can potentially have 64
+    // bits) also is not done. But if one of the operands is a scalar type that is larger than int
+    // then the operator is disabled altogether. We do not want an implicit demotion.
+    using type = SimdArray<
+        conditional<(std::is_integral<LScalar>::value &&std::is_integral<RScalar>::value &&
+                     sizeof(LScalar) < sizeof(int) &&
+                     sizeof(RScalar) < sizeof(int)),
+                    conditional<(sizeof(LScalar) == sizeof(RScalar)),
+                                conditional<std::is_unsigned<LScalar>::value, LScalar, RScalar>,
+                                conditional<(sizeof(LScalar) > sizeof(RScalar)), LScalar, RScalar>>,
+                    decltype(std::declval<LScalar>() + std::declval<RScalar>())>,
+        N>;
+};
+
+}  // namespace result_vector_type_internal
+
+template <typename L, typename R>
+using result_vector_type = typename result_vector_type_internal::evaluate<L, R>::type;
+
+static_assert(
+    std::is_same<result_vector_type<short int, Vc::SimdArray<short unsigned int, 32ul>>,
+                 Vc::SimdArray<short unsigned int, 32ul>>::value,
+    "result_vector_type does not work");
+
+#define Vc_BINARY_OPERATORS_(op_)                                                        \
+    /*!\brief Applies op_ component-wise and concurrently.  */                           \
+    template <typename L, typename R>                                                    \
+    Vc_INTRINSIC result_vector_type<L, R> operator op_(L &&lhs, R &&rhs)                 \
+    {                                                                                    \
+        using Return = result_vector_type<L, R>;                                         \
+        return Return(std::forward<L>(lhs)) op_ Return(std::forward<R>(rhs));            \
+    }
+/**
+ * \name Arithmetic and Bitwise Operators
+ *
+ * Applies the operator component-wise and concurrently on \p lhs and \p rhs and returns
+ * a new SimdArray object containing the result values.
+ *
+ * This operator only participates in overload resolution if:
+ * \li At least one of the template parameters \p L or \p R is a SimdArray type.
+ * \li Either \p L or \p R is a fundamental arithmetic type but not an integral type
+ *     larger than \c int \n
+ *     or \n
+ *     \p L or \p R is a Vc::Vector type with equal number of elements (Vector::size() ==
+ *     SimdArray::size()).
+ *
+ * The return type of the operator is a SimdArray type using the more precise EntryType of
+ * \p L or \p R and the same number of elements as the SimdArray argument(s).
+ */
+///@{
+Vc_ALL_ARITHMETICS(Vc_BINARY_OPERATORS_);
+Vc_ALL_BINARY(Vc_BINARY_OPERATORS_);
+///@}
+#undef Vc_BINARY_OPERATORS_
+#define Vc_BINARY_OPERATORS_(op_)                                                        \
+    /*!\brief Applies op_ component-wise and concurrently.  */                           \
+    template <typename L, typename R>                                                    \
+    Vc_INTRINSIC typename result_vector_type<L, R>::mask_type operator op_(L &&lhs,      \
+                                                                           R &&rhs)      \
+    {                                                                                    \
+        using Promote = result_vector_type<L, R>;                                        \
+        return Promote(std::forward<L>(lhs)) op_ Promote(std::forward<R>(rhs));          \
+    }
+/**
+ * \name Compare Operators
+ *
+ * Applies the operator component-wise and concurrently on \p lhs and \p rhs and returns
+ * a new SimdMaskArray object containing the result values.
+ *
+ * This operator only participates in overload resolution if (same rules as above):
+ * \li At least one of the template parameters \p L or \p R is a SimdArray type.
+ * \li Either \p L or \p R is a fundamental arithmetic type but not an integral type
+ *     larger than \c int \n
+ *     or \n
+ *     \p L or \p R is a Vc::Vector type with equal number of elements (Vector::size() ==
+ *     SimdArray::size()).
+ *
+ * The return type of the operator is a SimdMaskArray type using the more precise EntryType of
+ * \p L or \p R and the same number of elements as the SimdArray argument(s).
+ */
+///@{
+Vc_ALL_COMPARES(Vc_BINARY_OPERATORS_);
+///@}
+#undef Vc_BINARY_OPERATORS_
+
+// math functions {{{1
+#define Vc_FORWARD_UNARY_OPERATOR(name_)                                                 \
+    /*!\brief Applies the std::name_ function component-wise and concurrently. */        \
+    template <typename T, std::size_t N, typename V, std::size_t M>                      \
+    inline SimdArray<T, N, V, M> name_(const SimdArray<T, N, V, M> &x)                   \
+    {                                                                                    \
+        return SimdArray<T, N, V, M>::fromOperation(                                     \
+            Common::Operations::Forward_##name_(), x);                                   \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+#define Vc_FORWARD_UNARY_BOOL_OPERATOR(name_)                                            \
+    /*!\brief Applies the std::name_ function component-wise and concurrently. */        \
+    template <typename T, std::size_t N, typename V, std::size_t M>                      \
+    inline SimdMaskArray<T, N, V, M> name_(const SimdArray<T, N, V, M> &x)               \
+    {                                                                                    \
+        return SimdMaskArray<T, N, V, M>::fromOperation(                                 \
+            Common::Operations::Forward_##name_(), x);                                   \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+#define Vc_FORWARD_BINARY_OPERATOR(name_)                                                \
+    /*!\brief Applies the std::name_ function component-wise and concurrently. */        \
+    template <typename T, std::size_t N, typename V, std::size_t M>                      \
+    inline SimdArray<T, N, V, M> name_(const SimdArray<T, N, V, M> &x,                   \
+                                       const SimdArray<T, N, V, M> &y)                   \
+    {                                                                                    \
+        return SimdArray<T, N, V, M>::fromOperation(                                     \
+            Common::Operations::Forward_##name_(), x, y);                                \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+/**
+ * \name Math functions
+ * These functions evaluate the 
+ */
+///@{
+Vc_FORWARD_UNARY_OPERATOR(abs);
+Vc_FORWARD_UNARY_OPERATOR(asin);
+Vc_FORWARD_UNARY_OPERATOR(atan);
+Vc_FORWARD_BINARY_OPERATOR(atan2);
+Vc_FORWARD_UNARY_OPERATOR(ceil);
+Vc_FORWARD_BINARY_OPERATOR(copysign);
+Vc_FORWARD_UNARY_OPERATOR(cos);
+Vc_FORWARD_UNARY_OPERATOR(exp);
+Vc_FORWARD_UNARY_OPERATOR(exponent);
+Vc_FORWARD_UNARY_OPERATOR(floor);
+/// Applies the std::fma function component-wise and concurrently.
+template <typename T, std::size_t N>
+inline SimdArray<T, N> fma(const SimdArray<T, N> &a, const SimdArray<T, N> &b,
+                           const SimdArray<T, N> &c)
+{
+    return SimdArray<T, N>::fromOperation(Common::Operations::Forward_fma(), a, b, c);
+}
+Vc_FORWARD_UNARY_BOOL_OPERATOR(isfinite);
+Vc_FORWARD_UNARY_BOOL_OPERATOR(isinf);
+Vc_FORWARD_UNARY_BOOL_OPERATOR(isnan);
+#if defined Vc_MSVC && defined Vc_IMPL_SSE
+inline SimdMaskArray<double, 8, SSE::Vector<double>, 2> isnan(
+    const SimdArray<double, 8, SSE::Vector<double>, 2> &x)
+{
+    using V = SSE::Vector<double>;
+    const SimdArray<double, 4, V, 2> &x0 = internal_data0(x);
+    const SimdArray<double, 4, V, 2> &x1 = internal_data1(x);
+    SimdMaskArray<double, 4, V, 2> r0;
+    SimdMaskArray<double, 4, V, 2> r1;
+    internal_data(internal_data0(r0)) = isnan(internal_data(internal_data0(x0)));
+    internal_data(internal_data1(r0)) = isnan(internal_data(internal_data1(x0)));
+    internal_data(internal_data0(r1)) = isnan(internal_data(internal_data0(x1)));
+    internal_data(internal_data1(r1)) = isnan(internal_data(internal_data1(x1)));
+    return {std::move(r0), std::move(r1)};
+}
+#endif
+Vc_FORWARD_UNARY_BOOL_OPERATOR(isnegative);
+/// Applies the std::frexp function component-wise and concurrently.
+template <typename T, std::size_t N>
+inline SimdArray<T, N> frexp(const SimdArray<T, N> &x, SimdArray<int, N> *e)
+{
+    return SimdArray<T, N>::fromOperation(Common::Operations::Forward_frexp(), x, e);
+}
+/// Applies the std::ldexp function component-wise and concurrently.
+template <typename T, std::size_t N>
+inline SimdArray<T, N> ldexp(const SimdArray<T, N> &x, const SimdArray<int, N> &e)
+{
+    return SimdArray<T, N>::fromOperation(Common::Operations::Forward_ldexp(), x, e);
+}
+Vc_FORWARD_UNARY_OPERATOR(log);
+Vc_FORWARD_UNARY_OPERATOR(log10);
+Vc_FORWARD_UNARY_OPERATOR(log2);
+Vc_FORWARD_UNARY_OPERATOR(reciprocal);
+Vc_FORWARD_UNARY_OPERATOR(round);
+Vc_FORWARD_UNARY_OPERATOR(rsqrt);
+Vc_FORWARD_UNARY_OPERATOR(sin);
+/// Determines sine and cosine concurrently and component-wise on \p x.
+template <typename T, std::size_t N>
+void sincos(const SimdArray<T, N> &x, SimdArray<T, N> *sin, SimdArray<T, N> *cos)
+{
+    SimdArray<T, N>::callOperation(Common::Operations::Forward_sincos(), x, sin, cos);
+}
+Vc_FORWARD_UNARY_OPERATOR(sqrt);
+Vc_FORWARD_UNARY_OPERATOR(trunc);
+Vc_FORWARD_BINARY_OPERATOR(min);
+Vc_FORWARD_BINARY_OPERATOR(max);
+///@}
+#undef Vc_FORWARD_UNARY_OPERATOR
+#undef Vc_FORWARD_UNARY_BOOL_OPERATOR
+#undef Vc_FORWARD_BINARY_OPERATOR
+
+// simd_cast {{{1
+#ifdef Vc_MSVC
+#define Vc_DUMMY_ARG0 , int = 0
+#define Vc_DUMMY_ARG1 , long = 0
+#define Vc_DUMMY_ARG2 , short = 0
+#define Vc_DUMMY_ARG3 , char = '0'
+#define Vc_DUMMY_ARG4 , unsigned = 0u
+#define Vc_DUMMY_ARG5 , unsigned short = 0u
+#else
+#define Vc_DUMMY_ARG0
+#define Vc_DUMMY_ARG1
+#define Vc_DUMMY_ARG2
+#define Vc_DUMMY_ARG3
+#define Vc_DUMMY_ARG4
+#define Vc_DUMMY_ARG5
+#endif  // Vc_MSVC
+
+// simd_cast_impl_smaller_input {{{2
+// The following function can be implemented without the sizeof...(From) overload.
+// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the
+// function in two works around the issue.
+template <typename Return, std::size_t N, typename T, typename... From>
+Vc_INTRINSIC Vc_CONST enable_if<sizeof...(From) != 0, Return>
+simd_cast_impl_smaller_input(const From &... xs, const T &last)
+{
+    Return r = simd_cast<Return>(xs...);
+    for (size_t i = 0; i < N; ++i) {
+        r[i + N * sizeof...(From)] = static_cast<typename Return::EntryType>(last[i]);
+    }
+    return r;
+}
+template <typename Return, std::size_t N, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast_impl_smaller_input(const T &last)
+{
+    Return r = Return();
+    for (size_t i = 0; i < N; ++i) {
+        r[i] = static_cast<typename Return::EntryType>(last[i]);
+    }
+    return r;
+}
+template <typename Return, std::size_t N, typename T, typename... From>
+Vc_INTRINSIC Vc_CONST enable_if<sizeof...(From) != 0, Return> simd_cast_impl_larger_input(
+    const From &... xs, const T &last)
+{
+    Return r = simd_cast<Return>(xs...);
+    for (size_t i = N * sizeof...(From); i < Return::Size; ++i) {
+        r[i] = static_cast<typename Return::EntryType>(last[i - N * sizeof...(From)]);
+    }
+    return r;
+}
+template <typename Return, std::size_t N, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast_impl_larger_input(const T &last)
+{
+    Return r = Return();
+    for (size_t i = 0; i < Return::size(); ++i) {
+        r[i] = static_cast<typename Return::EntryType>(last[i]);
+    }
+    return r;
+}
+
+// simd_cast_without_last (declaration) {{{2
+template <typename Return, typename T, typename... From>
+Vc_INTRINSIC_L Vc_CONST_L Return
+    simd_cast_without_last(const From &... xs, const T &) Vc_INTRINSIC_R Vc_CONST_R;
+
+// are_all_types_equal {{{2
+template <typename... Ts> struct are_all_types_equal;
+template <typename T>
+struct are_all_types_equal<T> : public std::integral_constant<bool, true>
+{
+};
+template <typename T0, typename T1, typename... Ts>
+struct are_all_types_equal<T0, T1, Ts...>
+    : public std::integral_constant<
+          bool, std::is_same<T0, T1>::value && are_all_types_equal<T1, Ts...>::value>
+{
+};
+
+// simd_cast_interleaved_argument_order (declarations) {{{2
+/*! \internal
+  The need for simd_cast_interleaved_argument_order stems from a shortcoming in pack
+  expansion of variadic templates in C++. For a simd_cast with SimdArray arguments that
+  are bisectable (i.e.  \c storage_type0 and \c storage_type1 are equal) the generic
+  implementation needs to forward to a simd_cast of the \c internal_data0 and \c
+  internal_data1 of the arguments. But the required order of arguments is
+  `internal_data0(arg0), internal_data1(arg0), internal_data0(arg1), ...`. This is
+  impossible to achieve with pack expansion. It is only possible to write
+  `internal_data0(args)..., internal_data1(args)...` and thus have the argument order
+  mixed up. The simd_cast_interleaved_argument_order “simply” calls simd_cast with the
+  arguments correctly reordered (i.e. interleaved).
+
+  The implementation of simd_cast_interleaved_argument_order is done generically, so that
+  it supports any number of arguments. The central idea of the implementation is an
+  `extract` function which returns one value of an argument pack determined via an index
+  passed as template argument. This index is generated via an index_sequence. The
+  `extract` function uses two argument packs (of equal size) to easily return values from
+  the front and middle of the argument pack (for doing the deinterleave).
+ */
+template <typename Return, typename... Ts>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast_interleaved_argument_order(const Ts &... a, const Ts &... b);
+
+// simd_cast_with_offset (declarations and one impl) {{{2
+// offset == 0 {{{3
+template <typename Return, std::size_t offset, typename From, typename... Froms>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<From, Froms...>::value && offset == 0), Return>
+        simd_cast_with_offset(const From &x, const Froms &... xs);
+// offset > 0 && offset divisible by Return::Size {{{3
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size == 0), Return>
+        simd_cast_with_offset(const From &x);
+// offset > 0 && offset NOT divisible && Return is non-atomic simd(mask)array {{{3
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&
+               ((Traits::isSimdArray<Return>::value &&
+                 !Traits::isAtomicSimdArray<Return>::value) ||
+                (Traits::isSimdMaskArray<Return>::value &&
+                 !Traits::isAtomicSimdMaskArray<Return>::value))),
+              Return>
+        simd_cast_with_offset(const From &x);
+// offset > 0 && offset NOT divisible && Return is atomic simd(mask)array {{{3
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&
+               ((Traits::isSimdArray<Return>::value &&
+                 Traits::isAtomicSimdArray<Return>::value) ||
+                (Traits::isSimdMaskArray<Return>::value &&
+                 Traits::isAtomicSimdMaskArray<Return>::value))),
+              Return>
+        simd_cast_with_offset(const From &x);
+// offset > first argument (drops first arg) {{{3
+template <typename Return, std::size_t offset, typename From, typename... Froms>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (are_all_types_equal<From, Froms...>::value && From::Size <= offset), Return>
+    simd_cast_with_offset(const From &, const Froms &... xs)
+{
+    return simd_cast_with_offset<Return, offset - From::Size>(xs...);
+}
+
+// offset > first and only argument (returns Zero) {{{3
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST enable_if<(From::Size <= offset), Return> simd_cast_with_offset(
+    const From &)
+{
+    return Return::Zero();
+}
+
+// first_type_of {{{2
+template <typename T, typename... Ts> struct first_type_of_impl
+{
+    using type = T;
+};
+template <typename... Ts> using first_type_of = typename first_type_of_impl<Ts...>::type;
+
+// simd_cast_drop_arguments (declarations) {{{2
+template <typename Return, typename From>
+Vc_INTRINSIC Vc_CONST Return simd_cast_drop_arguments(From x);
+template <typename Return, typename... Froms>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<Froms...>::value &&
+               sizeof...(Froms) * first_type_of<Froms...>::Size < Return::Size),
+              Return>
+        simd_cast_drop_arguments(Froms... xs, first_type_of<Froms...> x);
+// The following function can be implemented without the sizeof...(From) overload.
+// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the
+// function in two works around the issue.
+template <typename Return, typename From, typename... Froms>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (are_all_types_equal<From, Froms...>::value &&
+     (1 + sizeof...(Froms)) * From::Size >= Return::Size && sizeof...(Froms) != 0),
+    Return>
+simd_cast_drop_arguments(Froms... xs, From x, From);
+template <typename Return, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<From>::value && From::Size >= Return::Size), Return>
+    simd_cast_drop_arguments(From x, From);
+
+namespace
+{
+#ifdef Vc_DEBUG_SIMD_CAST
+void debugDoNothing(const std::initializer_list<void *> &) {}
+template <typename T0, typename... Ts>
+inline void vc_debug_(const char *prefix, const char *suffix, const T0 &arg0,
+                      const Ts &... args)
+{
+    std::cerr << prefix << arg0;
+    debugDoNothing({&(std::cerr << ", " << args)...});
+    std::cerr << suffix;
+}
+#else
+template <typename T0, typename... Ts>
+Vc_INTRINSIC void vc_debug_(const char *, const char *, const T0 &, const Ts &...)
+{
+}
+#endif
+}  // unnamed namespace
+
+// is_less trait{{{2
+template <size_t A, size_t B>
+struct is_less : public std::integral_constant<bool, (A < B)> {
+};
+
+// is_power_of_2 trait{{{2
+template <size_t N>
+struct is_power_of_2 : public std::integral_constant<bool, ((N - 1) & N) == 0> {
+};
+
+// simd_cast<T>(xs...) to SimdArray/-mask {{{2
+#define Vc_SIMDARRAY_CASTS(SimdArrayType_, NativeType_)                                  \
+    template <typename Return, typename T, typename A, typename... Froms>                \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (Traits::isAtomic##SimdArrayType_<Return>::value &&                              \
+         is_less<NativeType_<T, A>::Size * sizeof...(Froms), Return::Size>::value &&     \
+         are_all_types_equal<NativeType_<T, A>, Froms...>::value),                       \
+        Return>                                                                          \
+    simd_cast(NativeType_<T, A> x, Froms... xs)                                          \
+    {                                                                                    \
+        vc_debug_("simd_cast{1}(", ")\n", x, xs...);                                     \
+        return {simd_cast<typename Return::storage_type>(x, xs...)};                     \
+    }                                                                                    \
+    template <typename Return, typename T, typename A, typename... Froms>                \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (Traits::isAtomic##SimdArrayType_<Return>::value &&                              \
+         !is_less<NativeType_<T, A>::Size * sizeof...(Froms), Return::Size>::value &&    \
+         are_all_types_equal<NativeType_<T, A>, Froms...>::value),                       \
+        Return>                                                                          \
+    simd_cast(NativeType_<T, A> x, Froms... xs)                                          \
+    {                                                                                    \
+        vc_debug_("simd_cast{2}(", ")\n", x, xs...);                                     \
+        return {simd_cast_without_last<Return, NativeType_<T, A>, Froms...>(x, xs...)};  \
+    }                                                                                    \
+    template <typename Return, typename T, typename A, typename... Froms>                \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(Traits::is##SimdArrayType_<Return>::value &&                          \
+                   !Traits::isAtomic##SimdArrayType_<Return>::value &&                   \
+                   is_less<Common::left_size<Return::Size>(),                            \
+                           NativeType_<T, A>::Size *(1 + sizeof...(Froms))>::value &&    \
+                   are_all_types_equal<NativeType_<T, A>, Froms...>::value),             \
+                  Return>                                                                \
+        simd_cast(NativeType_<T, A> x, Froms... xs)                                      \
+    {                                                                                    \
+        vc_debug_("simd_cast{3}(", ")\n", x, xs...);                                     \
+        using R0 = typename Return::storage_type0;                                       \
+        using R1 = typename Return::storage_type1;                                       \
+        return {simd_cast_drop_arguments<R0, Froms...>(x, xs...),                        \
+                simd_cast_with_offset<R1, R0::Size>(x, xs...)};                          \
+    }                                                                                    \
+    template <typename Return, typename T, typename A, typename... Froms>                \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(Traits::is##SimdArrayType_<Return>::value &&                          \
+                   !Traits::isAtomic##SimdArrayType_<Return>::value &&                   \
+                   !is_less<Common::left_size<Return::Size>(),                           \
+                            NativeType_<T, A>::Size *(1 + sizeof...(Froms))>::value &&   \
+                   are_all_types_equal<NativeType_<T, A>, Froms...>::value),             \
+                  Return>                                                                \
+        simd_cast(NativeType_<T, A> x, Froms... xs)                                      \
+    {                                                                                    \
+        vc_debug_("simd_cast{4}(", ")\n", x, xs...);                                     \
+        using R0 = typename Return::storage_type0;                                       \
+        using R1 = typename Return::storage_type1;                                       \
+        return {simd_cast<R0>(x, xs...), R1::Zero()};                                    \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+Vc_SIMDARRAY_CASTS(SimdArray, Vc::Vector);
+Vc_SIMDARRAY_CASTS(SimdMaskArray, Vc::Mask);
+#undef Vc_SIMDARRAY_CASTS
+
+// simd_cast<SimdArray/-mask, offset>(V) {{{2
+#define Vc_SIMDARRAY_CASTS(SimdArrayType_, NativeType_)                                  \
+    /* SIMD Vector/Mask to atomic SimdArray/simdmaskarray */                             \
+    template <typename Return, int offset, typename T, typename A>                       \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<Traits::isAtomic##SimdArrayType_<Return>::value, Return>               \
+        simd_cast(NativeType_<T, A> x Vc_DUMMY_ARG0)                                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, atomic}(", ")\n", offset, x);                       \
+        return {simd_cast<typename Return::storage_type, offset>(x)};                    \
+    }                                                                                    \
+    /* both halves of Return array are extracted from argument */                        \
+    template <typename Return, int offset, typename T, typename A>                       \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(Traits::is##SimdArrayType_<Return>::value &&                          \
+                   !Traits::isAtomic##SimdArrayType_<Return>::value &&                   \
+                   Return::Size * offset + Common::left_size<Return::Size>() <           \
+                       NativeType_<T, A>::Size),                                         \
+                  Return>                                                                \
+        simd_cast(NativeType_<T, A> x Vc_DUMMY_ARG1)                                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, split Return}(", ")\n", offset, x);                 \
+        using R0 = typename Return::storage_type0;                                       \
+        constexpr int entries_offset = offset * Return::Size;                            \
+        constexpr int entries_offset_right = entries_offset + R0::Size;                  \
+        return {                                                                         \
+            simd_cast_with_offset<typename Return::storage_type0, entries_offset>(x),    \
+            simd_cast_with_offset<typename Return::storage_type1, entries_offset_right>( \
+                x)};                                                                     \
+    }                                                                                    \
+    /* SIMD Vector/Mask to non-atomic SimdArray/simdmaskarray */                         \
+    /* right half of Return array is zero */                                             \
+    template <typename Return, int offset, typename T, typename A>                       \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(Traits::is##SimdArrayType_<Return>::value &&                          \
+                   !Traits::isAtomic##SimdArrayType_<Return>::value &&                   \
+                   Return::Size * offset + Common::left_size<Return::Size>() >=          \
+                       NativeType_<T, A>::Size),                                         \
+                  Return>                                                                \
+        simd_cast(NativeType_<T, A> x Vc_DUMMY_ARG2)                                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, R1::Zero}(", ")\n", offset, x);                     \
+        using R0 = typename Return::storage_type0;                                       \
+        using R1 = typename Return::storage_type1;                                       \
+        constexpr int entries_offset = offset * Return::Size;                            \
+        return {simd_cast_with_offset<R0, entries_offset>(x), R1::Zero()};               \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+Vc_SIMDARRAY_CASTS(SimdArray, Vc::Vector);
+Vc_SIMDARRAY_CASTS(SimdMaskArray, Vc::Mask);
+#undef Vc_SIMDARRAY_CASTS
+
+// simd_cast<T>(xs...) from SimdArray/-mask {{{2
+#define Vc_SIMDARRAY_CASTS(SimdArrayType_)                                               \
+    /* indivisible SimdArrayType_ */                                                     \
+    template <typename Return, typename T, std::size_t N, typename V, typename... From>  \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(are_all_types_equal<SimdArrayType_<T, N, V, N>, From...>::value &&    \
+                   (sizeof...(From) == 0 || N * sizeof...(From) < Return::Size) &&       \
+                   !std::is_same<Return, SimdArrayType_<T, N, V, N>>::value),            \
+                  Return>                                                                \
+        simd_cast(const SimdArrayType_<T, N, V, N> &x0, const From &... xs)              \
+    {                                                                                    \
+        vc_debug_("simd_cast{indivisible}(", ")\n", x0, xs...);                          \
+        return simd_cast<Return>(internal_data(x0), internal_data(xs)...);               \
+    }                                                                                    \
+    /* indivisible SimdArrayType_ && can drop arguments from the end */                  \
+    template <typename Return, typename T, std::size_t N, typename V, typename... From>  \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(are_all_types_equal<SimdArrayType_<T, N, V, N>, From...>::value &&    \
+                   (sizeof...(From) > 0 && (N * sizeof...(From) >= Return::Size)) &&     \
+                   !std::is_same<Return, SimdArrayType_<T, N, V, N>>::value),            \
+                  Return>                                                                \
+        simd_cast(const SimdArrayType_<T, N, V, N> &x0, const From &... xs)              \
+    {                                                                                    \
+        vc_debug_("simd_cast{indivisible2}(", ")\n", x0, xs...);                         \
+        return simd_cast_without_last<Return,                                            \
+                                      typename SimdArrayType_<T, N, V, N>::storage_type, \
+                                      typename From::storage_type...>(                   \
+            internal_data(x0), internal_data(xs)...);                                    \
+    }                                                                                    \
+    /* bisectable SimdArrayType_ (N = 2^n) && never too large */                         \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M,     \
+              typename... From>                                                          \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (N != M && are_all_types_equal<SimdArrayType_<T, N, V, M>, From...>::value &&    \
+         !std::is_same<Return, SimdArrayType_<T, N, V, M>>::value &&                     \
+         is_less<N * sizeof...(From), Return::Size>::value && is_power_of_2<N>::value),  \
+        Return>                                                                          \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x0, const From &... xs)                  \
+    {                                                                                    \
+        vc_debug_("simd_cast{bisectable}(", ")\n", x0, xs...);                           \
+        return simd_cast_interleaved_argument_order<                                     \
+            Return, typename SimdArrayType_<T, N, V, M>::storage_type0,                  \
+            typename From::storage_type0...>(internal_data0(x0), internal_data0(xs)...,  \
+                                             internal_data1(x0), internal_data1(xs)...); \
+    }                                                                                    \
+    /* bisectable SimdArrayType_ (N = 2^n) && input so large that at least the last      \
+     * input can be dropped */                                                           \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M,     \
+              typename... From>                                                          \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (N != M && are_all_types_equal<SimdArrayType_<T, N, V, M>, From...>::value &&    \
+         !is_less<N * sizeof...(From), Return::Size>::value && is_power_of_2<N>::value), \
+        Return>                                                                          \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x0, const From &... xs)                  \
+    {                                                                                    \
+        vc_debug_("simd_cast{bisectable2}(", ")\n", x0, xs...);                          \
+        return simd_cast_without_last<Return, SimdArrayType_<T, N, V, M>, From...>(      \
+            x0, xs...);                                                                  \
+    }                                                                                    \
+    /* remaining SimdArrayType_ input never larger (N != 2^n) */                         \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M,     \
+              typename... From>                                                          \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (N != M && are_all_types_equal<SimdArrayType_<T, N, V, M>, From...>::value &&    \
+         N * (1 + sizeof...(From)) <= Return::Size && !is_power_of_2<N>::value),         \
+        Return>                                                                          \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x0, const From &... xs)                  \
+    {                                                                                    \
+        vc_debug_("simd_cast{remaining}(", ")\n", x0, xs...);                            \
+        return simd_cast_impl_smaller_input<Return, N, SimdArrayType_<T, N, V, M>,       \
+                                            From...>(x0, xs...);                         \
+    }                                                                                    \
+    /* remaining SimdArrayType_ input larger (N != 2^n) */                               \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M,     \
+              typename... From>                                                          \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (N != M && are_all_types_equal<SimdArrayType_<T, N, V, M>, From...>::value &&    \
+         N * (1 + sizeof...(From)) > Return::Size && !is_power_of_2<N>::value),          \
+        Return>                                                                          \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x0, const From &... xs)                  \
+    {                                                                                    \
+        vc_debug_("simd_cast{remaining2}(", ")\n", x0, xs...);                           \
+        return simd_cast_impl_larger_input<Return, N, SimdArrayType_<T, N, V, M>,        \
+                                           From...>(x0, xs...);                          \
+    }                                                                                    \
+    /* a single bisectable SimdArrayType_ (N = 2^n) too large */                         \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M>     \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(N != M && N >= 2 * Return::Size && is_power_of_2<N>::value), Return>  \
+        simd_cast(const SimdArrayType_<T, N, V, M> &x)                                   \
+    {                                                                                    \
+        vc_debug_("simd_cast{single bisectable}(", ")\n", x);                            \
+        return simd_cast<Return>(internal_data0(x));                                     \
+    }                                                                                    \
+    template <typename Return, typename T, std::size_t N, typename V, std::size_t M>     \
+    Vc_INTRINSIC Vc_CONST enable_if<(N != M && N > Return::Size &&                       \
+                                     N < 2 * Return::Size && is_power_of_2<N>::value),   \
+                                    Return>                                              \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x)                                       \
+    {                                                                                    \
+        vc_debug_("simd_cast{single bisectable2}(", ")\n", x);                           \
+        return simd_cast<Return>(internal_data0(x), internal_data1(x));                  \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+
+Vc_SIMDARRAY_CASTS(SimdArray);
+Vc_SIMDARRAY_CASTS(SimdMaskArray);
+#undef Vc_SIMDARRAY_CASTS
+
+// simd_cast<T, offset>(SimdArray/-mask) {{{2
+#define Vc_SIMDARRAY_CASTS(SimdArrayType_)                                               \
+    /* offset == 0 is like without offset */                                             \
+    template <typename Return, int offset, typename T, std::size_t N, typename V,        \
+              std::size_t M>                                                             \
+    Vc_INTRINSIC Vc_CONST enable_if<(offset == 0), Return> simd_cast(                    \
+        const SimdArrayType_<T, N, V, M> &x Vc_DUMMY_ARG0)                               \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset == 0}(", ")\n", offset, x);                          \
+        return simd_cast<Return>(x);                                                     \
+    }                                                                                    \
+    /* forward to V */                                                                   \
+    template <typename Return, int offset, typename T, std::size_t N, typename V>        \
+    Vc_INTRINSIC Vc_CONST enable_if<(offset != 0), Return> simd_cast(                    \
+        const SimdArrayType_<T, N, V, N> &x Vc_DUMMY_ARG1)                               \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, forward}(", ")\n", offset, x);                      \
+        return simd_cast<Return, offset>(internal_data(x));                              \
+    }                                                                                    \
+    /* convert from right member of SimdArray */                                         \
+    template <typename Return, int offset, typename T, std::size_t N, typename V,        \
+              std::size_t M>                                                             \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(N != M && offset * Return::Size >= Common::left_size<N>() &&          \
+                   offset != 0 && Common::left_size<N>() % Return::Size == 0),           \
+                  Return>                                                                \
+        simd_cast(const SimdArrayType_<T, N, V, M> &x Vc_DUMMY_ARG2)                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, right}(", ")\n", offset, x);                        \
+        return simd_cast<Return, offset - Common::left_size<N>() / Return::Size>(        \
+            internal_data1(x));                                                          \
+    }                                                                                    \
+    /* same as above except for odd cases where offset * Return::Size doesn't fit the    \
+     * left side of the SimdArray */                                                     \
+    template <typename Return, int offset, typename T, std::size_t N, typename V,        \
+              std::size_t M>                                                             \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(N != M && offset * Return::Size >= Common::left_size<N>() &&          \
+                   offset != 0 && Common::left_size<N>() % Return::Size != 0),           \
+                  Return>                                                                \
+        simd_cast(const SimdArrayType_<T, N, V, M> &x Vc_DUMMY_ARG3)                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, right, nofit}(", ")\n", offset, x);                 \
+        return simd_cast_with_offset<Return,                                             \
+                                     offset * Return::Size - Common::left_size<N>()>(    \
+            internal_data1(x));                                                          \
+    }                                                                                    \
+    /* convert from left member of SimdArray */                                          \
+    template <typename Return, int offset, typename T, std::size_t N, typename V,        \
+              std::size_t M>                                                             \
+    Vc_INTRINSIC Vc_CONST enable_if<                                                     \
+        (N != M && /*offset * Return::Size < Common::left_size<N>() &&*/                 \
+         offset != 0 && (offset + 1) * Return::Size <= Common::left_size<N>()),          \
+        Return>                                                                          \
+    simd_cast(const SimdArrayType_<T, N, V, M> &x Vc_DUMMY_ARG4)                         \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, left}(", ")\n", offset, x);                         \
+        return simd_cast<Return, offset>(internal_data0(x));                             \
+    }                                                                                    \
+    /* fallback to copying scalars */                                                    \
+    template <typename Return, int offset, typename T, std::size_t N, typename V,        \
+              std::size_t M>                                                             \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<(N != M && (offset * Return::Size < Common::left_size<N>()) &&         \
+                   offset != 0 && (offset + 1) * Return::Size > Common::left_size<N>()), \
+                  Return>                                                                \
+        simd_cast(const SimdArrayType_<T, N, V, M> &x Vc_DUMMY_ARG5)                     \
+    {                                                                                    \
+        vc_debug_("simd_cast{offset, copy scalars}(", ")\n", offset, x);                 \
+        using R = typename Return::EntryType;                                            \
+        Return r = Return::Zero();                                                       \
+        for (std::size_t i = offset * Return::Size;                                      \
+             i < std::min(N, (offset + 1) * Return::Size); ++i) {                        \
+            r[i - offset * Return::Size] = static_cast<R>(x[i]);                         \
+        }                                                                                \
+        return r;                                                                        \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_SIMDARRAY_CASTS(SimdArray);
+Vc_SIMDARRAY_CASTS(SimdMaskArray);
+#undef Vc_SIMDARRAY_CASTS
+// simd_cast_drop_arguments (definitions) {{{2
+template <typename Return, typename From>
+Vc_INTRINSIC Vc_CONST Return simd_cast_drop_arguments(From x)
+{
+    return simd_cast<Return>(x);
+}
+template <typename Return, typename... Froms>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<Froms...>::value &&
+               sizeof...(Froms) * first_type_of<Froms...>::Size < Return::Size),
+              Return>
+        simd_cast_drop_arguments(Froms... xs, first_type_of<Froms...> x)
+{
+    return simd_cast<Return>(xs..., x);
+}
+// The following function can be implemented without the sizeof...(From) overload.
+// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the
+// function in two works around the issue.
+template <typename Return, typename From, typename... Froms>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (are_all_types_equal<From, Froms...>::value &&
+     (1 + sizeof...(Froms)) * From::Size >= Return::Size && sizeof...(Froms) != 0),
+    Return>
+simd_cast_drop_arguments(Froms... xs, From x, From)
+{
+    return simd_cast_drop_arguments<Return, Froms...>(xs..., x);
+}
+template <typename Return, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<From>::value && From::Size >= Return::Size), Return>
+    simd_cast_drop_arguments(From x, From)
+{
+    return simd_cast_drop_arguments<Return>(x);
+}
+
+// simd_cast_with_offset (definitions) {{{2
+    template <typename Return, std::size_t offset, typename From>
+    Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size == 0),
+              Return> simd_cast_with_offset(const From &x)
+{
+    return simd_cast<Return, offset / Return::Size>(x);
+}
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&
+               ((Traits::isSimdArray<Return>::value &&
+                 !Traits::isAtomicSimdArray<Return>::value) ||
+                (Traits::isSimdMaskArray<Return>::value &&
+                 !Traits::isAtomicSimdMaskArray<Return>::value))),
+              Return>
+        simd_cast_with_offset(const From &x)
+{
+    using R0 = typename Return::storage_type0;
+    using R1 = typename Return::storage_type1;
+    return {simd_cast_with_offset<R0, offset>(x),
+            simd_cast_with_offset<R1, offset + R0::Size>(x)};
+}
+template <typename Return, std::size_t offset, typename From>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&
+               ((Traits::isSimdArray<Return>::value &&
+                 Traits::isAtomicSimdArray<Return>::value) ||
+                (Traits::isSimdMaskArray<Return>::value &&
+                 Traits::isAtomicSimdMaskArray<Return>::value))),
+              Return>
+        simd_cast_with_offset(const From &x)
+{
+    return simd_cast<Return, offset / Return::Size>(x.shifted(offset % Return::Size));
+}
+template <typename Return, std::size_t offset, typename From, typename... Froms>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(are_all_types_equal<From, Froms...>::value && offset == 0), Return>
+        simd_cast_with_offset(const From &x, const Froms &... xs)
+{
+    return simd_cast<Return>(x, xs...);
+}
+
+// simd_cast_without_last (definition) {{{2
+template <typename Return, typename T, typename... From>
+Vc_INTRINSIC Vc_CONST Return simd_cast_without_last(const From &... xs, const T &)
+{
+    return simd_cast<Return>(xs...);
+}
+
+// simd_cast_interleaved_argument_order (definitions) {{{2
+
+#ifdef Vc_MSVC
+// MSVC doesn't see that the Ts pack below can be empty and thus complains when extract_interleaved
+// is called with only 2 arguments. These overloads here are *INCORRECT standard C++*, but they make
+// MSVC do the right thing.
+template <std::size_t I, typename T0>
+Vc_INTRINSIC Vc_CONST enable_if<(I == 0), T0> extract_interleaved(const T0 &a0, const T0 &)
+{
+    return a0;
+}
+template <std::size_t I, typename T0>
+Vc_INTRINSIC Vc_CONST enable_if<(I == 1), T0> extract_interleaved(const T0 &, const T0 &b0)
+{
+    return b0;
+}
+#endif  // Vc_MSVC
+
+/// \internal returns the first argument
+template <std::size_t I, typename T0, typename... Ts>
+Vc_INTRINSIC Vc_CONST enable_if<(I == 0), T0> extract_interleaved(const T0 &a0,
+                                                                  const Ts &...,
+                                                                  const T0 &,
+                                                                  const Ts &...)
+{
+    return a0;
+}
+/// \internal returns the center argument
+template <std::size_t I, typename T0, typename... Ts>
+Vc_INTRINSIC Vc_CONST enable_if<(I == 1), T0> extract_interleaved(const T0 &,
+                                                                  const Ts &...,
+                                                                  const T0 &b0,
+                                                                  const Ts &...)
+{
+    return b0;
+}
+/// \internal drops the first and center arguments and recurses
+template <std::size_t I, typename T0, typename... Ts>
+Vc_INTRINSIC Vc_CONST enable_if<(I > 1), T0> extract_interleaved(const T0 &,
+                                                                 const Ts &... a,
+                                                                 const T0 &,
+                                                                 const Ts &... b)
+{
+    return extract_interleaved<I - 2, Ts...>(a..., b...);
+}
+/// \internal calls simd_cast with correct argument order thanks to extract_interleaved
+template <typename Return, typename... Ts, std::size_t... Indexes>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast_interleaved_argument_order_1(index_sequence<Indexes...>, const Ts &... a,
+                                           const Ts &... b)
+{
+    return simd_cast<Return>(extract_interleaved<Indexes, Ts...>(a..., b...)...);
+}
+/// \internal constructs the necessary index_sequence to pass it to
+/// simd_cast_interleaved_argument_order_1
+template <typename Return, typename... Ts>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast_interleaved_argument_order(const Ts &... a, const Ts &... b)
+{
+    using seq = make_index_sequence<sizeof...(Ts)*2>;
+    return simd_cast_interleaved_argument_order_1<Return, Ts...>(seq(), a..., b...);
+}
+
+// conditional_assign {{{1
+#define Vc_CONDITIONAL_ASSIGN(name_, op_)                                                \
+    template <Operator O, typename T, std::size_t N, typename V, size_t VN, typename M,  \
+              typename U>                                                                \
+    Vc_INTRINSIC enable_if<O == Operator::name_, void> conditional_assign(               \
+        SimdArray<T, N, V, VN> &lhs, M &&mask, U &&rhs)                                  \
+    {                                                                                    \
+        lhs(mask) op_ rhs;                                                               \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(          Assign,  =);
+Vc_CONDITIONAL_ASSIGN(      PlusAssign, +=);
+Vc_CONDITIONAL_ASSIGN(     MinusAssign, -=);
+Vc_CONDITIONAL_ASSIGN(  MultiplyAssign, *=);
+Vc_CONDITIONAL_ASSIGN(    DivideAssign, /=);
+Vc_CONDITIONAL_ASSIGN( RemainderAssign, %=);
+Vc_CONDITIONAL_ASSIGN(       XorAssign, ^=);
+Vc_CONDITIONAL_ASSIGN(       AndAssign, &=);
+Vc_CONDITIONAL_ASSIGN(        OrAssign, |=);
+Vc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);
+Vc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);
+#undef Vc_CONDITIONAL_ASSIGN
+
+#define Vc_CONDITIONAL_ASSIGN(name_, expr_)                                              \
+    template <Operator O, typename T, std::size_t N, typename V, size_t VN, typename M>  \
+    Vc_INTRINSIC enable_if<O == Operator::name_, SimdArray<T, N, V, VN>>                 \
+    conditional_assign(SimdArray<T, N, V, VN> &lhs, M &&mask)                            \
+    {                                                                                    \
+        return expr_;                                                                    \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++);
+Vc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask));
+Vc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--);
+Vc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask));
+#undef Vc_CONDITIONAL_ASSIGN
+// transpose_impl {{{1
+namespace Common
+{
+template <typename T, size_t N, typename V>
+inline void transpose_impl(
+    TransposeTag<4, 4>, SimdArray<T, N, V, N> *Vc_RESTRICT r[],
+    const TransposeProxy<SimdArray<T, N, V, N>, SimdArray<T, N, V, N>,
+                         SimdArray<T, N, V, N>, SimdArray<T, N, V, N>> &proxy)
+{
+    V *Vc_RESTRICT r2[4] = {&internal_data(*r[0]), &internal_data(*r[1]),
+                            &internal_data(*r[2]), &internal_data(*r[3])};
+    transpose_impl(TransposeTag<4, 4>(), &r2[0],
+                   TransposeProxy<V, V, V, V>{internal_data(std::get<0>(proxy.in)),
+                                              internal_data(std::get<1>(proxy.in)),
+                                              internal_data(std::get<2>(proxy.in)),
+                                              internal_data(std::get<3>(proxy.in))});
+}
+
+template <typename T, typename V>
+inline void transpose_impl(
+    TransposeTag<2, 4>, SimdArray<T, 4, V, 1> *Vc_RESTRICT r[],
+    const TransposeProxy<SimdArray<T, 2, V, 1>, SimdArray<T, 2, V, 1>,
+                         SimdArray<T, 2, V, 1>, SimdArray<T, 2, V, 1>> &proxy)
+{
+    auto &lo = *r[0];
+    auto &hi = *r[1];
+    internal_data0(internal_data0(lo)) = internal_data0(std::get<0>(proxy.in));
+    internal_data1(internal_data0(lo)) = internal_data0(std::get<1>(proxy.in));
+    internal_data0(internal_data1(lo)) = internal_data0(std::get<2>(proxy.in));
+    internal_data1(internal_data1(lo)) = internal_data0(std::get<3>(proxy.in));
+    internal_data0(internal_data0(hi)) = internal_data1(std::get<0>(proxy.in));
+    internal_data1(internal_data0(hi)) = internal_data1(std::get<1>(proxy.in));
+    internal_data0(internal_data1(hi)) = internal_data1(std::get<2>(proxy.in));
+    internal_data1(internal_data1(hi)) = internal_data1(std::get<3>(proxy.in));
+}
+
+template <typename T, typename V>
+inline void transpose_impl(
+    TransposeTag<4, 4>, SimdArray<T, 1, V, 1> *Vc_RESTRICT r[],
+    const TransposeProxy<SimdArray<T, 1, V, 1>, SimdArray<T, 1, V, 1>,
+                         SimdArray<T, 1, V, 1>, SimdArray<T, 1, V, 1>> &proxy)
+{
+    V *Vc_RESTRICT r2[4] = {&internal_data(*r[0]), &internal_data(*r[1]),
+                            &internal_data(*r[2]), &internal_data(*r[3])};
+    transpose_impl(TransposeTag<4, 4>(), &r2[0],
+                   TransposeProxy<V, V, V, V>{internal_data(std::get<0>(proxy.in)),
+                                              internal_data(std::get<1>(proxy.in)),
+                                              internal_data(std::get<2>(proxy.in)),
+                                              internal_data(std::get<3>(proxy.in))});
+}
+
+template <typename T, size_t N, typename V>
+inline void transpose_impl(
+    TransposeTag<4, 4>, SimdArray<T, N, V, 1> *Vc_RESTRICT r[],
+    const TransposeProxy<SimdArray<T, N, V, 1>, SimdArray<T, N, V, 1>,
+                         SimdArray<T, N, V, 1>, SimdArray<T, N, V, 1>> &proxy)
+{
+    SimdArray<T, N, V, 1> *Vc_RESTRICT r0[4 / 2] = {r[0], r[1]};
+    SimdArray<T, N, V, 1> *Vc_RESTRICT r1[4 / 2] = {r[2], r[3]};
+    using H = SimdArray<T, 2>;
+    transpose_impl(TransposeTag<2, 4>(), &r0[0],
+                   TransposeProxy<H, H, H, H>{internal_data0(std::get<0>(proxy.in)),
+                                              internal_data0(std::get<1>(proxy.in)),
+                                              internal_data0(std::get<2>(proxy.in)),
+                                              internal_data0(std::get<3>(proxy.in))});
+    transpose_impl(TransposeTag<2, 4>(), &r1[0],
+                   TransposeProxy<H, H, H, H>{internal_data1(std::get<0>(proxy.in)),
+                                              internal_data1(std::get<1>(proxy.in)),
+                                              internal_data1(std::get<2>(proxy.in)),
+                                              internal_data1(std::get<3>(proxy.in))});
+}
+
+/* TODO:
+template <typename T, std::size_t N, typename V, std::size_t VSize>
+inline enable_if<(N > VSize), void> transpose_impl(
+    std::array<SimdArray<T, N, V, VSize> * Vc_RESTRICT, 4> & r,
+    const TransposeProxy<SimdArray<T, N, V, VSize>, SimdArray<T, N, V, VSize>,
+                         SimdArray<T, N, V, VSize>, SimdArray<T, N, V, VSize>> &proxy)
+{
+    typedef SimdArray<T, N, V, VSize> SA;
+    std::array<typename SA::storage_type0 * Vc_RESTRICT, 4> r0 = {
+        {&internal_data0(*r[0]), &internal_data0(*r[1]), &internal_data0(*r[2]),
+         &internal_data0(*r[3])}};
+    transpose_impl(
+        r0, TransposeProxy<typename SA::storage_type0, typename SA::storage_type0,
+                           typename SA::storage_type0, typename SA::storage_type0>{
+                internal_data0(std::get<0>(proxy.in)),
+                internal_data0(std::get<1>(proxy.in)),
+                internal_data0(std::get<2>(proxy.in)),
+                internal_data0(std::get<3>(proxy.in))});
+
+    std::array<typename SA::storage_type1 * Vc_RESTRICT, 4> r1 = {
+        {&internal_data1(*r[0]), &internal_data1(*r[1]), &internal_data1(*r[2]),
+         &internal_data1(*r[3])}};
+    transpose_impl(
+        r1, TransposeProxy<typename SA::storage_type1, typename SA::storage_type1,
+                           typename SA::storage_type1, typename SA::storage_type1>{
+                internal_data1(std::get<0>(proxy.in)),
+                internal_data1(std::get<1>(proxy.in)),
+                internal_data1(std::get<2>(proxy.in)),
+                internal_data1(std::get<3>(proxy.in))});
+}
+*/
+}  // namespace Common
+
+// Traits static assertions {{{1
+static_assert(Traits::has_no_allocated_data<const volatile Vc::SimdArray<int, 4> &>::value, "");
+static_assert(Traits::has_no_allocated_data<const volatile Vc::SimdArray<int, 4>>::value, "");
+static_assert(Traits::has_no_allocated_data<volatile Vc::SimdArray<int, 4> &>::value, "");
+static_assert(Traits::has_no_allocated_data<volatile Vc::SimdArray<int, 4>>::value, "");
+static_assert(Traits::has_no_allocated_data<const Vc::SimdArray<int, 4> &>::value, "");
+static_assert(Traits::has_no_allocated_data<const Vc::SimdArray<int, 4>>::value, "");
+static_assert(Traits::has_no_allocated_data<Vc::SimdArray<int, 4>>::value, "");
+static_assert(Traits::has_no_allocated_data<Vc::SimdArray<int, 4> &&>::value, "");
+// }}}1
+/// @}
+
+} // namespace Vc_VERSIONED_NAMESPACE
+
+// numeric_limits {{{1
+namespace std
+{
+template <typename T, size_t N, typename V, size_t VN>
+struct numeric_limits<Vc::SimdArray<T, N, V, VN>> : public numeric_limits<T> {
+private:
+    using R = Vc::SimdArray<T, N, V, VN>;
+
+public:
+    static Vc_ALWAYS_INLINE Vc_CONST R max() noexcept { return numeric_limits<T>::max(); }
+    static Vc_ALWAYS_INLINE Vc_CONST R min() noexcept { return numeric_limits<T>::min(); }
+    static Vc_ALWAYS_INLINE Vc_CONST R lowest() noexcept
+    {
+        return numeric_limits<T>::lowest();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R epsilon() noexcept
+    {
+        return numeric_limits<T>::epsilon();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R round_error() noexcept
+    {
+        return numeric_limits<T>::round_error();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R infinity() noexcept
+    {
+        return numeric_limits<T>::infinity();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R quiet_NaN() noexcept
+    {
+        return numeric_limits<T>::quiet_NaN();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R signaling_NaN() noexcept
+    {
+        return numeric_limits<T>::signaling_NaN();
+    }
+    static Vc_ALWAYS_INLINE Vc_CONST R denorm_min() noexcept
+    {
+        return numeric_limits<T>::denorm_min();
+    }
+};
+}  // namespace std
+//}}}1
+
+#endif // VC_COMMON_SIMDARRAY_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/simdarrayhelper.h vc-1.3.0/common/simdarrayhelper.h
--- vc-0.7.4/common/simdarrayhelper.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simdarrayhelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,563 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMDARRAYHELPER_H_
+#define VC_COMMON_SIMDARRAYHELPER_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+/// \addtogroup SimdArray
+/// @{
+
+namespace Operations/*{{{*/
+{
+struct tag {};
+#define Vc_DEFINE_OPERATION(name_)                                                       \
+    struct name_ : public tag {                                                          \
+        template <typename V, typename... Args>                                          \
+        Vc_INTRINSIC void operator()(V &v, Args &&... args)                              \
+        {                                                                                \
+            v.name_(std::forward<Args>(args)...);                                        \
+        }                                                                                \
+    }
+Vc_DEFINE_OPERATION(gather);
+Vc_DEFINE_OPERATION(scatter);
+Vc_DEFINE_OPERATION(load);
+Vc_DEFINE_OPERATION(store);
+Vc_DEFINE_OPERATION(setZero);
+Vc_DEFINE_OPERATION(setZeroInverted);
+Vc_DEFINE_OPERATION(assign);
+#undef Vc_DEFINE_OPERATION
+#define Vc_DEFINE_OPERATION(name_, code_)                                                \
+    struct name_ : public tag {                                                          \
+        template <typename V> Vc_INTRINSIC void operator()(V &v) { code_; }              \
+    }
+Vc_DEFINE_OPERATION(increment, ++(v));
+Vc_DEFINE_OPERATION(decrement, --(v));
+Vc_DEFINE_OPERATION(random, v = V::Random());
+#undef Vc_DEFINE_OPERATION
+#define Vc_DEFINE_OPERATION_FORWARD(name_)                                               \
+    struct Forward_##name_ : public tag                                                  \
+    {                                                                                    \
+        template <typename... Args, typename = decltype(name_(std::declval<Args>()...))> \
+        Vc_INTRINSIC void operator()(decltype(name_(std::declval<Args>()...)) &v,        \
+                                     Args &&... args)                                    \
+        {                                                                                \
+            v = name_(std::forward<Args>(args)...);                                      \
+        }                                                                                \
+        template <typename... Args, typename = decltype(name_(std::declval<Args>()...))> \
+        Vc_INTRINSIC void operator()(std::nullptr_t, Args && ... args)                   \
+        {                                                                                \
+            name_(std::forward<Args>(args)...);                                          \
+        }                                                                                \
+    }
+Vc_DEFINE_OPERATION_FORWARD(abs);
+Vc_DEFINE_OPERATION_FORWARD(asin);
+Vc_DEFINE_OPERATION_FORWARD(atan);
+Vc_DEFINE_OPERATION_FORWARD(atan2);
+Vc_DEFINE_OPERATION_FORWARD(cos);
+Vc_DEFINE_OPERATION_FORWARD(ceil);
+Vc_DEFINE_OPERATION_FORWARD(copysign);
+Vc_DEFINE_OPERATION_FORWARD(exp);
+Vc_DEFINE_OPERATION_FORWARD(exponent);
+Vc_DEFINE_OPERATION_FORWARD(fma);
+Vc_DEFINE_OPERATION_FORWARD(floor);
+Vc_DEFINE_OPERATION_FORWARD(frexp);
+Vc_DEFINE_OPERATION_FORWARD(isfinite);
+Vc_DEFINE_OPERATION_FORWARD(isinf);
+Vc_DEFINE_OPERATION_FORWARD(isnan);
+Vc_DEFINE_OPERATION_FORWARD(isnegative);
+Vc_DEFINE_OPERATION_FORWARD(ldexp);
+Vc_DEFINE_OPERATION_FORWARD(log);
+Vc_DEFINE_OPERATION_FORWARD(log10);
+Vc_DEFINE_OPERATION_FORWARD(log2);
+Vc_DEFINE_OPERATION_FORWARD(reciprocal);
+Vc_DEFINE_OPERATION_FORWARD(round);
+Vc_DEFINE_OPERATION_FORWARD(rsqrt);
+Vc_DEFINE_OPERATION_FORWARD(sin);
+Vc_DEFINE_OPERATION_FORWARD(sincos);
+Vc_DEFINE_OPERATION_FORWARD(sqrt);
+Vc_DEFINE_OPERATION_FORWARD(trunc);
+Vc_DEFINE_OPERATION_FORWARD(min);
+Vc_DEFINE_OPERATION_FORWARD(max);
+#undef Vc_DEFINE_OPERATION_FORWARD
+template<typename T> using is_operation = std::is_base_of<tag, T>;
+}  // namespace Operations }}}
+
+/**
+ * \internal
+ * Helper type to statically communicate segmentation of one vector register into 2^n parts
+ * (Pieces).
+ */
+template <typename T_, std::size_t Pieces_, std::size_t Index_> struct Segment/*{{{*/
+{
+    static_assert(Index_ < Pieces_, "You found a bug in Vc. Please report.");
+
+    using type = T_;
+    using type_decayed = typename std::decay<type>::type;
+    static constexpr std::size_t Pieces = Pieces_;
+    static constexpr std::size_t Index = Index_;
+    using simd_array_type = SimdArray<
+        typename std::conditional<Traits::is_simd_vector<type_decayed>::value,
+                                  typename type_decayed::EntryType, float>::type,
+        type_decayed::Size / Pieces>;
+
+    type data;
+
+    static constexpr std::size_t EntryOffset = Index * type_decayed::Size / Pieces;
+
+    // no non-const operator[] needed (and problematic because of non-movable ElementReference)
+    decltype(std::declval<const type &>()[0]) operator[](size_t i) const { return data[i + EntryOffset]; }
+
+    simd_array_type asSimdArray() const
+    {
+        return simd_cast<simd_array_type, Index>(data);
+    }
+};/*}}}*/
+
+//Segment<T *, ...> specialization {{{
+template <typename T_, std::size_t Pieces_, std::size_t Index_>
+struct Segment<T_ *, Pieces_, Index_> {
+    static_assert(Index_ < Pieces_, "You found a bug in Vc. Please report.");
+
+    using type = T_ *;
+    using type_decayed = typename std::decay<T_>::type;
+    static constexpr size_t Pieces = Pieces_;
+    static constexpr size_t Index = Index_;
+    using simd_array_type = SimdArray<
+        typename std::conditional<Traits::is_simd_vector<type_decayed>::value,
+                                  typename type_decayed::VectorEntryType, float>::type,
+        type_decayed::Size / Pieces> *;
+
+    type data;
+
+    static constexpr std::size_t EntryOffset = Index * type_decayed::size() / Pieces;
+
+    simd_array_type asSimdArray() const
+    {
+        return reinterpret_cast<
+#ifdef Vc_GCC
+                   // GCC might ICE if this type is declared with may_alias. If it doesn't
+                   // ICE it warns about ignoring the attribute.
+                   typename std::remove_pointer<simd_array_type>::type
+#else
+                   MayAlias<typename std::remove_pointer<simd_array_type>::type>
+#endif
+                       *>(data) +
+               Index;
+    }
+
+    //decltype(std::declval<type>()[0]) operator[](size_t i) { return data[i + EntryOffset]; }
+    //decltype(std::declval<type>()[0]) operator[](size_t i) const { return data[i + EntryOffset]; }
+};/*}}}*/
+
+/** \internal
+  Template class that is used to attach an offset value to an existing type. It is used
+  for IndexesFromZero construction in SimdArray. The \c data1 constructor needs to know
+  that the IndexesFromZero constructor requires an offset so that the whole data is
+  constructed as a correct sequence from `0` to `Size - 1`.
+
+  \tparam T The original type that needs the offset attached.
+  \tparam Offset An integral value that determines the offset in the complete SimdArray.
+ */
+template <typename T, std::size_t Offset> struct AddOffset
+{
+    constexpr AddOffset() = default;
+};
+
+// class Split {{{1
+/** \internal
+  Helper type with static functions to generically adjust arguments for the \c data0 and
+  \c data1 members of SimdArray and SimdMaskArray.
+
+  \tparam secondOffset The offset in number of elements that \c data1 has in the SimdArray
+                       / SimdMaskArray. This is essentially equal to the number of
+                       elements in \c data0.
+ */
+template <std::size_t secondOffset> class Split
+{
+    static Vc_INTRINSIC AddOffset<VectorSpecialInitializerIndexesFromZero, secondOffset>
+        hiImpl(VectorSpecialInitializerIndexesFromZero)
+    {
+        return {};
+    }
+    template <std::size_t Offset>
+    static Vc_INTRINSIC
+        AddOffset<VectorSpecialInitializerIndexesFromZero, Offset + secondOffset>
+            hiImpl(AddOffset<VectorSpecialInitializerIndexesFromZero, Offset>)
+    {
+        return {};
+    }
+
+    // split composite SimdArray
+    template <typename U, std::size_t N, typename V, std::size_t M,
+              typename = enable_if<N != M>>
+    static Vc_INTRINSIC auto loImpl(const SimdArray<U, N, V, M> &x)
+        -> decltype(internal_data0(x))
+    {
+        return internal_data0(x);
+    }
+    template <typename U, std::size_t N, typename V, std::size_t M,
+              typename = enable_if<N != M>>
+    static Vc_INTRINSIC auto hiImpl(const SimdArray<U, N, V, M> &x)
+        -> decltype(internal_data1(x))
+    {
+        return internal_data1(x);
+    }
+    template <typename U, std::size_t N, typename V, std::size_t M,
+              typename = enable_if<N != M>>
+    static Vc_INTRINSIC auto loImpl(SimdArray<U, N, V, M> *x)
+        -> decltype(&internal_data0(*x))
+    {
+        return &internal_data0(*x);
+    }
+    template <typename U, std::size_t N, typename V, std::size_t M,
+              typename = enable_if<N != M>>
+    static Vc_INTRINSIC auto hiImpl(SimdArray<U, N, V, M> *x)
+        -> decltype(&internal_data1(*x))
+    {
+        return &internal_data1(*x);
+    }
+
+    // split atomic SimdArray
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<V, 2, 0> loImpl(const SimdArray<U, N, V, N> &x)
+    {
+        return {internal_data(x)};
+    }
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<V, 2, 1> hiImpl(const SimdArray<U, N, V, N> &x)
+    {
+        return {internal_data(x)};
+    }
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<V *, 2, 0> loImpl(SimdArray<U, N, V, N> *x)
+    {
+        return {&internal_data(*x)};
+    }
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<V *, 2, 1> hiImpl(SimdArray<U, N, V, N> *x)
+    {
+        return {&internal_data(*x)};
+    }
+
+    // split composite SimdMaskArray
+    template <typename U, std::size_t N, typename V, std::size_t M>
+    static Vc_INTRINSIC auto loImpl(const SimdMaskArray<U, N, V, M> &x) -> decltype(internal_data0(x))
+    {
+        return internal_data0(x);
+    }
+    template <typename U, std::size_t N, typename V, std::size_t M>
+    static Vc_INTRINSIC auto hiImpl(const SimdMaskArray<U, N, V, M> &x) -> decltype(internal_data1(x))
+    {
+        return internal_data1(x);
+    }
+
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<typename SimdMaskArray<U, N, V, N>::mask_type, 2, 0> loImpl(
+        const SimdMaskArray<U, N, V, N> &x)
+    {
+        return {internal_data(x)};
+    }
+    template <typename U, std::size_t N, typename V>
+    static Vc_INTRINSIC Segment<typename SimdMaskArray<U, N, V, N>::mask_type, 2, 1> hiImpl(
+        const SimdMaskArray<U, N, V, N> &x)
+    {
+        return {internal_data(x)};
+    }
+
+    // split Vector<T> and Mask<T>
+    template <typename T>
+    static constexpr bool is_vector_or_mask(){
+        return (Traits::is_simd_vector<T>::value && !Traits::isSimdArray<T>::value) ||
+               (Traits::is_simd_mask<T>::value && !Traits::isSimdMaskArray<T>::value);
+    }
+    template <typename V>
+    static Vc_INTRINSIC Segment<V, 2, 0> loImpl(V &&x, enable_if<is_vector_or_mask<V>()> = nullarg)
+    {
+        return {std::forward<V>(x)};
+    }
+    template <typename V>
+    static Vc_INTRINSIC Segment<V, 2, 1> hiImpl(V &&x, enable_if<is_vector_or_mask<V>()> = nullarg)
+    {
+        return {std::forward<V>(x)};
+    }
+
+    // generically split Segments
+    template <typename V, std::size_t Pieces, std::size_t Index>
+    static Vc_INTRINSIC Segment<V, 2 * Pieces, 2 * Index> loImpl(
+        const Segment<V, Pieces, Index> &x)
+    {
+        return {x.data};
+    }
+    template <typename V, std::size_t Pieces, std::size_t Index>
+    static Vc_INTRINSIC Segment<V, 2 * Pieces, 2 * Index + 1> hiImpl(
+        const Segment<V, Pieces, Index> &x)
+    {
+        return {x.data};
+    }
+
+    /** \internal
+     * \name Checks for existence of \c loImpl / \c hiImpl
+     */
+    //@{
+    template <typename T, typename = decltype(loImpl(std::declval<T>()))>
+    static std::true_type have_lo_impl(int);
+    template <typename T> static std::false_type have_lo_impl(float);
+    template <typename T> static constexpr bool have_lo_impl()
+    {
+        return decltype(have_lo_impl<T>(1))::value;
+    }
+
+    template <typename T, typename = decltype(hiImpl(std::declval<T>()))>
+    static std::true_type have_hi_impl(int);
+    template <typename T> static std::false_type have_hi_impl(float);
+    template <typename T> static constexpr bool have_hi_impl()
+    {
+        return decltype(have_hi_impl<T>(1))::value;
+    }
+    //@}
+
+public:
+    /** \internal
+     * \name with Operations tag
+     *
+     * These functions don't overload on the data parameter. The first parameter (the tag) clearly
+     * identifies the intended function.
+     */
+    //@{
+    template <typename U>
+    static Vc_INTRINSIC const U *lo(Operations::gather, const U *ptr)
+    {
+        return ptr;
+    }
+    template <typename U>
+    static Vc_INTRINSIC const U *hi(Operations::gather, const U *ptr)
+    {
+        return ptr + secondOffset;
+    }
+    template <typename U, typename = enable_if<!std::is_pointer<U>::value>>
+    static Vc_ALWAYS_INLINE decltype(loImpl(std::declval<U>()))
+        lo(Operations::gather, U &&x)
+    {
+        return loImpl(std::forward<U>(x));
+    }
+    template <typename U, typename = enable_if<!std::is_pointer<U>::value>>
+    static Vc_ALWAYS_INLINE decltype(hiImpl(std::declval<U>()))
+        hi(Operations::gather, U &&x)
+    {
+        return hiImpl(std::forward<U>(x));
+    }
+    template <typename U>
+    static Vc_INTRINSIC const U *lo(Operations::scatter, const U *ptr)
+    {
+        return ptr;
+    }
+    template <typename U>
+    static Vc_INTRINSIC const U *hi(Operations::scatter, const U *ptr)
+    {
+        return ptr + secondOffset;
+    }
+    //@}
+
+    /** \internal
+      \name without Operations tag
+
+      These functions are not clearly tagged as to where they are used and therefore
+      behave differently depending on the type of the parameter. Different behavior is
+      implemented via overloads of \c loImpl and \c hiImpl. They are not overloads of \c
+      lo and \c hi directly because it's hard to compete against a universal reference
+      (i.e. an overload for `int` requires overloads for `int &`, `const int &`, and `int
+      &&`. If one of them were missing `U &&` would win in overload resolution).
+     */
+    //@{
+    template <typename U>
+    static Vc_ALWAYS_INLINE decltype(loImpl(std::declval<U>())) lo(U &&x)
+    {
+        return loImpl(std::forward<U>(x));
+    }
+    template <typename U>
+    static Vc_ALWAYS_INLINE decltype(hiImpl(std::declval<U>())) hi(U &&x)
+    {
+        return hiImpl(std::forward<U>(x));
+    }
+
+    template <typename U>
+    static Vc_ALWAYS_INLINE enable_if<!have_lo_impl<U>(), U> lo(U &&x)
+    {
+        return std::forward<U>(x);
+    }
+    template <typename U>
+    static Vc_ALWAYS_INLINE enable_if<!have_hi_impl<U>(), U> hi(U &&x)
+    {
+        return std::forward<U>(x);
+    }
+    //@}
+};
+
+// actual_value {{{1
+template <typename Op, typename U, std::size_t M, typename V>
+static Vc_INTRINSIC const V &actual_value(Op, const SimdArray<U, M, V, M> &x)
+{
+  return internal_data(x);
+}
+template <typename Op, typename U, std::size_t M, typename V>
+static Vc_INTRINSIC V *actual_value(Op, SimdArray<U, M, V, M> *x)
+{
+  return &internal_data(*x);
+}
+template <typename Op, typename T, size_t Pieces, size_t Index>
+static Vc_INTRINSIC typename Segment<T, Pieces, Index>::simd_array_type actual_value(
+    Op, Segment<T, Pieces, Index> &&seg)
+{
+    return seg.asSimdArray();
+}
+
+template <typename Op, typename U, std::size_t M, typename V>
+static Vc_INTRINSIC const typename V::Mask &actual_value(Op, const SimdMaskArray<U, M, V, M> &x)
+{
+  return internal_data(x);
+}
+template <typename Op, typename U, std::size_t M, typename V>
+static Vc_INTRINSIC typename V::Mask *actual_value(Op, SimdMaskArray<U, M, V, M> *x)
+{
+  return &internal_data(*x);
+}
+
+// unpackArgumentsAuto {{{1
+/**\internal
+ * \name unpackArgumentsAuto
+ *
+ * Search for the right amount of SimdArray "unpacking" (via actual_value) to match the
+ * interface of the function to be called.
+ *
+ * The compiler can figure this out for us thanks to SFINAE. The approach is to have a
+ * number \c I that determines the indexes of the arguments to be transformed via
+ * actual_value.  Each bit of \c I identifies an argument. unpackArgumentsAuto starts the
+ * recursion with `I = 0`, i.e. no actual_value transformations. If the overload calling
+ * \c op is unavailable due to a substitution failure \c I is incremented and the function
+ * recurses. Otherwise there are two unpackArgumentsAutoImpl functions in the overload
+ * set. The first argument (\c int / \c float) leads to a preference of the function
+ * calling \c op, thus ending the recursion.
+ */
+///@{
+
+///\internal transforms \p arg via actual_value
+template <typename Op, typename Arg>
+Vc_INTRINSIC decltype(actual_value(std::declval<Op &>(), std::declval<Arg>()))
+conditionalUnpack(std::true_type, Op op, Arg &&arg)
+{
+    return actual_value(op, std::forward<Arg>(arg));
+}
+///\internal forwards \p arg to its return value
+template <typename Op, typename Arg>
+Vc_INTRINSIC Arg conditionalUnpack(std::false_type, Op, Arg &&arg)
+{
+    return std::forward<Arg>(arg);
+}
+
+///\internal true-/false_type that selects whether the argument with index B should be unpacked
+template <size_t A, size_t B>
+struct selectorType : public std::integral_constant<bool, !((A & (size_t(1) << B)) != 0)> {
+};
+
+///\internal ends the recursion, transforms arguments, and calls \p op
+template <size_t I, typename Op, typename R, typename... Args, size_t... Indexes>
+Vc_INTRINSIC decltype(std::declval<Op &>()(std::declval<R &>(),
+                                           conditionalUnpack(selectorType<I, Indexes>(),
+                                                             std::declval<Op &>(),
+                                                             std::declval<Args>())...))
+unpackArgumentsAutoImpl(int, index_sequence<Indexes...>, Op op, R &&r, Args &&... args)
+{
+    op(std::forward<R>(r),
+       conditionalUnpack(selectorType<I, Indexes>(), op, std::forward<Args>(args))...);
+}
+
+///\internal the current actual_value calls don't work: recurse to I + 1
+template <size_t I, typename Op, typename R, typename... Args, size_t... Indexes>
+Vc_INTRINSIC enable_if<(I <= (size_t(1) << sizeof...(Args))), void> unpackArgumentsAutoImpl(
+    float, index_sequence<Indexes...> is, Op op, R &&r, Args &&... args)
+{
+    // if R is nullptr_t then the return type cannot enforce that actually any unwrapping
+    // of the SimdArray types happens. Thus, you could get an endless loop of the
+    // SimdArray function overload calling itself, if the index goes up to (1 <<
+    // sizeof...(Args)) - 1 (which means no argument transformations via actual_value).
+    static_assert(
+        I < (1 << sizeof...(Args)) - (std::is_same<R, std::nullptr_t>::value ? 1 : 0),
+        "Vc or compiler bug. Please report. Failed to find a combination of "
+        "actual_value(arg) transformations that allows calling Op.");
+    unpackArgumentsAutoImpl<I + 1, Op, R, Args...>(int(), is, op, std::forward<R>(r),
+                                                   std::forward<Args>(args)...);
+}
+
+#ifdef Vc_ICC
+template <size_t, typename... Ts> struct IccWorkaround {
+    using type = void;
+};
+template <typename... Ts> struct IccWorkaround<2, Ts...> {
+    using type = typename std::remove_pointer<typename std::decay<
+        typename std::tuple_element<1, std::tuple<Ts...>>::type>::type>::type;
+};
+#endif
+
+///\internal The interface to start the machinery.
+template <typename Op, typename R, typename... Args>
+Vc_INTRINSIC void unpackArgumentsAuto(Op op, R &&r, Args &&... args)
+{
+#ifdef Vc_ICC
+    // ugly hacky workaround for ICC:
+    // The compiler fails to do SFINAE right on recursion. We have to hit the right
+    // recursionStart number from the start.
+    const int recursionStart =
+        Traits::isSimdArray<
+            typename IccWorkaround<sizeof...(Args), Args...>::type>::value &&
+                (std::is_same<Op, Common::Operations::Forward_frexp>::value ||
+                 std::is_same<Op, Common::Operations::Forward_ldexp>::value)
+            ? 2
+            : 0;
+#else
+    const int recursionStart = 0;
+#endif
+    unpackArgumentsAutoImpl<recursionStart>(
+        int(), make_index_sequence<sizeof...(Args)>(), op, std::forward<R>(r),
+        std::forward<Args>(args)...);
+}
+///@}
+
+//}}}1
+///@}
+}  // namespace Common
+}  // namespace Vc
+
+#endif  // VC_COMMON_SIMDARRAYHELPER_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/simd_cast_caller.tcc vc-1.3.0/common/simd_cast_caller.tcc
--- vc-0.7.4/common/simd_cast_caller.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simd_cast_caller.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,85 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMD_CAST_CALLER_TCC_
+#define VC_COMMON_SIMD_CAST_CALLER_TCC_
+
+#include "macros.h"
+namespace Vc_VERSIONED_NAMESPACE {
+
+template <typename T, std::size_t N, typename VectorType>
+template <typename U, typename V>
+Vc_INTRINSIC SimdMaskArray<T, N, VectorType, N>::SimdMaskArray(
+    const SimdMaskArray<U, N, V> &x,
+    enable_if<N == V::Size>)
+    : data(simd_cast<mask_type>(internal_data(x)))
+{
+}
+template <typename T, std::size_t N, typename VectorType>
+template <typename U, typename V>
+Vc_INTRINSIC SimdMaskArray<T, N, VectorType, N>::SimdMaskArray(
+    const SimdMaskArray<U, N, V> &x,
+    enable_if<(N > V::Size && N <= 2 * V::Size)>)
+    : data(simd_cast<mask_type>(internal_data(internal_data0(x)), internal_data(internal_data1(x))))
+{
+}
+template <typename T, std::size_t N, typename VectorType>
+template <typename U, typename V>
+Vc_INTRINSIC SimdMaskArray<T, N, VectorType, N>::SimdMaskArray(
+    const SimdMaskArray<U, N, V> &x,
+    enable_if<(N > 2 * V::Size && N <= 4 * V::Size)>)
+    : data(simd_cast<mask_type>(internal_data(internal_data0(internal_data0(x))),
+                                internal_data(internal_data1(internal_data0(x))),
+                                internal_data(internal_data0(internal_data1(x))),
+                                internal_data(internal_data1(internal_data1(x)))))
+{
+}
+// conversion from any Segment object (could be SimdMaskArray or Mask<T>)
+template <typename T, std::size_t N, typename VectorType>
+template <typename M, std::size_t Pieces, std::size_t Index>
+Vc_INTRINSIC SimdMaskArray<T, N, VectorType, N>::SimdMaskArray(
+    Common::Segment<M, Pieces, Index> &&x,
+    enable_if<Traits::simd_vector_size<M>::value == Size * Pieces>)
+    : data(simd_cast<mask_type, Index>(x.data))
+{
+}
+// conversion from Mask<T>
+template <typename T, std::size_t N, typename VectorType>
+template <typename M>
+Vc_INTRINSIC SimdMaskArray<T, N, VectorType, N>::SimdMaskArray(
+    M k,
+    enable_if<(Traits::is_simd_mask<M>::value && !Traits::isSimdMaskArray<M>::value &&
+               Traits::simd_vector_size<M>::value == Size)>)
+    : data(simd_cast<mask_type>(k))
+{
+}
+
+}
+
+#endif  // VC_COMMON_SIMD_CAST_CALLER_TCC_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/simd_cast.h vc-1.3.0/common/simd_cast.h
--- vc-0.7.4/common/simd_cast.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simd_cast.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,68 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMD_CAST_H_
+#define VC_COMMON_SIMD_CAST_H_
+
+#include <type_traits>
+#include "macros.h"
+
+// declare a bogus simd_cast function template in the global namespace to enable ADL for
+// simd_cast<T>
+template <class> void simd_cast();
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * Casts the argument \p x from type \p From to type \p To.
+ *
+ * This function implements the trivial case where \p To and \p From are the same type.
+ *
+ * \param x The object of type \p From to be converted to type \p To.
+ * \returns An object of type \p To with all vector components converted according to
+ *          standard conversion behavior as mandated by the C++ standard for the
+ *          underlying arithmetic types.
+ */
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(From &&x, enable_if<std::is_same<To, Traits::decay<From>>::value> = nullarg)
+{
+    return std::forward<From>(x);
+}
+
+/**
+ * A cast from nothing results in default-initialization of \p To.
+ *
+ * This function can be useful in generic code where a parameter pack expands to nothing.
+ *
+ * \returns A zero-initialized object of type \p To.
+ */
+template <typename To> Vc_INTRINSIC Vc_CONST To simd_cast() { return To(); }
+
+}  // namespace Vc
+
+#endif // VC_COMMON_SIMD_CAST_H_
diff -Nru vc-0.7.4/common/simdize.h vc-1.3.0/common/simdize.h
--- vc-0.7.4/common/simdize.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simdize.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,1809 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMDIZE_H_
+#define VC_COMMON_SIMDIZE_H_
+
+#include <tuple>
+#include <array>
+
+#include "macros.h"
+
+/*!
+\addtogroup Simdize
+
+Automatic type vectorization.
+
+The simdize<T> expression transforms the type \c T to a vectorized variant. This requires the type
+\c T to be a class template instance.
+
+Example:
+First, we declare a class template for a three-dimensional point. The template parameter \c T
+determines the type of the members and is \c float in the scalar (classical) case.
+\code
+template <typename T> struct PointTemplate
+{
+  T x, y, z;
+
+  // Declares tuple_size and makes the members accessible via get<N>(point), allowing
+  // the simdize implementation to convert between Point and PointV (see below).
+  Vc_SIMDIZE_INTERFACE((x, y, z));
+
+  PointTemplate(T xx, T yy, T zz) : x{xx}, y{yy}, z{zz} {};
+
+  // The following function will automatically be vectorized in the PointV type.
+  T distance_to_origin() const { return std::sqrt(x * x + y * y + z * z); }
+};
+\endcode
+
+In the following we create a type alias for the scalar type, which simply means instantiating
+\c PointTemplate with \c float. The resulting type can then be transformed with \ref simdize.
+\code
+using Point  = PointTemplate<float>;  // A simple struct with three floats and two functions.
+using PointV = Vc::simdize<Point>;    // The vectorization of Point stores three float_v and thus
+                                      // float_v::size() Points.
+\endcode
+
+The following shows a code example using the above \c Point and \c PointV types.
+\code
+PointV pv = Point{0.f, 1.f, 2.f};  // Constructs a PointV containing PointV::size()
+                                   // copies of Point{0, 1, 2}.
+for (int i = 1; i < int(pv.size()); ++i) {
+  assign(pv, i, {i + 0.f, i + 1.f, i + 2.f});
+}
+
+const Vc::float_v l = pv.distance_to_origin();
+std::cout << l << '\n';
+// prints [2.23607, 3.74166, 5.38516, 7.07107, 8.77496, 10.4881, 12.2066, 13.9284] with
+// float_v::size() == 8
+
+const Point most_distant = extract(pv, (l.max() == l).firstOne());
+std::cout << '(' << most_distant.x << ", " << most_distant.y << ", " << most_distant.z << ")\n";
+// prints (7, 8, 9) with float_v::size() == 8
+\endcode
+ */
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**\internal
+ * \ingroup Simdize
+ * This namespace contains all the required code for implementing simdize<T>. None of this
+ * code should be directly accessed by users, though the unit test for simdize<T>
+ * certainly may look into some of the details if necessary.
+ */
+namespace SimdizeDetail
+{
+/**
+ * \addtogroup Simdize
+ * @{
+ */
+using std::is_same;
+using std::is_base_of;
+using std::false_type;
+using std::true_type;
+using std::iterator_traits;
+using std::conditional;
+using std::size_t;
+template <bool B, typename T, typename F>
+using conditional_t = typename conditional<B, T, F>::type;
+
+/**\internal
+ * Typelist is a simple helper class for supporting multiple parameter packs in one class
+ * template.
+ */
+template <typename... Ts> struct Typelist;
+
+/**\internal
+ * The Category identifies how the type argument to simdize<T> has to be transformed.
+ */
+enum class Category {
+    ///\internal No transformation
+    None,
+    ///\internal simple Vector<T> transformation
+    ArithmeticVectorizable,
+    ///\internal transform an input iterator to return vectorized entries
+    InputIterator,
+    ///\internal transform a forward iterator to return vectorized entries
+    OutputIterator,
+    ///\internal transform an output iterator to return vectorized entries
+    ForwardIterator,
+    ///\internal transform a bidirectional iterator to return vectorized entries
+    BidirectionalIterator,
+    ///\internal transform a random access iterator to return vectorized entries
+    RandomAccessIterator,
+    ///\internal transform a class template recursively
+    ClassTemplate
+};
+
+/**\internal
+ * iteratorCategories<T>(int()) returns whether iterator_traits<T>::iterator_category is a
+ * valid type and whether it is derived from RandomAccessIterator or ForwardIterator.
+ */
+template <typename T, typename ItCat = typename T::iterator_category>
+constexpr Category iteratorCategories(int, ItCat * = nullptr)
+{
+    return is_base_of<std::random_access_iterator_tag, ItCat>::value
+               ? Category::RandomAccessIterator
+               : is_base_of<std::bidirectional_iterator_tag, ItCat>::value
+                     ? Category::BidirectionalIterator
+                     : is_base_of<std::forward_iterator_tag, ItCat>::value
+                           ? Category::ForwardIterator
+                           : is_base_of<std::output_iterator_tag, ItCat>::value
+                                 ? Category::OutputIterator
+                                 : is_base_of<std::input_iterator_tag, ItCat>::value
+                                       ? Category::InputIterator
+                                       : Category::None;
+}
+/**\internal
+ * This overload is selected for pointer types => RandomAccessIterator.
+ */
+template <typename T>
+constexpr enable_if<std::is_pointer<T>::value, Category> iteratorCategories(float)
+{
+    return Category::RandomAccessIterator;
+}
+/**\internal
+ * This overload is selected if T does not work with iterator_traits.
+ */
+template <typename T> constexpr Category iteratorCategories(...)
+{
+    return Category::None;
+}
+
+/**\internal
+ * Simple trait to identify whether a type T is a class template or not.
+ */
+template <typename T> struct is_class_template : public false_type
+{
+};
+template <template <typename...> class C, typename... Ts>
+struct is_class_template<C<Ts...>> : public true_type
+{
+};
+
+/**\internal
+ * Returns the Category for the given type \p T.
+ */
+template <typename T> constexpr Category typeCategory()
+{
+    return (is_same<T, bool>::value || is_same<T, short>::value ||
+            is_same<T, unsigned short>::value || is_same<T, int>::value ||
+            is_same<T, unsigned int>::value || is_same<T, float>::value ||
+            is_same<T, double>::value)
+               ? Category::ArithmeticVectorizable
+               : iteratorCategories<T>(int()) != Category::None
+                     ? iteratorCategories<T>(int())
+                     : is_class_template<T>::value ? Category::ClassTemplate
+                                                   : Category::None;
+}
+
+/**\internal
+ * Trait determining the number of data members that get<N>(x) can access.
+ * The type \p T either has to provide a std::tuple_size specialization or contain a
+ * constexpr tuple_size member.
+ */
+template <typename T, size_t TupleSize = std::tuple_size<T>::value>
+constexpr size_t determine_tuple_size()
+{
+    return TupleSize;
+}
+template <typename T, size_t TupleSize = T::tuple_size>
+constexpr size_t determine_tuple_size(size_t = T::tuple_size)
+{
+    return TupleSize;
+}
+
+// workaround for MSVC limitation: constexpr functions in template arguments
+// confuse the compiler
+template <typename T> struct determine_tuple_size_
+: public std::integral_constant<size_t, determine_tuple_size<T>()>
+{};
+
+namespace
+{
+template <typename T> struct The_simdization_for_the_requested_type_is_not_implemented;
+}  // unnamed namespace
+
+/**\internal
+ * The type behind the simdize expression whose member type \c type determines the
+ * transformed type.
+ *
+ * \tparam T The type to be transformed.
+ * \tparam N The width the resulting vectorized type should have. A value of 0 lets the
+ *           implementation choose the width.
+ * \tparam MT The base type to use for mask types. If set to \c void the implementation
+ *            chooses the type itself.
+ * \tparam Category The type category of \p T. This determines the implementation strategy
+ *                  (via template specialization).
+ */
+template <typename T, size_t N, typename MT, Category = typeCategory<T>()>
+struct ReplaceTypes : public The_simdization_for_the_requested_type_is_not_implemented<T>
+{
+};
+
+/**\internal
+ * Specialization of ReplaceTypes that is used for types that should not be transformed by
+ * simdize.
+ */
+template <typename T, size_t N, typename MT> struct ReplaceTypes<T, N, MT, Category::None>
+{
+    typedef T type;
+};
+
+/**\internal
+ * The ReplaceTypes class template is nicer to use as an alias template. This is exported
+ * to the outer Vc namespace.
+ */
+template <typename T, size_t N = 0, typename MT = void>
+using simdize = typename SimdizeDetail::ReplaceTypes<T, N, MT>::type;
+
+/**\internal
+ * ReplaceTypes specialization for simdizable arithmetic types. This results in either
+ * Vector<T> or SimdArray<T, N>.
+ */
+template <typename T, size_t N, typename MT>
+struct ReplaceTypes<T, N, MT, Category::ArithmeticVectorizable>
+    : public conditional<(N == 0 || Vector<T>::Size == N), Vector<T>, SimdArray<T, N>>
+{
+};
+
+/**\internal
+ * ReplaceTypes specialization for bool. This results either in Mask<MT> or
+ * SimdMaskArray<MT, N>.
+ */
+template <size_t N, typename MT>
+struct ReplaceTypes<bool, N, MT, Category::ArithmeticVectorizable>
+    : public conditional<(N == 0 || Mask<MT>::Size == N), Mask<MT>,
+                         SimdMaskArray<MT, N>>
+{
+};
+/**\internal
+ * ReplaceTypes specialization for bool and MT = void. In that case MT is set to float.
+ */
+template <size_t N>
+struct ReplaceTypes<bool, N, void, Category::ArithmeticVectorizable>
+    : public ReplaceTypes<bool, N, float, Category::ArithmeticVectorizable>
+{
+};
+
+/**\internal
+ * This type substitutes the first type (\p T) in \p Remaining via simdize<T, N, MT> and
+ * appends it to the Typelist in \p Replaced. If \p N = 0, the first simdize expression
+ * that yields a vectorized type determines \p N for the subsequent SubstituteOneByOne
+ * instances.
+ */
+template <size_t N, typename MT, typename Replaced, typename... Remaining>
+struct SubstituteOneByOne;
+
+/**\internal
+ * Template specialization for the case that there is at least one type in \p Remaining.
+ * The member type \p type recurses via SubstituteOneByOne.
+ */
+template <size_t N, typename MT, typename... Replaced, typename T,
+          typename... Remaining>
+struct SubstituteOneByOne<N, MT, Typelist<Replaced...>, T, Remaining...>
+{
+private:
+    /**\internal
+     * If \p U::size() yields a constant expression convertible to size_t then value will
+     * be equal to U::size(), 0 otherwise.
+     */
+    template <typename U, size_t M = U::Size>
+    static std::integral_constant<size_t, M> size_or_0(int);
+    template <typename U> static std::integral_constant<size_t, 0> size_or_0(...);
+
+    ///\internal The vectorized type for \p T.
+    using V = simdize<T, N, MT>;
+
+    /**\internal
+     * Determine the new \p N to use for the SubstituteOneByOne expression below. If N is
+     * non-zero that value is used. Otherwise size_or_0<V> determines the new value.
+     */
+    static constexpr auto NewN = N != 0 ? N : decltype(size_or_0<V>(int()))::value;
+
+    /**\internal
+     * Determine the new \p MT type to use for the SubstituteOneByOne expression below.
+     * This is normally the old \p MT type. However, if N != NewN and MT = void, NewMT is
+     * set to either \c float or \p T, depending on whether \p T is \c bool or not.
+     */
+    typedef conditional_t<(N != NewN && is_same<MT, void>::value),
+                          conditional_t<is_same<T, bool>::value, float, T>, MT> NewMT;
+
+public:
+    /**\internal
+     * An alias to the type member of the completed recursion over SubstituteOneByOne.
+     */
+    using type = typename SubstituteOneByOne<NewN, NewMT, Typelist<Replaced..., V>,
+                                             Remaining...>::type;
+};
+
+///\internal Generates the SubstitutedWithValues member. This needs specialization for the
+/// number of types in the template argument list.
+template <size_t Size, typename... Replaced> struct SubstitutedBase;
+///\internal Specialization for one type parameter.
+template <typename Replaced> struct SubstitutedBase<1, Replaced> {
+    template <typename ValueT, template <typename, ValueT...> class C, ValueT... Values>
+    using SubstitutedWithValues = C<Replaced, Values...>;
+};
+///\internal Specialization for two type parameters.
+template <typename R0, typename R1> struct SubstitutedBase<2, R0, R1>
+{
+    template <typename ValueT, template <typename, typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<R0, R1, Values...>;
+};
+///\internal Specialization for three type parameters.
+template <typename R0, typename R1, typename R2> struct SubstitutedBase<3, R0, R1, R2>
+{
+    template <typename ValueT, template <typename, typename, typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<R0, R1, R2, Values...>;
+};
+#if defined Vc_ICC || defined Vc_MSVC
+#define Vc_VALUE_PACK_EXPANSION_IS_BROKEN 1
+#endif
+///\internal Specialization for four type parameters.
+template <typename... Replaced> struct SubstitutedBase<4, Replaced...> {
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+    template <typename ValueT,
+              template <typename, typename, typename, typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<Replaced..., Values...>;
+#endif // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+};
+///\internal Specialization for five type parameters.
+template <typename... Replaced> struct SubstitutedBase<5, Replaced...> {
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+    template <typename ValueT, template <typename, typename, typename, typename, typename,
+                                         ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<Replaced..., Values...>;
+#endif // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+};
+///\internal Specialization for six type parameters.
+template <typename... Replaced> struct SubstitutedBase<6, Replaced...> {
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+    template <typename ValueT, template <typename, typename, typename, typename, typename,
+                                         typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<Replaced..., Values...>;
+#endif // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+};
+///\internal Specialization for seven type parameters.
+template <typename... Replaced> struct SubstitutedBase<7, Replaced...> {
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+    template <typename ValueT, template <typename, typename, typename, typename, typename,
+                                         typename, typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<Replaced..., Values...>;
+#endif // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+};
+///\internal Specialization for eight type parameters.
+template <typename... Replaced> struct SubstitutedBase<8, Replaced...> {
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+    template <typename ValueT, template <typename, typename, typename, typename, typename,
+                                         typename, typename, typename, ValueT...> class C,
+              ValueT... Values>
+    using SubstitutedWithValues = C<Replaced..., Values...>;
+#endif // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+};
+
+/**\internal
+ * Template specialization that ends the recursion and determines the return type \p type.
+ * The end of the recursion is identified by an empty typelist (i.e. no template
+ * parameters) after the Typelist parameter.
+ */
+template <size_t N_, typename MT, typename Replaced0, typename... Replaced>
+struct SubstituteOneByOne<N_, MT, Typelist<Replaced0, Replaced...>>
+{
+    /**\internal
+     * Return type for returning the vector width and list of substituted types
+     */
+    struct type
+        : public SubstitutedBase<sizeof...(Replaced) + 1, Replaced0, Replaced...> {
+        static constexpr auto N = N_;
+        /**\internal
+         * Alias template to construct a class template instantiation with the replaced
+         * types.
+         */
+        template <template <typename...> class C>
+        using Substituted = C<Replaced0, Replaced...>;
+    };
+};
+
+/**\internal
+ * Vectorized class templates are not substituted directly by ReplaceTypes/simdize.
+ * Instead the replaced type is used as a base class for an adapter type which enables
+ * the addition of extra operations. Specifically the following features are added:
+ * \li a constexpr \p size() function, which returns the width of the vectorization. Note
+ *     that this may hide a \p size() member in the original class template (e.g. for STL
+ *     container classes).
+ * \li The member type \p base_type is an alias for the vectorized (i.e. substituted)
+ *     class template
+ * \li The member type \p scalar_type is an alias for the class template argument
+ *     originally passed to the \ref simdize expression.
+ *
+ * \tparam Scalar
+ * \tparam Base
+ * \tparam N
+ */
+template <typename Scalar, typename Base, size_t N> class Adapter;
+
+/**\internal
+ * Specialization of ReplaceTypes for class templates (\p C) where each template argument
+ * needs to be substituted via SubstituteOneByOne.
+ */
+template <template <typename...> class C, typename... Ts, size_t N, typename MT>
+struct ReplaceTypes<C<Ts...>, N, MT, Category::ClassTemplate>
+{
+    ///\internal The \p type member of the SubstituteOneByOne instantiation
+    using SubstitutionResult =
+        typename SubstituteOneByOne<N, MT, Typelist<>, Ts...>::type;
+    /**\internal
+     * This expression instantiates the class template \p C with the substituted template
+     * arguments in the \p Ts parameter pack. The alias \p Vectorized thus is the
+     * vectorized equivalent to \p C<Ts...>.
+     */
+    using Vectorized = typename SubstitutionResult::template Substituted<C>;
+    /**\internal
+     * The result type of this ReplaceTypes instantiation is set to \p C<Ts...> if no
+     * template parameter substitution was done in SubstituteOneByOne. Otherwise, the type
+     * aliases an Adapter instantiation.
+     */
+    using type = conditional_t<is_same<C<Ts...>, Vectorized>::value, C<Ts...>,
+                               Adapter<C<Ts...>, Vectorized, SubstitutionResult::N>>;
+};
+
+/**\internal
+ * Specialization of the ReplaceTypes class template allowing transformation of class
+ * templates with non-type parameters. This is impossible to express with variadic
+ * templates and therefore requires a lot of code duplication.
+ */
+#ifdef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+// ICC barfs on packs of values
+#define Vc_DEFINE_NONTYPE_REPLACETYPES_(ValueType_)                                      \
+    template <template <typename, ValueType_...> class C, typename T, ValueType_ Value0, \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T, Value0, Values...>> : public true_type {               \
+    };                                                                                   \
+    template <template <typename, typename, ValueType_...> class C, typename T0,         \
+              typename T1, ValueType_ Value0, ValueType_... Values>                      \
+    struct is_class_template<C<T0, T1, Value0, Values...>> : public true_type {          \
+    };                                                                                   \
+    template <template <typename, typename, typename, ValueType_...> class C,            \
+              typename T0, typename T1, typename T2, ValueType_ Value0,                  \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T0, T1, T2, Value0, Values...>> : public true_type {      \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, ValueType_...> class C,  \
+              typename T0, typename T1, typename T2, typename T3, ValueType_ Value0,     \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T0, T1, T2, T3, Value0, Values...>> : public true_type {  \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, ValueType_...> \
+              class C,                                                                   \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              ValueType_ Value0, ValueType_... Values>                                   \
+    struct is_class_template<C<T0, T1, T2, T3, T4, Value0, Values...>>                   \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, typename,      \
+                        ValueType_...> class C,                                          \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              typename T5, ValueType_ Value0, ValueType_... Values>                      \
+    struct is_class_template<C<T0, T1, T2, T3, T4, T5, Value0, Values...>>               \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, typename,      \
+                        typename, ValueType_...> class C,                                \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              typename T5, typename T6, ValueType_ Value0, ValueType_... Values>         \
+    struct is_class_template<C<T0, T1, T2, T3, T4, T5, T6, Value0, Values...>>           \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, ValueType_> class C, typename T0, ValueType_ Value0,   \
+              size_t N, typename MT>                                                     \
+    struct ReplaceTypes<C<T0, Value0>, N, MT, Category::ClassTemplate> {                 \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0>::type tmp;            \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0>      \
+            Substituted;                                                                 \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<is_same<C<T0, Value0>, Substituted>::value, C<T0, Value0>, \
+                              Adapter<C<T0, Value0>, Substituted, NN>> type;             \
+    };                                                                                   \
+    template <template <typename, typename, ValueType_> class C, typename T0,            \
+              typename T1, ValueType_ Value0, size_t N, typename MT>                     \
+    struct ReplaceTypes<C<T0, T1, Value0>, N, MT, Category::ClassTemplate> {             \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0, T1>::type tmp;        \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0>      \
+            Substituted;                                                                 \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<is_same<C<T0, T1, Value0>, Substituted>::value,            \
+                              C<T0, T1, Value0>,                                         \
+                              Adapter<C<T0, T1, Value0>, Substituted, NN>> type;         \
+    };                                                                                   \
+    template <template <typename, typename, typename, ValueType_> class C, typename T0,  \
+              typename T1, typename T2, ValueType_ Value0, size_t N, typename MT>        \
+    struct ReplaceTypes<C<T0, T1, T2, Value0>, N, MT, Category::ClassTemplate> {         \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0, T1, T2>::type tmp;    \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0>      \
+            Substituted;                                                                 \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<is_same<C<T0, T1, T2, Value0>, Substituted>::value,        \
+                              C<T0, T1, T2, Value0>,                                     \
+                              Adapter<C<T0, T1, T2, Value0>, Substituted, NN>> type;     \
+    }
+#else
+#define Vc_DEFINE_NONTYPE_REPLACETYPES_(ValueType_)                                      \
+    template <template <typename, ValueType_...> class C, typename T, ValueType_ Value0, \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T, Value0, Values...>> : public true_type {               \
+    };                                                                                   \
+    template <template <typename, typename, ValueType_...> class C, typename T0,         \
+              typename T1, ValueType_ Value0, ValueType_... Values>                      \
+    struct is_class_template<C<T0, T1, Value0, Values...>> : public true_type {          \
+    };                                                                                   \
+    template <template <typename, typename, typename, ValueType_...> class C,            \
+              typename T0, typename T1, typename T2, ValueType_ Value0,                  \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T0, T1, T2, Value0, Values...>> : public true_type {      \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, ValueType_...> class C,  \
+              typename T0, typename T1, typename T2, typename T3, ValueType_ Value0,     \
+              ValueType_... Values>                                                      \
+    struct is_class_template<C<T0, T1, T2, T3, Value0, Values...>> : public true_type {  \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, ValueType_...> \
+              class C,                                                                   \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              ValueType_ Value0, ValueType_... Values>                                   \
+    struct is_class_template<C<T0, T1, T2, T3, T4, Value0, Values...>>                   \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, typename,      \
+                        ValueType_...> class C,                                          \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              typename T5, ValueType_ Value0, ValueType_... Values>                      \
+    struct is_class_template<C<T0, T1, T2, T3, T4, T5, Value0, Values...>>               \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, typename, typename, typename, typename, typename,      \
+                        typename, ValueType_...> class C,                                \
+              typename T0, typename T1, typename T2, typename T3, typename T4,           \
+              typename T5, typename T6, ValueType_ Value0, ValueType_... Values>         \
+    struct is_class_template<C<T0, T1, T2, T3, T4, T5, T6, Value0, Values...>>           \
+        : public true_type {                                                             \
+    };                                                                                   \
+    template <template <typename, ValueType_...> class C, typename T0,                   \
+              ValueType_ Value0, ValueType_... Values, size_t N, typename MT>            \
+    struct ReplaceTypes<C<T0, Value0, Values...>, N, MT, Category::ClassTemplate> {      \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0>::type tmp;            \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0,      \
+                                                             Values...> Substituted;     \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<is_same<C<T0, Value0, Values...>, Substituted>::value,     \
+                              C<T0, Value0, Values...>,                                  \
+                              Adapter<C<T0, Value0, Values...>, Substituted, NN>> type;  \
+    };                                                                                   \
+    template <template <typename, typename, ValueType_...> class C, typename T0,         \
+              typename T1, ValueType_ Value0, ValueType_... Values, size_t N,            \
+              typename MT>                                                               \
+    struct ReplaceTypes<C<T0, T1, Value0, Values...>, N, MT, Category::ClassTemplate> {  \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0, T1>::type tmp;        \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0,      \
+                                                             Values...> Substituted;     \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<is_same<C<T0, T1, Value0, Values...>, Substituted>::value, \
+                              C<T0, T1, Value0, Values...>,                              \
+                              Adapter<C<T0, T1, Value0, Values...>, Substituted, NN>>    \
+            type;                                                                        \
+    };                                                                                   \
+    template <template <typename, typename, typename, ValueType_...> class C,            \
+              typename T0, typename T1, typename T2, ValueType_ Value0,                  \
+              ValueType_... Values, size_t N, typename MT>                               \
+    struct ReplaceTypes<C<T0, T1, T2, Value0, Values...>, N, MT,                         \
+                        Category::ClassTemplate> {                                       \
+        typedef typename SubstituteOneByOne<N, MT, Typelist<>, T0, T1, T2>::type tmp;    \
+        typedef typename tmp::template SubstitutedWithValues<ValueType_, C, Value0,      \
+                                                             Values...> Substituted;     \
+        static constexpr auto NN = tmp::N;                                               \
+        typedef conditional_t<                                                           \
+            is_same<C<T0, T1, T2, Value0, Values...>, Substituted>::value,               \
+            C<T0, T1, T2, Value0, Values...>,                                            \
+            Adapter<C<T0, T1, T2, Value0, Values...>, Substituted, NN>> type;            \
+    }
+#endif  // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+Vc_DEFINE_NONTYPE_REPLACETYPES_(bool);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(wchar_t);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(char);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(  signed char);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(unsigned char);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(  signed short);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(unsigned short);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(  signed int);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(unsigned int);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(  signed long);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(unsigned long);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(  signed long long);
+Vc_DEFINE_NONTYPE_REPLACETYPES_(unsigned long long);
+#undef Vc_DEFINE_NONTYPE_REPLACETYPES_
+
+namespace is_constructible_with_single_paren_impl
+{
+template <typename T> T create();
+#if defined Vc_CLANG || defined Vc_APPLECLANG
+template <typename Class, typename... Args, typename = decltype(Class(create<Args>()...))>
+char test(int);
+#else
+template <typename Class, typename... Args>
+typename std::conditional<
+#ifndef Vc_ICC
+    0 !=
+#endif
+        sizeof(Class(create<Args>()...)),
+    char, char>::type
+test(int);
+#endif
+template <typename Class, typename... Args> double test(...);
+}  // namespace is_constructible_with_single_paren_impl
+
+template <typename Class, typename... Args>
+struct is_constructible_with_single_paren
+    : public std::integral_constant<
+          bool,
+          1 == sizeof(is_constructible_with_single_paren_impl::test<Class, Args...>(1))> {
+};
+static_assert(
+    !is_constructible_with_single_paren<int, std::tuple<int, int, int>>::value,
+    "is_constructible_with_single_paren<int> does not work as expected");
+static_assert(
+    is_constructible_with_single_paren<std::tuple<int, int, int>, int, int, int>::value,
+    "is_constructible_with_single_paren<tuple> does not work as expected");
+static_assert(
+    !is_constructible_with_single_paren<std::array<int, 3>, int, int, int>::value,
+    "is_constructible_with_single_paren<array> does not work as expected");
+
+namespace is_constructible_with_single_brace_impl
+{
+template <typename T> T create();
+#ifdef Vc_ICC
+template <typename Class, typename... Args> char test(int);
+#elif defined Vc_CLANG || defined Vc_APPLECLANG
+template <typename Class, typename... Args, typename = decltype(Class{create<Args>()...})>
+char test(int);
+#else
+template <typename Class, typename... Args>
+typename std::conditional<
+#ifndef Vc_ICC
+    0 !=
+#endif
+        sizeof(Class{create<Args>()...}),
+    char, char>::type
+test(int);
+#endif
+template <typename Class, typename... Args> double test(...);
+}  // namespace is_constructible_with_single_brace_impl
+
+template <typename Class, typename... Args>
+struct is_constructible_with_single_brace
+    : public std::integral_constant<
+          bool,
+          1 == sizeof(is_constructible_with_single_brace_impl::test<Class, Args...>(1))> {
+};
+#ifndef Vc_ICC
+static_assert(
+    !is_constructible_with_single_brace<int, std::tuple<int, int, int>>::value,
+    "is_constructible_with_single_brace<int> does not work as expected");
+#endif
+static_assert(
+    is_constructible_with_single_brace<std::tuple<int, int, int>, int, int, int>::value,
+    "is_constructible_with_single_brace<tuple> does not work as expected");
+static_assert(
+    is_constructible_with_single_brace<std::array<int, 3>, int, int, int>::value,
+    "is_constructible_with_single_brace<array> does not work as expected");
+
+namespace is_constructible_with_double_brace_impl
+{
+template <typename T> T create();
+#if defined Vc_CLANG || defined Vc_APPLECLANG
+template <typename Class, typename... Args,
+          typename = decltype(Class{{create<Args>()...}})>
+char test(int);
+#else
+template <typename Class, typename... Args>
+typename std::conditional<
+#ifndef Vc_ICC
+    0 !=
+#endif
+        sizeof(Class{{create<Args>()...}}),
+    char, char>::type
+test(int);
+#endif
+template <typename Class, typename... Args> double test(...);
+}  // namespace is_constructible_with_double_brace_impl
+
+template <typename Class, typename... Args>
+struct is_constructible_with_double_brace
+    : public std::integral_constant<
+          bool,
+          1 == sizeof(is_constructible_with_double_brace_impl::test<Class, Args...>(1))> {
+};
+#if !(defined Vc_CLANG || defined Vc_APPLECLANG)
+// clang allows int{{1}} but warns that it's wrong. Thus the assertion fails. If I expect
+// the incorrect answer from clang, the assertion won't fail, but the compiler warns about
+// the trait invocation. Annoying feature...
+static_assert(
+    !is_constructible_with_double_brace<int, int>::value,
+    "is_constructible_with_double_brace<int> does not work as expected");
+#endif
+static_assert(
+    !is_constructible_with_double_brace<std::tuple<int, int, int>, int, int, int>::value,
+    "is_constructible_with_double_brace<tuple> does not work as expected");
+static_assert(is_constructible_with_double_brace<std::array<int, 3>, int, int, int>::value,
+              "is_constructible_with_double_brace<array> does not work as expected");
+
+template <size_t I, typename T,
+          typename R = decltype(std::declval<T &>().template vc_get_<I>())>
+R get_dispatcher(T &x, void * = nullptr)
+{
+    return x.template vc_get_<I>();
+}
+template <size_t I, typename T,
+          typename R = decltype(std::declval<const T &>().template vc_get_<I>())>
+R get_dispatcher(const T &x, void * = nullptr)
+{
+    return x.template vc_get_<I>();
+}
+template <size_t I, typename T, typename R = decltype(std::get<I>(std::declval<T &>()))>
+R get_dispatcher(T &x, int = 0)
+{
+    return std::get<I>(x);
+}
+template <size_t I, typename T,
+          typename R = decltype(std::get<I>(std::declval<const T &>()))>
+R get_dispatcher(const T &x, int = 0)
+{
+    return std::get<I>(x);
+}
+
+
+// see above
+template <typename Scalar, typename Base, size_t N> class Adapter : public Base
+{
+private:
+    /// helper for the broadcast ctor below using double braces for Base initialization
+    template <std::size_t... Indexes, typename T>
+    Adapter(Vc::index_sequence<Indexes...>, const Scalar &x_, T, std::true_type)
+        : Base{{get_dispatcher<Indexes>(x_)...}}
+    {
+    }
+
+    /// helper for the broadcast ctor below using single braces for Base initialization
+    template <std::size_t... Indexes>
+    Adapter(Vc::index_sequence<Indexes...>, const Scalar &x_, std::false_type,
+            std::false_type)
+        : Base{get_dispatcher<Indexes>(x_)...}
+    {
+    }
+
+    /// helper for the broadcast ctor below using parenthesis for Base initialization
+    template <std::size_t... Indexes>
+    Adapter(Vc::index_sequence<Indexes...>, const Scalar &x_, std::true_type,
+            std::false_type)
+        : Base(get_dispatcher<Indexes>(x_)...)
+    {
+    }
+
+    template <std::size_t... Indexes>
+    Adapter(Vc::index_sequence<Indexes...> seq_, const Scalar &x_)
+        : Adapter(seq_, x_,
+                  std::integral_constant<
+                      bool, is_constructible_with_single_paren<
+                                Base, decltype(get_dispatcher<Indexes>(
+                                          std::declval<const Scalar &>()))...>::value>(),
+                  std::integral_constant<
+                      bool, is_constructible_with_double_brace<
+                                Base, decltype(get_dispatcher<Indexes>(
+                                          std::declval<const Scalar &>()))...>::value>())
+    {
+    }
+
+public:
+    /// The SIMD vector width of the members.
+    static constexpr size_t size() { return N; }
+    static constexpr size_t Size = N;
+
+    /// The vectorized base class template instantiation this Adapter class derives from.
+    using base_type = Base;
+    /// The original non-vectorized class template instantiation that was passed to the
+    /// simdize expression.
+    using scalar_type = Scalar;
+
+    /// Allow default construction. This is automatically ill-formed if Base() is
+    /// ill-formed.
+    Adapter() = default;
+
+    /// Defaulted copy and move construction and assignment
+#if defined Vc_CLANG && Vc_CLANG < 0x30700
+    Vc_INTRINSIC Adapter(const Adapter &x) : Base(x) {}
+#else
+    Adapter(const Adapter &) = default;
+#endif
+    /// Defaulted copy and move construction and assignment
+    Adapter(Adapter &&) = default;
+    /// Defaulted copy and move construction and assignment
+    Adapter &operator=(const Adapter &) = default;
+    /// Defaulted copy and move construction and assignment
+    Adapter &operator=(Adapter &&) = default;
+
+    /// Broadcast constructor
+    template <typename U, size_t TupleSize = determine_tuple_size_<Scalar>::value,
+              typename Seq = Vc::make_index_sequence<TupleSize>,
+              typename = enable_if<std::is_convertible<U, Scalar>::value>>
+    Adapter(U &&x_)
+        : Adapter(Seq(), static_cast<const Scalar &>(x_))
+    {
+    }
+
+    /// perfect forward all Base constructors
+    template <typename A0, typename... Args,
+              typename = typename std::enable_if<
+                  !Traits::is_index_sequence<A0>::value &&
+                  (sizeof...(Args) > 0 || !std::is_convertible<A0, Scalar>::value)>::type>
+    Adapter(A0 &&arg0_, Args &&... arguments_)
+        : Base(std::forward<A0>(arg0_), std::forward<Args>(arguments_)...)
+    {
+    }
+
+    /// perfect forward Base constructors that accept an initializer_list
+    template <typename T,
+              typename = decltype(Base(std::declval<const std::initializer_list<T> &>()))>
+    Adapter(const std::initializer_list<T> &l_)
+        : Base(l_)
+    {
+    }
+
+    /// Overload the new operator to adhere to the alignment requirements which C++11
+    /// ignores by default.
+    void *operator new(size_t size)
+    {
+        return Vc::Common::aligned_malloc<alignof(Adapter)>(size);
+    }
+    void *operator new(size_t, void *p_) { return p_; }
+    void *operator new[](size_t size)
+    {
+        return Vc::Common::aligned_malloc<alignof(Adapter)>(size);
+    }
+    void *operator new[](size_t , void *p_) { return p_; }
+    void operator delete(void *ptr_, size_t) { Vc::Common::free(ptr_); }
+    void operator delete(void *, void *) {}
+    void operator delete[](void *ptr_, size_t) { Vc::Common::free(ptr_); }
+    void operator delete[](void *, void *) {}
+};
+
+/**\internal
+ * Delete compare operators for simdize<tuple<...>> types because the tuple compares
+ * require the compares to be bool based.
+ */
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator==(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator!=(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator<=(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator>=(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator<(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+template <class... TTypes, class... TTypesV, class... UTypes, class... UTypesV, size_t N>
+inline void operator>(
+    const Adapter<std::tuple<TTypes...>, std::tuple<TTypesV...>, N> &t,
+    const Adapter<std::tuple<UTypes...>, std::tuple<UTypesV...>, N> &u) = delete;
+
+/** @}*/
+}  // namespace SimdizeDetail
+}  // namespace Vc
+
+namespace std
+{
+/**\internal
+ * A std::tuple_size specialization for the SimdizeDetail::Adapter class.
+ */
+template <typename Scalar, typename Base, size_t N>
+class tuple_size<Vc::SimdizeDetail::Adapter<Scalar, Base, N>> : public tuple_size<Base>
+{
+};
+/**\internal
+ * A std::tuple_element specialization for the SimdizeDetail::Adapter class.
+ */
+template <size_t I, typename Scalar, typename Base, size_t N>
+class tuple_element<I, Vc::SimdizeDetail::Adapter<Scalar, Base, N>>
+    : public tuple_element<I, Base>
+{
+};
+// std::get does not need additional work because Vc::Adapter derives from
+// C<Ts...> and therefore if get<N>(C<Ts...>) works it works for Adapter as well.
+
+/**\internal
+ * A std::allocator specialization for SimdizeDetail::Adapter which uses the Vc::Allocator
+ * class to make allocation correctly aligned per default.
+ */
+template <typename S, typename T, size_t N>
+class allocator<Vc::SimdizeDetail::Adapter<S, T, N>>
+    : public Vc::Allocator<Vc::SimdizeDetail::Adapter<S, T, N>>
+{
+public:
+    template <typename U> struct rebind
+    {
+        typedef std::allocator<U> other;
+    };
+};
+}  // namespace std
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace SimdizeDetail
+{
+/**\addtogroup Simdize
+ * @{
+ */
+/**\internal
+ * Since std::decay can ICE GCC (with types that are declared as may_alias), this is used
+ * as an alternative approach. Using decltype the template type deduction implements the
+ * std::decay behavior.
+ */
+template <typename T> static inline T decay_workaround(const T &x) { return x; }
+
+/**\internal
+ * Generic implementation of assign using the std::tuple get interface.
+ */
+template <typename S, typename T, size_t N, size_t... Indexes>
+inline void assign_impl(Adapter<S, T, N> &a, size_t i, const S &x,
+                        Vc::index_sequence<Indexes...>)
+{
+    const std::tuple<decltype(decay_workaround(get_dispatcher<Indexes>(x)))...> tmp(
+        decay_workaround(get_dispatcher<Indexes>(x))...);
+    auto &&unused = {(get_dispatcher<Indexes>(a)[i] = get_dispatcher<Indexes>(tmp), 0)...};
+    if (&unused == &unused) {}
+}
+
+/**
+ * Assigns one scalar object \p x to a SIMD slot at offset \p i in the simdized object \p
+ * a.
+ */
+template <typename S, typename T, size_t N>
+inline void assign(Adapter<S, T, N> &a, size_t i, const S &x)
+{
+    assign_impl(a, i, x, Vc::make_index_sequence<determine_tuple_size<T>()>());
+}
+/**\internal
+ * Overload for standard Vector/SimdArray types.
+ */
+template <typename V, typename = enable_if<Traits::is_simd_vector<V>::value>>
+Vc_INTRINSIC void assign(V &v, size_t i, typename V::EntryType x)
+{
+    v[i] = x;
+}
+
+/**\internal
+ * index_sequence based implementation for extract below.
+ */
+template <typename S, typename T, size_t N, size_t... Indexes>
+inline S extract_impl(const Adapter<S, T, N> &a, size_t i, Vc::index_sequence<Indexes...>)
+{
+    const std::tuple<decltype(decay_workaround(get_dispatcher<Indexes>(a)[i]))...> tmp(
+        decay_workaround(get_dispatcher<Indexes>(a)[i])...);
+    return S(get_dispatcher<Indexes>(tmp)...);
+}
+
+/**
+ * Extracts and returns one scalar object from a SIMD slot at offset \p i in the simdized
+ * object \p a.
+ */
+template <typename S, typename T, size_t N>
+inline S extract(const Adapter<S, T, N> &a, size_t i)
+{
+    return extract_impl(a, i, Vc::make_index_sequence<determine_tuple_size<S>()>());
+}
+/**\internal
+ * Overload for standard Vector/SimdArray types.
+ */
+template <typename V, typename = enable_if<Traits::is_simd_vector<V>::value>>
+Vc_INTRINSIC typename V::EntryType extract(const V &v, size_t i)
+{
+    return v[i];
+}
+
+template <typename S, typename T, std::size_t N, std::size_t... Indexes>
+inline Adapter<S, T, N> shifted_impl(const Adapter<S, T, N> &a, int shift,
+                                     Vc::index_sequence<Indexes...>)
+{
+    Adapter<S, T, N> r;
+    auto &&unused = {(get_dispatcher<Indexes>(r) = get_dispatcher<Indexes>(a).shifted(shift), 0)...};
+    if (&unused == &unused) {}
+    return r;
+}
+
+/**
+ * Returns a new vectorized object where each entry is shifted by \p shift. This basically
+ * calls Vector<T>::shifted on every entry.
+ *
+ * \param a The object to apply the shift on.
+ * \param shift The number of entries to shift by.
+ * \returns a copy of \p a shifted by \p shift.
+ */
+template <typename S, typename T, size_t N>
+inline Adapter<S, T, N> shifted(const Adapter<S, T, N> &a, int shift)
+{
+    return shifted_impl(a, shift, Vc::make_index_sequence<determine_tuple_size<T>()>());
+}
+
+/** \internal
+ * Generic implementation of simdize_swap using the std::tuple get interface.
+ */
+template <typename S, typename T, std::size_t N, std::size_t... Indexes>
+inline void swap_impl(Adapter<S, T, N> &a, std::size_t i, S &x,
+                      Vc::index_sequence<Indexes...>)
+{
+    const auto &a_const = a;
+    const std::tuple<decltype(decay_workaround(get_dispatcher<Indexes>(a_const)[0]))...>
+        tmp{decay_workaround(get_dispatcher<Indexes>(a_const)[i])...};
+    auto &&unused = {(get_dispatcher<Indexes>(a)[i] = get_dispatcher<Indexes>(x), 0)...};
+    auto &&unused2 = {(get_dispatcher<Indexes>(x) = get_dispatcher<Indexes>(tmp), 0)...};
+    if (&unused == &unused2) {}
+}
+template <typename S, typename T, std::size_t N, std::size_t... Indexes>
+inline void swap_impl(Adapter<S, T, N> &a, std::size_t i, Adapter<S, T, N> &b,
+                      std::size_t j, Vc::index_sequence<Indexes...>)
+{
+    const auto &a_const = a;
+    const auto &b_const = b;
+    const std::tuple<decltype(decay_workaround(get_dispatcher<Indexes>(a_const)[0]))...>
+        tmp{decay_workaround(get_dispatcher<Indexes>(a_const)[i])...};
+    auto &&unused = {(get_dispatcher<Indexes>(a)[i] = get_dispatcher<Indexes>(b_const)[j], 0)...};
+    auto &&unused2 = {(get_dispatcher<Indexes>(b)[j] = get_dispatcher<Indexes>(tmp), 0)...};
+    if (&unused == &unused2) {}
+}
+
+/**
+ * Swaps one scalar object \p x with a SIMD slot at offset \p i in the simdized object \p
+ * a.
+ */
+template <typename S, typename T, std::size_t N>
+inline void swap(Adapter<S, T, N> &a, std::size_t i, S &x)
+{
+    swap_impl(a, i, x, Vc::make_index_sequence<determine_tuple_size<T>()>());
+}
+template <typename S, typename T, std::size_t N>
+inline void swap(Adapter<S, T, N> &a, std::size_t i, Adapter<S, T, N> &b, std::size_t j)
+{
+    swap_impl(a, i, b, j, Vc::make_index_sequence<determine_tuple_size<T>()>());
+}
+
+template <typename A> class Scalar
+{
+    using reference = typename std::add_lvalue_reference<A>::type;
+    using S = typename A::scalar_type;
+    using IndexSeq = Vc::make_index_sequence<determine_tuple_size<S>()>;
+
+public:
+    Scalar(reference aa, size_t ii) : a(aa), i(ii) {}
+
+    // delete copy and move to keep the type a pure proxy temporary object.
+    Scalar(const Scalar &) = delete;
+    Scalar(Scalar &&) = delete;
+    Scalar &operator=(const Scalar &) = delete;
+    Scalar &operator=(Scalar &&) = delete;
+
+    void operator=(const S &x) { assign_impl(a, i, x, IndexSeq()); }
+    operator S() const { return extract_impl(a, i, IndexSeq()); }
+
+    template <typename AA>
+    friend inline void swap(Scalar<AA> &&a, typename AA::scalar_type &b);
+    template <typename AA>
+    friend inline void swap(typename AA::scalar_type &b, Scalar<AA> &&a);
+    template <typename AA> friend inline void swap(Scalar<AA> &&a, Scalar<AA> &&b);
+
+private:
+    reference a;
+    size_t i;
+};
+
+/// std::swap interface to swapping one scalar object with a (virtual) reference to
+/// another object inside a vectorized object
+template <typename A> inline void swap(Scalar<A> &&a, typename A::scalar_type &b)
+{
+    swap_impl(a.a, a.i, b, typename Scalar<A>::IndexSeq());
+}
+/// std::swap interface to swapping one scalar object with a (virtual) reference to
+/// another object inside a vectorized object
+template <typename A> inline void swap(typename A::scalar_type &b, Scalar<A> &&a)
+{
+    swap_impl(a.a, a.i, b, typename Scalar<A>::IndexSeq());
+}
+
+template <typename A> inline void swap(Scalar<A> &&a, Scalar<A> &&b)
+{
+    swap_impl(a.a, a.i, b.a, b.i, typename Scalar<A>::IndexSeq());
+}
+
+template <typename A> class Interface
+{
+    using reference = typename std::add_lvalue_reference<A>::type;
+    using IndexSeq =
+        Vc::make_index_sequence<determine_tuple_size<typename A::scalar_type>()>;
+
+public:
+    Interface(reference aa) : a(aa) {}
+
+    Scalar<A> operator[](size_t i)
+    {
+        return {a, i};
+    }
+    typename A::scalar_type operator[](size_t i) const
+    {
+        return extract_impl(a, i, IndexSeq());
+    }
+
+    A shifted(int amount) const
+    {
+        return shifted_impl(a, amount, IndexSeq());
+    }
+
+private:
+    reference a;
+};
+
+template <typename S, typename T, size_t N>
+Interface<Adapter<S, T, N>> decorate(Adapter<S, T, N> &a)
+{
+    return {a};
+}
+template <typename S, typename T, size_t N>
+const Interface<const Adapter<S, T, N>> decorate(const Adapter<S, T, N> &a)
+{
+    return {a};
+}
+
+namespace IteratorDetails
+{
+enum class Mutable { Yes, No };
+
+template <typename It, typename V, size_t I, size_t End>
+Vc_INTRINSIC V fromIteratorImpl(enable_if<(I == End), It>)
+{
+    return {};
+}
+template <typename It, typename V, size_t I, size_t End>
+Vc_INTRINSIC V fromIteratorImpl(enable_if<(I < End), It> it)
+{
+    V r = fromIteratorImpl<It, V, I + 1, End>(it);
+    Traits::decay<decltype(get_dispatcher<I>(r))> tmp;
+    for (size_t j = 0; j < V::size(); ++j, ++it) {
+        tmp[j] = get_dispatcher<I>(*it);
+    }
+    get_dispatcher<I>(r) = tmp;
+    return r;
+}
+template <typename It, typename V>
+Vc_INTRINSIC V fromIterator(enable_if<!Traits::is_simd_vector<V>::value, const It &> it)
+{
+    return fromIteratorImpl<It, V, 0, determine_tuple_size<V>()>(it);
+}
+template <typename It, typename V>
+Vc_INTRINSIC V fromIterator(enable_if<Traits::is_simd_vector<V>::value, It> it)
+{
+    V r;
+    for (size_t j = 0; j < V::size(); ++j, ++it) {
+        r[j] = *it;
+    }
+    return r;
+}
+
+// Note: §13.5.6 says: “An expression x->m is interpreted as (x.operator->())->m for a
+// class object x of type T if T::operator->() exists and if the operator is selected as
+// the best match function by the overload resolution mechanism (13.3).”
+template <typename T, typename value_vector, Mutable> class Pointer;
+
+/**\internal
+ * Proxy type for a pointer returned from operator->(). The mutable variant requires at
+ * least a ForwardIterator. An InputIterator cannot work since no valid copies and
+ * independent iteration can be guaranteed.
+ *
+ * The implementation creates the pointer-like behavior by creating an lvalue for the
+ * proxied data. This
+ */
+template <typename T, typename value_vector> class Pointer<T, value_vector, Mutable::Yes>
+{
+    static constexpr auto Size = value_vector::size();
+
+public:
+    /// \returns a pointer to the (temporary) member object.
+    value_vector *operator->() { return &data; }
+
+    /**
+     * A Pointer can only be constructed from a scalar iterator or move constructed (for
+     * function returns).
+     */
+    Pointer() = delete;
+    Pointer(const Pointer &) = delete;
+    Pointer &operator=(const Pointer &) = delete;
+    Pointer &operator=(Pointer &&) = delete;
+
+    /// required for returning the Pointer
+    Pointer(Pointer &&) = default;
+
+    /**
+     * Writes the vectorized object back to the scalar objects referenced by the
+     * iterator. This store is done unconditionally for the mutable variant of the
+     * Pointer. The immutable Pointer OTOH does not store back at all.
+     */
+    ~Pointer()
+    {
+        // store data back to where it came from
+        for (size_t i = 0; i < Size; ++i, ++begin_iterator) {
+            *begin_iterator = extract(data, i);
+        }
+    }
+
+    /// Construct the Pointer object from the values returned by the scalar iterator \p it.
+    Pointer(const T &it) : data(fromIterator<T, value_vector>(it)), begin_iterator(it) {}
+
+private:
+    /// The vectorized object needed for dereferencing the pointer.
+    value_vector data;
+    /// A copy of the scalar iterator, used for storing the results back.
+    T begin_iterator;
+};
+/**\internal
+ * The immutable variant of the Pointer class specialization above. It behaves the same as
+ * the mutable Pointer except that it returns a const pointer from \c operator-> and
+ * avoids the write back in the destructor.
+ */
+template <typename T, typename value_vector> class Pointer<T, value_vector, Mutable::No>
+{
+    static constexpr auto Size = value_vector::size();
+
+public:
+    const value_vector *operator->() const { return &data; }
+
+    Pointer() = delete;
+    Pointer(const Pointer &) = delete;
+    Pointer &operator=(const Pointer &) = delete;
+    Pointer &operator=(Pointer &&) = delete;
+
+    Pointer(Pointer &&) = default;  // required for returning the Pointer
+
+    Pointer(const T &it) : data(fromIterator<T, value_vector>(it)) {}
+
+private:
+    value_vector data;
+};
+
+/**\internal
+ * The Reference class behaves as much as possible like a reference to an object of type
+ * \p value_vector. The \p Mutable parameter determines whether the referenced object my
+ * be modified or not (basically whether it's a ref or a const-ref, though the semantics
+ * of mutable are actually stricter than that of const. Const only determines the logical
+ * constness whereas mutability identifies the constness on the bit-level.)
+ *
+ * \tparam T The scalar iterator type.
+ * \tparam value_vector The vector object the scalar iterator needs to fill.
+ * \tparam M A flag that determines whether the reference acts as a mutable or immutable
+ *           reference.
+ */
+template <typename T, typename value_vector, Mutable M> class Reference;
+
+///\internal mutable specialization of the Reference proxy class
+template <typename T, typename value_vector>
+class Reference<T, value_vector, Mutable::Yes> : public value_vector
+{
+    static constexpr auto Size = value_vector::size();
+
+    using reference = typename std::add_lvalue_reference<T>::type;
+    reference scalar_it;
+
+public:
+    /// Construct the reference from the given iterator \p first_it and store a reference
+    /// to the iterator for write back in the assignment operator.
+    Reference(reference first_it)
+        : value_vector(fromIterator<T, value_vector>(first_it)), scalar_it(first_it)
+    {
+    }
+
+    /// disable all copy and move operations, except the one needed for function returns
+    Reference(const Reference &) = delete;
+    Reference(Reference &&) = default;
+    Reference &operator=(const Reference &) = delete;
+    Reference &operator=(Reference &&) = delete;
+
+    /**
+     * Assignment to the reference assigns to the storage pointed to by the scalar
+     * iterator as well as the reference object itself. (The compiler should eliminate the
+     * store to \c this if it's never used since it is clearly a dead store.)
+     */
+    void operator=(const value_vector &x)
+    {
+        static_cast<value_vector &>(*this) = x;
+        auto it = scalar_it;
+        for (size_t i = 0; i < Size; ++i, ++it) {
+            *it = extract(x, i);
+        }
+    }
+};
+#define Vc_OP(op_)                                                                       \
+    template <typename T0, typename V0, typename T1, typename V1>                        \
+    decltype(std::declval<const V0 &>() op_ std::declval<const V1 &>()) operator op_(    \
+        const Reference<T0, V0, Mutable::Yes> &x,                                        \
+        const Reference<T1, V1, Mutable::Yes> &y)                                        \
+    {                                                                                    \
+        return static_cast<const V0 &>(x) op_ static_cast<const V1 &>(y);                \
+    }
+Vc_ALL_COMPARES(Vc_OP);
+Vc_ALL_ARITHMETICS(Vc_OP);
+Vc_ALL_BINARY(Vc_OP);
+Vc_ALL_LOGICAL(Vc_OP);
+Vc_ALL_SHIFTS(Vc_OP);
+#undef Vc_OP
+
+///\internal immutable specialization of the Reference proxy class
+template <typename T, typename value_vector>
+class Reference<T, value_vector, Mutable::No> : public value_vector
+{
+    static constexpr auto Size = value_vector::size();
+
+public:
+    Reference(const T &it) : value_vector(fromIterator<T, value_vector>(it)) {}
+
+    Reference(const Reference &) = delete;
+    Reference(Reference &&) = default;
+    Reference &operator=(const Reference &) = delete;
+    Reference &operator=(Reference &&) = delete;
+
+    /// Explicitly disable assignment to an immutable reference.
+    void operator=(const value_vector &x) = delete;
+};
+
+template <typename T, size_t N,
+          IteratorDetails::Mutable M =
+              (Traits::is_output_iterator<T>::value ? Mutable::Yes : Mutable::No),
+          typename V = simdize<typename std::iterator_traits<T>::value_type, N>,
+          size_t Size = V::Size,
+          typename = typename std::iterator_traits<T>::iterator_category>
+class Iterator;
+
+template <typename T, size_t N, IteratorDetails::Mutable M, typename V, size_t Size_>
+class Iterator<T, N, M, V, Size_, std::forward_iterator_tag>
+    : public std::iterator<typename std::iterator_traits<T>::iterator_category, V,
+                           typename std::iterator_traits<T>::difference_type,
+                           IteratorDetails::Pointer<T, V, M>,
+                           IteratorDetails::Reference<T, V, M>>
+{
+public:
+    using pointer = IteratorDetails::Pointer<T, V, M>;
+    using reference = IteratorDetails::Reference<T, V, M>;
+    using const_pointer = IteratorDetails::Pointer<T, V, IteratorDetails::Mutable::No>;
+    using const_reference =
+        IteratorDetails::Reference<T, V, IteratorDetails::Mutable::No>;
+
+    /// Returns the vector width the iterator covers with each step.
+    static constexpr std::size_t size() { return Size_; }
+    static constexpr std::size_t Size = Size_;
+
+    Iterator() = default;
+
+    /**
+     * A vectorizing iterator is typically initialized from a scalar iterator. The
+     * scalar iterator points to the first entry to place into the vectorized object.
+     * Subsequent entries returned by the iterator are used to fill the rest of the
+     * vectorized object.
+     */
+    Iterator(const T &x) : scalar_it(x) {}
+    /**
+     * Move optimization of the above constructor.
+     */
+    Iterator(T &&x) : scalar_it(std::move(x)) {}
+    /**
+     * Reset the vectorizing iterator to the given start point \p x.
+     */
+    Iterator &operator=(const T &x)
+    {
+        scalar_it = x;
+        return *this;
+    }
+    /**
+     * Move optimization of the above constructor.
+     */
+    Iterator &operator=(T &&x)
+    {
+        scalar_it = std::move(x);
+        return *this;
+    }
+
+    /// Default copy constructor.
+    Iterator(const Iterator &) = default;
+    /// Default move constructor.
+    Iterator(Iterator &&) = default;
+    /// Default copy assignment.
+    Iterator &operator=(const Iterator &) = default;
+    /// Default move assignment.
+    Iterator &operator=(Iterator &&) = default;
+
+    /// Advances the iterator by one vector width, or respectively N scalar steps.
+    Iterator &operator++()
+    {
+        std::advance(scalar_it, Size);
+        return *this;
+    }
+    /// Postfix overload of the above.
+    Iterator operator++(int)
+    {
+        Iterator copy(*this);
+        operator++();
+        return copy;
+    }
+
+    /**
+     * Returns whether the two iterators point to the same scalar entry.
+     *
+     * \warning If the end iterator you compare against is not a multiple of the SIMD
+     * width away from the incrementing iterator then the two iterators may pass each
+     * other without ever comparing equal. In debug builds (when NDEBUG is not
+     * defined) an assertion tries to locate such passing iterators.
+     */
+    bool operator==(const Iterator &rhs) const
+    {
+#ifndef NDEBUG
+        if (scalar_it == rhs.scalar_it) {
+            return true;
+        } else {
+            T it(scalar_it);
+            for (size_t i = 1; i < Size; ++i) {
+                Vc_ASSERT((++it != rhs.scalar_it));
+            }
+            return false;
+        }
+#else
+        return scalar_it == rhs.scalar_it;
+#endif
+    }
+    /**
+     * Returns whether the two iterators point to different scalar entries.
+     *
+     * \warning If the end iterator you compare against is not a multiple of the SIMD
+     * width away from the incrementing iterator then the two iterators may pass each
+     * other without ever comparing equal. In debug builds (when NDEBUG is not
+     * defined) an assertion tries to locate such passing iterators.
+     */
+    bool operator!=(const Iterator &rhs) const
+    {
+        return !operator==(rhs);
+    }
+
+    pointer operator->() { return scalar_it; }
+
+    /**
+     * Returns a copy of the objects behind the iterator in a vectorized type. You can use
+     * the assignment operator to modify the values in the container referenced by the
+     * iterator. Use of any other mutating operation is undefined behavior and will most
+     * likely not be reflected in the container.
+     */
+    reference operator*() { return scalar_it; }
+
+    const_pointer operator->() const { return scalar_it; }
+
+    /**
+     * Returns a copy of the objects behind the iterator in a vectorized type.
+     *
+     * \warning This does not behave like the standard iterator interface as it does not
+     * return an lvalue reference. Thus, changes to the container the iterator references
+     * will not be reflected in the reference object you receive.
+     */
+    const_reference operator*() const { return scalar_it; }
+
+    /**
+     * Returns a const lvalue reference to the underlying scalar iterator. This
+     * effectively allows you to cast simdized iterator objects to their scalar ancestor
+     * type.
+     *
+     * Example:
+     * \code
+        const auto mask = *it == value_v;
+        if (any_of(mask)) {
+          return static_cast<ScalarIt>(it) + mask.firstOne();
+        }
+     * \endcode
+     */
+    operator const T &() const { return scalar_it; }
+
+protected:
+    T scalar_it;
+};
+
+/**
+ * This is the iterator type created when applying simdize to a bidirectional
+ * iterator type.
+ */
+template <typename T, size_t N, IteratorDetails::Mutable M, typename V, size_t Size>
+class Iterator<T, N, M, V, Size, std::bidirectional_iterator_tag>
+    : public Iterator<T, N, M, V, Size, std::forward_iterator_tag>
+{
+    using Base = Iterator<T, N, M, V, Size, std::forward_iterator_tag>;
+
+protected:
+    using Base::scalar_it;
+
+public:
+    using pointer = typename Base::pointer;
+    using reference = typename Base::reference;
+    using const_pointer = typename Base::const_pointer;
+    using const_reference = typename Base::const_reference;
+
+    using Iterator<T, N, M, V, Size,
+                   std::forward_iterator_tag>::Iterator;  // in short: "using
+                                                          // Base::Iterator", but that
+                                                          // confuses ICC
+    /// Advances the iterator by one vector width, or respectively N scalar steps.
+    Iterator &operator--()
+    {
+        std::advance(scalar_it, -Size);
+        return *this;
+    }
+    /// Postfix overload of the above.
+    Iterator operator--(int)
+    {
+        Iterator copy(*this);
+        operator--();
+        return copy;
+    }
+};
+
+/**
+ * This is the iterator type created when applying simdize to a random access iterator
+ * type.
+ */
+template <typename T, size_t N, IteratorDetails::Mutable M, typename V, size_t Size>
+class Iterator<T, N, M, V, Size, std::random_access_iterator_tag>
+    : public Iterator<T, N, M, V, Size, std::bidirectional_iterator_tag>
+{
+    using Base = Iterator<T, N, M, V, Size, std::bidirectional_iterator_tag>;
+
+protected:
+    using Base::scalar_it;
+
+public:
+    using pointer = typename Base::pointer;
+    using reference = typename Base::reference;
+    using const_pointer = typename Base::const_pointer;
+    using const_reference = typename Base::const_reference;
+    using difference_type = typename std::iterator_traits<T>::difference_type;
+
+    using Iterator<T, N, M, V, Size, std::bidirectional_iterator_tag>::
+        Iterator;  // in short: "using Base::Iterator", but that confuses ICC
+
+    Iterator &operator+=(difference_type n)
+    {
+        scalar_it += n * difference_type(Size);
+        return *this;
+    }
+    Iterator operator+(difference_type n) const { return Iterator(*this) += n; }
+
+    Iterator &operator-=(difference_type n)
+    {
+        scalar_it -= n * difference_type(Size);
+        return *this;
+    }
+    Iterator operator-(difference_type n) const { return Iterator(*this) -= n; }
+
+    difference_type operator-(const Iterator &rhs) const
+    {
+        constexpr difference_type n = Size;
+        Vc_ASSERT((scalar_it - rhs.scalar_it) % n ==
+                  0);  // if this fails the two iterators are not a multiple of the vector
+                       // width apart. The distance would be fractional and that doesn't
+                       // make too much sense for iteration. Therefore, it is a
+                       // precondition for the distance of the two iterators to be a
+                       // multiple of Size.
+        return (scalar_it - rhs.scalar_it) / n;
+    }
+
+    /**
+     * Returns whether all entries accessed via iterator dereferencing come before the
+     * iterator \p rhs.
+     */
+    bool operator<(const Iterator &rhs) const
+    {
+        return rhs.scalar_it - scalar_it >= difference_type(Size);
+    }
+
+    bool operator>(const Iterator &rhs) const
+    {
+        return scalar_it - rhs.scalar_it >= difference_type(Size);
+    }
+
+    bool operator<=(const Iterator &rhs) const
+    {
+        return rhs.scalar_it - scalar_it >= difference_type(Size) - 1;
+    }
+
+    bool operator>=(const Iterator &rhs) const
+    {
+        return scalar_it - rhs.scalar_it >= difference_type(Size) - 1;
+    }
+
+    reference operator[](difference_type i) { return *(*this + i); }
+    const_reference operator[](difference_type i) const { return *(*this + i); }
+};
+
+template <typename T, size_t N, IteratorDetails::Mutable M, typename V, size_t Size>
+Iterator<T, N, M, V, Size, std::random_access_iterator_tag> operator+(
+    typename Iterator<T, N, M, V, Size, std::random_access_iterator_tag>::difference_type
+        n,
+    const Iterator<T, N, M, V, Size, std::random_access_iterator_tag> &i)
+{
+    return i + n;
+}
+
+}  // namespace IteratorDetails
+
+/**\internal
+ *
+ * Creates a member type \p type that acts as a vectorizing bidirectional iterator.
+ *
+ * \tparam T The bidirectional iterator type to be transformed.
+ * \tparam N The width the resulting vectorized type should have.
+ * \tparam MT The base type to use for mask types. Ignored for this specialization.
+ */
+template <typename T, size_t N, typename MT>
+struct ReplaceTypes<T, N, MT, Category::ForwardIterator>
+{
+    using type = IteratorDetails::Iterator<T, N>;
+};
+template <typename T, size_t N, typename MT>
+struct ReplaceTypes<T, N, MT, Category::BidirectionalIterator>
+{
+    using type = IteratorDetails::Iterator<T, N>;
+};
+template <typename T, size_t N, typename MT>
+struct ReplaceTypes<T, N, MT, Category::RandomAccessIterator>
+{
+    using type = IteratorDetails::Iterator<T, N>;
+};
+
+/**\internal
+ * Implementation for conditional assignment of whole vectorized objects.
+ */
+template <Vc::Operator Op, typename S, typename T, std::size_t N, typename M, typename U,
+          std::size_t Offset>
+Vc_INTRINSIC Vc::enable_if<(Offset >= determine_tuple_size_<S>::value && M::Size == N), void>
+    conditional_assign(Adapter<S, T, N> &, const M &, const U &)
+{
+}
+template <Vc::Operator Op, typename S, typename T, std::size_t N, typename M, typename U,
+          std::size_t Offset = 0>
+Vc_INTRINSIC Vc::enable_if<(Offset < determine_tuple_size_<S>::value && M::Size == N), void>
+    conditional_assign(Adapter<S, T, N> &lhs, const M &mask, const U &rhs)
+{
+    using V = typename std::decay<decltype(get_dispatcher<Offset>(lhs))>::type;
+    using M2 = typename V::mask_type;
+    conditional_assign<Op>(get_dispatcher<Offset>(lhs), simd_cast<M2>(mask), get_dispatcher<Offset>(rhs));
+    conditional_assign<Op, S, T, N, M, U, Offset + 1>(lhs, mask, rhs);
+}
+template <Vc::Operator Op, typename S, typename T, std::size_t N, typename M,
+          std::size_t Offset>
+Vc_INTRINSIC Vc::enable_if<(Offset >= determine_tuple_size_<S>::value && M::Size == N), void>
+    conditional_assign(Adapter<S, T, N> &, const M &)
+{
+}
+template <Vc::Operator Op, typename S, typename T, std::size_t N, typename M,
+          std::size_t Offset = 0>
+Vc_INTRINSIC Vc::enable_if<(Offset < determine_tuple_size_<S>::value && M::Size == N), void>
+    conditional_assign(Adapter<S, T, N> &lhs, const M &mask)
+{
+    using V = typename std::decay<decltype(get_dispatcher<Offset>(lhs))>::type;
+    using M2 = typename V::mask_type;
+    conditional_assign<Op>(get_dispatcher<Offset>(lhs), simd_cast<M2>(mask));
+    conditional_assign<Op, S, T, N, M, Offset + 1>(lhs, mask);
+}
+
+/** @}*/
+}  // namespace SimdizeDetail
+
+/*!\ingroup Simdize
+ * Vectorize/Simdize the given type T.
+ *
+ * \tparam T This type must be a class template instance where the template arguments can
+ * be recursively replaced with their vectorized variant. If the type implements a
+ * specific interface for introspection and member modification, the resulting type can
+ * easily be constructed from objects of type T and scalar objects of type T can be
+ * extracted from it.
+ *
+ * \tparam N This value determines the width of the vectorization. Per default it is set
+ * to 0 making the implementation choose the value considering the compilation target and
+ * the given type T.
+ *
+ * \tparam MT This type determines the type to be used when replacing bool with Mask<MT>.
+ * If it is set to void the implementation choosed the type as smart as possible.
+ *
+ * \see Vc_SIMDIZE_STRUCT, Vc_SIMDIZE_MEMBER
+ */
+template <typename T, size_t N = 0, typename MT = void>
+using simdize = SimdizeDetail::simdize<T, N, MT>;
+
+/*!\ingroup Simdize
+ * Declares functions and constants for introspection by the simdize functions. This
+ * allows e.g. conversion between scalar \c T and \c simdize<T>.
+ *
+ * \param MEMBERS_ The data members of this struct/class listed inside extra parenthesis.
+ * The extra parenthesis are required because the macro would otherwise see a variable
+ * number of arguments.
+ *
+ * Example:
+ * \code
+ * template <typename T, typename U> struct X {
+ *   T a;
+ *   U b;
+ *   Vc_SIMDIZE_INTERFACE((a, b));
+ * };
+ * \endcode
+ *
+ * \note You must use this macros in the public section of a class.
+ */
+#define Vc_SIMDIZE_INTERFACE(MEMBERS_)                                                   \
+    template <std::size_t N_>                                                            \
+    inline auto vc_get_()->decltype(std::get<N_>(std::tie MEMBERS_))                     \
+    {                                                                                    \
+        return std::get<N_>(std::tie MEMBERS_);                                          \
+    }                                                                                    \
+    template <std::size_t N_>                                                            \
+    inline auto vc_get_() const->decltype(std::get<N_>(std::tie MEMBERS_))               \
+    {                                                                                    \
+        return std::get<N_>(std::tie MEMBERS_);                                          \
+    }                                                                                    \
+    enum : std::size_t {                                                                 \
+        tuple_size = std::tuple_size<decltype(std::make_tuple MEMBERS_)>::value          \
+    }
+
+}  // namespace Vc
+
+namespace std
+{
+using Vc::SimdizeDetail::swap;
+}  // namespace std
+
+#endif  // VC_COMMON_SIMDIZE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/simdmaskarray.h vc-1.3.0/common/simdmaskarray.h
--- vc-0.7.4/common/simdmaskarray.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/simdmaskarray.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,675 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SIMDMASKARRAY_H_
+#define VC_COMMON_SIMDMASKARRAY_H_
+
+#include <type_traits>
+#include <array>
+#include "simdarrayhelper.h"
+#include "utility.h"
+#include "maskbool.h"
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/// \addtogroup SimdArray
+/// @{
+// atomic SimdMaskArray {{{1
+/**\internal
+ * Specialization of `SimdMaskArray<T, N, VectorType, VectorSize>` for the case where `N
+ * == VectorSize`.
+ *
+ * This is specialized for implementation purposes: Since the general implementation uses
+ * two SimdMaskArray data members it recurses over different SimdMaskArray instantiations.
+ * The recursion is ended by this specialization, which has a single \p storage_type data
+ * member to which all functions are forwarded more or less directly.
+ */
+template <typename T, std::size_t N, typename VectorType_>
+class SimdMaskArray<T, N, VectorType_, N>
+{
+public:
+    using VectorType = VectorType_;
+    using vector_type = VectorType;
+    using mask_type = typename vector_type::Mask;
+    using storage_type = mask_type;
+
+    friend storage_type &internal_data(SimdMaskArray &m) { return m.data; }
+    friend const storage_type &internal_data(const SimdMaskArray &m) { return m.data; }
+
+    static constexpr std::size_t size() { return N; }
+    static constexpr std::size_t Size = size();
+    static constexpr std::size_t MemoryAlignment = storage_type::MemoryAlignment;
+    static_assert(Size == vector_type::Size, "size mismatch");
+
+    using vectorentry_type = typename mask_type::VectorEntryType;
+    using value_type = typename mask_type::EntryType;
+    using Mask = mask_type;
+    using VectorEntryType = vectorentry_type;
+    using EntryType = value_type;
+    using EntryReference = Vc::Detail::ElementReference<storage_type, SimdMaskArray>;
+    using reference = EntryReference;
+    using Vector = SimdArray<T, N, VectorType, N>;
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(mask_type));
+
+    // zero init
+    SimdMaskArray() = default;
+
+    // broadcasts
+    Vc_INTRINSIC explicit SimdMaskArray(VectorSpecialInitializerOne one) : data(one) {}
+    Vc_INTRINSIC explicit SimdMaskArray(VectorSpecialInitializerZero zero) : data(zero) {}
+    Vc_INTRINSIC explicit SimdMaskArray(bool b) : data(b) {}
+    Vc_INTRINSIC static SimdMaskArray Zero() { return {storage_type::Zero()}; }
+    Vc_INTRINSIC static SimdMaskArray One() { return {storage_type::One()}; }
+
+    // conversion (casts)
+    template <typename U, typename V>
+    Vc_INTRINSIC_L SimdMaskArray(const SimdMaskArray<U, N, V> &x,
+                                   enable_if<N == V::Size> = nullarg) Vc_INTRINSIC_R;
+    template <typename U, typename V>
+    Vc_INTRINSIC_L SimdMaskArray(const SimdMaskArray<U, N, V> &x,
+                                   enable_if<(N > V::Size && N <= 2 * V::Size)> = nullarg)
+        Vc_INTRINSIC_R;
+    template <typename U, typename V>
+    Vc_INTRINSIC_L SimdMaskArray(const SimdMaskArray<U, N, V> &x,
+                                   enable_if<(N > 2 * V::Size && N <= 4 * V::Size)> = nullarg)
+        Vc_INTRINSIC_R;
+
+    // conversion from any Segment object (could be SimdMaskArray or Mask<T>)
+    template <typename M, std::size_t Pieces, std::size_t Index>
+    Vc_INTRINSIC_L SimdMaskArray(
+        Common::Segment<M, Pieces, Index> &&x,
+        enable_if<Traits::simd_vector_size<M>::value == Size * Pieces> = nullarg) Vc_INTRINSIC_R;
+
+    // conversion from Mask<T>
+    template <typename M>
+    Vc_INTRINSIC_L SimdMaskArray(
+        M k,
+        enable_if<(Traits::is_simd_mask<M>::value && !Traits::isSimdMaskArray<M>::value &&
+                   Traits::simd_vector_size<M>::value == Size)> = nullarg) Vc_INTRINSIC_R;
+
+    // implicit conversion to Mask<U, AnyAbi> for if Mask<U, AnyAbi>::size() == N
+    template <typename U, typename A, typename = enable_if<Vc::Mask<U, A>::Size == N>>
+    operator Vc::Mask<U, A>() const
+    {
+        return simd_cast<Vc::Mask<U, A>>(data);
+    }
+
+    // load/store (from/to bool arrays)
+    template <typename Flags = DefaultLoadTag>
+    Vc_INTRINSIC explicit SimdMaskArray(const bool *mem, Flags f = Flags())
+        : data(mem, f)
+    {
+    }
+
+    Vc_INTRINSIC void load(const bool *mem) { data.load(mem); }
+    template <typename Flags> Vc_INTRINSIC void load(const bool *mem, Flags f)
+    {
+        data.load(mem, f);
+    }
+
+    Vc_INTRINSIC void store(bool *mem) const { data.store(mem); }
+    template <typename Flags> Vc_INTRINSIC void store(bool *mem, Flags f) const
+    {
+        data.store(mem, f);
+    }
+
+    // compares
+    Vc_INTRINSIC Vc_PURE bool operator==(const SimdMaskArray &rhs) const
+    {
+        return data == rhs.data;
+    }
+    Vc_INTRINSIC Vc_PURE bool operator!=(const SimdMaskArray &rhs) const
+    {
+        return data != rhs.data;
+    }
+
+    // inversion
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator!() const
+    {
+        return {!data};
+    }
+
+    // binary operators
+    Vc_INTRINSIC SimdMaskArray &operator&=(const SimdMaskArray &rhs)
+    {
+        data &= rhs.data;
+        return *this;
+    }
+    Vc_INTRINSIC SimdMaskArray &operator|=(const SimdMaskArray &rhs)
+    {
+        data |= rhs.data;
+        return *this;
+    }
+    Vc_INTRINSIC SimdMaskArray &operator^=(const SimdMaskArray &rhs)
+    {
+        data ^= rhs.data;
+        return *this;
+    }
+
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator&(const SimdMaskArray &rhs) const
+    {
+        return {data & rhs.data};
+    }
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator|(const SimdMaskArray &rhs) const
+    {
+        return {data | rhs.data};
+    }
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator^(const SimdMaskArray &rhs) const
+    {
+        return {data ^ rhs.data};
+    }
+
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator&&(const SimdMaskArray &rhs) const
+    {
+        return {data && rhs.data};
+    }
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator||(const SimdMaskArray &rhs) const
+    {
+        return {data || rhs.data};
+    }
+
+    Vc_INTRINSIC Vc_PURE bool isFull() const { return data.isFull(); }
+    Vc_INTRINSIC Vc_PURE bool isNotEmpty() const { return data.isNotEmpty(); }
+    Vc_INTRINSIC Vc_PURE bool isEmpty() const { return data.isEmpty(); }
+    Vc_INTRINSIC Vc_PURE bool isMix() const { return data.isMix(); }
+
+    Vc_INTRINSIC Vc_PURE int shiftMask() const { return data.shiftMask(); }
+
+    Vc_INTRINSIC Vc_PURE int toInt() const { return data.toInt(); }
+
+private:
+    friend reference;
+    static Vc_INTRINSIC value_type get(const storage_type &k, int i) noexcept
+    {
+        return k[i];
+    }
+    template <typename U>
+    static Vc_INTRINSIC void set(storage_type &k, int i, U &&v) noexcept(
+        noexcept(std::declval<storage_type &>()[0] = std::declval<U>()))
+    {
+        k[i] = std::forward<U>(v);
+    }
+
+public:
+    Vc_INTRINSIC Vc_PURE reference operator[](size_t index) noexcept
+    {
+        return {data, int(index)};
+    }
+    Vc_INTRINSIC Vc_PURE value_type operator[](size_t index) const noexcept
+    {
+        return data[index];
+    }
+
+    Vc_INTRINSIC Vc_PURE int count() const { return data.count(); }
+
+    /**
+     * Returns the index of the first one in the mask.
+     *
+     * The return value is undefined if the mask is empty.
+     */
+    Vc_INTRINSIC Vc_PURE int firstOne() const { return data.firstOne(); }
+
+    template <typename G> static Vc_INTRINSIC SimdMaskArray generate(const G &gen)
+    {
+        return {mask_type::generate(gen)};
+    }
+
+    Vc_INTRINSIC Vc_PURE SimdMaskArray shifted(int amount) const
+    {
+        return {data.shifted(amount)};
+    }
+
+    /// \internal execute specified Operation
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC SimdMaskArray fromOperation(Op op, Args &&... args)
+    {
+        SimdMaskArray r;
+        Common::unpackArgumentsAuto(op, r.data, std::forward<Args>(args)...);
+        return r;
+    }
+
+    /// \internal
+    Vc_INTRINSIC SimdMaskArray(mask_type &&x) : data(std::move(x)) {}
+
+private:
+    // The alignas attribute attached to the class declaration above is ignored by ICC
+    // 17.0.0 (at least). So just move the alignas attribute down here where it works for
+    // all compilers.
+    alignas(static_cast<std::size_t>(
+        Common::BoundedAlignment<Common::NextPowerOfTwo<N>::value * sizeof(VectorType_) /
+                                 VectorType_::size()>::value)) storage_type data;
+};
+
+template <typename T, std::size_t N, typename VectorType> constexpr std::size_t SimdMaskArray<T, N, VectorType, N>::Size;
+template <typename T, std::size_t N, typename VectorType>
+constexpr std::size_t SimdMaskArray<T, N, VectorType, N>::MemoryAlignment;
+
+// generic SimdArray {{{1
+/**
+ * Data-parallel mask type with user-defined number of boolean elements.
+ *
+ * \tparam T The value type of the corresponding SimdArray. Depending on the target
+ *           platform this type determines a different bit representation to work most
+ *           efficient with SimdArray types instantiated for \p T.
+ *
+ * \tparam N The number of boolean elements to store and process concurrently. You can
+ *           choose an arbitrary number, though not every number is a good idea.
+ *           Generally, a power of two value or the sum of two power of two values might
+ *           work efficiently, though this depends a lot on the target system.
+ *
+ * \tparam V Don't change the default value unless you really know what you are doing.
+ *           This type is set to the underlying native Vc::Vector type used in the
+ *           implementation of the type.
+ *           Having it as part of the type name guards against some cases of ODR
+ *           violations (i.e. linking incompatible translation units / libraries).
+ *
+ * \tparam Wt Don't ever change the default value.
+ *           This parameter is an unfortunate implementation detail shining through.
+ *
+ * \headerfile simdmaskarray.h <Vc/SimdArray>
+ */
+template <typename T, size_t N, typename V, size_t Wt>
+class SimdMaskArray
+{
+    static constexpr std::size_t N0 = Common::left_size<N>();
+
+    using Split = Common::Split<N0>;
+
+public:
+    using storage_type0 = SimdMaskArray<T, N0>;
+    using storage_type1 = SimdMaskArray<T, N - N0>;
+    static_assert(storage_type0::size() == N0, "");
+
+    using vector_type = SimdArray<T, N>;
+
+    friend storage_type0 &internal_data0(SimdMaskArray &m) { return m.data0; }
+    friend storage_type1 &internal_data1(SimdMaskArray &m) { return m.data1; }
+    friend const storage_type0 &internal_data0(const SimdMaskArray &m) { return m.data0; }
+    friend const storage_type1 &internal_data1(const SimdMaskArray &m) { return m.data1; }
+
+    using mask_type = SimdMaskArray;
+
+    ///\copydoc Mask::size()
+    static constexpr std::size_t size() { return N; }
+    ///\copydoc Mask::Size
+    static constexpr std::size_t Size = size();
+    ///\copydoc Mask::MemoryAlignment
+    static constexpr std::size_t MemoryAlignment =
+        storage_type0::MemoryAlignment > storage_type1::MemoryAlignment
+            ? storage_type0::MemoryAlignment
+            : storage_type1::MemoryAlignment;
+    static_assert(Size == vector_type::Size, "size mismatch");
+
+    ///\internal
+    using vectorentry_type = typename storage_type0::VectorEntryType;
+
+    ///\copydoc Mask::value_type
+    using value_type = typename storage_type0::EntryType;
+    ///\copydoc Mask::Mask
+    using MaskType = mask_type;
+    ///\copydoc Mask::VectorEntryType
+    using VectorEntryType = vectorentry_type;
+    ///\copydoc Mask::EntryType
+    using EntryType = value_type;
+    ///\copydoc Mask::EntryReference
+    using EntryReference = Vc::Detail::ElementReference<SimdMaskArray>;
+    using reference = EntryReference;
+    /// An alias for the corresponding SimdArray type.
+    using Vector = SimdArray<T, N, V, V::Size>;
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(mask_type));
+
+    // zero init
+    ///\copydoc Mask::Mask()
+    SimdMaskArray() = default;
+
+    // default copy ctor/operator
+    SimdMaskArray(const SimdMaskArray &) = default;
+    SimdMaskArray(SimdMaskArray &&) = default;
+    SimdMaskArray &operator=(const SimdMaskArray &) = default;
+    SimdMaskArray &operator=(SimdMaskArray &&) = default;
+
+    // implicit conversion from SimdMaskArray with same N
+    template <typename U, typename W>
+    Vc_INTRINSIC SimdMaskArray(const SimdMaskArray<U, N, W> &rhs)
+        : data0(Split::lo(rhs)), data1(Split::hi(rhs))
+    {
+    }
+
+    // conversion from any Segment object (could be SimdMaskArray or Mask<T>)
+    template <typename M, std::size_t Pieces, std::size_t Index>
+    Vc_INTRINSIC SimdMaskArray(
+        Common::Segment<M, Pieces, Index> &&rhs,
+        enable_if<Traits::simd_vector_size<M>::value == Size * Pieces> = nullarg)
+        : data0(Split::lo(rhs)), data1(Split::hi(rhs))
+    {
+    }
+
+    // conversion from Mask<T>
+    template <typename M>
+    Vc_INTRINSIC SimdMaskArray(
+        M k,
+        enable_if<(Traits::is_simd_mask<M>::value && !Traits::isSimdMaskArray<M>::value &&
+                   Traits::simd_vector_size<M>::value == Size)> = nullarg)
+        : data0(Split::lo(k)), data1(Split::hi(k))
+    {
+    }
+
+    // implicit conversion to Mask<U, AnyAbi> for if Mask<U, AnyAbi>::size() == N
+    template <typename U, typename A, typename = enable_if<Vc::Mask<U, A>::Size == N>>
+    operator Vc::Mask<U, A>() const
+    {
+        return simd_cast<Vc::Mask<U, A>>(data0, data1);
+    }
+
+    ///\copybrief Mask::Mask(VectorSpecialInitializerOne)
+    Vc_INTRINSIC explicit SimdMaskArray(VectorSpecialInitializerOne one)
+        : data0(one), data1(one)
+    {
+    }
+    ///\copybrief Mask::Mask(VectorSpecialInitializerZero)
+    Vc_INTRINSIC explicit SimdMaskArray(VectorSpecialInitializerZero zero)
+        : data0(zero), data1(zero)
+    {
+    }
+    ///\copydoc Mask::Mask(bool)
+    Vc_INTRINSIC explicit SimdMaskArray(bool b) : data0(b), data1(b) {}
+
+    ///\copydoc Mask::Zero()
+    Vc_INTRINSIC static SimdMaskArray Zero() { return {storage_type0::Zero(), storage_type1::Zero()}; }
+    ///\copydoc Mask::One()
+    Vc_INTRINSIC static SimdMaskArray One() { return {storage_type0::One(), storage_type1::One()}; }
+
+    ///\name Loads & Stores
+    ///@{
+
+    /**
+     * Load N boolean values from the consecutive addresses starting at \p mem.
+     *
+     * \param mem A pointer to an array of booleans.
+     * \param f A combination of flags to modify specific behavior of the load.
+     */
+    template <typename Flags = DefaultLoadTag>
+    Vc_INTRINSIC explicit SimdMaskArray(const bool *mem, Flags f = Flags())
+        : data0(mem, f), data1(mem + storage_type0::size(), f)
+    {
+    }
+
+    /**
+     * Load N boolean values from the consecutive addresses starting at \p mem.
+     *
+     * \param mem A pointer to an array of booleans.
+     */
+    Vc_INTRINSIC void load(const bool *mem)
+    {
+        data0.load(mem);
+        data1.load(mem + storage_type0::size());
+    }
+
+    /**
+     * Load N boolean values from the consecutive addresses starting at \p mem.
+     *
+     * \param mem A pointer to an array of booleans.
+     * \param f A combination of flags to modify specific behavior of the load.
+     */
+    template <typename Flags> Vc_INTRINSIC void load(const bool *mem, Flags f)
+    {
+        data0.load(mem, f);
+        data1.load(mem + storage_type0::size(), f);
+    }
+
+    /**
+     * Store N boolean values to the consecutive addresses starting at \p mem.
+     *
+     * \param mem A pointer to an array of booleans.
+     */
+    Vc_INTRINSIC void store(bool *mem) const
+    {
+        data0.store(mem);
+        data1.store(mem + storage_type0::size());
+    }
+
+    /**
+     * Store N boolean values to the consecutive addresses starting at \p mem.
+     *
+     * \param mem A pointer to an array of booleans.
+     * \param f A combination of flags to modify specific behavior of the load.
+     */
+    template <typename Flags> Vc_INTRINSIC void store(bool *mem, Flags f) const
+    {
+        data0.store(mem, f);
+        data1.store(mem + storage_type0::size(), f);
+    }
+    ///@}
+
+    ///\copydoc Mask::operator==
+    Vc_INTRINSIC Vc_PURE bool operator==(const SimdMaskArray &mask) const
+    {
+        return data0 == mask.data0 && data1 == mask.data1;
+    }
+    ///\copydoc Mask::operator!=
+    Vc_INTRINSIC Vc_PURE bool operator!=(const SimdMaskArray &mask) const
+    {
+        return data0 != mask.data0 || data1 != mask.data1;
+    }
+
+    ///\copybrief Mask::operator!
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator!() const
+    {
+        return {!data0, !data1};
+    }
+
+    ///\copybrief Mask::operator&=
+    Vc_INTRINSIC SimdMaskArray &operator&=(const SimdMaskArray &rhs)
+    {
+        data0 &= rhs.data0;
+        data1 &= rhs.data1;
+        return *this;
+    }
+    ///\copybrief Mask::operator|=
+    Vc_INTRINSIC SimdMaskArray &operator|=(const SimdMaskArray &rhs)
+    {
+        data0 |= rhs.data0;
+        data1 |= rhs.data1;
+        return *this;
+    }
+    ///\copybrief Mask::operator^=
+    Vc_INTRINSIC SimdMaskArray &operator^=(const SimdMaskArray &rhs)
+    {
+        data0 ^= rhs.data0;
+        data1 ^= rhs.data1;
+        return *this;
+    }
+
+    ///\copybrief Mask::operator&
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator&(const SimdMaskArray &rhs) const
+    {
+        return {data0 & rhs.data0, data1 & rhs.data1};
+    }
+    ///\copybrief Mask::operator|
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator|(const SimdMaskArray &rhs) const
+    {
+        return {data0 | rhs.data0, data1 | rhs.data1};
+    }
+    ///\copybrief Mask::operator^
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator^(const SimdMaskArray &rhs) const
+    {
+        return {data0 ^ rhs.data0, data1 ^ rhs.data1};
+    }
+
+    ///\copybrief Mask::operator&&
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator&&(const SimdMaskArray &rhs) const
+    {
+        return {data0 && rhs.data0, data1 && rhs.data1};
+    }
+    ///\copybrief Mask::operator||
+    Vc_INTRINSIC Vc_PURE SimdMaskArray operator||(const SimdMaskArray &rhs) const
+    {
+        return {data0 || rhs.data0, data1 || rhs.data1};
+    }
+
+    ///\copybrief Mask::isFull
+    Vc_INTRINSIC Vc_PURE bool isFull() const { return data0.isFull() && data1.isFull(); }
+    ///\copybrief Mask::isNotEmpty
+    Vc_INTRINSIC Vc_PURE bool isNotEmpty() const { return data0.isNotEmpty() || data1.isNotEmpty(); }
+    ///\copybrief Mask::isEmpty
+    Vc_INTRINSIC Vc_PURE bool isEmpty() const { return data0.isEmpty() && data1.isEmpty(); }
+    ///\copybrief Mask::isMix
+    Vc_INTRINSIC Vc_PURE bool isMix() const { return !isFull() && !isEmpty(); }
+
+    ///\copydoc Mask::toInt
+    Vc_INTRINSIC Vc_PURE int toInt() const
+    {
+        return data0.toInt() | (data1.toInt() << data0.size());
+    }
+
+private:
+    friend reference;
+    static Vc_INTRINSIC value_type get(const SimdMaskArray &o, int i) noexcept
+    {
+        if (i < int(o.data0.size())) {
+            return o.data0[i];
+        } else {
+            return o.data1[i - o.data0.size()];
+        }
+    }
+    template <typename U>
+    static Vc_INTRINSIC void set(SimdMaskArray &o, int i, U &&v) noexcept(
+        noexcept(std::declval<storage_type0 &>()[0] = std::declval<U>()) &&
+        noexcept(std::declval<storage_type1 &>()[0] = std::declval<U>()))
+    {
+        if (i < int(o.data0.size())) {
+            o.data0[i] = std::forward<U>(v);
+        } else {
+            o.data1[i - o.data0.size()] = std::forward<U>(v);
+        }
+    }
+
+public:
+    /**
+     * Return a smart reference to the boolean element at index \p index.
+     *
+     * \param index The element index to be accessed.
+     *
+     * \returns A temporary smart reference object which acts as much as an lvalue
+     * reference as possible.
+     */
+    Vc_INTRINSIC Vc_PURE reference operator[](size_t index) noexcept
+    {
+        return {*this, int(index)};
+    }
+    /**
+     * Return a copy of the boolean element at index \p index.
+     *
+     * \param index The element index to be accessed.
+     *
+     * \returns A temporary boolean object with the value of the element at index \p
+     * index.
+     */
+    Vc_INTRINSIC Vc_PURE value_type operator[](size_t index) const noexcept
+    {
+        return get(*this, index);
+    }
+
+    ///\copybrief Mask::count
+    Vc_INTRINSIC Vc_PURE int count() const { return data0.count() + data1.count(); }
+
+    ///\copydoc Mask::firstOne
+    Vc_INTRINSIC Vc_PURE int firstOne() const {
+        if (data0.isEmpty()) {
+            return data1.firstOne() + storage_type0::size();
+        }
+        return data0.firstOne();
+    }
+
+    ///\copybrief Mask::generate
+    template <typename G> static Vc_INTRINSIC SimdMaskArray generate(const G &gen)
+    {
+        return {storage_type0::generate(gen),
+                storage_type1::generate([&](std::size_t i) { return gen(i + N0); })};
+    }
+
+    ///\copybrief Mask::shifted
+    inline Vc_PURE SimdMaskArray shifted(int amount) const
+    {
+        if (Vc_IS_UNLIKELY(amount == 0)) {
+            return *this;
+        }
+        return generate([&](unsigned i) {
+            // modulo arithmetic of unsigned makes the check for j >= 0 unnecessary
+            const unsigned j = i + amount;
+            return j < size() ? get(*this, j) : false;
+        });
+    }
+
+    /// \internal execute specified Operation
+    template <typename Op, typename... Args>
+    static Vc_INTRINSIC SimdMaskArray fromOperation(Op op, Args &&... args)
+    {
+        SimdMaskArray r = {
+            storage_type0::fromOperation(op, Split::lo(args)...),  // no forward here - it
+                                                                   // could move and thus
+                                                                   // break the next line
+            storage_type1::fromOperation(op, Split::hi(std::forward<Args>(args))...)};
+        return r;
+    }
+
+    /// \internal
+    Vc_INTRINSIC SimdMaskArray(storage_type0 &&x, storage_type1 &&y)
+        : data0(std::move(x)), data1(std::move(y))
+    {
+    }
+
+private:
+    // The alignas attribute attached to the class declaration above is ignored by ICC
+    // 17.0.0 (at least). So just move the alignas attribute down here where it works for
+    // all compilers.
+    alignas(static_cast<std::size_t>(
+        Common::BoundedAlignment<Common::NextPowerOfTwo<N>::value * sizeof(V) /
+                                 V::size()>::value)) storage_type0 data0;
+    storage_type1 data1;
+};
+template <typename T, std::size_t N, typename V, std::size_t M>
+constexpr std::size_t SimdMaskArray<T, N, V, M>::Size;
+template <typename T, std::size_t N, typename V, std::size_t M>
+constexpr std::size_t SimdMaskArray<T, N, V, M>::MemoryAlignment;
+
+///}}}1
+/// @}
+
+}  // namespace Vc
+
+// XXX: this include should be in <Vc/vector.h>. But at least clang 3.4 then fails to compile the
+// code. Not sure yet what is going on, but it looks a lot like a bug in clang.
+#include "simd_cast_caller.tcc"
+
+#endif // VC_COMMON_SIMDMASKARRAY_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/storage.h vc-1.3.0/common/storage.h
--- vc-0.7.4/common/storage.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/storage.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,130 +1,388 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_STORAGE_H
-#define VC_COMMON_STORAGE_H
+#ifndef VC_COMMON_STORAGE_H_
+#define VC_COMMON_STORAGE_H_
 
 #include "aliasingentryhelper.h"
-#include "macros.h"
 #include "types.h"
+#include "maskbool.h"
+#ifdef Vc_IMPL_AVX
+#include "../avx/intrinsics.h"
+#endif
+#include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
+namespace Detail
+{
+template <typename V> inline V zero();
+}  // namespace Detail
 namespace Common
 {
+namespace Detail
+{
+#ifdef Vc_IMPL_AVX
+template <typename ValueType, size_t Size> struct IntrinsicType {
+    using type = typename std::conditional<
+        std::is_integral<ValueType>::value,
+        typename std::conditional<sizeof(ValueType) * Size == 16, __m128i, __m256i>::type,
+        typename std::conditional<
+            std::is_same<ValueType, double>::value,
+            typename std::conditional<sizeof(ValueType) * Size == 16, __m128d,
+                                      __m256d>::type,
+            typename std::conditional<sizeof(ValueType) * Size == 16, __m128,
+                                      __m256>::type>::type>::type;
+};
+#elif defined Vc_IMPL_SSE
+template <typename ValueType, size_t Size> struct IntrinsicType {
+    using type = typename std::conditional<
+        std::is_integral<ValueType>::value, __m128i,
+        typename std::conditional<std::is_same<ValueType, double>::value, __m128d,
+                                  __m128>::type>::type;
+};
+#elif defined Vc_IMPL_MIC
+template <typename ValueType, size_t Size> struct IntrinsicType {
+    using type = typename std::conditional<
+        std::is_integral<ValueType>::value, __m512i,
+        typename std::conditional<std::is_same<ValueType, double>::value, __m512d,
+                                  __m512>::type>::type;
+};
+#else
+template <typename ValueType, size_t Size> struct IntrinsicType {
+    static_assert(Size == 1,
+                  "IntrinsicType without SIMD target support may only have Size = 1");
+    using type = ValueType;
+};
+#endif
+template <typename ValueType, size_t Size, size_t Bytes = sizeof(ValueType) * Size>
+struct BuiltinType;
+#ifdef Vc_USE_BUILTIN_VECTOR_TYPES
+#define Vc_VECBUILTIN __attribute__((__vector_size__(16)))
+template <size_t Size> struct BuiltinType<         double   , Size, 16> { typedef          double    type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         float    , Size, 16> { typedef          float     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         long long, Size, 16> { typedef          long long type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned long long, Size, 16> { typedef unsigned long long type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         long     , Size, 16> { typedef          long      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned long     , Size, 16> { typedef unsigned long      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         int      , Size, 16> { typedef          int       type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned int      , Size, 16> { typedef unsigned int       type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         short    , Size, 16> { typedef          short     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned short    , Size, 16> { typedef unsigned short     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         char     , Size, 16> { typedef          char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned char     , Size, 16> { typedef unsigned char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<  signed char     , Size, 16> { typedef   signed char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         bool     , Size, 16> { typedef unsigned char      type Vc_VECBUILTIN; };
+#undef Vc_VECBUILTIN
+#define Vc_VECBUILTIN __attribute__((__vector_size__(32)))
+template <size_t Size> struct BuiltinType<         double   , Size, 32> { typedef          double    type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         float    , Size, 32> { typedef          float     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         long long, Size, 32> { typedef          long long type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned long long, Size, 32> { typedef unsigned long long type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         long     , Size, 32> { typedef          long      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned long     , Size, 32> { typedef unsigned long      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         int      , Size, 32> { typedef          int       type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned int      , Size, 32> { typedef unsigned int       type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         short    , Size, 32> { typedef          short     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned short    , Size, 32> { typedef unsigned short     type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         char     , Size, 32> { typedef          char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<unsigned char     , Size, 32> { typedef unsigned char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<  signed char     , Size, 32> { typedef   signed char      type Vc_VECBUILTIN; };
+template <size_t Size> struct BuiltinType<         bool     , Size, 32> { typedef unsigned char      type Vc_VECBUILTIN; };
+#undef Vc_VECBUILTIN
+#endif
+}  // namespace Detail
+
+template <typename ValueType, size_t Size>
+using IntrinsicType = typename Detail::IntrinsicType<ValueType, Size>::type;
 
-template<typename _VectorType, typename _EntryType, typename VectorTypeBase = _VectorType> class VectorMemoryUnion
+template <typename ValueType, size_t Size>
+using BuiltinType = typename Detail::BuiltinType<ValueType, Size>::type;
+
+namespace AliasStrategy
 {
-    public:
-        typedef _VectorType VectorType;
-        typedef _EntryType EntryType;
-        typedef EntryType AliasingEntryType Vc_MAY_ALIAS;
-        Vc_ALWAYS_INLINE VectorMemoryUnion() { assertCorrectAlignment(&v()); }
-#if defined VC_ICC || defined VC_MSVC
-        Vc_ALWAYS_INLINE VectorMemoryUnion(const VectorType &x) { data.v = x; assertCorrectAlignment(&data.v); }
-        Vc_ALWAYS_INLINE VectorMemoryUnion &operator=(const VectorType &x) {
-            data.v = x; return *this;
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE VectorType &v() { return reinterpret_cast<VectorType &>(data.v); }
-        Vc_ALWAYS_INLINE Vc_PURE const VectorType &v() const { return reinterpret_cast<const VectorType &>(data.v); }
-
-#if defined VC_ICC
-        Vc_ALWAYS_INLINE Vc_PURE AliasingEntryHelper<VectorMemoryUnion> m(size_t index) {
-            return AliasingEntryHelper<VectorMemoryUnion>(this, index);
-        }
-        Vc_ALWAYS_INLINE void assign(size_t index, EntryType x) {
-            data.m[index] = x;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE EntryType read(size_t index) const {
-            return data.m[index];
-        }
+struct Union {};
+struct MayAlias {};
+struct VectorBuiltin {};
+struct UnionMembers {};
+}  // namespace AliasStrategy
+
+using DefaultStrategy =
+#if defined Vc_USE_BUILTIN_VECTOR_TYPES
+    AliasStrategy::VectorBuiltin;
+#elif defined Vc_MSVC
+    AliasStrategy::UnionMembers;
+#elif defined Vc_ICC
+    AliasStrategy::Union;
+#elif defined __GNUC__
+    AliasStrategy::MayAlias;
 #else
-        Vc_ALWAYS_INLINE Vc_PURE EntryType &m(size_t index) {
-            return data.m[index];
-        }
-#endif
-
-        Vc_ALWAYS_INLINE Vc_PURE EntryType m(size_t index) const {
-            return data.m[index];
-        }
-
-#ifdef VC_COMPILE_BENCHMARKS
-    public:
-#endif
-    private:
-        union VectorScalarUnion {
-            VectorTypeBase v;
-            EntryType m[sizeof(VectorTypeBase)/sizeof(EntryType)];
-        } data;
+    AliasStrategy::Union;
+#endif
+
+template <typename ValueType, size_t Size, typename Strategy = DefaultStrategy>
+class Storage;
+
+// GCC 6 forbids `EntryType m[]` altogether
+template <typename ValueType, size_t Size>
+class Storage<ValueType, Size, AliasStrategy::Union>
+{
+    static_assert(std::is_fundamental<ValueType>::value &&
+                      std::is_arithmetic<ValueType>::value,
+                  "Only works for fundamental arithmetic types.");
+
+public:
+    using VectorType = IntrinsicType<ValueType, Size>;
+    using EntryType = ValueType;
+
+    union Alias {
+        Vc_INTRINSIC Alias(VectorType vv) : v(vv) {}
+        VectorType v;
+        EntryType m[Size];
+    };
+
+    Vc_INTRINSIC Storage() : data(Vc::Detail::zero<VectorType>()) {}
+    Vc_INTRINSIC Storage(const VectorType &x) : data(x) { assertCorrectAlignment(&data); }
+    template <typename U>
+    Vc_INTRINSIC explicit Storage(const U &x,
+                                  enable_if<sizeof(U) == sizeof(VectorType)> = nullarg)
+        : data(reinterpret_cast<VectorType>(x))
+    {
+        assertCorrectAlignment(&data);
+    }
+
+    Vc_INTRINSIC Storage(const Storage &) = default;
+    Vc_INTRINSIC Storage &operator=(const Storage &) = default;
+
+    Vc_INTRINSIC operator const VectorType &() const { return data; }
+    Vc_INTRINSIC Vc_PURE VectorType &v() { return data; }
+    Vc_INTRINSIC Vc_PURE const VectorType &v() const { return data; }
+    Vc_INTRINSIC Vc_PURE EntryType m(size_t i) const { return Alias(data).m[i]; }
+    Vc_INTRINSIC void set(size_t i, EntryType x)
+    {
+        Alias a(data);
+        a.m[i] = x;
+        data = a.v;
+    }
+
+private:
+    VectorType data;
+};
+
+template <typename ValueType, size_t Size>
+class Storage<ValueType, Size, AliasStrategy::MayAlias>
+{
+    static_assert(std::is_fundamental<ValueType>::value &&
+                      std::is_arithmetic<ValueType>::value,
+                  "Only works for fundamental arithmetic types.");
+
+public:
+    using VectorType = IntrinsicType<ValueType, Size>;
+    using EntryType = ValueType;
+
+    Vc_INTRINSIC Storage() : data() { assertCorrectAlignment(&data); }
+    Vc_INTRINSIC Storage(const VectorType &x) : data(x)
+    {
+        assertCorrectAlignment(&data);
+    }
+    template <typename U>
+    Vc_INTRINSIC explicit Storage(const U &x,
+                                  enable_if<sizeof(U) == sizeof(VectorType)> = nullarg)
+        : data(reinterpret_cast<const VectorType &>(x))
+    {
+        assertCorrectAlignment(&data);
+    }
+    Vc_INTRINSIC Storage &operator=(const VectorType &x)
+    {
+        data = x;
+        return *this;
+    }
+
+    Vc_INTRINSIC Storage(const Storage &) = default;
+    Vc_INTRINSIC Storage &operator=(const Storage &) = default;
+
+    Vc_INTRINSIC operator const VectorType &() const { return v(); }
+    Vc_INTRINSIC Vc_PURE VectorType &v() { return data; }
+    Vc_INTRINSIC Vc_PURE const VectorType &v() const { return data; }
+
+    Vc_INTRINSIC Vc_PURE EntryType m(size_t i) const
+    {
+        return reinterpret_cast<const MayAlias<EntryType> *>(&data)[i];
+    }
+    Vc_INTRINSIC void set(size_t i, EntryType x)
+    {
+        reinterpret_cast<MayAlias<EntryType> *>(&data)[i] = x;
+    }
+
+private:
+    VectorType data;
+};
+
+template <typename ValueType, size_t Size>
+class Storage<ValueType, Size, AliasStrategy::VectorBuiltin>
+{
+    static_assert(std::is_fundamental<ValueType>::value &&
+                      std::is_arithmetic<ValueType>::value,
+                  "Only works for fundamental arithmetic types.");
+
+    using Builtin = BuiltinType<ValueType, Size>;
+
+public:
+    using VectorType =
+#ifdef Vc_TEMPLATES_DROP_ATTRIBUTES
+        MayAlias<IntrinsicType<ValueType, Size>>;
 #else
-        Vc_ALWAYS_INLINE VectorMemoryUnion(VectorType x) : data(x) { assertCorrectAlignment(&data); }
-        Vc_ALWAYS_INLINE VectorMemoryUnion &operator=(VectorType x) {
-            data = x; return *this;
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE VectorType &v() { return data; }
-        Vc_ALWAYS_INLINE Vc_PURE const VectorType &v() const { return data; }
-
-        Vc_ALWAYS_INLINE Vc_PURE AliasingEntryType &m(size_t index) {
-            return reinterpret_cast<AliasingEntryType *>(&data)[index];
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE EntryType m(size_t index) const {
-            return reinterpret_cast<const AliasingEntryType *>(&data)[index];
-        }
-
-    private:
-#ifdef VC_COMPILE_BENCHMARKS
-    public:
-#endif
-        VectorType data;
+        IntrinsicType<ValueType, Size>;
 #endif
+    using EntryType = ValueType;
+
+    Vc_INTRINSIC Storage() : data() { assertCorrectAlignment(&data); }
+    Vc_INTRINSIC Storage(const VectorType &x)
+        : data(reinterpret_cast<const MayAlias<Builtin> &>(x))
+    {
+        assertCorrectAlignment(&data);
+    }
+    template <typename U>
+    Vc_INTRINSIC explicit Storage(const U &x,
+                                  enable_if<sizeof(U) == sizeof(VectorType)> = nullarg)
+        : data(reinterpret_cast<const MayAlias<Builtin> &>(x))
+    {
+        assertCorrectAlignment(&data);
+    }
+    Vc_INTRINSIC Storage &operator=(const VectorType &x)
+    {
+        data = reinterpret_cast<const MayAlias<Builtin> &>(x);
+        return *this;
+    }
+
+    Vc_INTRINSIC Storage(const Storage &) = default;
+    Vc_INTRINSIC Storage &operator=(const Storage &) = default;
+
+    Vc_INTRINSIC operator const VectorType &() const { return v(); }
+    Vc_INTRINSIC Vc_PURE VectorType &v() { return reinterpret_cast<VectorType &>(data); }
+    Vc_INTRINSIC Vc_PURE const VectorType &v() const { return reinterpret_cast<const VectorType &>(data); }
+
+    Vc_INTRINSIC Vc_PURE EntryType m(size_t i) const { return data[i]; }
+    Vc_INTRINSIC void set(size_t i, EntryType x) { data[i] = x; }
+
+    Vc_INTRINSIC Builtin &builtin() { return data; }
+    Vc_INTRINSIC const Builtin &builtin() const { return data; }
+
+private:
+    Builtin data;
 };
 
-#if VC_GCC == 0x40700 || (VC_GCC >= 0x40600 && VC_GCC <= 0x40603)
-// workaround bug 52736 in GCC
-template<typename T, typename V> static Vc_ALWAYS_INLINE Vc_CONST T &vectorMemoryUnionAliasedMember(V *data, size_t index) {
-    if (__builtin_constant_p(index) && index == 0) {
-        T *ret;
-        asm("mov %1,%0" : "=r"(ret) : "r"(data));
-        return *ret;
-    } else {
-        return reinterpret_cast<T *>(data)[index];
-    }
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE VectorMemoryUnion<__m128d, double>::AliasingEntryType &VectorMemoryUnion<__m128d, double>::m(size_t index) {
-    return vectorMemoryUnionAliasedMember<AliasingEntryType>(&data, index);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE VectorMemoryUnion<__m128i, long long>::AliasingEntryType &VectorMemoryUnion<__m128i, long long>::m(size_t index) {
-    return vectorMemoryUnionAliasedMember<AliasingEntryType>(&data, index);
-}
-template<> Vc_ALWAYS_INLINE Vc_PURE VectorMemoryUnion<__m128i, unsigned long long>::AliasingEntryType &VectorMemoryUnion<__m128i, unsigned long long>::m(size_t index) {
-    return vectorMemoryUnionAliasedMember<AliasingEntryType>(&data, index);
-}
-#endif
-
-} // namespace Common
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+template <typename ValueType, size_t Size>
+class Storage<ValueType, Size, AliasStrategy::UnionMembers>
+{
+    static_assert(std::is_fundamental<ValueType>::value &&
+                      std::is_arithmetic<ValueType>::value,
+                  "Only works for fundamental arithmetic types.");
+
+public:
+    using VectorType = IntrinsicType<ValueType, Size>;
+    using EntryType = ValueType;
+
+    Vc_INTRINSIC Storage() : data() { assertCorrectAlignment(&data); }
+    Vc_INTRINSIC Storage(const VectorType &x) : data(x)
+    {
+        assertCorrectAlignment(&data);
+    }
+    template <typename U>
+    Vc_INTRINSIC explicit Storage(const U &x,
+                                  enable_if<sizeof(U) == sizeof(VectorType)> = nullarg)
+        : data(reinterpret_cast<const VectorType &>(x))
+    {
+        assertCorrectAlignment(&data);
+    }
+    Vc_INTRINSIC Storage &operator=(const VectorType &x)
+    {
+        data = x;
+        return *this;
+    }
+
+    Vc_INTRINSIC Storage(const Storage &) = default;
+    Vc_INTRINSIC Storage &operator=(const Storage &) = default;
+
+    Vc_INTRINSIC Vc_PURE VectorType &v() { return data; }
+    Vc_INTRINSIC Vc_PURE const VectorType &v() const { return data; }
+
+    Vc_INTRINSIC_L Vc_PURE_L EntryType m(size_t i) const Vc_INTRINSIC_R Vc_PURE_R;
+    Vc_INTRINSIC void set(size_t i, EntryType x) { ref(i) = x; }
+
+private:
+    Vc_INTRINSIC_L Vc_PURE_L EntryType &ref(size_t i) Vc_INTRINSIC_R Vc_PURE_R;
+    VectorType data;
+};
+
+#ifdef Vc_MSVC
+template <> Vc_INTRINSIC Vc_PURE          double Storage<         double, 2, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128d_f64[i]; }
+template <> Vc_INTRINSIC Vc_PURE          float  Storage<         float , 4, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128_f32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed int    Storage<  signed int   , 4, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_i32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed short  Storage<  signed short , 8, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_i16[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed char   Storage<  signed char  ,16, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_i8[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned int    Storage<unsigned int   , 4, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_u32[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned short  Storage<unsigned short , 8, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_u16[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned char   Storage<unsigned char  ,16, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m128i_u8[i]; }
+
+template <> Vc_INTRINSIC Vc_PURE          double &Storage<         double, 2, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128d_f64[i]; }
+template <> Vc_INTRINSIC Vc_PURE          float  &Storage<         float , 4, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128_f32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed int    &Storage<  signed int   , 4, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128i_i32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed short  &Storage<  signed short , 8, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128i_i16[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed char   &Storage<  signed char  ,16, AliasStrategy::UnionMembers>::ref(size_t i) { return reinterpret_cast<signed char &>(data.m128i_i8[i]); }
+template <> Vc_INTRINSIC Vc_PURE unsigned int    &Storage<unsigned int   , 4, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128i_u32[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned short  &Storage<unsigned short , 8, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128i_u16[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned char   &Storage<unsigned char  ,16, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m128i_u8[i]; }
+
+#ifdef Vc_IMPL_AVX
+template <> Vc_INTRINSIC Vc_PURE          double Storage<         double, 4, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256d_f64[i]; }
+template <> Vc_INTRINSIC Vc_PURE          float  Storage<         float , 8, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256_f32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed int    Storage<  signed int   , 8, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_i32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed short  Storage<  signed short ,16, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_i16[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed char   Storage<  signed char  ,32, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_i8[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned int    Storage<unsigned int   , 8, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_u32[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned short  Storage<unsigned short ,16, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_u16[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned char   Storage<unsigned char  ,32, AliasStrategy::UnionMembers>::m(size_t i) const { return data.m256i_u8[i]; }
+
+template <> Vc_INTRINSIC Vc_PURE          double &Storage<         double, 4, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256d_f64[i]; }
+template <> Vc_INTRINSIC Vc_PURE          float  &Storage<         float , 8, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256_f32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed int    &Storage<  signed int   , 8, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256i_i32[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed short  &Storage<  signed short ,16, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256i_i16[i]; }
+template <> Vc_INTRINSIC Vc_PURE   signed char   &Storage<  signed char  ,32, AliasStrategy::UnionMembers>::ref(size_t i) { return reinterpret_cast<signed char &>(data.m256i_i8[i]); }
+template <> Vc_INTRINSIC Vc_PURE unsigned int    &Storage<unsigned int   , 8, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256i_u32[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned short  &Storage<unsigned short ,16, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256i_u16[i]; }
+template <> Vc_INTRINSIC Vc_PURE unsigned char   &Storage<unsigned char  ,32, AliasStrategy::UnionMembers>::ref(size_t i) { return data.m256i_u8[i]; }
+#endif
+#endif  // Vc_MSVC
+
+template <typename VectorType, typename EntryType>
+using VectorMemoryUnion = Storage<EntryType, sizeof(VectorType) / sizeof(EntryType)>;
 
-#include "undomacros.h"
+}  // namespace Common
+}  // namespace Vc
 
-#endif // VC_COMMON_STORAGE_H
+#endif // VC_COMMON_STORAGE_H_
diff -Nru vc-0.7.4/common/storeinterface.h vc-1.3.0/common/storeinterface.h
--- vc-0.7.4/common/storeinterface.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/storeinterface.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,92 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// stores
+
+/**
+ * Store the vector data to \p mem.
+ *
+ * \param mem A pointer to memory, where \VSize{T} consecutive values will be stored.
+ * \param flags The flags parameter can be used to select e.g. the Vc::Aligned,
+ *              Vc::Unaligned, Vc::Streaming, and/or Vc::PrefetchDefault flags.
+ */
+template <
+    typename U,
+    typename Flags = DefaultStoreTag,
+    typename = enable_if<std::is_arithmetic<U>::value &&Traits::is_load_store_flag<Flags>::value>>
+Vc_INTRINSIC_L void store(U *mem, Flags flags = Flags()) const Vc_INTRINSIC_R;
+
+/**
+ * Store the vector data to \p mem where \p mask is set.
+ *
+ * \param mem A pointer to memory, where \VSize{T} consecutive values will be stored.
+ * \param mask A mask object that determines which entries of the vector should be stored
+ *             to \p mem.
+ * \param flags The flags parameter can be used to select e.g. the Vc::Aligned,
+ *              Vc::Unaligned, Vc::Streaming, and/or Vc::PrefetchDefault flags.
+ *
+ * \note
+ * The masked store does not pack the values into memory. I.e. the value at offset \c i
+ * will be stored to `mem[i]`, independent of whether `mask[j]` for any `j < i` is \c
+ * false.
+ */
+template <
+    typename U,
+    typename Flags = DefaultStoreTag,
+    typename = enable_if<std::is_arithmetic<U>::value &&Traits::is_load_store_flag<Flags>::value>>
+Vc_INTRINSIC_L void Vc_VDECL store(U *mem, MaskType mask, Flags flags = Flags()) const Vc_INTRINSIC_R;
+
+//@{
+/**
+ * The following store overloads support classes that have a cast operator to `EntryType
+ * *`.
+ */
+Vc_INTRINSIC void store(EntryType *mem) const
+{
+    store<EntryType, DefaultStoreTag>(mem, DefaultStoreTag());
+}
+
+template <typename Flags, typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+Vc_INTRINSIC void store(EntryType *mem, Flags flags) const
+{
+    store<EntryType, Flags>(mem, flags);
+}
+
+Vc_INTRINSIC void Vc_VDECL store(EntryType *mem, MaskType mask) const
+{
+    store<EntryType, DefaultStoreTag>(mem, mask, DefaultStoreTag());
+}
+
+template <typename Flags, typename = enable_if<Traits::is_load_store_flag<Flags>::value>>
+Vc_INTRINSIC void Vc_VDECL store(EntryType *mem, MaskType mask, Flags flags) const
+{
+    store<EntryType, Flags>(mem, mask, flags);
+}
+//@}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/subscript.h vc-1.3.0/common/subscript.h
--- vc-0.7.4/common/subscript.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/subscript.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,599 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_SUBSCRIPT_H_
+#define VC_COMMON_SUBSCRIPT_H_
+
+#include <initializer_list>
+#include <ratio>
+#include <type_traits>
+#include <vector>
+#include "types.h"
+#include "macros.h"
+#include <assert.h>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+// AdaptSubscriptOperator {{{1
+template <typename Base> class AdaptSubscriptOperator : public Base
+{
+public:
+    // perfect forward all Base constructors
+    template <typename... Args>
+    Vc_ALWAYS_INLINE AdaptSubscriptOperator(Args &&... arguments)
+        : Base(std::forward<Args>(arguments)...)
+    {
+    }
+
+    // perfect forward all Base constructors
+    template <typename T>
+    Vc_ALWAYS_INLINE AdaptSubscriptOperator(std::initializer_list<T> l)
+        : Base(l)
+    {
+    }
+
+    // explicitly enable Base::operator[] because the following would hide it
+    using Base::operator[];
+
+    /// \internal forward to non-member subscript_operator function
+    template <typename I,
+              typename = enable_if<!std::is_arithmetic<
+                  typename std::decay<I>::type>::value>  // arithmetic types
+                                                         // should always use
+                                                         // Base::operator[] and
+                                                         // never match this one
+              >
+    Vc_ALWAYS_INLINE auto operator[](I &&arg_)
+        -> decltype(subscript_operator(*this, std::forward<I>(arg_)))
+    {
+        return subscript_operator(*this, std::forward<I>(arg_));
+    }
+
+    // const overload of the above
+    template <typename I, typename = enable_if<
+                              !std::is_arithmetic<typename std::decay<I>::type>::value>>
+    Vc_ALWAYS_INLINE auto operator[](I &&arg_) const
+        -> decltype(subscript_operator(*this, std::forward<I>(arg_)))
+    {
+        return subscript_operator(*this, std::forward<I>(arg_));
+    }
+};
+// apply Scale (std::ratio) functions {{{1
+template <typename Scale, typename T>
+Vc_ALWAYS_INLINE enable_if<Scale::num == Scale::den, Traits::decay<T>> applyScale(T &&x)
+{
+    return std::forward<T>(x);
+}
+
+template <typename Scale, typename T>
+Vc_ALWAYS_INLINE enable_if<
+    Scale::num != Scale::den && Traits::has_multiply_operator<T, std::intmax_t>::value,
+    Traits::decay<T>>
+    applyScale(T &&x)
+{
+    static_assert(Scale::num % Scale::den == 0,
+                  "Non-integral index scaling requested. This typically happens only for "
+                  "Vc::Scalar on 32-bit for gathers on double. You can work around the "
+                  "issue by ensuring that all doubles in the structure are aligned on 8 "
+                  "Bytes.");
+    constexpr auto value = Scale::num / Scale::den;
+    Vc_ASSERT(Vc::all_of((x * value) / value == x));
+    return std::forward<T>(x) * value;
+}
+
+template <typename Scale, typename T>
+Vc_ALWAYS_INLINE enable_if<
+    Scale::num != Scale::den && !Traits::has_multiply_operator<T, std::intmax_t>::value,
+    T>
+    applyScale(T x)
+{
+    static_assert(Scale::num % Scale::den == 0,
+                  "Non-integral index scaling requested. This typically happens only for "
+                  "Vc::Scalar on 32-bit for gathers on double. You can work around the "
+                  "issue by ensuring that all doubles in the structure are aligned on 8 "
+                  "Bytes.");
+    constexpr auto value = Scale::num / Scale::den;
+    for (size_t i = 0; i < x.size(); ++i) {
+        Vc_ASSERT((x[i] * value) / value == x[i]);
+        x[i] *= value;
+    }
+    return x;
+}
+
+template <typename Scale, typename T, typename U,
+          typename = enable_if<Traits::has_multiply_operator<T, std::intmax_t>::value &&
+                               Traits::has_addition_operator<T, U>::value>>
+Vc_ALWAYS_INLINE typename std::decay<T>::type applyScaleAndAdd(T &&x, U &&y)
+{
+    constexpr auto value = Scale::num / Scale::den;
+    if (value == 1) {  // static evaluation
+        return std::forward<T>(x) + std::forward<U>(y);
+    }
+    return std::forward<T>(x) * value + std::forward<U>(y);
+}
+
+template <
+    typename Scale, typename T, typename U,
+    typename = enable_if<
+        !(Traits::has_multiply_operator<T &, std::intmax_t>::value &&
+          Traits::has_addition_operator<T &, decltype(std::declval<U>()[0])>::value) &&
+        Traits::has_subscript_operator<U>::value>>
+Vc_ALWAYS_INLINE T applyScaleAndAdd(T x, U &&y)
+{
+    constexpr auto value = Scale::num / Scale::den;
+    for (size_t i = 0; i < x.size(); ++i) {
+        if (value == 1) {  // static evaluation
+            x[i] = x[i] + y[i];
+        } else {
+            x[i] = x[i] * value + y[i];
+        }
+    }
+    return x;
+}
+
+template <typename Scale, typename T, typename U>
+Vc_ALWAYS_INLINE enable_if<!(Traits::has_multiply_operator<T &, std::intmax_t>::value &&
+                             Traits::has_addition_operator<T &, U>::value) &&
+                               !Traits::has_subscript_operator<U>::value,
+                           T>
+    applyScaleAndAdd(T x, U &&y)
+{
+    constexpr auto value = Scale::num / Scale::den;
+    for (size_t i = 0; i < x.size(); ++i) {
+        if (value == 1) {  // static evaluation
+            x[i] = x[i] + y;
+        } else {
+            x[i] = x[i] * value + y;
+        }
+    }
+    return x;
+}
+
+// IndexVectorSizeMatches {{{1
+template <std::size_t MinSize,
+          typename IndexT,
+          bool = Traits::is_simd_vector<IndexT>::value>
+struct IndexVectorSizeMatches
+    : public std::true_type  // you might expect this should be false_type here, but the point is
+                             // that IndexT is a type where the size is not known at compile time.
+                             // Thus it may be good but we cannot know from the type. The only check
+                             // we could do is a runtime check, but the type is fine.
+{
+};
+
+template <std::size_t MinSize, typename V>
+struct IndexVectorSizeMatches<MinSize,
+                              V,
+                              true> : public std::integral_constant<bool, (MinSize <= V::Size)>
+{
+};
+
+template <std::size_t MinSize, typename T, std::size_t ArraySize>
+struct IndexVectorSizeMatches<MinSize,
+                              T[ArraySize],
+                              false> : public std::integral_constant<bool, (MinSize <= ArraySize)>
+{
+};
+
+template <std::size_t MinSize, typename T, std::size_t ArraySize>
+struct IndexVectorSizeMatches<MinSize,
+                              std::array<T, ArraySize>,
+                              false> : public std::integral_constant<bool, (MinSize <= ArraySize)>
+{
+};
+
+template <std::size_t MinSize, typename T, std::size_t ArraySize>
+struct IndexVectorSizeMatches<MinSize,
+                              Vc::array<T, ArraySize>,
+                              false> : public std::integral_constant<bool, (MinSize <= ArraySize)>
+{
+};
+// convertIndexVector {{{1
+// if the argument is a Vector<T> already we definitely want to keep it that way
+template <typename IV>
+enable_if<
+    (Traits::is_simd_vector<IV>::value && sizeof(typename IV::EntryType) >= sizeof(int)),
+    const IV &>
+    convertIndexVector(const IV &indexVector)
+{
+    return indexVector;
+}
+
+// but if the scalar (integral) type is smaller than int we convert it up to int. Otherwise it's
+// very likely that the calculations we have to perform will overflow.
+template <typename IV>
+enable_if<
+    (Traits::is_simd_vector<IV>::value && sizeof(typename IV::EntryType) < sizeof(int)),
+    SimdArray<int, IV::Size>>
+    convertIndexVector(const IV &indexVector)
+{
+    return static_cast<SimdArray<int, IV::Size>>(indexVector);
+}
+
+// helper for promoting int types to int or higher
+template<typename T> using promoted_type = decltype(std::declval<T>() + 1);
+
+// std::array, Vc::array, and C-array are fixed size and can therefore be converted to a
+// SimdArray of the same size
+template <typename T, std::size_t N>
+enable_if<std::is_integral<T>::value, SimdArray<promoted_type<T>, N>> convertIndexVector(
+    const std::array<T, N> &indexVector)
+{
+    return {std::addressof(indexVector[0]), Vc::Unaligned};
+}
+template <typename T, std::size_t N>
+enable_if<std::is_integral<T>::value, SimdArray<promoted_type<T>, N>> convertIndexVector(
+    const Vc::array<T, N> &indexVector)
+{
+    return {std::addressof(indexVector[0]), Vc::Unaligned};
+}
+template <typename T, std::size_t N>
+enable_if<std::is_integral<T>::value, SimdArray<promoted_type<T>, N>> convertIndexVector(
+    const T (&indexVector)[N])
+{
+    return SimdArray<promoted_type<T>, N>{std::addressof(indexVector[0]), Vc::Unaligned};
+}
+
+// a plain pointer won't work. Because we need some information on the number of values in
+// the index argument
+#ifndef Vc_MSVC
+// MSVC treats the function as usable in SFINAE context if it is deleted. If it's not declared we
+// seem to get what we wanted (except for bad diagnostics)
+template <typename T>
+enable_if<std::is_pointer<T>::value, void> convertIndexVector(T indexVector) = delete;
+#endif
+
+// an initializer_list works, but is runtime-sized (before C++14, at least) so we have to
+// fall back to std::vector
+template <typename T>
+std::vector<promoted_type<T>> convertIndexVector(
+    const std::initializer_list<T> &indexVector)
+{
+    return {begin(indexVector), end(indexVector)};
+}
+
+// a std::vector cannot be converted to anything better
+template <typename T>
+enable_if<(std::is_integral<T>::value && sizeof(T) >= sizeof(int)), std::vector<T>>
+    convertIndexVector(const std::vector<T> &indexVector)
+{
+    return indexVector;
+}
+template <typename T>
+enable_if<(std::is_integral<T>::value && sizeof(T) < sizeof(int)),
+          std::vector<promoted_type<T>>>
+    convertIndexVector(const std::vector<T> &indexVector)
+{
+    return {std::begin(indexVector), std::end(indexVector)};
+}
+
+template <typename T>
+std::true_type is_valid_indexvector(
+    T &&, Traits::decay<decltype(convertIndexVector(std::declval<T>()))> * = nullptr);
+std::false_type is_valid_indexvector(...);
+
+template <typename IndexVector, typename Test = decltype(is_valid_indexvector(std::declval<const IndexVector &>()))>
+struct is_valid_indexvector_ : public std::integral_constant<bool, Test::value>
+{};
+static_assert(!is_valid_indexvector_<const int *>::value, "Pointer is incorrectly classified as valid index vector type");
+static_assert( is_valid_indexvector_<const int[4]>::value, "C-Array is incorrectly classified as invalid index vector type");
+
+// SubscriptOperation {{{1
+template <
+    typename T, typename IndexVector, typename Scale = std::ratio<1, 1>,
+    bool = is_valid_indexvector_<IndexVector>::value>
+class SubscriptOperation
+{
+    const IndexVector m_indexes;
+    T *const m_address;
+    using ScalarType = typename std::decay<T>::type;
+
+    using IndexVectorScaled = Traits::decay<decltype(convertIndexVector(std::declval<const IndexVector &>()))>;
+
+public:
+    template <typename U,
+              typename = enable_if<((std::is_convertible<const U &, IndexVector>::value ||
+                                     std::is_same<U, IndexVector>::value) &&
+                                    std::is_copy_constructible<IndexVector>::value)>>
+    constexpr Vc_ALWAYS_INLINE SubscriptOperation(T *address, const U &indexes)
+        : m_indexes(indexes), m_address(address)
+    {
+    }
+
+    template <std::size_t... Indexes>
+    constexpr Vc_ALWAYS_INLINE SubscriptOperation(T *address, const IndexVector &indexes,
+                                                  index_sequence<Indexes...>)
+        : m_indexes{indexes[Indexes]...}, m_address(address)
+    {}
+
+    template <typename U>
+    constexpr Vc_ALWAYS_INLINE SubscriptOperation(
+        T *address, const U &indexes,
+        enable_if<((std::is_convertible<const U &, IndexVector>::value ||
+                    std::is_same<U, IndexVector>::value) &&
+                   !std::is_copy_constructible<IndexVector>::value &&
+                   std::is_array<IndexVector>::value &&
+                   std::extent<IndexVector>::value > 0)> = nullarg)
+        : SubscriptOperation(address, indexes,
+                             make_index_sequence<std::extent<IndexVector>::value>())
+    {
+    }
+
+    Vc_ALWAYS_INLINE GatherArguments<T, IndexVectorScaled> gatherArguments() const
+    {
+        static_assert(std::is_arithmetic<ScalarType>::value,
+                      "Incorrect type for a SIMD vector gather. Must be an arithmetic type.");
+        return {applyScale<Scale>(convertIndexVector(m_indexes)), m_address};
+    }
+
+    Vc_ALWAYS_INLINE ScatterArguments<T, IndexVectorScaled> scatterArguments() const
+    {
+        static_assert(std::is_arithmetic<ScalarType>::value,
+                      "Incorrect type for a SIMD vector scatter. Must be an arithmetic type.");
+        return {applyScale<Scale>(convertIndexVector(m_indexes)), m_address};
+    }
+
+    template <typename V,
+              typename = enable_if<(std::is_arithmetic<ScalarType>::value &&Traits::is_simd_vector<
+                  V>::value &&IndexVectorSizeMatches<V::Size, IndexVector>::value)>>
+    Vc_ALWAYS_INLINE operator V() const
+    {
+        static_assert(std::is_arithmetic<ScalarType>::value,
+                      "Incorrect type for a SIMD vector gather. Must be an arithmetic type.");
+        const auto indexes = applyScale<Scale>(convertIndexVector(m_indexes));
+        return V(m_address, indexes);
+    }
+
+    template <typename V,
+              typename = enable_if<(std::is_arithmetic<ScalarType>::value &&Traits::is_simd_vector<
+                  V>::value &&IndexVectorSizeMatches<V::Size, IndexVector>::value)>>
+    Vc_ALWAYS_INLINE SubscriptOperation &operator=(const V &rhs)
+    {
+        static_assert(std::is_arithmetic<ScalarType>::value,
+                      "Incorrect type for a SIMD vector scatter. Must be an arithmetic type.");
+        const auto indexes = applyScale<Scale>(convertIndexVector(m_indexes));
+        rhs.scatter(m_address, indexes);
+        return *this;
+    }
+
+    // precondition: m_address points to a struct/class/union
+    template <
+        typename U,
+        typename S,  // S must be equal to T. Still we require this template parameter -
+        // otherwise instantiation of SubscriptOperation would only be valid for
+        // structs/unions.
+        typename = enable_if<std::is_same<S, typename std::remove_cv<T>::type>::value &&(
+            std::is_class<T>::value || std::is_union<T>::value)>>
+    Vc_ALWAYS_INLINE auto operator[](U S::*member)
+        -> SubscriptOperation<
+              typename std::conditional<std::is_const<T>::value,
+                                        const typename std::remove_reference<U>::type,
+                                        typename std::remove_reference<U>::type>::type,
+              IndexVector,
+              // By passing the scale factor as a fraction of integers in the template
+              // arguments the value does not lose information if the division yields a
+              // non-integral value. This could happen e.g. for a struct of struct (S2 {
+              // S1, char }, with sizeof(S1) = 16, sizeof(S2) = 20. Then scale would be
+              // 20/16)
+              std::ratio_multiply<Scale, std::ratio<sizeof(S), sizeof(U)>>>
+    {
+        static_assert(std::is_same<Traits::decay<decltype(m_address->*member)>,
+                                   Traits::decay<U>>::value,
+                      "Type mismatch that should be impossible.");
+        // TODO: check whether scale really works for unions correctly
+        return {&(m_address->*member), m_indexes};
+    }
+
+    /*
+     * The following functions allow subscripting of nested arrays. But
+     * there are two cases of containers and only one that we want to support:
+     * 1. actual arrays (e.g. T[N] or std::array<T, N>)
+     * 2. dynamically allocated vectors (e.g. std::vector<T>)
+     *
+     * For (1.) the offset calculation is straightforward.
+     * For (2.) the m_address pointer points to memory where pointers are
+     * stored to the actual data. Meaning the data can be scattered
+     * freely in memory (and far away from what m_address points to). Supporting this leads to
+     * serious trouble with the pointer (it does not really point to the start of a memory
+     * region anymore) and inefficient code. The user is better off to write a loop that assigns the
+     * scalars to the vector object sequentially.
+     */
+
+private:
+    // The following is a workaround for MSVC 2015 Update 2. Whenever the ratio
+    // in the return type of the following operator[] is encountered with a sizeof
+    // expression that fails, MSVC decides to substitute a 0 for the sizeof instead of
+    // just leaving the ratio instantiation alone via proper SFINAE. The make_ratio helper
+    // ensures that the 0 from the sizeof failure does not reach the denominator of
+    // std::ratio where it would hit a static_assert.
+    template <intmax_t N, intmax_t D> struct make_ratio {
+        using type = std::ratio<N, D == 0 ? 1 : D>;
+    };
+
+public:
+    // precondition: m_address points to a type that implements the subscript operator
+    template <typename U>
+    // U is only required to delay name lookup to the 2nd phase (on use).
+    // This is necessary because m_address[0][index] is only a correct
+    // expression if has_subscript_operator<T>::value is true.
+    Vc_ALWAYS_INLINE auto operator[](U index) -> typename std::enable_if<
+#ifndef Vc_IMPROVE_ERROR_MESSAGES
+        Traits::has_no_allocated_data<T>::value &&
+#endif
+            std::is_convertible<U, size_t>::value,
+        SubscriptOperation<
+            // the following decltype expression must depend on index and cannot
+            // simply use [0][0] because it would yield an invalid expression in
+            // case m_address[0] returns a struct/union
+            typename std::remove_reference<decltype(m_address[0][index])>::type,
+            IndexVector,
+            std::ratio_multiply<
+                Scale,
+                typename make_ratio<sizeof(T), sizeof(m_address[0][index])>::type>>>::type
+    {
+        static_assert(Traits::has_subscript_operator<T>::value,
+                      "The subscript operator was called on a type that does not implement it.\n");
+        static_assert(Traits::has_no_allocated_data<T>::value,
+                      "Invalid container type in gather/scatter operation.\nYou may only use "
+                      "nested containers that store the data inside the object (such as builtin "
+                      "arrays or std::array) but not containers that store data in allocated "
+                      "memory (such as std::vector).\nSince this feature cannot be queried "
+                      "generically at compile time you need to spezialize the "
+                      "Vc::Traits::has_no_allocated_data_impl<T> type-trait for custom types that "
+                      "meet the requirements.\n");
+        static_assert(std::is_lvalue_reference<decltype(m_address[0][index])>::value,
+                      "The container does not return an lvalue reference to the data at "
+                      "the requested offset. This makes it impossible to execute a "
+                      "gather operation.\n");
+        return {&(m_address[0][index]), m_indexes};
+    }
+
+    // precondition: m_address points to a type that implements the subscript operator
+    template <typename IT>
+    Vc_ALWAYS_INLINE typename std::enable_if<
+#ifndef Vc_IMPROVE_ERROR_MESSAGES
+        Traits::has_no_allocated_data<T>::value &&
+            Traits::has_subscript_operator<T>::value &&
+#endif
+            Traits::has_subscript_operator<IT>::value,
+        SubscriptOperation<typename std::remove_reference<decltype(
+                               m_address[0][std::declval<
+                                   const IT &>()[0]]  // std::declval<IT>()[0] could
+                                                      // be replaced with 0 if it
+                               // were not for two-phase lookup. We need to make the
+                               // m_address[0][0] expression dependent on IT
+                               )>::type,
+                           IndexVectorScaled,
+                           std::ratio<1, 1>  // reset Scale to 1 since it is applied below
+                           >>::type
+    operator[](const IT &index)
+    {
+        static_assert(Traits::has_subscript_operator<T>::value,
+                      "The subscript operator was called on a type that does not implement it.\n");
+        static_assert(Traits::has_no_allocated_data<T>::value,
+                      "Invalid container type in gather/scatter operation.\nYou may only use "
+                      "nested containers that store the data inside the object (such as builtin "
+                      "arrays or std::array) but not containers that store data in allocated "
+                      "memory (such as std::vector).\nSince this feature cannot be queried "
+                      "generically at compile time you need to spezialize the "
+                      "Vc::Traits::has_no_allocated_data_impl<T> type-trait for custom types that "
+                      "meet the requirements.\n");
+        return {&(m_address[0][0]),
+                applyScaleAndAdd<std::ratio_multiply<
+                    Scale, std::ratio<sizeof(T), sizeof(m_address[0][0])>>>(
+                    convertIndexVector(m_indexes), index)};
+    }
+};
+
+// specialization for invalid IndexVector type
+template <typename T, typename IndexVector, typename Scale>
+class SubscriptOperation<T, IndexVector, Scale, false>;
+
+// subscript_operator {{{1
+template <
+    typename Container,
+    typename IndexVector,
+    typename = enable_if<
+        Traits::has_subscript_operator<IndexVector>::value  // The index vector must provide [] for
+                                                            // the implementations of gather/scatter
+        &&Traits::has_contiguous_storage<Container>::value  // Container must use contiguous
+                                                            // storage, otherwise the index vector
+        // cannot be used as memory offsets, which is required for efficient
+        // gather/scatter implementations
+        &&std::is_lvalue_reference<decltype(*begin(std::declval<
+            Container>()))>::value  // dereferencing the begin iterator must yield an lvalue
+                                    // reference (const or non-const). Otherwise it is not possible
+                                    // to determine a pointer to the data storage (see above).
+        >>
+Vc_ALWAYS_INLINE SubscriptOperation<
+    typename std::remove_reference<decltype(*begin(std::declval<Container>()))>::
+        type,  // the type of the first value in the container is what the internal array pointer
+               // has to point to. But if the subscript operator of the container returns a
+               // reference we need to drop that part because it's useless information for us. But
+               // const and volatile, as well as array rank/extent are interesting and need not be
+               // dropped.
+    typename std::remove_const<typename std::remove_reference<
+        IndexVector>::type>::type  // keep volatile and possibly the array extent, but the const and
+                                   // & parts of the type need to be removed because
+                                   // SubscriptOperation explicitly adds them for its member type
+    > subscript_operator(Container &&c, IndexVector &&indexes)
+{
+    Vc_ASSERT(std::addressof(*begin(c)) + 1 ==
+              std::addressof(*(begin(c) + 1)));  // runtime assertion for contiguous storage, this
+                                                 // requires a RandomAccessIterator - but that
+                                                 // should be given for a container with contiguous
+                                                 // storage
+    return {std::addressof(*begin(c)), std::forward<IndexVector>(indexes)};
+}
+
+static_assert(!Traits::has_subscript_operator<SubscriptOperation<int[100][100], const int *>, int>::value, "has_subscript_operator fails");
+static_assert(!Traits::has_subscript_operator<SubscriptOperation<int[100][100], const int *>, int[4]>::value, "has_subscript_operator fails");
+static_assert(!Traits::has_subscript_operator<SubscriptOperation<std::vector<int>, const int *>, int[4]>::value, "has_subscript_operator fails");
+static_assert( Traits::has_subscript_operator<SubscriptOperation<int[100][100], const int[4]>, int>::value, "has_subscript_operator fails");
+static_assert( Traits::has_subscript_operator<SubscriptOperation<int[100][100], const int[4]>, int[4]>::value, "has_subscript_operator fails");
+static_assert(!Traits::has_subscript_operator<SubscriptOperation<std::vector<int>, const int[4]>, int[4]>::value, "has_subscript_operator fails");
+
+/**
+ * \internal
+ * Implement subscripts of std::initializer_list. This function must be in the global scope
+ * because Container arguments may be in any scope. The other argument is in std scope.
+ *
+ * -----
+ * std::initializer_list does not have constexpr member functions in C++11, but from C++14 onwards
+ * the world is a happier place. :)
+ */
+template <typename Container, typename I>
+Vc_ALWAYS_INLINE Vc::Common::SubscriptOperation<
+    typename std::remove_reference<decltype(std::declval<Container>()[0])>::type,
+    const std::initializer_list<I> &> subscript_operator(Container &&vec,
+                                                   const std::initializer_list<I> &indexes)
+{
+    return {&vec[0], indexes};
+}
+//}}}1
+
+}  // namespace Common
+
+using Common::subscript_operator;
+
+namespace Traits
+{
+template <typename T, typename IndexVector, typename Scale>
+struct is_subscript_operation_internal<Common::SubscriptOperation<T, IndexVector, Scale>> : public std::true_type
+{
+};
+}  // namespace Traits
+
+using Common::subscript_operator;
+
+}  // namespace Vc
+
+#endif // VC_COMMON_SUBSCRIPT_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/support.h vc-1.3.0/common/support.h
--- vc-0.7.4/common/support.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/support.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,7 +1,7 @@
-#ifndef VC_DEPRECATED_COMMON_SUPPORT_H
-#define VC_DEPRECATED_COMMON_SUPPORT_H
+#ifndef VC_DEPRECATED_COMMON_SUPPORT_H_
+#define VC_DEPRECATED_COMMON_SUPPORT_H_
 #ifdef __GNUC__
 #warning "the <Vc/common/support.h> header is deprecated. Use <Vc/support.h> instead."
 #endif
 #include <Vc/support.h>
-#endif // VC_DEPRECATED_COMMON_SUPPORT_H
+#endif // VC_DEPRECATED_COMMON_SUPPORT_H_
diff -Nru vc-0.7.4/common/transpose.h vc-1.3.0/common/transpose.h
--- vc-0.7.4/common/transpose.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/transpose.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,57 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_TRANSPOSE_H_
+#define VC_COMMON_TRANSPOSE_H_
+
+#include "macros.h"
+#include <tuple>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+template <typename... Inputs> struct TransposeProxy
+{
+    TransposeProxy(const Inputs &... inputs) : in{inputs...} {}
+
+    std::tuple<const Inputs &...> in;
+};
+
+template <int LhsLength, size_t RhsLength> struct TransposeTag {
+};
+}  // namespace Common
+
+template <typename... Vs> Common::TransposeProxy<Vs...> transpose(Vs... vs)
+{
+    return {vs...};
+}
+}  // namespace Vc
+
+#endif  // VC_COMMON_TRANSPOSE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/trigonometric.h vc-1.3.0/common/trigonometric.h
--- vc-0.7.4/common/trigonometric.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/trigonometric.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,83 +1,81 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_TRIGONOMETRIC_H
-#define VC_COMMON_TRIGONOMETRIC_H
-
-#ifndef VC__USE_NAMESPACE
-#error "Do not include Vc/common/trigonometric.h outside of Vc itself"
-#endif
+#ifndef VC_COMMON_TRIGONOMETRIC_H_
+#define VC_COMMON_TRIGONOMETRIC_H_
 
 #include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace
-{
-    using Vc::VC__USE_NAMESPACE::Vector;
-} // namespace
 
-namespace Internal
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
 {
 template<Vc::Implementation Impl> struct MapImpl { enum Dummy { Value = Impl }; };
 template<> struct MapImpl<Vc::SSE42Impl> { enum Dummy { Value = MapImpl<Vc::SSE41Impl>::Value }; };
-typedef ImplementationT<MapImpl<VC_IMPL>::Value
-#if defined(VC_IMPL_XOP) && defined(VC_IMPL_FMA4)
+
+template<Vc::Implementation Impl> using TrigonometricImplementation =
+    ImplementationT<MapImpl<Impl>::Value
+#if defined(Vc_IMPL_XOP) && defined(Vc_IMPL_FMA4)
     + Vc::XopInstructions
     + Vc::Fma4Instructions
 #endif
-    > TrigonometricImplementation;
-} // namespace Internal
+    >;
+}  // namespace Detail
 
+namespace Common
+{
 template<typename Impl> struct Trigonometric
 {
-    template<typename T> static Vector<T> sin(const Vector<T> &_x);
-    template<typename T> static Vector<T> cos(const Vector<T> &_x);
-    template<typename T> static void sincos(const Vector<T> &_x, Vector<T> *_sin, Vector<T> *_cos);
-    template<typename T> static Vector<T> asin (const Vector<T> &_x);
-    template<typename T> static Vector<T> atan (const Vector<T> &_x);
-    template<typename T> static Vector<T> atan2(const Vector<T> &y, const Vector<T> &x);
+    template<typename T> static T sin(const T &_x);
+    template<typename T> static T cos(const T &_x);
+    template<typename T> static void sincos(const T &_x, T *_sin, T *_cos);
+    template<typename T> static T asin (const T &_x);
+    template<typename T> static T atan (const T &_x);
+    template<typename T> static T atan2(const T &y, const T &x);
 };
-namespace VC__USE_NAMESPACE
-#undef VC__USE_NAMESPACE
+}  // namespace Common
+
+#ifdef Vc_IMPL_SSE
+// this is either SSE, AVX, or AVX2
+namespace Detail
 {
-    template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> sin(const Vector<T> &_x) {
-        return Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sin(_x);
-    }
-    template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> cos(const Vector<T> &_x) {
-        return Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::cos(_x);
-    }
-    template<typename T> static Vc_ALWAYS_INLINE void sincos(const Vector<T> &_x, Vector<T> *_sin, Vector<T> *_cos) {
-        Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sincos(_x, _sin, _cos);
-    }
-    template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> asin (const Vector<T> &_x) {
-        return Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::asin(_x);
-    }
-    template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> atan (const Vector<T> &_x) {
-        return Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan(_x);
-    }
-    template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> atan2(const Vector<T> &y, const Vector<T> &x) {
-        return Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan2(y, x);
-    }
-} // namespace VC__USE_NAMESPACE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+template <typename T, typename Abi>
+using Trig = Common::Trigonometric<Detail::TrigonometricImplementation<
+    (std::is_same<Abi, VectorAbi::Sse>::value
+         ? SSE42Impl
+         : std::is_same<Abi, VectorAbi::Avx>::value ? AVXImpl : ScalarImpl)>>;
+}  // namespace Detail
+template <typename T, typename Abi> Vc_INTRINSIC Vector<T, Abi> sin(const Vector<T, Abi> &x) { return Detail::Trig<T, Abi>::sin(x); }
+template <typename T, typename Abi> Vc_INTRINSIC Vector<T, Abi> cos(const Vector<T, Abi> &x) { return Detail::Trig<T, Abi>::cos(x); }
+template <typename T, typename Abi> Vc_INTRINSIC Vector<T, Abi> asin(const Vector<T, Abi> &x) { return Detail::Trig<T, Abi>::asin(x); }
+template <typename T, typename Abi> Vc_INTRINSIC Vector<T, Abi> atan(const Vector<T, Abi> &x) { return Detail::Trig<T, Abi>::atan(x); }
+template <typename T, typename Abi> Vc_INTRINSIC Vector<T, Abi> atan2(const Vector<T, Abi> &y, const Vector<T, Abi> &x) { return Detail::Trig<T, Abi>::atan2(y, x); }
+template <typename T, typename Abi> Vc_INTRINSIC void sincos(const Vector<T, Abi> &x, Vector<T, Abi> *sin, Vector<T, Abi> *cos) { Detail::Trig<T, Abi>::sincos(x, sin, cos); }
+#endif
+}  // namespace Vc
 
-#include "undomacros.h"
-#endif // VC_COMMON_TRIGONOMETRIC_H
+#endif // VC_COMMON_TRIGONOMETRIC_H_
diff -Nru vc-0.7.4/common/types.h vc-1.3.0/common/types.h
--- vc-0.7.4/common/types.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/types.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,217 +1,216 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_COMMON_TYPES_H
-#define VC_COMMON_TYPES_H
+#ifndef VC_COMMON_TYPES_H_
+#define VC_COMMON_TYPES_H_
 
-#ifdef VC_CHECK_ALIGNMENT
+#ifdef Vc_CHECK_ALIGNMENT
 #include <cstdlib>
 #include <cstdio>
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#include <Vc/global.h>
+#include "../traits/type_traits.h"
+#include "permutation.h"
+#include "vectorabi.h"
+
+namespace Vc_VERSIONED_NAMESPACE
 {
+template<typename T, typename Abi> class Mask;
+template<typename T, typename Abi> class Vector;
 
-// helper type to implement sfloat_v (Vector<Vc::sfloat>)
-struct sfloat {};
+///\addtogroup Utilities
+///@{
 
-template<typename T> struct DetermineEntryType { typedef T Type; };
-template<> struct DetermineEntryType<sfloat> { typedef float Type; };
-
-template<typename T> struct NegateTypeHelper { typedef T Type; };
-template<> struct NegateTypeHelper<unsigned char > { typedef char  Type; };
-template<> struct NegateTypeHelper<unsigned short> { typedef short Type; };
-template<> struct NegateTypeHelper<unsigned int  > { typedef int   Type; };
-
-namespace VectorSpecialInitializerZero { enum ZEnum { Zero = 0 }; }
-namespace VectorSpecialInitializerOne { enum OEnum { One = 1 }; }
-namespace VectorSpecialInitializerIndexesFromZero { enum IEnum { IndexesFromZero }; }
-
-template<typename V, size_t Size1, size_t Size2> class Memory;
-#ifdef VC_MSVC
-#  if defined(VC_IMPL_Scalar)
-namespace Scalar {
-    template<typename T> class Vector;
-    template<unsigned int VectorSize> class Mask;
-}
-#define _Vector Vc::Scalar::Vector
-#  elif defined(VC_IMPL_SSE)
-namespace SSE {
-    template<typename T> class Vector;
-    template<unsigned int VectorSize> class Mask;
-    class Float8Mask;
-}
-#define _Vector Vc::SSE::Vector
-#  elif defined(VC_IMPL_AVX)
-namespace AVX {
-    template<typename T> class Vector;
-    template<unsigned int VectorSize, size_t RegisterWidth> class Mask;
-}
-#define _Vector Vc::AVX::Vector
-#  else
-#    error "Sorry, MSVC is a nasty compiler and needs extra care. Please help."
-#  endif
-#endif
-namespace
-{
-    template<bool Test, typename T = void> struct EnableIf { typedef T Value; };
-    template<typename T> struct EnableIf<false, T> {};
-
-    template<typename T> struct IsSignedInteger    { enum { Value = 0 }; };
-    template<> struct IsSignedInteger<signed char> { enum { Value = 1 }; };
-    template<> struct IsSignedInteger<short>       { enum { Value = 1 }; };
-    template<> struct IsSignedInteger<int>         { enum { Value = 1 }; };
-    template<> struct IsSignedInteger<long>        { enum { Value = 1 }; };
-    template<> struct IsSignedInteger<long long>   { enum { Value = 1 }; };
-
-    template<typename T> struct IsUnsignedInteger           { enum { Value = 0 }; };
-    template<> struct IsUnsignedInteger<unsigned char>      { enum { Value = 1 }; };
-    template<> struct IsUnsignedInteger<unsigned short>     { enum { Value = 1 }; };
-    template<> struct IsUnsignedInteger<unsigned int>       { enum { Value = 1 }; };
-    template<> struct IsUnsignedInteger<unsigned long>      { enum { Value = 1 }; };
-    template<> struct IsUnsignedInteger<unsigned long long> { enum { Value = 1 }; };
-
-    template<typename T> struct IsInteger { enum { Value = IsSignedInteger<T>::Value | IsUnsignedInteger<T>::Value }; };
-
-    template<typename T> struct IsReal { enum { Value = 0 }; };
-    template<> struct IsReal<float>    { enum { Value = 1 }; };
-    template<> struct IsReal<double>   { enum { Value = 1 }; };
-
-    template<typename T, typename U> struct IsEqualType { enum { Value = 0 }; };
-    template<typename T> struct IsEqualType<T, T> { enum { Value = 1 }; };
-
-    template<typename T, typename List0, typename List1 = void, typename List2 = void, typename List3 = void, typename List4 = void, typename List5 = void, typename List6 = void>
-        struct IsInTypelist { enum { Value = false }; };
-    template<typename T, typename List1, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, T, List1, List2, List3, List4, List5, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, T, List2, List3, List4, List5, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List1, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, T, List3, List4, List5, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List1, typename List2, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, T, List4, List5, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List1, typename List2, typename List3, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, T, List5, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, List4, T, List6> { enum { Value = true }; };
-    template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List5> struct IsInTypelist<T, List0, List1, List2, List3, List4, List5, T> { enum { Value = true }; };
-
-    template<typename Arg0, typename Arg1, typename T0, typename T1> struct IsCombinationOf { enum { Value = false }; };
-    template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg0, Arg1> { enum { Value = true }; };
-    template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg1, Arg0> { enum { Value = true }; };
-
-    namespace
-    {
-        struct yes { char x; };
-        struct  no { yes x, y; };
-    } // anonymous namespace
-
-    template<typename From, typename To> struct HasImplicitCast
-    {
-#ifdef VC_MSVC
-        // MSVC can't compile this code if we pass a type that has large alignment restrictions by
-        // value
-        // clang OTOH warns about this code if we pass a null-reference, thus we ifdef the const-ref
-        // for MSVC only
-        static yes test(const To &) { return yes(); }
+/// \internal Allow writing \c size_t without the `std::` prefix.
+using std::size_t;
+
+/// long long shorthand
+using llong = long long;
+/// unsigned long long shorthand
+using ullong = unsigned long long;
+/// unsigned long shorthand
+using ulong = unsigned long;
+/// unsigned int shorthand
+using uint = unsigned int;
+/// unsigned short shorthand
+using ushort = unsigned short;
+/// unsigned char shorthand
+using uchar = unsigned char;
+/// signed char shorthand
+using schar = signed char;
+
+/**\internal
+ * Tag type for explicit zero-initialization
+ */
+struct VectorSpecialInitializerZero {};
+/**\internal
+ * Tag type for explicit one-initialization
+ */
+struct VectorSpecialInitializerOne {};
+/**\internal
+ * Tag type for explicit "iota-initialization"
+ */
+struct VectorSpecialInitializerIndexesFromZero {};
+
+/**
+ * The special object \p Vc::Zero can be used to construct Vector and Mask objects
+ * initialized to zero/\c false.
+ */
+constexpr VectorSpecialInitializerZero Zero = {};
+/**
+ * The special object \p Vc::One can be used to construct Vector and Mask objects
+ * initialized to one/\c true.
+ */
+constexpr VectorSpecialInitializerOne One = {};
+/**
+ * The special object \p Vc::IndexesFromZero can be used to construct Vector objects
+ * initialized to values 0, 1, 2, 3, 4, ...
+ */
+constexpr VectorSpecialInitializerIndexesFromZero IndexesFromZero = {};
+///@}
+
+namespace Detail
+{
+template<typename T> struct MayAliasImpl {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wattributes"
+#endif
+    typedef T type Vc_MAY_ALIAS;
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+};
+//template<size_t Bytes> struct MayAlias<MaskBool<Bytes>> { typedef MaskBool<Bytes> type; };
+}  // namespace Detail
+/**\internal
+ * Helper MayAlias<T> that turns T into the type to be used for an aliasing pointer. This
+ * adds the may_alias attribute to T (with compilers that support it). But for MaskBool this
+ * attribute is already part of the type and applying it a second times leads to warnings/errors,
+ * therefore MaskBool is simply forwarded as is.
+ */
+#ifdef Vc_ICC
+template <typename T> using MayAlias [[gnu::may_alias]] = T;
 #else
-        static yes test( To) { return yes(); }
+template <typename T> using MayAlias = typename Detail::MayAliasImpl<T>::type;
 #endif
-        static  no test(...) { return  no(); }
-        enum {
-#ifdef VC_MSVC
-            // I want to test whether implicit cast works. If it works MSVC thinks it should give a warning. Wrong. Shut up.
-#pragma warning(suppress : 4257 4267)
-#endif
-            Value = !!(sizeof(test(*static_cast<From *>(0))) == sizeof(yes))
-        };
-    };
-#if defined(VC_GCC) && VC_GCC < 0x40300
-    // GCC 4.1 is very noisy because of the float->int and double->int type trait tests. We get
-    // around this noise with a little specialization.
-    template<> struct HasImplicitCast<float , int> { enum { Value = true }; };
-    template<> struct HasImplicitCast<double, int> { enum { Value = true }; };
-#endif
-
-#ifdef VC_MSVC
-    // MSVC is such a broken compiler :'(
-    // HasImplicitCast breaks if From has an __declspec(align(#)) modifier and has no implicit cast
-    // to To.  That's because it'll call test(...) as test(From) and not test(const From &).
-    // This results in C2718. And MSVC is too stupid to see that it should just shut up and
-    // everybody would be happy.
-    //
-    // Because the HasImplicitCast specializations can only be implemented after the Vector class
-    // was declared we have to write some nasty hacks.
-    template<typename T1, typename T2> struct HasImplicitCast<_Vector<T1>, T2> { enum { Value = false }; };
-#if defined(VC_IMPL_Scalar)
-    template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::Scalar::Mask<VS>, T2> { enum { Value = false }; };
-    template<unsigned int VS> struct HasImplicitCast<Vc::Scalar::Mask<VS>, Vc::Scalar::Mask<VS> > { enum { Value = true }; };
-#elif defined(VC_IMPL_SSE)
-    template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::SSE::Mask<VS>, T2> { enum { Value = false }; };
-    template<unsigned int VS> struct HasImplicitCast<Vc::SSE::Mask<VS>, Vc::SSE::Mask<VS> > { enum { Value = true }; };
-    template<typename T2> struct HasImplicitCast<Vc::SSE::Float8Mask, T2> { enum { Value = false }; };
-    template<> struct HasImplicitCast<Vc::SSE::Float8Mask, Vc::SSE::Float8Mask> { enum { Value = true }; };
-#elif defined(VC_IMPL_AVX)
-    template<unsigned int VectorSize, size_t RegisterWidth, typename T2> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, T2> { enum { Value = false }; };
-    template<unsigned int VectorSize, size_t RegisterWidth> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, Vc::AVX::Mask<VectorSize, RegisterWidth> > { enum { Value = true }; };
-#endif
-    template<typename T> struct HasImplicitCast<_Vector<T>, _Vector<T> > { enum { Value = true }; };
-    //template<> struct HasImplicitCast<_Vector<           int>, _Vector<  unsigned int>> { enum { Value = true }; };
-    //template<> struct HasImplicitCast<_Vector<  unsigned int>, _Vector<           int>> { enum { Value = true }; };
-    //template<> struct HasImplicitCast<_Vector<         short>, _Vector<unsigned short>> { enum { Value = true }; };
-    //template<> struct HasImplicitCast<_Vector<unsigned short>, _Vector<         short>> { enum { Value = true }; };
-    template<typename V, size_t Size1, size_t Size2, typename T2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, T2> { enum { Value = false }; };
-    template<typename V, size_t Size1, size_t Size2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, Vc::Memory<V, Size1, Size2> > { enum { Value = true }; };
-#undef _Vector
-#endif
-
-    template<typename T> struct CanConvertToInt : public HasImplicitCast<T, int> {};
-    template<> struct CanConvertToInt<bool>     { enum { Value = 0 }; };
-    //template<> struct CanConvertToInt<float>    { enum { Value = 0 }; };
-    //template<> struct CanConvertToInt<double>   { enum { Value = 0 }; };
-
-    enum TestEnum {};
-    VC_STATIC_ASSERT(CanConvertToInt<int>::Value == 1, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<unsigned char>::Value == 1, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<bool>::Value == 0, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<float>::Value == 1, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<double>::Value == 1, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<float*>::Value == 0, CanConvertToInt_is_broken);
-    VC_STATIC_ASSERT(CanConvertToInt<TestEnum>::Value == 1, CanConvertToInt_is_broken);
-
-    typedef HasImplicitCast<TestEnum, short> HasImplicitCastTest0;
-    typedef HasImplicitCast<int *, void *> HasImplicitCastTest1;
-    typedef HasImplicitCast<int *, const void *> HasImplicitCastTest2;
-    typedef HasImplicitCast<const int *, const void *> HasImplicitCastTest3;
-    typedef HasImplicitCast<const int *, int *> HasImplicitCastTest4;
-
-    VC_STATIC_ASSERT(HasImplicitCastTest0::Value ==  true, HasImplicitCast0_is_broken);
-    VC_STATIC_ASSERT(HasImplicitCastTest1::Value ==  true, HasImplicitCast1_is_broken);
-    VC_STATIC_ASSERT(HasImplicitCastTest2::Value ==  true, HasImplicitCast2_is_broken);
-    VC_STATIC_ASSERT(HasImplicitCastTest3::Value ==  true, HasImplicitCast3_is_broken);
-    VC_STATIC_ASSERT(HasImplicitCastTest4::Value == false, HasImplicitCast4_is_broken);
-
-    template<typename T> struct IsLikeInteger { enum { Value = !IsReal<T>::Value && CanConvertToInt<T>::Value }; };
-    template<typename T> struct IsLikeSignedInteger { enum { Value = IsLikeInteger<T>::Value && !IsUnsignedInteger<T>::Value }; };
-} // anonymous namespace
 
-#ifndef VC_CHECK_ALIGNMENT
+/**\internal
+ * This enumeration lists all possible operators in C++.
+ *
+ * The assignment and compound assignment enumerators are used with the conditional_assign
+ * implementation.
+ */
+enum class Operator : char {
+    Assign,
+    Multiply,
+    MultiplyAssign,
+    Divide,
+    DivideAssign,
+    Remainder,
+    RemainderAssign,
+    Plus,
+    PlusAssign,
+    Minus,
+    MinusAssign,
+    RightShift,
+    RightShiftAssign,
+    LeftShift,
+    LeftShiftAssign,
+    And,
+    AndAssign,
+    Xor,
+    XorAssign,
+    Or,
+    OrAssign,
+    PreIncrement,
+    PostIncrement,
+    PreDecrement,
+    PostDecrement,
+    LogicalAnd,
+    LogicalOr,
+    Comma,
+    UnaryPlus,
+    UnaryMinus,
+    UnaryNot,
+    UnaryOnesComplement,
+    CompareEqual,
+    CompareNotEqual,
+    CompareLess,
+    CompareGreater,
+    CompareLessEqual,
+    CompareGreaterEqual
+};
+
+// forward declaration for Vc::array in <Vc/array>
+template <typename T, std::size_t N> struct array;
+
+/* TODO: add type for half-float, something along these lines:
+class half_float
+{
+    uint16_t data;
+public:
+    constexpr half_float() : data(0) {}
+    constexpr half_float(const half_float &) = default;
+    constexpr half_float(half_float &&) = default;
+    constexpr half_float &operator=(const half_float &) = default;
+
+    constexpr explicit half_float(float);
+    constexpr explicit half_float(double);
+    constexpr explicit half_float(int);
+    constexpr explicit half_float(unsigned int);
+
+    explicit operator float       () const;
+    explicit operator double      () const;
+    explicit operator int         () const;
+    explicit operator unsigned int() const;
+
+    bool operator==(half_float rhs) const;
+    bool operator!=(half_float rhs) const;
+    bool operator>=(half_float rhs) const;
+    bool operator<=(half_float rhs) const;
+    bool operator> (half_float rhs) const;
+    bool operator< (half_float rhs) const;
+
+    half_float operator+(half_float rhs) const;
+    half_float operator-(half_float rhs) const;
+    half_float operator*(half_float rhs) const;
+    half_float operator/(half_float rhs) const;
+};
+*/
+
+// TODO: the following doesn't really belong into the toplevel Vc namespace.
+#ifndef Vc_CHECK_ALIGNMENT
 template<typename _T> static Vc_ALWAYS_INLINE void assertCorrectAlignment(const _T *){}
 #else
 template<typename _T> static Vc_ALWAYS_INLINE void assertCorrectAlignment(const _T *ptr)
 {
-    const size_t s = Vc_ALIGNOF(_T);
+    const size_t s = alignof(_T);
     if((reinterpret_cast<size_t>(ptr) & ((s ^ (s & (s - 1))) - 1)) != 0) {
         fprintf(stderr, "A vector with incorrect alignment has just been created. Look at the stacktrace to find the guilty object.\n");
         abort();
@@ -219,7 +218,153 @@
 }
 #endif
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+namespace Common
+{
+/**
+ * \internal
+ *
+ * Helper interface to make m_indexes in InterleavedMemoryAccessBase behave like an integer vector.
+ * Only that the entries are successive entries from the given start index.
+ */
+template<size_t StructSize> class SuccessiveEntries
+{
+#ifdef Vc_MSVC
+    // scatterinterleavedmemory fails with garbage values in m_first if size_type is a
+    // 64-bit integer type. Using a 32-bit type seems to work around the miscompilation.
+    using size_type = unsigned;
+#else
+    using size_type = size_t;
+#endif
+    const size_type m_first;
+
+public:
+    typedef SuccessiveEntries AsArg;
+    Vc_INTRINSIC SuccessiveEntries(size_type first) : m_first(first) {}
+    Vc_INTRINSIC Vc_PURE size_type operator[](size_type offset) const
+    {
+        return m_first + offset * StructSize;
+    }
+    Vc_INTRINSIC Vc_PURE size_type data() const { return m_first; }
+    Vc_INTRINSIC Vc_PURE SuccessiveEntries operator+(const SuccessiveEntries &rhs) const
+    {
+        return SuccessiveEntries(m_first + rhs.m_first);
+    }
+    Vc_INTRINSIC Vc_PURE SuccessiveEntries operator*(const SuccessiveEntries &rhs) const
+    {
+        return SuccessiveEntries(m_first * rhs.m_first);
+    }
+    Vc_INTRINSIC Vc_PURE SuccessiveEntries operator<<(size_type x) const
+    {
+        return {m_first << x};
+    }
+
+    friend Vc_INTRINSIC SuccessiveEntries &internal_data(SuccessiveEntries &x)
+    {
+        return x;
+    }
+    friend Vc_INTRINSIC const SuccessiveEntries &internal_data(const SuccessiveEntries &x)
+    {
+        return x;
+    }
+};
+
+// declaration for functions in common/malloc.h
+template <std::size_t alignment>
+Vc_INTRINSIC_L void *aligned_malloc(std::size_t n) Vc_INTRINSIC_R;
+Vc_ALWAYS_INLINE_L void free(void *p) Vc_ALWAYS_INLINE_R;
+
+/**\internal
+ * Central definition of the type combinations that convert implicitly.
+ */
+template <typename T, typename U>
+using enable_if_mask_converts_implicitly =
+    enable_if<(Traits::is_simd_mask<U>::value && !Traits::isSimdMaskArray<U>::value &&
+               Traits::is_implicit_cast_allowed_mask<
+                   Traits::entry_type_of<typename Traits::decay<U>::Vector>, T>::value)>;
+/**\internal
+ * Central definition of the type combinations that only convert explicitly.
+ */
+template <typename T, typename U>
+using enable_if_mask_converts_explicitly = enable_if<(
+    Traits::isSimdMaskArray<U>::value ||
+    (Traits::is_simd_mask<U>::value &&
+     !Traits::is_implicit_cast_allowed_mask<
+         Traits::entry_type_of<typename Traits::decay<U>::Vector>, T>::value))>;
+
+/**\internal
+ * Tag type for overloading on the width (\VSize{T}) of a vector.
+ */
+template <typename T> using WidthT = std::integral_constant<std::size_t, sizeof(T)>;
+
+// forward declaration of MaskBool in common/maskbool.h
+template <std::size_t Bytes> class MaskBool;
+
+// forward declaration of SubscriptOperation in common/subscript.h
+template <typename T, typename IndexVector, typename Scale, bool>
+class SubscriptOperation;
+
+/**
+ * \internal
+ * Helper type to pass along the two arguments for a gather operation.
+ *
+ * \tparam IndexVector  Normally an integer SIMD vector, but an array or std::vector also
+ *                      works (though often not as efficient).
+ */
+template <typename T, typename IndexVector> struct GatherArguments
+{
+    const IndexVector indexes;
+    const T *const address;
+};
+
+/**
+ * \internal
+ * Helper type to pass along the two arguments for a scatter operation.
+ *
+ * \tparam IndexVector  Normally an integer SIMD vector, but an array or std::vector also
+ *                      works (though often not as efficient).
+ */
+template <typename T, typename IndexVector> struct ScatterArguments
+{
+    const IndexVector indexes;
+    T *const address;
+};
+
+/**\internal
+ * Break the recursion of the function below.
+ */
+template <typename I, I Begin, I End, typename F>
+Vc_INTRINSIC enable_if<(Begin >= End), void> unrolled_loop(F &&)
+{
+}
+
+/**\internal
+ * Force the code in the lambda \p f to be called with indexes starting from \p Begin up
+ * to (excluding) \p End to be called without compare and jump instructions (i.e. an
+ * unrolled loop).
+ */
+template <typename I, I Begin, I End, typename F>
+Vc_INTRINSIC Vc_FLATTEN enable_if<(Begin < End), void> unrolled_loop(F &&f)
+{
+    f(Begin);
+    unrolled_loop<I, Begin + 1, End>(f);
+}
+
+/**\internal
+ * Small simplification of the unrolled_loop call for ranges from 0 to \p Size using
+ * std::size_t as the index type.
+ */
+template <std::size_t Size, typename F> Vc_INTRINSIC void for_all_vector_entries(F &&f)
+{
+    unrolled_loop<std::size_t, 0u, Size>(std::forward<F>(f));
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#include "vector.h"
+#include "mask.h"
+#include "memoryfwd.h"
+
+#endif // VC_COMMON_TYPES_H_
 
-#endif // VC_COMMON_TYPES_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/undomacros.h vc-1.3.0/common/undomacros.h
--- vc-0.7.4/common/undomacros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/undomacros.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,110 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_UNDOMACROS_H
-#define VC_COMMON_UNDOMACROS_H
-#undef VC_COMMON_MACROS_H
-
-#undef Vc_ALIGNOF
-
-#undef Vc_INTRINSIC
-#undef Vc_INTRINSIC_L
-#undef Vc_INTRINSIC_R
-#undef Vc_CONST
-#undef Vc_CONST_L
-#undef Vc_CONST_R
-#undef Vc_PURE
-#undef Vc_PURE_L
-#undef Vc_PURE_R
-#undef Vc_MAY_ALIAS
-#undef Vc_ALWAYS_INLINE
-#undef Vc_ALWAYS_INLINE_L
-#undef Vc_ALWAYS_INLINE_R
-#undef VC_IS_UNLIKELY
-#undef VC_IS_LIKELY
-#undef VC_RESTRICT
-#undef VC_DEPRECATED
-#undef _VC_CONSTEXPR
-#undef _VC_CONSTEXPR_L
-#undef _VC_CONSTEXPR_R
-#undef _VC_NOEXCEPT
-
-#undef ALIGN
-#undef STRUCT_ALIGN1
-#undef STRUCT_ALIGN2
-#undef ALIGNED_TYPEDEF
-#undef _CAT_IMPL
-#undef CAT
-#undef unrolled_loop16
-#undef for_all_vector_entries
-#undef FREE_STORE_OPERATORS_ALIGNED
-
-#undef VC_WARN_INLINE
-#undef VC_WARN
-
-#ifdef VC_EXTERNAL_ASSERT
-#undef VC_EXTERNAL_ASSERT
-#else
-#undef VC_ASSERT
-#endif
-
-#undef VC_HAS_BUILTIN
-
-#undef Vc_buildDouble
-#undef Vc_buildFloat
-
-#undef _VC_APPLY_IMPL_1
-#undef _VC_APPLY_IMPL_2
-#undef _VC_APPLY_IMPL_3
-#undef _VC_APPLY_IMPL_4
-#undef _VC_APPLY_IMPL_5
-
-#undef VC_LIST_FLOAT_VECTOR_TYPES
-#undef VC_LIST_INT_VECTOR_TYPES
-#undef VC_LIST_VECTOR_TYPES
-#undef VC_LIST_COMPARES
-#undef VC_LIST_LOGICAL
-#undef VC_LIST_BINARY
-#undef VC_LIST_SHIFTS
-#undef VC_LIST_ARITHMETICS
-
-#undef VC_APPLY_0
-#undef VC_APPLY_1
-#undef VC_APPLY_2
-#undef VC_APPLY_3
-#undef VC_APPLY_4
-
-#undef VC_ALL_COMPARES
-#undef VC_ALL_LOGICAL
-#undef VC_ALL_BINARY
-#undef VC_ALL_SHIFTS
-#undef VC_ALL_ARITHMETICS
-#undef VC_ALL_FLOAT_VECTOR_TYPES
-#undef VC_ALL_VECTOR_TYPES
-
-#undef VC_EXACT_TYPE
-#undef VC_ALIGNED_PARAMETER
-#undef VC_OFFSETOF
-
-#ifdef Vc_POP_GCC_DIAGNOSTIC__
-#pragma GCC diagnostic pop
-#undef Vc_POP_GCC_DIAGNOSTIC__
-#endif
-
-#endif // VC_COMMON_UNDOMACROS_H
diff -Nru vc-0.7.4/common/utility.h vc-1.3.0/common/utility.h
--- vc-0.7.4/common/utility.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/utility.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,96 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_UTILITY_H_
+#define VC_COMMON_UTILITY_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+/**
+ * \internal
+ * Returns the next power of 2 larger than or equal to \p x.
+ */
+template <size_t x, bool = (x & (x - 1)) == 0> struct NextPowerOfTwo;
+template <size_t x>
+struct NextPowerOfTwo<x, true> : public std::integral_constant<size_t, x> {
+};
+template <size_t x>
+struct NextPowerOfTwo<x, false>
+    : public std::integral_constant<
+          size_t, NextPowerOfTwo<(x | (x >> 1) | (x >> 2) | (x >> 5)) + 1>::value> {
+};
+
+/**
+ * \internal
+ * Enforce an upper bound to an alignment value. This is necessary because some compilers
+ * implement such an upper bound and emit a warning if it is encountered.
+ */
+template <size_t A>
+struct BoundedAlignment : public std::integral_constant<size_t,
+#if defined Vc_MSVC || defined Vc_GCC
+                                                        ((A - 1) &
+#ifdef Vc_MSVC
+                                                         31
+#elif defined __AVX__
+                                                         255
+#else
+                                                         127
+#endif
+                                                         ) + 1
+#else
+                                                        A
+#endif
+                                                        > {
+};
+
+/**
+ * \internal
+ * Returns the size of the left/first SimdArray member.
+ */
+template <std::size_t N> static constexpr std::size_t left_size()
+{
+    return Common::NextPowerOfTwo<(N + 1) / 2>::value;
+}
+/**
+ * \internal
+ * Returns the size of the right/second SimdArray member.
+ */
+template <std::size_t N> static constexpr std::size_t right_size()
+{
+    return N - left_size<N>();
+}
+
+}  // namespace Common
+}  // namespace Vc
+
+#endif  // VC_COMMON_UTILITY_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/vector/casts.h vc-1.3.0/common/vector/casts.h
--- vc-0.7.4/common/vector/casts.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/vector/casts.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,69 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+public:
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // casts - implemented in simd_cast_caller.tcc
+
+    // implict conversion from compatible Vector<U>
+    template <typename U>
+    Vc_INTRINSIC_L Vector(
+        U &&x,
+        enable_if<NEON::is_vector<Traits::decay<U>>::value &&
+                  !std::is_same<Vector, Traits::decay<U>>::value &&
+                  Traits::is_implicit_cast_allowed<Traits::entry_type_of<U>, T>::value> =
+            nullarg) Vc_INTRINSIC_R;
+
+    // static_cast from other types
+    template <typename U>
+    Vc_INTRINSIC_L explicit Vector(U &&x,
+                                   enable_if<Traits::is_simd_vector<U>::value &&
+                                             !std::is_same<Vector, Traits::decay<U>>::value>>
+                                   = nullarg) Vc_INTRINSIC_R;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // broadcast
+    Vc_INTRINSIC Vector(EntryType a);
+    template <typename U>
+    Vc_INTRINSIC Vector(
+        U a,
+        typename std::enable_if<std::is_same<U, int>::value && !std::is_same<U, EntryType>::value,
+                                void *>::type = nullptr)
+        : Vector(static_cast<EntryType>(a))
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // explicitly forbid construction from initializer_list
+    explicit Vector(std::initializer_list<EntryType>)
+    {
+        static_assert(std::is_same<EntryType, void>::value,
+                      "A SIMD vector object cannot be initialized from an initializer list "
+                      "because the number of entries in the vector is target-dependent.");
+    }
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/vectorabi.h vc-1.3.0/common/vectorabi.h
--- vc-0.7.4/common/vectorabi.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/vectorabi.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,75 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_VECTORABI_H_
+#define VC_COMMON_VECTORABI_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace VectorAbi
+{
+struct Scalar {};
+struct Sse {};
+struct Avx {};
+struct Mic {};
+template <typename T>
+using Avx1Abi = typename std::conditional<std::is_integral<T>::value, VectorAbi::Sse,
+                                          VectorAbi::Avx>::type;
+template <typename T>
+using Best = typename std::conditional<
+    CurrentImplementation::is(ScalarImpl), Scalar,
+    typename std::conditional<
+        CurrentImplementation::is_between(SSE2Impl, SSE42Impl), Sse,
+        typename std::conditional<
+            CurrentImplementation::is(AVXImpl), Avx1Abi<T>,
+            typename std::conditional<
+                CurrentImplementation::is(AVX2Impl), Avx,
+                typename std::conditional<CurrentImplementation::is(MICImpl), Mic,
+                                          void>::type>::type>::type>::type>::type;
+#ifdef Vc_IMPL_AVX2
+static_assert(std::is_same<Best<float>, Avx>::value, "");
+static_assert(std::is_same<Best<int>, Avx>::value, "");
+#elif defined Vc_IMPL_AVX
+static_assert(std::is_same<Best<float>, Avx>::value, "");
+static_assert(std::is_same<Best<int>, Sse>::value, "");
+#elif defined Vc_IMPL_SSE
+static_assert(CurrentImplementation::is_between(SSE2Impl, SSE42Impl), "");
+static_assert(std::is_same<Best<float>, Sse>::value, "");
+static_assert(std::is_same<Best<int>, Sse>::value, "");
+#elif defined Vc_IMPL_MIC
+static_assert(std::is_same<Best<float>, Mic>::value, "");
+static_assert(std::is_same<Best<int>, Mic>::value, "");
+#elif defined Vc_IMPL_Scalar
+static_assert(std::is_same<Best<float>, Scalar>::value, "");
+static_assert(std::is_same<Best<int>, Scalar>::value, "");
+#endif
+}  // namespace VectorAbi
+}  // namespace Vc
+
+#endif  // VC_COMMON_VECTORABI_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/vector.h vc-1.3.0/common/vector.h
--- vc-0.7.4/common/vector.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,848 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_VECTOR_H_
+#define VC_COMMON_VECTOR_H_
+
+#include <ratio>
+#include "elementreference.h"
+#include "types.h"
+#include "vectorabi.h"
+#include "vectortraits.h"
+#include "simdarrayfwd.h"
+#include "loadstoreflags.h"
+#include "writemaskedvector.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * \ingroup Math
+ * Copies the sign(s) of \p sign to the value(s) in \p magnitude and returns the resulting
+ * vector.
+ *
+ * \param magnitude This vector's magnitude will be used in the return vector.
+ * \param sign This vector's sign bit will be used in the return vector.
+ *
+ * \return a value where the sign of the value equals the sign of \p sign. I.e.
+ * `sign(copysign(v, r)) == sign(r)`.
+ */
+template <typename T, typename Abi,
+          typename = enable_if<std::is_floating_point<T>::value>>
+inline Vector<T, Abi> copysign(Vector<T, Abi> magnitude, Vector<T, Abi> sign);
+
+/**
+ * \ingroup Math
+ * Extracts the exponent of each floating-point vector component.
+ *
+ * \param x The vector of values to check for the sign.
+ * \return the exponent to base 2.
+ *
+ * This function provides efficient access to the exponent of the floating point number. The
+ * returned value is a fast approximation to the logarithm of base 2. The absolute error of that
+ * approximation is between [0, 1[.
+ *
+ * Examples:
+\verbatim
+ value | exponent | log2
+=======|==========|=======
+   1.0 |        0 | 0
+   2.0 |        1 | 1
+   3.0 |        1 | 1.585
+   3.9 |        1 | 1.963
+   4.0 |        2 | 2
+   4.1 |        2 | 2.036
+\endverbatim
+ *
+ * \warning This function assumes a positive value (non-zero). If the value is negative the sign bit will
+ * modify the returned value. An input value of zero will return the bias of the floating-point
+ * representation. If you compile with Vc runtime checks, the function will assert
+ * values greater than or equal to zero.
+ *
+ * You may use abs to apply this function to negative values:
+ * \code
+ * exponent(abs(v))
+ * \endcode
+ */
+template <typename T, typename Abi,
+          typename = enable_if<std::is_floating_point<T>::value>>
+inline Vector<T, Abi> exponent(Vector<T, Abi> x);
+
+/**
+ * \ingroup Math
+ * Returns for each vector component whether it stores a negative value.
+ *
+ * \param x The vector of values to check for the sign.
+ * \returns a mask which is \c true only in those components that are negative in \p x.
+ */
+template <typename T, typename Abi>
+Vc_INTRINSIC Vc_CONST typename Vector<T, Abi>::MaskType isnegative(Vector<T, Abi> x)
+{
+    return x < Vector<T, Abi>::Zero();
+}
+
+/**
+ * \class Vector types.h <Vc/vector.h>
+ * \ingroup Vectors
+ *
+ * The main vector class for expressing data parallelism.
+ *
+ * are specializations of this class.
+ * For most cases there are no API differences for the specializations.
+ * Make use of Vector<T> for generic programming, otherwise you might prefer to use
+ * the \p *_v aliases.
+ *
+ * \see Vc::float_v, Vc::double_v, Vc::int_v, Vc::uint_v, Vc::short_v, Vc::ushort_v
+ * \see Mask
+ */
+template<typename T, typename Abi = VectorAbi::Best<T>> class Vector
+{
+public:
+    /**
+     * Returns the number of scalar components (\VSize{T}) in a vector of this type.
+     *
+     * The size of the vector. I.e. the number of scalar entries in the vector. Do not
+     * make any assumptions about the size of vectors. If you need vectors of \c float and
+     * \c int types use Vector::IndexType or SimdArray.
+     *
+     * You can easily use if clauses to compare Vector sizes. The compiler can
+     * statically evaluate and fully optimize dead code away (very much like \#ifdef, but
+     * with syntax checking).
+     *
+     * \returns The number of components (i.e. \VSize{T}) objects of this vector type
+     * store and manipulate.
+     */
+    static constexpr size_t size() { return VectorTraits<T, Abi>::size(); }
+
+    /**
+     * Specifies the alignment requirement for aligned load and store calls for objects of
+     * this vector type.
+     */
+    static constexpr size_t MemoryAlignment = VectorTraits<T, Abi>::memoryAlignment();
+
+    /// The ABI tag type of the current template instantiation.
+    using abi = Abi;
+
+    /// The type of the entries in the vector.
+    using EntryType = typename VectorTraits<T, Abi>::EntryType;
+    /// \copydoc EntryType
+    using value_type = EntryType;
+
+    using VectorEntryType = typename VectorTraits<T, Abi>::VectorEntryType;
+    /**\internal
+     * This type reveals the implementation-specific type used for the data member.
+     */
+    using VectorType = typename VectorTraits<T, Abi>::VectorType;
+    /**\internal
+     * \copydoc VectorType
+     */
+    using vector_type = VectorType;
+
+    /// The type of the mask used for masked operations and returned from comparisons.
+    using MaskType = Vc::Mask<T, Abi>;
+    /// \copydoc MaskType
+    using mask_type = MaskType;
+
+    using MaskArgument = MaskType;
+    using VectorArgument = Vector;
+
+    /// The type of the vector used for indexes in gather and scatter operations.
+    using IndexType = Vc::SimdArray<int, VectorTraits<T, Abi>::size()>;
+    /// \copydoc IndexType
+    using index_type = IndexType;
+
+    using reference = Detail::ElementReference<Vector>;
+
+    /// \name Generators
+    ///@{
+    /**
+     * Returns a vector with the entries initialized to zero.
+     */
+    static inline Vector Zero();
+
+    /**
+     * Returns a vector with the entries initialized to one.
+     */
+    static inline Vector One();
+
+    /**
+     * Returns a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...
+     */
+    static inline Vector IndexesFromZero();
+
+    /**
+     * Returns a vector with pseudo-random entries.
+     *
+     * Currently the state of the random number generator cannot be modified and starts
+     * off with the same state. Thus you will get the same sequence of numbers for the
+     * same sequence of calls.
+     *
+     * \return a new random vector. Floating-point values will be in the 0-1 range.
+     * Integers will use the full range the integer representation allows.
+     *
+     * \note This function may use a very small amount of state and thus will be a weak
+     * random number generator.
+     */
+    static inline Vector Random();
+
+    /// Generate a vector object from return values of \p gen (static variant of \ref fill).
+    template <typename G> static inline Vector generate(G gen);
+    ///@}
+
+    /// \name Compile-Time Constant Initialization
+    ///@{
+    /**
+     * Construct a zero-initialized vector object.
+     *
+     * This constructor follows the behavior of the underlying arithmetic type \p T in
+     * that the expression `T()` zero-initializes the object. On the other hand the
+     * variable \c x in `T x;` is uninitialized.
+     * Since, for class types, both expressions call the default constructor `Vector<T> x`
+     * must zero-initialize \c x as well.
+     */
+    inline Vector() = default;
+
+    /**
+     * Construct a vector with the entries initialized to zero.
+     *
+     * \see Vc::Zero, Zero()
+     */
+    explicit inline Vector(VectorSpecialInitializerZero);
+
+    /**
+     * Construct a vector with the entries initialized to one.
+     *
+     * \see Vc::One, One()
+     */
+    explicit inline Vector(VectorSpecialInitializerOne);
+
+    /**
+     * Construct a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...
+     *
+     * \see Vc::IndexesFromZero, IndexesFromZero()
+     */
+    explicit inline Vector(VectorSpecialInitializerIndexesFromZero);
+    ///@}
+
+    /// \name Conversion/Broadcast Constructors
+    ///@{
+    /**
+     * Implict conversion from compatible Vector<U, Abi> types.
+     */
+    template <typename U>
+    inline Vector(Vector<U, abi> x,
+                  enable_if<Traits::is_implicit_cast_allowed<U, T>::value> = nullarg);
+
+#if Vc_IS_VERSION_1
+    /**
+     * Explicit conversion (i.e. `static_cast`) from the remaining Vector<U, Abi> types.
+     *
+     * \param x A vector object to use for initialization of the new vector object. If \p
+     *          x contains more entries than the new object the high components will be
+     *          ignored. If \p x contains fewer entries than the new object the high
+     *          components of the new object will be zero-initialized. Type conversion is
+     *          done according to the standard conversion rules for the underlying
+     *          fundamental arithmetic types.
+     */
+    template <typename U>
+    Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                  "vector types") inline explicit Vector(
+        Vector<U, abi> x,
+        enable_if<!Traits::is_implicit_cast_allowed<U, T>::value> = nullarg);
+#endif
+
+    /**
+     * Broadcast Constructor.
+     *
+     * Constructs a vector with all entries of the vector filled with the given value.
+     *
+     * \param a The scalar value to broadcast to all entries of the constructed vector.
+     */
+    inline Vector(EntryType a);
+    template <typename U>
+    inline Vector(U a, enable_if<std::is_same<U, int>::value &&
+                                 !std::is_same<U, EntryType>::value> = nullarg);
+    ///@}
+
+    /**
+     * \name Loads & Stores
+     */
+    ///@{
+#include "../common/loadinterface.h"
+#include "../common/storeinterface.h"
+    ///@}
+
+    /**
+     * Set all entries to zero.
+     */
+    inline void setZero();
+
+    /**
+     * Set all entries to zero where the mask is set.
+     *
+     * A 4-vector with a mask of `[0111]` therefore would set the last three entries to 0.
+     *
+     * \param mask Selects the entries to be set to zero.
+     */
+    inline void setZero(MaskType mask);
+
+    /**
+     * Set all entries to zero where the mask is not set.
+     *
+     * A 4-vector with a mask of `[0111]` therefore would set only the first entry to 0.
+     *
+     * \param mask Selects the entries to not be set to zero.
+     */
+    inline void setZeroInverted(MaskType mask);
+
+    /**
+     * Set all entries to the bit representation of a QNaN.
+     */
+    inline void setQnan();
+
+    /**
+     * Set all entries to the bit representation of a QNaN where the mask is set.
+     *
+     * \param mask Selects the entries to be set to QNaN.
+     */
+    inline void setQnan(MaskType mask);
+
+#define Vc_CURRENT_CLASS_NAME Vector
+#include "../common/gatherinterface.h"
+#include "../common/scatterinterface.h"
+#undef Vc_CURRENT_CLASS_NAME
+
+    /// \name Scalar Subscript Operators
+    ///@{
+    /**
+     * This operator can be used to modify scalar entries of the vector.
+     *
+     * \param index A value between 0 and Size. This value is not checked internally so
+     *              you must make/be sure it is in range.
+     *
+     * \return a reference to the vector entry at the given \p index.
+     *
+     * \warning The use of this function may result in suboptimal performance. Please
+     *          check whether you can find a more vector-friendly way to do what you
+     *          intended.
+     */
+    inline reference operator[](size_t index) noexcept;
+    /**
+     * This operator can be used to read scalar entries of the vector.
+     *
+     * \param index A value between 0 and Size. This value is not checked internally so
+     *              you must make/be sure it is in range.
+     *
+     * \return a copy of the vector entry at the given \p index.
+     */
+    inline EntryType operator[](size_t index) const noexcept;
+    ///@}
+
+    /// \name Unary Operators
+    ///@{
+    /**
+     * Determine where the vector is null.
+     *
+     * \returns a mask which denotes the zero entries of this vector object.
+     */
+    inline MaskType operator!() const;
+
+    /**
+     * Inverts all bits.
+     *
+     * \returns a new vector which has all bits inverted. I.e. `v & ~v == 0`.
+     *
+     * \note This operator is only defined for integral types \p T.
+     */
+    inline Vector operator~() const;
+
+    /// Returns a new vector object with all entries negated.
+    inline Vector operator-() const;
+    /// Returns a copy of the vector object.
+    inline Vector operator+() const;
+    ///@}
+
+    /**
+     * \name Increment and Decrement Operators
+     * The increment and decrement operators apply the increment/decrement operation per
+     * component.
+     *
+     * The semantics are equal to the semantics of the fundamental arithmetics type \p T.
+     *
+     * \note Over-/Underflow of signed integral types is undefined behavior and may
+     * actually break your code.
+     */
+    ///@{
+    inline Vector &operator++();  // prefix
+    inline Vector operator++(int);  // postfix
+    inline Vector &operator--();  // prefix
+    inline Vector operator--(int);  // postfix
+    ///@}
+
+#define Vc_OP(symbol)                                                                    \
+    inline Vc_PURE Vector operator symbol(const Vector &x) const;
+    /**
+     * \name Arithmetic Operations
+     *
+     * The arithmetic operations are implemented as component-wise
+     * application of the operator on the two vector objects.
+     *
+     * Example:
+     * \code
+     * void foo(float_v a, float_v b) {
+     *   const float_v product    = a * b;
+     *   const float_v difference = a - b;
+     *   a += b;
+     *   auto quotient = a / b;
+     *   auto modulo = static_cast<int_v>(a) % static_cast<int_v>(b);
+     * }
+     * \endcode
+     *
+     * \param x The vector to add, subtract, multiply, or divide by.
+     * \returns A vector object of the same type with the components filled according to a
+     *          component-wise application of the operator.
+     *
+     * \note If a signed integral vector operation overflows the result is undefined.
+     * (which is in agreement to the behavior of the fundamental signed integral types in
+     * C++)
+     */
+    ///@{
+    Vc_ALL_ARITHMETICS(Vc_OP);
+    ///@}
+
+    /**
+     * \name Binary Operations
+     *
+     * The binary operations are implemented as component-wise
+     * application of the operator on the two vector objects.
+     *
+     * Example:
+     * \code
+     * void foo(int_v a, int_v b) {
+     *   const int_v combined_bits = a | b;
+     *   const int_v masked_bits = a & b;
+     *   a ^= b;  // flipped bits
+     * }
+     * \endcode
+     *
+     * \returns A vector object of the same type with the components filled according to a
+     *          component-wise application of the operator.
+     */
+    ///@{
+    Vc_ALL_BINARY(Vc_OP);
+    ///@}
+
+    /**
+     * \name Shift Operations
+     *
+     * The shift operations are implemented as component-wise
+     * application of the operator on the two vector objects.
+     *
+     * Example:
+     * \code
+     * void foo(int_v a, int_v b) {
+     *   const int_v right = a >> b;
+     *   a <<= b;
+     * }
+     * \endcode
+     *
+     * \returns A vector object of the same type with the components filled according to a
+     *          component-wise application of the operator.
+     */
+    ///@{
+    Vc_ALL_SHIFTS(Vc_OP);
+    ///@}
+#undef Vc_OP
+
+    /**
+     * \name Comparisons
+     *
+     * All comparison operators return a mask object.
+     *
+     * Example:
+     * \code
+     * void foo(const float_v &a, const float_v &b) {
+     *   const float_m mask = a < b;
+     *   ...
+     * }
+     * \endcode
+     *
+     * \param x The vector to compare against.
+     * \returns A mask object. Its components contain the boolean results of the
+     *          component-wise compare operation.
+     */
+    ///@{
+#define Vc_CMP_OP(symbol) inline Vc_PURE MaskType operator symbol(const Vector &x) const;
+    Vc_ALL_COMPARES(Vc_CMP_OP);
+#undef Vc_CMP_OP
+    ///@}
+
+    /**
+     * Writemask the vector before an assignment.
+     *
+     * \param mask The writemask to be used.
+     *
+     * \return an object that can be used for any kind of masked assignment.
+     *
+     * The returned object is only to be used for assignments and should not be assigned
+     * to a variable.
+     *
+     * Examples:
+     * \code
+     * float_v v = float_v::Zero();         // v  = [0, 0, 0, 0]
+     * int_v v2 = int_v::IndexesFromZero(); // v2 = [0, 1, 2, 3]
+     * v(v2 < 2) = 1.f;                     // v  = [1, 1, 0, 0]
+     * v(v2 < 3) += 1.f;                    // v  = [2, 2, 1, 0]
+     * ++v2(v < 1.f);                       // v2 = [0, 1, 2, 4]
+     * \endcode
+     */
+    inline Common::WriteMaskedVector<Vector, MaskType> operator()(MaskType mask);
+
+    /**
+     * \name Horizontal Reduction Operations
+     *
+     * Horizontal operations can be used to reduce the values of a vector to a scalar
+     * value.
+     *
+     * Example:
+     * \code
+     * void foo(const float_v &v) {
+     *   float min = v.min(); // smallest value in v
+     *   float sum = v.sum(); // sum of all values in v
+     * }
+     * \endcode
+     */
+    ///@{
+
+    /// Returns the smallest entry in the vector.
+    inline EntryType min() const;
+    /// Returns the largest entry in the vector.
+    inline EntryType max() const;
+    /// Returns the product of all entries in the vector.
+    inline EntryType product() const;
+    /// Returns the sum of all entries in the vector.
+    inline EntryType sum() const;
+    /// Returns a vector containing the sum of all entries with smaller index.
+    inline Vector partialSum() const;
+    /// Returns the smallest entry of the vector components selected by \p mask.
+    inline EntryType min(MaskType mask) const;
+    /// Returns the largest entry of the vector components selected by \p mask.
+    inline EntryType max(MaskType mask) const;
+    /// Returns the product of the vector components selected by \p mask.
+    inline EntryType product(MaskType mask) const;
+    /// Returns the sum of the vector components selected by \p mask.
+    inline EntryType sum(MaskType mask) const;
+    ///@}
+
+    /**
+     * \name Shift and Rotate
+     *
+     * These functions allow to shift or rotate the entries in a vector.
+     *
+     * All functions with an \p amount parameter support positive and negative numbers for
+     * the shift/rotate value.
+     *
+     * Example:
+     * \code
+     * using namespace Vc;
+     * int_v foo = int_v::IndexesFromZero() + 1; // e.g. [1, 2, 3, 4] with SSE
+     * int_v x;
+     * x = foo.shifted( 1); // [2, 3, 4, 0]
+     * x = foo.shifted( 2); // [3, 4, 0, 0]
+     * x = foo.shifted( 3); // [4, 0, 0, 0]
+     * x = foo.shifted( 4); // [0, 0, 0, 0]
+     * x = foo.shifted(-1); // [0, 1, 2, 3]
+     * x = foo.shifted(-2); // [0, 0, 1, 2]
+     * x = foo.shifted(-3); // [0, 0, 0, 1]
+     * x = foo.shifted(-4); // [0, 0, 0, 0]
+     *
+     * x = foo.rotated( 1); // [2, 3, 4, 1]
+     * x = foo.rotated( 2); // [3, 4, 1, 2]
+     * x = foo.rotated( 3); // [4, 1, 2, 3]
+     * x = foo.rotated( 4); // [1, 2, 3, 4]
+     * x = foo.rotated(-1); // [4, 1, 2, 3]
+     * x = foo.rotated(-2); // [3, 4, 1, 2]
+     * x = foo.rotated(-3); // [2, 3, 4, 1]
+     * x = foo.rotated(-4); // [1, 2, 3, 4]
+     * \endcode
+     *
+     * These functions are slightly related to the above swizzles. In any case, they are
+     * often useful for communication between SIMD lanes or binary decoding operations.
+     *
+     * \warning Use of these functions leads to less portable code. Consider the scalar
+     * implementation where every vector has only one entry. The shift and rotate
+     * functions have no useful task to fulfil there and you will almost certainly not get
+     * any useful results. It is recommended to add a static_assert for the assumed
+     * minimum vector size.
+     */
+    ///@{
+
+    /// Shift vector entries to the left by \p amount; shifting in zeros.
+    inline Vector shifted(int amount) const;
+    /**
+     * Shift vector entries to the left by \p amount; shifting in values from shiftIn
+     * (instead of zeros).
+     *
+     * This function can be used to create vectors from unaligned memory locations.
+     *
+     * Example:
+     * \code
+     * Vc::Memory<int_v, 256> mem;
+     * for (int i = 0; i < 256; ++i) { mem[i] = i + 1; }
+     * int_v a = mem.vectorAt(0);
+     * int_v b = mem.vectorAt(int_v::Size);
+     * int_v x = a.shifted(1, b);
+     * // now x == mem.vectorAt(1, Vc::Unaligned)
+     * \endcode
+     *
+     * \param amount  The number of entries to shift by. \p amount must be between \c
+     *                -Size and \c Size, otherwise the result is undefined.
+     * \param shiftIn The vector of values to shift in.
+     * \return        A new vector with values from \p this and \p shiftIn concatenated
+     *                and then shifted by \p amount.
+     */
+    inline Vector shifted(int amount, Vector shiftIn) const;
+    /// Rotate vector entries to the left by \p amount.
+    inline Vector rotated(int amount) const;
+    /// Returns a vector with all components reversed.
+    inline Vector reversed() const;
+    ///@}
+
+    /**
+     * Return a sorted copy of the vector.
+     *
+     * \returns a sorted vector. The returned values are in ascending order:
+       \verbatim
+       v[0] <= v[1] <= v[2] <= v[3] ...
+       \endverbatim
+     *
+     * \note If the vector contains NaNs the result is undefined.
+     *
+     * Example:
+     * \code
+     * int_v v = int_v::Random();
+     * int_v s = v.sorted();
+     * std::cout << v << '\n' << s << '\n';
+     * \endcode
+     *
+     * With SSE the output would be:
+     *
+       \verbatim
+       [1513634383, -963914658, 1763536262, -1285037745]
+       [-1285037745, -963914658, 1513634383, 1763536262]
+       \endverbatim
+     *
+     * With the Scalar implementation:
+       \verbatim
+       [1513634383]
+       [1513634383]
+       \endverbatim
+     */
+    inline Vector sorted() const;
+
+    /*!
+     * \name Apply/Call/Fill Functions
+     *
+     * There are still many situations where the code needs to switch from SIMD operations
+     * to scalar execution. In this case you can, of course rely on operator[]. But there
+     * are also a number of functions that can help with common patterns.
+     *
+     * The apply functions expect a function that returns a scalar value, i.e. a function
+     * of the form "T f(T)".  The call functions do not return a value and thus the
+     * function passed does not need a return value. The fill functions are used to
+     * serially set the entries of the vector from the return values of a function.
+     *
+     * Example:
+     * \code
+     * void foo(float_v v) {
+     *   float_v logarithm = v.apply(std::log);
+     *   float_v exponential = v.apply(std::exp);
+     * }
+     * \endcode
+     *
+     * Of course, you can also use lambdas here:
+     * \code
+     *   float_v power = v.apply([](float f) { return std::pow(f, 0.6f); })
+     * \endcode
+     *
+     * \param f A functor: this can either be a function or an object that implements
+     * operator().
+     */
+    ///@{
+
+    /// Call \p f sequentially, starting with the minimum up to the maximum value.
+    template <typename F> void callWithValuesSorted(F &&f);
+    /// Call \p f with the scalar entries of the vector.
+    template <typename F> inline void call(F &&f) const;
+    /// As above, but skip the entries where \p mask is not set.
+    template <typename F> inline void call(F &&f, MaskType mask) const;
+
+    /// Call \p f on every entry of the vector and return the results as a new vector.
+    template <typename F> inline Vector apply(F &&f) const;
+    /// As above, but skip the entries where \p mask is not set.
+    template <typename F> inline Vector apply(F &&f, MaskType mask) const;
+
+    /// Fill the vector with the values [f(0), f(1), f(2), ...].
+    template <typename IndexT> inline void fill(EntryType(&f)(IndexT));
+    /// Fill the vector with the values [f(), f(), f(), ...].
+    inline void fill(EntryType(&f)());
+    ///@}
+
+    /**\internal
+     * Interleaves this vector and \p x and returns the resulting low vector.
+     * Used to implement Vc::interleave.
+     */
+    inline Vector interleaveLow(Vector x) const;
+    /**\internal
+     * Interleaves this vector and \p x and returns the resulting low vector.
+     * Used to implement Vc::interleave.
+     */
+    inline Vector interleaveHigh(Vector x) const;
+
+    /**\internal
+     * Assigns the components of \p v where \p m is \c true.
+     */
+    inline void assign(const Vector &v, const MaskType &m);
+
+    /**
+     * \internal
+     * \name Internal Data Access
+     * Returns a (const) reference the internal data member, storing the vector data.
+     */
+    ///@{
+    inline VectorType &data();
+    inline const VectorType &data() const;
+    ///@}
+
+    /// \name Deprecated Members
+    ///@{
+
+    /**
+     * Returns the exponents of the floating-point values in the vector.
+     *
+     * \return A new vector object of the same type containing the exponents.
+     *
+     * \deprecated use Vc::exponent instead.
+     */
+    Vc_DEPRECATED("use exponent(x) instead") inline Vector exponent() const;
+
+    /**
+     * Returns whether a value is negative.
+     *
+     * \return A new mask object indicating the sign of each vector element.
+     *
+     * \deprecated use Vc::isnegative instead.
+     */
+    Vc_DEPRECATED("use isnegative(x) instead") inline MaskType isNegative() const;
+
+    ///\copydoc size
+    ///\deprecated Use Vc::Vector::size instead.
+    static constexpr size_t Size = VectorTraits<T, Abi>::size();
+
+    /**
+     * Casts the current object to \p V2.
+     *
+     * \returns a converted object of type \p Vc.
+     *
+     * \deprecated Use Vc::simd_cast instead.
+     */
+    template <typename V2> inline V2 staticCast() const;
+
+    /**
+     * reinterpret_cast the vector components to construct a vector of type \p V2.
+     *
+     * \returns An object of type \p V2 with the smae bit-representation.
+     *
+     * \deprecated use Vc::reinterpret_components_cast instead.
+     */
+    template <typename V2>
+    Vc_DEPRECATED("use reinterpret_components_cast instead") inline V2
+        reinterpretCast() const;
+
+    /**
+     * Copies the signs of the components of \p reference to the components of the current
+     * vector, returning the result.
+     *
+     * \param reference A vector object that determines the sign of the the result.
+     * \returns A new vector with sign taken from \p reference and absolute value taken
+     * from the current vector object.
+     *
+     * \deprecated Use Vc::copysign instead.
+     */
+    Vc_DEPRECATED("use copysign(x, y) instead") inline Vector
+        copySign(Vector reference) const;
+    ///@}
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(Vector));
+
+private:
+    VectorType d;
+};
+
+/**
+ * \ingroup Utilities
+ * Constructs a new Vector object of type \p V from the Vector \p x, reinterpreting the
+ * bits of \p x for the new type \p V.
+ *
+ * This function is only applicable if:
+ * - the \c sizeof of the input and output types is equal
+ * - the Vector::size() of the input and output types is equal
+ * - the \c VectorEntryTypes of input and output have equal \c sizeof
+ *
+ * \tparam V The requested type to change \p x into.
+ * \param x The Vector to reinterpret as an object of type \p V.
+ * \returns A new object (rvalue) of type \p V.
+ *
+ * \warning This cast is non-portable since the applicability (see above) may change
+ * depending on the default vector types of the target platform. The function is perfectly
+ * safe to use with fully specified \p Abi, though.
+ */
+template <typename V, typename T, typename Abi>
+Vc_ALWAYS_INLINE Vc_CONST enable_if<
+    (V::size() == Vector<T, Abi>::size() &&
+     sizeof(typename V::VectorEntryType) ==
+         sizeof(typename Vector<T, Abi>::VectorEntryType) &&
+     sizeof(V) == sizeof(Vector<T, Abi>) && alignof(V) <= alignof(Vector<T, Abi>)),
+    V>
+reinterpret_components_cast(const Vector<T, Abi> &x)
+{
+    return reinterpret_cast<const V &>(x);
+}
+
+#define Vc_OP(symbol)                                                                    \
+    template <typename T, typename Abi>                                                  \
+    inline Vector<T, Abi> &operator symbol##=(Vector<T, Abi> &,                          \
+                                              const Vector<T, Abi> &x);
+    //Vc_ALL_ARITHMETICS(Vc_OP);
+    //Vc_ALL_BINARY(Vc_OP);
+    //Vc_ALL_SHIFTS(Vc_OP);
+#undef Vc_OP
+
+}  // namespace Vc
+
+#endif  // VC_COMMON_VECTOR_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/vectortraits.h vc-1.3.0/common/vectortraits.h
--- vc-0.7.4/common/vectortraits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/vectortraits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,40 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_VECTORTRAITS_H_
+#define VC_COMMON_VECTORTRAITS_H_
+
+#include "vectorabi.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+template <typename T, typename Abi> struct VectorTraits;
+}  // namespace Vc
+
+#endif  // VC_COMMON_VECTORTRAITS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/common/vectortuple.h vc-1.3.0/common/vectortuple.h
--- vc-0.7.4/common/vectortuple.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/vectortuple.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,160 +1,142 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_COMMON_VECTORTUPLE_H
-#define VC_COMMON_VECTORTUPLE_H
+#ifndef VC_COMMON_VECTORTUPLE_H_
+#define VC_COMMON_VECTORTUPLE_H_
 
+#include "transpose.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace Common
 {
 
-template<size_t StructSize, typename V> struct InterleavedMemoryReadAccess;
+template<size_t StructSize, typename V, typename I, bool Readonly = true> struct InterleavedMemoryReadAccess;
 
-template<int Length, typename V> struct VectorTuple;
-template<typename V> struct VectorTuple<2, V>
+template <int Length, typename V> class VectorReferenceArray
 {
     typedef typename V::EntryType T;
-    typedef V &VC_RESTRICT Reference;
-    Reference l, r;
+    typedef V &Vc_RESTRICT Reference;
+    std::array<V * Vc_RESTRICT, Length> r;
+
+    typedef make_index_sequence<Length> IndexSequence;
 
-    Vc_ALWAYS_INLINE VectorTuple(Reference a, Reference b)
-        : l(a), r(b)
+    template <typename VV, std::size_t... Indexes>
+    constexpr VectorReferenceArray<Length + 1, VV> appendOneReference(
+        VV &a, index_sequence<Indexes...>) const
     {
+        return {*r[Indexes]..., a};
     }
 
-    Vc_ALWAYS_INLINE VectorTuple<3, V> operator,(V &a) const
+    template <typename A, std::size_t... Indexes>
+    Vc_INTRINSIC void callDeinterleave(const A &access, index_sequence<Indexes...>) const
     {
-        return VectorTuple<3, V>(*this, a);
+        access.deinterleave(*r[Indexes]...);
     }
 
-    Vc_ALWAYS_INLINE VectorTuple<3, const V> operator,(const V &a) const
+public:
+    template <typename... Us, typename = enable_if<(sizeof...(Us) == Length)>>
+    constexpr VectorReferenceArray(Us &&... args)
+        : r{{std::addressof(std::forward<Us>(args))...}}
     {
-        return VectorTuple<3, const V>(*this, a);
     }
 
-    template<size_t StructSize>
-    Vc_ALWAYS_INLINE void operator=(const InterleavedMemoryReadAccess<StructSize, V> &access) const
+    template <typename VV, typename = enable_if<!std::is_const<V>::value &&
+                                                std::is_same<VV, V>::value>>
+    Vc_DEPRECATED("build the tuple with Vc::tie instead")
+    constexpr VectorReferenceArray<Length + 1, V> operator, (VV & a) const
     {
-        VC_STATIC_ASSERT(2 <= StructSize, You_are_trying_to_extract_more_data_from_the_struct_than_it_has);
-        access.deinterleave(l, r);
+        return appendOneReference(a, IndexSequence());
     }
-};
 
-template<typename V> struct VectorTuple<2, const V>
-{
-    typedef typename V::EntryType T;
-    typedef const V &VC_RESTRICT Reference;
-    Reference l, r;
+    Vc_DEPRECATED("build the tuple with Vc::tie instead")
+    constexpr VectorReferenceArray<Length + 1, const V> operator, (const V &a) const
+    {
+        return appendOneReference(a, IndexSequence());
+    }
+
+    template <size_t StructSize, typename I, bool RO>
+    Vc_ALWAYS_INLINE enable_if<(Length <= StructSize), void> operator=(
+        const InterleavedMemoryReadAccess<StructSize, V, I, RO> &access)
+    {
+        callDeinterleave(access, IndexSequence());
+    }
+
+    template <size_t StructSize, typename I, bool RO>
+    enable_if<(Length > StructSize), void> operator=(
+        const InterleavedMemoryReadAccess<StructSize, V, I, RO> &access) =
+        delete;  //("You are trying to extract more data from the struct than it has");
 
-    Vc_ALWAYS_INLINE VectorTuple(Reference a, Reference b)
-        : l(a), r(b)
+    template <typename... Inputs> void operator=(TransposeProxy<Inputs...> &&proxy)
     {
+        transpose_impl(TransposeTag<Length, sizeof...(Inputs)>(), &r[0], proxy);
     }
 
-    Vc_ALWAYS_INLINE VectorTuple<3, const V> operator,(const V &a) const
+    template <typename T, typename IndexVector, typename Scale, bool Flag>
+    void operator=(const SubscriptOperation<T, IndexVector, Scale, Flag> &sub)
     {
-        return VectorTuple<3, const V>(*this, a);
+        const auto &args = sub.gatherArguments();
+        //const IndexVector args.indexes;
+        //const T *const args.address;
+        Common::InterleavedMemoryReadAccess<1, V, Traits::decay<decltype(args.indexes)>>
+            deinterleaver(args.address, args.indexes);
+        callDeinterleave(deinterleaver, IndexSequence());
     }
+
+    Vc_ALWAYS_INLINE Reference operator[](std::size_t i) { return *r[i]; }
 };
 
-#define _VC_VECTORTUPLE_SPECIALIZATION(LENGTH, parameters) \
-template<typename V> struct VectorTuple<LENGTH, V> \
-{ \
-    typedef typename V::EntryType T; \
-    typedef V &VC_RESTRICT Reference; \
-    const VectorTuple<LENGTH - 1, V> &l; \
-    Reference r; \
- \
-    Vc_ALWAYS_INLINE VectorTuple(const VectorTuple<LENGTH - 1, V> &tuple, Reference a) \
-        : l(tuple), r(a) \
-    { \
-    } \
- \
-    Vc_ALWAYS_INLINE VectorTuple<LENGTH + 1, V> operator,(V &a) const \
-    { \
-        return VectorTuple<LENGTH + 1, V>(*this, a); \
-    } \
- \
-    template<size_t StructSize> \
-    Vc_ALWAYS_INLINE void operator=(const InterleavedMemoryReadAccess<StructSize, V> &access) const \
-    { \
-        VC_STATIC_ASSERT(LENGTH <= StructSize, You_are_trying_to_extract_more_data_from_the_struct_than_it_has); \
-        access.deinterleave parameters; \
-    } \
-}; \
-template<typename V> struct VectorTuple<LENGTH, const V> \
-{ \
-    typedef typename V::EntryType T; \
-    typedef const V &VC_RESTRICT Reference; \
-    const VectorTuple<LENGTH - 1, const V> &l; \
-    Reference r; \
- \
-    Vc_ALWAYS_INLINE VectorTuple(const VectorTuple<LENGTH - 1, const V> &tuple, Reference a) \
-        : l(tuple), r(a) \
-    { \
-    } \
- \
-    Vc_ALWAYS_INLINE VectorTuple<LENGTH + 1, const V> operator,(const V &a) const \
-    { \
-        return VectorTuple<LENGTH + 1, const V>(*this, a); \
-    } \
-}
-_VC_VECTORTUPLE_SPECIALIZATION(3, (l.l, l.r, r));
-_VC_VECTORTUPLE_SPECIALIZATION(4, (l.l.l, l.l.r, l.r, r));
-_VC_VECTORTUPLE_SPECIALIZATION(5, (l.l.l.l, l.l.l.r, l.l.r, l.r, r));
-_VC_VECTORTUPLE_SPECIALIZATION(6, (l.l.l.l.l, l.l.l.l.r, l.l.l.r, l.l.r, l.r, r));
-_VC_VECTORTUPLE_SPECIALIZATION(7, (l.l.l.l.l.l, l.l.l.l.l.r, l.l.l.l.r, l.l.l.r, l.l.r, l.r, r));
-_VC_VECTORTUPLE_SPECIALIZATION(8, (l.l.l.l.l.l.l, l.l.l.l.l.l.r, l.l.l.l.l.r, l.l.l.l.r, l.l.l.r, l.l.r, l.r, r));
-//        VC_STATIC_ASSERT(false, You_are_gathering_too_many_vectors__This_is_not_implemented);
-
-} // namespace Common
-
-#ifdef VC_IMPL_Scalar
-namespace Scalar
-#elif defined VC_IMPL_SSE
-namespace SSE
-#elif defined VC_IMPL_AVX
-namespace AVX
-#endif
-{
+}  // namespace Common
 
-template<typename T>
-Vc_ALWAYS_INLINE Common::VectorTuple<2, Vc::Vector<T> > operator,(Vc::Vector<T> &a, Vc::Vector<T> &b)
+template <typename T, typename Abi>
+Vc_DEPRECATED("build the tuple with Vc::tie instead")
+constexpr Common::VectorReferenceArray<2, Vc::Vector<T, Abi>>
+operator,(Vc::Vector<T, Abi> &a, Vc::Vector<T, Abi> &b)
 {
-    return Common::VectorTuple<2, Vc::Vector<T> >(a, b);
+    return {a, b};
 }
 
-template<typename T>
-Vc_ALWAYS_INLINE Common::VectorTuple<2, const Vc::Vector<T> > operator,(const Vc::Vector<T> &a, const Vc::Vector<T> &b)
+template <typename T, typename Abi>
+Vc_DEPRECATED("build the tuple with Vc::tie instead")
+constexpr Common::VectorReferenceArray<2, const Vc::Vector<T, Abi>>
+operator,(const Vc::Vector<T, Abi> &a, const Vc::Vector<T, Abi> &b)
 {
-    return Common::VectorTuple<2, const Vc::Vector<T> >(a, b);
+    return {a, b};
 }
 
-} // namespace Scalar/SSE/AVX
-
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+template <typename V, typename... Vs>
+constexpr Common::VectorReferenceArray<sizeof...(Vs) + 1,
+                                       typename std::remove_reference<V>::type>
+    tie(V &&a, Vs &&... b)
+{
+    return {std::forward<V>(a), std::forward<Vs>(b)...};
+}
 
-#include "undomacros.h"
+}  // namespace Vc
 
-#endif // VC_COMMON_VECTORTUPLE_H
+#endif // VC_COMMON_VECTORTUPLE_H_
diff -Nru vc-0.7.4/common/where.h vc-1.3.0/common/where.h
--- vc-0.7.4/common/where.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/where.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,241 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_WHERE_H_
+#define VC_COMMON_WHERE_H_
+
+#include "types.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+namespace WhereImpl
+{
+
+    /** \internal
+     * The default implementation covers Vc::Mask types and any \p _LValue type that implements an
+     * overload for the Vc::conditional_assign function.
+     */
+    template<typename _Mask, typename _LValue> struct MaskedLValue
+    {
+        typedef _Mask Mask;
+        typedef _LValue LValue;
+
+        const Mask &mask;
+        LValue &lhs;
+
+        // the ctors must be present, otherwise GCC fails to warn for Vc_WARN_UNUSED_RESULT
+        constexpr MaskedLValue(const Mask &m, LValue &l) : mask(m), lhs(l) {}
+        MaskedLValue(const MaskedLValue &) = delete;
+        constexpr MaskedLValue(MaskedLValue &&) = default;
+
+        /* It is intentional that the assignment operators return void: When a bool is used for the
+         * mask the code might get skipped completely, thus nothing can be returned. This would be
+         * like requiring an if statement to return a value.
+         */
+        template<typename T> Vc_ALWAYS_INLINE void operator  =(T &&rhs) { conditional_assign<Operator::          Assign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator +=(T &&rhs) { conditional_assign<Operator::      PlusAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator -=(T &&rhs) { conditional_assign<Operator::     MinusAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator *=(T &&rhs) { conditional_assign<Operator::  MultiplyAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator /=(T &&rhs) { conditional_assign<Operator::    DivideAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator %=(T &&rhs) { conditional_assign<Operator:: RemainderAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator ^=(T &&rhs) { conditional_assign<Operator::       XorAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator &=(T &&rhs) { conditional_assign<Operator::       AndAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator |=(T &&rhs) { conditional_assign<Operator::        OrAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator<<=(T &&rhs) { conditional_assign<Operator:: LeftShiftAssign>(lhs, mask, std::forward<T>(rhs)); }
+        template<typename T> Vc_ALWAYS_INLINE void operator>>=(T &&rhs) { conditional_assign<Operator::RightShiftAssign>(lhs, mask, std::forward<T>(rhs)); }
+        Vc_ALWAYS_INLINE void operator++()    { conditional_assign<Operator:: PreIncrement>(lhs, mask); }
+        Vc_ALWAYS_INLINE void operator++(int) { conditional_assign<Operator::PostIncrement>(lhs, mask); }
+        Vc_ALWAYS_INLINE void operator--()    { conditional_assign<Operator:: PreDecrement>(lhs, mask); }
+        Vc_ALWAYS_INLINE void operator--(int) { conditional_assign<Operator::PostDecrement>(lhs, mask); }
+    };
+
+    template <typename _Mask, typename T_, typename I_, typename S_>
+    struct MaskedLValue<_Mask, Common::SubscriptOperation<T_, I_, S_, true>>
+    {
+        typedef _Mask Mask;
+        typedef Common::SubscriptOperation<T_, I_, S_, true> SO;
+
+        const Mask &mask;
+        const SO lhs;
+
+        template <typename T> using Decay = typename std::decay<T>::type;
+
+        // the ctors must be present, otherwise GCC fails to warn for Vc_WARN_UNUSED_RESULT
+        constexpr MaskedLValue(const Mask &m, SO &&l) : mask(m), lhs(l) {}
+        MaskedLValue(const MaskedLValue &) = delete;
+        constexpr MaskedLValue(MaskedLValue &&) = default;
+
+        /* It is intentional that the assignment operators return void: When a bool is used for the
+         * mask the code might get skipped completely, thus nothing can be returned. This would be
+         * like requiring an if statement to return a value.
+         */
+        template<typename T> Vc_ALWAYS_INLINE void operator  =(T &&rhs) { std::forward<T>(rhs).scatter(lhs.scatterArguments(), mask); }
+        /*
+         * The following operators maybe make some sense. But only if implemented directly on the
+         * scalar objects in memory. Thus, the user is probably better of with a manual loop.
+         *
+         * If implemented the operators would need to do a masked gather, one operation, and a
+         * masked scatter. There is no way this is going to be efficient.
+         *
+        template<typename T> Vc_ALWAYS_INLINE void operator +=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  + std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator -=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  - std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator *=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  * std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator /=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  / std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator %=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  % std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator ^=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  ^ std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator &=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  & std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator |=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask)  | std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator<<=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask) << std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        template<typename T> Vc_ALWAYS_INLINE void operator>>=(T &&rhs) { (Decay<T>(lhs.gatherArguments(), mask) >> std::forward<T>(rhs)).scatter(lhs.scatterArguments(), mask); }
+        Vc_ALWAYS_INLINE void operator++()    { ++lhs(mask); }
+        Vc_ALWAYS_INLINE void operator++(int) { lhs(mask)++; }
+        Vc_ALWAYS_INLINE void operator--()    { --lhs(mask); }
+        Vc_ALWAYS_INLINE void operator--(int) { lhs(mask)--; }
+        */
+    };
+
+    template<typename _LValue> struct MaskedLValue<bool, _LValue>
+    {
+        typedef bool Mask;
+        typedef _LValue LValue;
+
+        const Mask &mask;
+        LValue &lhs;
+
+        // the ctors must be present, otherwise GCC fails to warn for Vc_WARN_UNUSED_RESULT
+        constexpr MaskedLValue(const Mask &m, LValue &l) : mask(m), lhs(l) {}
+        MaskedLValue(const MaskedLValue &) = delete;
+        constexpr MaskedLValue(MaskedLValue &&) = default;
+
+        template<typename T> Vc_ALWAYS_INLINE void operator  =(T &&rhs) { if (mask) lhs   = std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator +=(T &&rhs) { if (mask) lhs  += std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator -=(T &&rhs) { if (mask) lhs  -= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator *=(T &&rhs) { if (mask) lhs  *= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator /=(T &&rhs) { if (mask) lhs  /= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator %=(T &&rhs) { if (mask) lhs  %= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator ^=(T &&rhs) { if (mask) lhs  ^= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator &=(T &&rhs) { if (mask) lhs  &= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator |=(T &&rhs) { if (mask) lhs  |= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator<<=(T &&rhs) { if (mask) lhs <<= std::forward<T>(rhs); }
+        template<typename T> Vc_ALWAYS_INLINE void operator>>=(T &&rhs) { if (mask) lhs >>= std::forward<T>(rhs); }
+        Vc_ALWAYS_INLINE void operator++()    { if (mask) ++lhs; }
+        Vc_ALWAYS_INLINE void operator++(int) { if (mask) lhs++; }
+        Vc_ALWAYS_INLINE void operator--()    { if (mask) --lhs; }
+        Vc_ALWAYS_INLINE void operator--(int) { if (mask) lhs--; }
+    };
+
+    template<typename _Mask> struct WhereMask
+    {
+        typedef _Mask Mask;
+        const Mask &mask;
+
+        // the ctors must be present, otherwise GCC fails to warn for Vc_WARN_UNUSED_RESULT
+        constexpr WhereMask(const Mask &m) : mask(m) {}
+        WhereMask(const WhereMask &) = delete;
+
+        template <typename T, typename I, typename S>
+        constexpr Vc_WARN_UNUSED_RESULT
+            MaskedLValue<Mask, Common::SubscriptOperation<T, I, S, true>>
+            operator|(Common::SubscriptOperation<T, I, S, true> &&lhs) const
+        {
+            static_assert(!std::is_const<T>::value,
+                          "masked scatter to constant memory not possible.");
+            return {mask, std::move(lhs)};
+        }
+
+        template<typename T> constexpr Vc_WARN_UNUSED_RESULT MaskedLValue<Mask, T> operator|(T &&lhs) const
+        {
+            static_assert(std::is_lvalue_reference<T>::value, "Syntax error: Incorrect use of Vc::where. Maybe operator precedence got you by surprise. Examples of correct usage:\n"
+                    "  Vc::where(x < 2) | x += 1;\n"
+                    "  (Vc::where(x < 2) | x)++;\n"
+                    "  Vc::where(x < 2)(x) += 1;\n"
+                    "  Vc::where(x < 2)(x)++;\n"
+                    );
+            return { mask, lhs };
+        }
+
+        template<typename T> constexpr Vc_WARN_UNUSED_RESULT MaskedLValue<Mask, T> operator()(T &&lhs) const
+        {
+            return operator|(std::forward<T>(lhs));
+        }
+    };
+}  // namespace WhereImpl
+
+/**
+ * \ingroup Utilities
+ *
+ * Conditional assignment.
+ *
+ * Since compares between SIMD vectors do not return a single boolean, but rather a vector of
+ * booleans (mask), one often cannot use if / else statements. Instead, one needs to state
+ * that only a subset of entries of a given SIMD vector should be modified. The \c where function
+ * can be prepended to any assignment operation to execute a masked assignment.
+ *
+ * \param mask The mask that selects the entries in the target vector that will be modified.
+ *
+ * \return This function returns an opaque object that binds to the left operand of an assignment
+ * via the binary-or operator or the functor operator. (i.e. either <code>where(mask) | x = y</code>
+ * or <code>where(mask)(x) = y</code>)
+ *
+ * Example:
+ * \code
+ * template<typename T> void f1(T &x, T &y)
+ * {
+ *   if (x < 2) {
+ *     x *= y;
+ *     y += 2;
+ *   }
+ * }
+ * template<typename T> void f2(T &x, T &y)
+ * {
+ *   where(x < 2) | x *= y;
+ *   where(x < 2) | y += 2;
+ * }
+ * \endcode
+ * The block following the if statement in \c f1 will be executed if <code>x &lt; 2</code> evaluates
+ * to \c true. If \c T is a scalar type you normally get what you expect. But if \c T is a SIMD
+ * vector type, the comparison will use the implicit conversion from a mask to bool, meaning
+ * <code>all_of(x &lt; 2)</code>.
+ *
+ * Most of the time the required operation is a masked assignment as stated in \c f2.
+ *
+ */
+template<typename M> constexpr Vc_WARN_UNUSED_RESULT WhereImpl::WhereMask<M> where(const M &mask)
+{
+    return { mask };
+}
+
+template<typename M> constexpr Vc_WARN_UNUSED_RESULT WhereImpl::WhereMask<M> _if(const M &m)
+{
+    return { m };
+}
+
+}  // namespace Vc
+
+#endif // VC_COMMON_WHERE_H_
diff -Nru vc-0.7.4/common/windows_fix_intrin.h vc-1.3.0/common/windows_fix_intrin.h
--- vc-0.7.4/common/windows_fix_intrin.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/common/windows_fix_intrin.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,300 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_WINDOWS_FIX_INTRIN_H
-#define VC_COMMON_WINDOWS_FIX_INTRIN_H
-
-#if defined(VC_MSVC) && !defined(__midl)
-// MSVC sucks. If you include intrin.h you get all SSE and AVX intrinsics
-// declared. This is a problem because we need to implement the intrinsics
-// that are not supported in hardware ourselves.
-// Something always includes intrin.h even if you don't
-// do it explicitly. Therefore we try to be the first to include it
-// but with __midl defined, in which case it is basically empty.
-#ifdef __INTRIN_H_
-#error "intrin.h was already included, polluting the namespace. Please fix your code to include the Vc headers before anything that includes intrin.h. (Vc will declare the relevant intrinsics as they are required by some system headers.)"
-#endif
-#define __midl
-#include <intrin.h>
-#undef __midl
-#include <crtdefs.h>
-#include <setjmp.h>
-#include <stddef.h>
-extern "C" {
-
-#ifdef _WIN64
-_CRTIMP double ceil(_In_ double);
-__int64 _InterlockedDecrement64(__int64 volatile *);
-__int64 _InterlockedExchange64(__int64 volatile *, __int64);
-void * _InterlockedExchangePointer(void * volatile *, void *);
-__int64 _InterlockedExchangeAdd64(__int64 volatile *, __int64);
-void *_InterlockedCompareExchangePointer (void * volatile *, void *, void *);
-__int64 _InterlockedIncrement64(__int64 volatile *);
-int __cdecl _setjmpex(jmp_buf);
-void __faststorefence(void);
-__int64 __mulh(__int64,__int64);
-unsigned __int64 __umulh(unsigned __int64,unsigned __int64);
-unsigned __int64 __readcr0(void);
-unsigned __int64 __readcr2(void);
-unsigned __int64 __readcr3(void);
-unsigned __int64 __readcr4(void);
-unsigned __int64 __readcr8(void);
-void __writecr0(unsigned __int64);
-void __writecr3(unsigned __int64);
-void __writecr4(unsigned __int64);
-void __writecr8(unsigned __int64);
-unsigned __int64 __readdr(unsigned int);
-void __writedr(unsigned int, unsigned __int64);
-unsigned __int64 __readeflags(void);
-void __writeeflags(unsigned __int64);
-void __movsq(unsigned long long *, unsigned long long const *, size_t);
-unsigned char __readgsbyte(unsigned long Offset);
-unsigned short __readgsword(unsigned long Offset);
-unsigned long __readgsdword(unsigned long Offset);
-unsigned __int64 __readgsqword(unsigned long Offset);
-void __writegsbyte(unsigned long Offset, unsigned char Data);
-void __writegsword(unsigned long Offset, unsigned short Data);
-void __writegsdword(unsigned long Offset, unsigned long Data);
-void __writegsqword(unsigned long Offset, unsigned __int64 Data);
-void __addgsbyte(unsigned long Offset, unsigned char Data);
-void __addgsword(unsigned long Offset, unsigned short Data);
-void __addgsdword(unsigned long Offset, unsigned long Data);
-void __addgsqword(unsigned long Offset, unsigned __int64 Data);
-void __incgsbyte(unsigned long Offset);
-void __incgsword(unsigned long Offset);
-void __incgsdword(unsigned long Offset);
-void __incgsqword(unsigned long Offset);
-unsigned char __vmx_vmclear(unsigned __int64*);
-unsigned char __vmx_vmlaunch(void);
-unsigned char __vmx_vmptrld(unsigned __int64*);
-unsigned char __vmx_vmread(size_t, size_t*);
-unsigned char __vmx_vmresume(void);
-unsigned char __vmx_vmwrite(size_t, size_t);
-unsigned char __vmx_on(unsigned __int64*);
-void __stosq(unsigned __int64 *,  unsigned __int64, size_t);
-unsigned char _interlockedbittestandset64(__int64 volatile *a, __int64 b);
-unsigned char _interlockedbittestandreset64(__int64 volatile *a, __int64 b);
-short _InterlockedCompareExchange16_np(short volatile *Destination, short Exchange, short Comparand);
-long _InterlockedCompareExchange_np (long volatile *, long, long);
-__int64 _InterlockedCompareExchange64_np(__int64 volatile *, __int64, __int64);
-void *_InterlockedCompareExchangePointer_np (void * volatile *, void *, void *);
-unsigned char _InterlockedCompareExchange128(__int64 volatile *, __int64, __int64, __int64 *);
-unsigned char _InterlockedCompareExchange128_np(__int64 volatile *, __int64, __int64, __int64 *);
-long _InterlockedAnd_np(long volatile *, long);
-char _InterlockedAnd8_np(char volatile *, char);
-short _InterlockedAnd16_np(short volatile *, short);
-__int64 _InterlockedAnd64_np(__int64 volatile *, __int64);
-long _InterlockedOr_np(long volatile *, long);
-char _InterlockedOr8_np(char volatile *, char);
-short _InterlockedOr16_np(short volatile *, short);
-__int64 _InterlockedOr64_np(__int64 volatile *, __int64);
-long _InterlockedXor_np(long volatile *, long);
-char _InterlockedXor8_np(char volatile *, char);
-short _InterlockedXor16_np(short volatile *, short);
-__int64 _InterlockedXor64_np(__int64 volatile *, __int64);
-unsigned __int64 __lzcnt64(unsigned __int64);
-unsigned __int64 __popcnt64(unsigned __int64);
-__int64 _InterlockedOr64(__int64 volatile *, __int64);
-__int64 _InterlockedXor64(__int64 volatile *, __int64);
-__int64 _InterlockedAnd64(__int64 volatile *, __int64);
-unsigned char _bittest64(__int64 const *a, __int64 b);
-unsigned char _bittestandset64(__int64 *a, __int64 b);
-unsigned char _bittestandreset64(__int64 *a, __int64 b);
-unsigned char _bittestandcomplement64(__int64 *a, __int64 b);
-unsigned char _BitScanForward64(unsigned long* Index, unsigned __int64 Mask);
-unsigned char _BitScanReverse64(unsigned long* Index, unsigned __int64 Mask);
-unsigned __int64 __shiftleft128(unsigned __int64 LowPart, unsigned __int64 HighPart, unsigned char Shift);
-unsigned __int64 __shiftright128(unsigned __int64 LowPart, unsigned __int64 HighPart, unsigned char Shift);
-unsigned __int64 _umul128(unsigned __int64 multiplier, unsigned __int64 multiplicand, unsigned __int64 *highproduct);
-__int64 _mul128(__int64 multiplier, __int64 multiplicand, __int64 *highproduct);
-#endif
-
-long _InterlockedOr(long volatile *, long);
-char _InterlockedOr8(char volatile *, char);
-short _InterlockedOr16(short volatile *, short);
-long _InterlockedXor(long volatile *, long);
-char _InterlockedXor8(char volatile *, char);
-short _InterlockedXor16(short volatile *, short);
-long _InterlockedAnd(long volatile *, long);
-char _InterlockedAnd8(char volatile *, char);
-short _InterlockedAnd16(short volatile *, short);
-unsigned char _bittest(long const *a, long b);
-unsigned char _bittestandset(long *a, long b);
-unsigned char _bittestandreset(long *a, long b);
-unsigned char _bittestandcomplement(long *a, long b);
-unsigned char _BitScanForward(unsigned long* Index, unsigned long Mask);
-unsigned char _BitScanReverse(unsigned long* Index, unsigned long Mask);
-_CRTIMP wchar_t * __cdecl wcscat( _Pre_cap_for_(_Source) _Prepost_z_ wchar_t *, _In_z_ const wchar_t * _Source);
-_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *,_In_z_  const wchar_t *);
-_CRTIMP wchar_t * __cdecl wcscpy(_Pre_cap_for_(_Source) _Post_z_ wchar_t *, _In_z_ const wchar_t * _Source);
-_Check_return_ _CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *);
-#pragma warning(suppress: 4985)
-_CRTIMP wchar_t * __cdecl _wcsset(_Inout_z_ wchar_t *, wchar_t);
-void _ReadBarrier(void);
-unsigned char _rotr8(unsigned char value, unsigned char shift);
-unsigned short _rotr16(unsigned short value, unsigned char shift);
-unsigned char _rotl8(unsigned char value, unsigned char shift);
-unsigned short _rotl16(unsigned short value, unsigned char shift);
-short _InterlockedIncrement16(short volatile *Addend);
-short _InterlockedDecrement16(short volatile *Addend);
-short _InterlockedCompareExchange16(short volatile *Destination, short Exchange, short Comparand);
-void __nvreg_save_fence(void);
-void __nvreg_restore_fence(void);
-
-#ifdef _M_IX86
-unsigned long __readcr0(void);
-unsigned long __readcr2(void);
-unsigned long __readcr3(void);
-unsigned long __readcr4(void);
-unsigned long __readcr8(void);
-void __writecr0(unsigned);
-void __writecr3(unsigned);
-void __writecr4(unsigned);
-void __writecr8(unsigned);
-unsigned __readdr(unsigned int);
-void __writedr(unsigned int, unsigned);
-unsigned __readeflags(void);
-void __writeeflags(unsigned);
-void __addfsbyte(unsigned long Offset, unsigned char Data);
-void __addfsword(unsigned long Offset, unsigned short Data);
-void __addfsdword(unsigned long Offset, unsigned long Data);
-void __incfsbyte(unsigned long Offset);
-void __incfsword(unsigned long Offset);
-void __incfsdword(unsigned long Offset);
-unsigned char __readfsbyte(unsigned long Offset);
-unsigned short __readfsword(unsigned long Offset);
-unsigned long __readfsdword(unsigned long Offset);
-unsigned __int64 __readfsqword(unsigned long Offset);
-void __writefsbyte(unsigned long Offset, unsigned char Data);
-void __writefsword(unsigned long Offset, unsigned short Data);
-void __writefsdword(unsigned long Offset, unsigned long Data);
-void __writefsqword(unsigned long Offset, unsigned __int64 Data);
-long _InterlockedAddLargeStatistic(__int64 volatile *, long);
-#endif
-
-_Ret_bytecap_(_Size) void * __cdecl _alloca(size_t _Size);
-int __cdecl abs(_In_ int);
-_Check_return_ unsigned short __cdecl _byteswap_ushort(_In_ unsigned short value);
-_Check_return_ unsigned long __cdecl _byteswap_ulong(_In_ unsigned long value);
-_Check_return_ unsigned __int64 __cdecl _byteswap_uint64(_In_ unsigned __int64 value);
-void __cdecl __debugbreak(void);
-void __cdecl _disable(void);
-__int64 __emul(int,int);
-unsigned __int64 __emulu(unsigned int,unsigned int);
-void __cdecl _enable(void);
-long __cdecl _InterlockedDecrement(long volatile *);
-long _InterlockedExchange(long volatile *, long);
-short _InterlockedExchange16(short volatile *, short);
-char _InterlockedExchange8(char volatile *, char);
-long _InterlockedExchangeAdd(long volatile *, long);
-short _InterlockedExchangeAdd16(short volatile *, short);
-char _InterlockedExchangeAdd8(char volatile *, char);
-long _InterlockedCompareExchange (long volatile *, long, long);
-__int64 _InterlockedCompareExchange64(__int64 volatile *, __int64, __int64);
-long __cdecl _InterlockedIncrement(long volatile *);
-int __cdecl _inp(unsigned short);
-int __cdecl inp(unsigned short);
-unsigned long __cdecl _inpd(unsigned short);
-unsigned long __cdecl inpd(unsigned short);
-unsigned short __cdecl _inpw(unsigned short);
-unsigned short __cdecl inpw(unsigned short);
-long __cdecl labs(_In_ long);
-_Check_return_ unsigned long __cdecl _lrotl(_In_ unsigned long,_In_ int);
-_Check_return_ unsigned long __cdecl _lrotr(_In_ unsigned long,_In_ int);
-unsigned __int64  __ll_lshift(unsigned __int64,int);
-__int64  __ll_rshift(__int64,int);
-_Check_return_ int __cdecl memcmp(_In_opt_bytecount_(_Size) const void *,_In_opt_bytecount_(_Size) const void *,_In_ size_t _Size);
-void * __cdecl memcpy(_Out_opt_bytecapcount_(_Size) void *,_In_opt_bytecount_(_Size) const void *,_In_ size_t _Size);
-void * __cdecl memset(_Out_opt_bytecapcount_(_Size) void *,_In_ int,_In_ size_t _Size);
-int __cdecl _outp(unsigned short,int);
-int __cdecl outp(unsigned short,int);
-unsigned long __cdecl _outpd(unsigned short,unsigned long);
-unsigned long __cdecl outpd(unsigned short,unsigned long);
-unsigned short __cdecl _outpw(unsigned short,unsigned short);
-unsigned short __cdecl outpw(unsigned short,unsigned short);
-void * _ReturnAddress(void);
-_Check_return_ unsigned int __cdecl _rotl(_In_ unsigned int,_In_ int);
-_Check_return_ unsigned int __cdecl _rotr(_In_ unsigned int,_In_ int);
-int __cdecl _setjmp(jmp_buf);
-_Check_return_ int __cdecl strcmp(_In_z_ const char *,_In_z_ const char *);
-_Check_return_ size_t __cdecl strlen(_In_z_ const char *);
-char * __cdecl strset(_Inout_z_ char *,_In_ int);
-unsigned __int64 __ull_rshift(unsigned __int64,int);
-void * _AddressOfReturnAddress(void);
-
-void _WriteBarrier(void);
-void _ReadWriteBarrier(void);
-void __wbinvd(void);
-void __invlpg(void*);
-unsigned __int64 __readmsr(unsigned long);
-void __writemsr(unsigned long, unsigned __int64);
-unsigned __int64 __rdtsc(void);
-void __movsb(unsigned char *, unsigned char const *, size_t);
-void __movsw(unsigned short *, unsigned short const *, size_t);
-void __movsd(unsigned long *, unsigned long const *, size_t);
-unsigned char __inbyte(unsigned short Port);
-unsigned short __inword(unsigned short Port);
-unsigned long __indword(unsigned short Port);
-void __outbyte(unsigned short Port, unsigned char Data);
-void __outword(unsigned short Port, unsigned short Data);
-void __outdword(unsigned short Port, unsigned long Data);
-void __inbytestring(unsigned short Port, unsigned char *Buffer, unsigned long Count);
-void __inwordstring(unsigned short Port, unsigned short *Buffer, unsigned long Count);
-void __indwordstring(unsigned short Port, unsigned long *Buffer, unsigned long Count);
-void __outbytestring(unsigned short Port, unsigned char *Buffer, unsigned long Count);
-void __outwordstring(unsigned short Port, unsigned short *Buffer, unsigned long Count);
-void __outdwordstring(unsigned short Port, unsigned long *Buffer, unsigned long Count);
-unsigned int __getcallerseflags();
-void __vmx_vmptrst(unsigned __int64 *);
-void __vmx_off(void);
-void __svm_clgi(void);
-void __svm_invlpga(void*, int);
-void __svm_skinit(int);
-void __svm_stgi(void);
-void __svm_vmload(size_t);
-void __svm_vmrun(size_t);
-void __svm_vmsave(size_t);
-void __halt(void);
-void __sidt(void*);
-void __lidt(void*);
-void __ud2(void);
-void __nop(void);
-void __stosb(unsigned char *, unsigned char, size_t);
-void __stosw(unsigned short *,  unsigned short, size_t);
-void __stosd(unsigned long *,  unsigned long, size_t);
-unsigned char _interlockedbittestandset(long volatile *a, long b);
-unsigned char _interlockedbittestandreset(long volatile *a, long b);
-void __cpuid(int a[4], int b);
-void __cpuidex(int a[4], int b, int c);
-unsigned __int64 __readpmc(unsigned long a);
-unsigned long __segmentlimit(unsigned long a);
-_Check_return_ unsigned __int64 __cdecl _rotl64(_In_ unsigned __int64,_In_ int);
-_Check_return_ unsigned __int64 __cdecl _rotr64(_In_ unsigned __int64,_In_ int);
-__int64 __cdecl _abs64(__int64);
-void __int2c(void);
-char _InterlockedCompareExchange8(char volatile *Destination, char Exchange, char Comparand);
-unsigned short __lzcnt16(unsigned short);
-unsigned int __lzcnt(unsigned int);
-unsigned short __popcnt16(unsigned short);
-unsigned int __popcnt(unsigned int);
-unsigned __int64 __rdtscp(unsigned int*);
-}
-#endif
-
-#endif // VC_COMMON_WINDOWS_FIX_INTRIN_H
diff -Nru vc-0.7.4/common/writemaskedvector.h vc-1.3.0/common/writemaskedvector.h
--- vc-0.7.4/common/writemaskedvector.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/writemaskedvector.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,137 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_WRITEMASKEDVECTOR_H_
+#define VC_COMMON_WRITEMASKEDVECTOR_H_
+
+#include <utility>
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+template <typename V, typename M = typename V::Mask> class WriteMaskedVector
+{
+    static_assert(
+        V::Size == M::Size,
+        "incorrect use of Vc::Common::WriteMaskedVector<V, M>. V and M must have the same «Size».");
+
+public:
+    typedef M Mask;
+    static constexpr size_t Size = V::Size;
+
+    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(Mask));
+
+    // implicit (allows {vec, mask} in places where WriteMaskedVector is expected)
+    Vc_INTRINSIC WriteMaskedVector(V &v, const Mask &k) : mask(k), vec(v)
+    {
+    }
+
+    // prefix
+    Vc_INTRINSIC V &operator++()
+    {
+        V one = V::One();
+        one.setZeroInverted(mask);
+        return vec += one;
+    }
+    Vc_INTRINSIC V &operator--()
+    {
+        V one = V::One();
+        one.setZeroInverted(mask);
+        return vec -= one;
+    }
+
+    // postfix
+    Vc_INTRINSIC V operator++(int)
+    {
+        V ret(vec);
+        operator++();
+        return ret;
+    }
+    Vc_INTRINSIC V operator--(int)
+    {
+        V ret(vec);
+        operator--();
+        return ret;
+    }
+
+#define Vc_OPERATOR_(op)                                                                 \
+    template <typename U> Vc_ALWAYS_INLINE void operator op##=(U &&x)                    \
+    {                                                                                    \
+        operator=(static_cast<V>(vec op std::forward<U>(x)));                            \
+    }
+    Vc_ALL_BINARY(Vc_OPERATOR_);
+    Vc_ALL_ARITHMETICS(Vc_OPERATOR_);
+    Vc_ALL_SHIFTS(Vc_OPERATOR_);
+#undef Vc_OPERATOR_
+
+    Vc_ALWAYS_INLINE void operator=(const V &x)
+    {
+        vec.assign(x, mask);
+    }
+
+    template <typename T, typename I, typename S>
+    Vc_ALWAYS_INLINE void operator=(SubscriptOperation<T, I, S, true> &&x)
+    {
+        vec.gather(x.gatherArguments(), mask);
+    }
+
+    template <typename F> Vc_INTRINSIC void call(const F &f) const
+    {
+        return vec.call(f, mask);
+    }
+    template <typename F> Vc_INTRINSIC V apply(const F &f) const
+    {
+        return vec.apply(f, mask);
+    }
+    template <typename F> Vc_INTRINSIC void call(F &&f) const
+    {
+        return vec.call(std::forward<F>(f), mask);
+    }
+    template <typename F> Vc_INTRINSIC V apply(F &&f) const
+    {
+        return vec.apply(std::forward<F>(f), mask);
+    }
+
+private:
+#ifdef Vc_ICC
+    // If ICC gets a by-value copy of Mask here, it'll generate a lot of superfluous
+    // stack-register copies.
+    const Mask &mask;
+#else
+    // If Clang gets a const-ref Mask here, it'll miscompile some of the masked assignment
+    // statements.
+    const Mask mask;
+#endif
+    V &vec;
+};
+}  // namespace Common
+}  // namespace Vc
+
+#endif // VC_COMMON_WRITEMASKEDVECTOR_H_
diff -Nru vc-0.7.4/common/x86_prefetches.h vc-1.3.0/common/x86_prefetches.h
--- vc-0.7.4/common/x86_prefetches.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/common/x86_prefetches.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,138 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_COMMON_X86_PREFETCHES_H_
+#define VC_COMMON_X86_PREFETCHES_H_
+
+#include <xmmintrin.h>
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+
+#if defined(Vc_IMPL_MIC)
+static constexpr int exclusive_hint = 0x4;
+#else
+static constexpr int exclusive_hint = 0;
+#endif
+
+// TODO: support AMD's prefetchw with correct flags and checks via cpuid
+
+template <typename ExclusiveOrShared = Vc::Shared>
+Vc_INTRINSIC void prefetchForOneRead(const void *addr)
+{
+    if (std::is_same<ExclusiveOrShared, Vc::Shared>::value) {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_NTA);
+    } else {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)),
+                     static_cast<decltype(_MM_HINT_NTA)>(_MM_HINT_NTA | exclusive_hint));
+    }
+}
+template <typename ExclusiveOrShared = Vc::Shared>
+Vc_INTRINSIC void prefetchClose(const void *addr)
+{
+    if (std::is_same<ExclusiveOrShared, Vc::Shared>::value) {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
+    } else {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)),
+                     static_cast<decltype(_MM_HINT_T0)>(_MM_HINT_T0 | exclusive_hint));
+    }
+}
+template <typename ExclusiveOrShared = Vc::Shared>
+Vc_INTRINSIC void prefetchMid(const void *addr)
+{
+    if (std::is_same<ExclusiveOrShared, Vc::Shared>::value) {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T1);
+    } else {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)),
+                     static_cast<decltype(_MM_HINT_T1)>(_MM_HINT_T1 | exclusive_hint));
+    }
+}
+template <typename ExclusiveOrShared = Vc::Shared>
+Vc_INTRINSIC void prefetchFar(const void *addr)
+{
+    if (std::is_same<ExclusiveOrShared, Vc::Shared>::value) {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T2);
+    } else {
+        _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)),
+                     static_cast<decltype(_MM_HINT_T2)>(_MM_HINT_T2 | exclusive_hint));
+    }
+}
+
+/*handlePrefetch/handleLoadPrefetches/handleStorePrefetches{{{*/
+namespace
+{
+template<size_t L1, size_t L2, bool UseExclusivePrefetch> Vc_INTRINSIC void handlePrefetch(const void *addr_, typename std::enable_if<L1 != 0 && L2 != 0, void *>::type = nullptr)
+{
+    const char *addr = static_cast<const char *>(addr_);
+    prefetchClose<typename std::conditional<UseExclusivePrefetch, Vc::Exclusive, Vc::Shared>::type>(addr + L1);
+    prefetchMid  <typename std::conditional<UseExclusivePrefetch, Vc::Exclusive, Vc::Shared>::type>(addr + L2);
+}
+template<size_t L1, size_t L2, bool UseExclusivePrefetch> Vc_INTRINSIC void handlePrefetch(const void *addr_, typename std::enable_if<L1 == 0 && L2 != 0, void *>::type = nullptr)
+{
+    const char *addr = static_cast<const char *>(addr_);
+    prefetchMid  <typename std::conditional<UseExclusivePrefetch, Vc::Exclusive, Vc::Shared>::type>(addr + L2);
+}
+template<size_t L1, size_t L2, bool UseExclusivePrefetch> Vc_INTRINSIC void handlePrefetch(const void *addr_, typename std::enable_if<L1 != 0 && L2 == 0, void *>::type = nullptr)
+{
+    const char *addr = static_cast<const char *>(addr_);
+    prefetchClose<typename std::conditional<UseExclusivePrefetch, Vc::Exclusive, Vc::Shared>::type>(addr + L1);
+}
+template<size_t L1, size_t L2, bool UseExclusivePrefetch> Vc_INTRINSIC void handlePrefetch(const void *, typename std::enable_if<L1 == 0 && L2 == 0, void *>::type = nullptr)
+{
+}
+
+template<typename Flags> Vc_INTRINSIC void handleLoadPrefetches(const void *    , Flags, typename Flags::EnableIfNotPrefetch = nullptr) {}
+template<typename Flags> Vc_INTRINSIC void handleLoadPrefetches(const void *addr, Flags, typename Flags::EnableIfPrefetch    = nullptr)
+{
+    // load prefetches default to Shared unless Exclusive was explicitely selected
+    handlePrefetch<Flags::L1Stride, Flags::L2Stride, Flags::IsExclusivePrefetch>(addr);
+}
+
+template<typename Flags> Vc_INTRINSIC void handleStorePrefetches(const void *    , Flags, typename Flags::EnableIfNotPrefetch = nullptr) {}
+template<typename Flags> Vc_INTRINSIC void handleStorePrefetches(const void *addr, Flags, typename Flags::EnableIfPrefetch    = nullptr)
+{
+    // store prefetches default to Exclusive unless Shared was explicitely selected
+    handlePrefetch<Flags::L1Stride, Flags::L2Stride, !Flags::IsSharedPrefetch>(addr);
+}
+
+} // anonymous namespace
+/*}}}*/
+
+}  // namespace Common
+
+using Common::prefetchForOneRead;
+using Common::prefetchClose;
+using Common::prefetchMid;
+using Common::prefetchFar;
+}  // namespace Vc
+
+#endif // VC_COMMON_X86_PREFETCHES_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/CTestConfig.cmake vc-1.3.0/CTestConfig.cmake
--- vc-0.7.4/CTestConfig.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/CTestConfig.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -1,9 +1,9 @@
 set(CTEST_PROJECT_NAME "Vc")
 set(CTEST_NIGHTLY_START_TIME "00:00:00 CEST")
 
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "code.compeng.uni-frankfurt.de")
-set(CTEST_DROP_LOCATION "/dashboard/submit.php?project=Vc-0.7")
+set(CTEST_DROP_METHOD "https")
+set(CTEST_DROP_SITE "cdash.gsi.de")
+set(CTEST_DROP_LOCATION "/submit.php?project=Vc")
 
 set(CTEST_DROP_SITE_CDASH TRUE)
 
diff -Nru vc-0.7.4/CTestCustom.cmake vc-1.3.0/CTestCustom.cmake
--- vc-0.7.4/CTestCustom.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/CTestCustom.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -3,24 +3,18 @@
    " C4756: " # MSVC 2012 can't suppress this warning
    "used uninitialized in this function"
    "Skipping compilation of tests gatherStruct and gather2dim because of clang bug" # Not a helpful warning for the dashboard
-   "GCC < 4.3 does not have full support for SSE2 intrinsics." # Ignore self-made warning, though what I really want is a message when the warning is absent
-   "call to .*Vc::Warnings::_operator_bracket_warning.* declared with attribute warning"
    "warning is a GCC extension"
    "^-- "  # Ignore output from cmake
-   "GCC 4.6.0 is broken.  The following tests are therefore disabled" # This warning is meant for users not the dashboard
-   "Your GCC is older than 4.4.6.  This is known to cause problems/bugs" # This warning is meant for users not the dashboard
-   "GCC 4.4.x shows false positives for -Wparentheses, thus we rather disable" # This warning is meant for users not the dashboard
    "AVX disabled per default because of old/broken compiler" # This warning is meant for users not the dashboard
-   "GCC 4.7.0 miscompiles at -O3, adding -fno-predictive-commoning to the" # This warning is meant for users not the dashboard
    "warning: the mangled name of .*typename Vc::{anonymous}::Decltype.* will change in a future version of GCC"
-   "^\\*\\*\\* WARNING non-zero return value in ctest from: make" # Ignore output from ctest
+   "WARNING non-zero return value in ctest from: make" # Ignore output from ctest
    "ipo: warning #11010:" # Ignore warning about incompatible libraries with ICC -m32 on 64-bit system
    "include/qt4" # -Wuninitialized in QWeakPointer(X *ptr)
-   "implicit_type_conversion.cpp.*(double|float).*argument 1 to.*TestImplicitCast" # ignore GCC 4.1 warning
-   "Vc::Warnings::_operator_bracket_warning" # GCC 4.3 is supposed to throw this warning like crazy
+   " note: " # Notes are additional lines from errors (or warnings) that we don't want to count as additional warnings
+   "clang: warning: argument unused during compilation: '-stdlib=libc"
    )
 
 set(CTEST_CUSTOM_ERROR_EXCEPTION ${CTEST_CUSTOM_ERROR_EXCEPTION}
    "^make\\[[1-9]\\]: "
    "^collect2: ld returned . exit status"
-   "^make: \\*\\*\\* \\[all\\] Error ")
+   "^make: \\*\\*\\* \\[.*\\] Error ")
diff -Nru vc-0.7.4/debian/changelog vc-1.3.0/debian/changelog
--- vc-0.7.4/debian/changelog	2014-08-11 07:00:54.000000000 -0500
+++ vc-1.3.0/debian/changelog	2017-02-11 18:54:07.000000000 -0600
@@ -1,3 +1,20 @@
+vc (1.3.0-0ubuntu1) zesty; urgency=medium
+
+  * New upstream release (LP: #1629881).
+  * Update debian/copyright with new license.
+  * Bump Standards-version to 3.9.8.
+  * Update debhelper version to 10.
+  * Change homepage to the correct one.
+  * Update maintainer to Debian/Kubuntu Qt/KDE Maintainers to be more
+    consistent with other KDE packaging.
+  * Remove outdated patches, not needed anymore.
+  * Clean up comments in debian/rules.
+  * Update debian/watch file to the new upstream location, using the
+    workaround for GitHub specified in the Debian wiki.
+  * Run wrap-and-sort.
+
+ -- Simon Quigley <tsimonq2@ubuntu.com>  Sat, 11 Feb 2017 18:54:07 -0600
+
 vc (0.7.4-0ubuntu1) utopic; urgency=medium
 
   * New upstream release
diff -Nru vc-0.7.4/debian/compat vc-1.3.0/debian/compat
--- vc-0.7.4/debian/compat	2014-08-11 06:59:58.000000000 -0500
+++ vc-1.3.0/debian/compat	2017-02-11 18:49:57.000000000 -0600
@@ -1 +1 @@
-8
+10
diff -Nru vc-0.7.4/debian/control vc-1.3.0/debian/control
--- vc-0.7.4/debian/control	2014-08-11 06:59:58.000000000 -0500
+++ vc-1.3.0/debian/control	2017-02-11 18:54:07.000000000 -0600
@@ -1,16 +1,15 @@
 Source: vc
 Priority: extra
-Maintainer: Kubuntu Developers <kubuntu-devel@lists.ubuntu.com>
-XSBC-Original-Maintainer: Jonathan Riddell <jriddell@ubuntu.com>
-Build-Depends: debhelper (>= 8.0.0), cmake
-Standards-Version: 3.9.4
+Maintainer: Debian/Kubuntu Qt/KDE Maintainers <debian-qt-kde@lists.debian.org>
+Build-Depends: cmake, debhelper (>= 10)
+Standards-Version: 3.9.8
 Section: libs
-Homepage: http://code.compeng.uni-frankfurt.de/projects/vc
+Homepage: https://github.com/VcDevel/Vc
 
 Package: vc-dev
 Section: libdevel
 Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
+Depends: ${misc:Depends}, ${shlibs:Depends}
 Description: library to ease explicit vectorization of C++ code
  Vc is a free software library to ease explicit vectorization of C++
  code. It has an intuitive API and provides portability between
diff -Nru vc-0.7.4/debian/copyright vc-1.3.0/debian/copyright
--- vc-0.7.4/debian/copyright	2014-08-11 06:59:58.000000000 -0500
+++ vc-1.3.0/debian/copyright	2017-02-11 18:54:07.000000000 -0600
@@ -1,22 +1,34 @@
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: vc
-Source: http://code.compeng.uni-frankfurt.de/projects/vc
+Source:
 
 Files: *
-Copyright: 2009-2012 Matthias Kretz <kretz@kde.org>
-License: LGPL-3+
- Vc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation, either version 3 of
- the License, or (at your option) any later version.
- .
- Vc is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Lesser General Public License for more details.
+Copyright: 2009-2015 Matthias Kretz <kretz@kde.org>
+License: BSD-3-clause
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ .
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
  .
- You should have received a copy of the GNU Lesser General Public
- License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+ .
+   * Neither the names of contributing organizations nor the
+     names of its contributors may be used to endorse or promote products
+     derived from this software without specific prior written permission.
+ .
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 Files: cmake/CheckCCompilerFlag.cmake
        cmake/CheckCXXCompilerFlag.cmake
@@ -26,7 +38,7 @@
 Copyright: 2009-2012 Matthias Kretz <kretz@kde.org>
            2006-2009 Kitware, Inc.
            2006 Alexander Neundorf <neundorf@kde.org>
-License: BSD CMake
+License: BSD-CMake
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are
  met:
@@ -56,6 +68,7 @@
 
 Files: debian/*
 Copyright: 2013 Jonathan Riddell <jriddell@ubuntu.com>
+           2017 Simon Quigley <tsimonq2@ubuntu.com>
 License: GPL-2+
  This package is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
diff -Nru vc-0.7.4/debian/patches/kubuntu_01_git.diff vc-1.3.0/debian/patches/kubuntu_01_git.diff
--- vc-0.7.4/debian/patches/kubuntu_01_git.diff	2014-08-11 06:59:58.000000000 -0500
+++ vc-1.3.0/debian/patches/kubuntu_01_git.diff	1969-12-31 18:00:00.000000000 -0600
@@ -1,331 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 88ebed2..9bfe655 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -142,7 +142,7 @@ if(NOT ROOT_RELEASE)
-    add_target_property(Vc LABELS "other")
-    add_dependencies(other Vc)
- 
--   install(TARGETS Vc DESTINATION lib/)
-+   install(TARGETS Vc DESTINATION lib${LIB_SUFFIX})
-    install(DIRECTORY include/Vc/ DESTINATION include/Vc)
-    install(DIRECTORY scalar sse avx common DESTINATION include/Vc FILES_MATCHING REGEX "/*.(h|tcc|def)$")
- else()
-diff --git a/cmake/AddCompilerFlag.cmake b/cmake/AddCompilerFlag.cmake
-index 75ad694..9f65d5b 100644
---- a/cmake/AddCompilerFlag.cmake
-+++ b/cmake/AddCompilerFlag.cmake
-@@ -1,6 +1,44 @@
-+# - Add a given compiler flag to flags variables.
-+# AddCompilerFlag(<flag> [<var>])
-+# or
-+# AddCompilerFlag(<flag> [C_FLAGS <var>] [CXX_FLAGS <var>] [C_RESULT <var>]
-+#                        [CXX_RESULT <var>])
-+
-+#=============================================================================
-+# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
-+#
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
-+#
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+#=============================================================================
-+
- get_filename_component(_currentDir "${CMAKE_CURRENT_LIST_FILE}" PATH)
- include("${_currentDir}/CheckCCompilerFlag.cmake")
- include("${_currentDir}/CheckCXXCompilerFlag.cmake")
-+
- macro(AddCompilerFlag _flag)
-    string(REGEX REPLACE "[-.+/:= ]" "_" _flag_esc "${_flag}")
-    check_c_compiler_flag("${_flag}" check_c_compiler_flag_${_flag_esc})
-diff --git a/cmake/AddTargetProperty.cmake b/cmake/AddTargetProperty.cmake
-index e5026aa..c410135 100644
---- a/cmake/AddTargetProperty.cmake
-+++ b/cmake/AddTargetProperty.cmake
-@@ -1,3 +1,34 @@
-+#=============================================================================
-+# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
-+#
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
-+#
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+#=============================================================================
-+
- macro(add_target_property _target _prop _value)
-    get_target_property(_oldprop "${_target}" ${_prop})
-    if(NOT _oldprop)
-diff --git a/cmake/CheckCCompilerFlag.cmake b/cmake/CheckCCompilerFlag.cmake
-index 2e71089..d8bc077 100644
---- a/cmake/CheckCCompilerFlag.cmake
-+++ b/cmake/CheckCCompilerFlag.cmake
-@@ -9,17 +9,35 @@
- #=============================================================================
- # Copyright 2006-2009 Kitware, Inc.
- # Copyright 2006 Alexander Neundorf <neundorf@kde.org>
--# Copyright 2011 Matthias Kretz <kretz@kde.org>
-+# Copyright 2011-2013 Matthias Kretz <kretz@kde.org>
- #
--# Distributed under the OSI-approved BSD License (the "License");
--# see accompanying file Copyright.txt for details.
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
- #
--# This software is distributed WITHOUT ANY WARRANTY; without even the
--# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
--# See the License for more information.
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- #=============================================================================
--# (To distributed this file outside of CMake, substitute the full
--#  License text for the above reference.)
- 
- INCLUDE(CheckCSourceCompiles)
- 
-diff --git a/cmake/CheckCXXCompilerFlag.cmake b/cmake/CheckCXXCompilerFlag.cmake
-index 5d73fce..b4ed992 100644
---- a/cmake/CheckCXXCompilerFlag.cmake
-+++ b/cmake/CheckCXXCompilerFlag.cmake
-@@ -9,17 +9,35 @@
- #=============================================================================
- # Copyright 2006-2009 Kitware, Inc.
- # Copyright 2006 Alexander Neundorf <neundorf@kde.org>
--# Copyright 2011 Matthias Kretz <kretz@kde.org>
-+# Copyright 2011-2013 Matthias Kretz <kretz@kde.org>
- #
--# Distributed under the OSI-approved BSD License (the "License");
--# see accompanying file Copyright.txt for details.
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
- #
--# This software is distributed WITHOUT ANY WARRANTY; without even the
--# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
--# See the License for more information.
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- #=============================================================================
--# (To distributed this file outside of CMake, substitute the full
--#  License text for the above reference.)
- 
- INCLUDE(CheckCXXSourceCompiles)
- 
-diff --git a/cmake/FindVc.cmake b/cmake/FindVc.cmake
-index bb9823f..704bc08 100644
---- a/cmake/FindVc.cmake
-+++ b/cmake/FindVc.cmake
-@@ -1,7 +1,5 @@
- # Locate the Vc template library. Vc can be found at http://gitorious.org/Vc/
- #
--# Copyright 2009-2012   Matthias Kretz <kretz@kde.org>
--#
- # This file is meant to be copied into projects that want to use Vc. It will
- # search for VcConfig.cmake, which ships with Vc and will provide up-to-date
- # buildsystem changes. Thus there should not be any need to update FindVc.cmake
-@@ -25,6 +23,37 @@
- # to use them to skip whole compilation units.
- # Vc_SSE_INTRINSICS_BROKEN
- # Vc_AVX_INTRINSICS_BROKEN
-+#
-+#=============================================================================
-+# Copyright 2009-2012   Matthias Kretz <kretz@kde.org>
-+#
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
-+#
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+#=============================================================================
- 
- find_package(Vc ${Vc_FIND_VERSION} QUIET NO_MODULE PATHS $ENV{HOME} /opt/Vc)
- 
-diff --git a/cmake/OptimizeForArchitecture.cmake b/cmake/OptimizeForArchitecture.cmake
-index bcacb73..9a0f13b 100644
---- a/cmake/OptimizeForArchitecture.cmake
-+++ b/cmake/OptimizeForArchitecture.cmake
-@@ -1,3 +1,34 @@
-+#=============================================================================
-+# Copyright 2010-2013 Matthias Kretz <kretz@kde.org>
-+#
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
-+#
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+#=============================================================================
-+
- get_filename_component(_currentDir "${CMAKE_CURRENT_LIST_FILE}" PATH)
- include("${_currentDir}/AddCompilerFlag.cmake")
- include(CheckIncludeFile)
-diff --git a/cmake/VcMacros.cmake b/cmake/VcMacros.cmake
-index 2203101..a97b888 100644
---- a/cmake/VcMacros.cmake
-+++ b/cmake/VcMacros.cmake
-@@ -5,14 +5,34 @@
- # vc_set_preferred_compiler_flags
- #
- #=============================================================================
--# Copyright 2009-2012   Matthias Kretz <kretz@kde.org>
-+# Copyright 2009-2013   Matthias Kretz <kretz@kde.org>
- #
--# Distributed under the OSI-approved BSD License (the "License");
--# see accompanying file CmakeCopyright.txt for details.
-+# Redistribution and use in source and binary forms, with or without
-+# modification, are permitted provided that the following conditions are
-+# met:
- #
--# This software is distributed WITHOUT ANY WARRANTY; without even the
--# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
--# See the License for more information.
-+#  * Redistributions of source code must retain the above copyright notice,
-+#    this list of conditions and the following disclaimer.
-+#
-+#  * Redistributions in binary form must reproduce the above copyright notice,
-+#    this list of conditions and the following disclaimer in the documentation
-+#    and/or other materials provided with the distribution.
-+#
-+#  * The names of Kitware, Inc., the Insight Consortium, or the names of
-+#    any consortium members, or of any contributors, may not be used to
-+#    endorse or promote products derived from this software without
-+#    specific prior written permission.
-+#
-+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
-+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- #=============================================================================
- 
- cmake_minimum_required(VERSION 2.8.3)
diff -Nru vc-0.7.4/debian/patches/kubuntu_disable-broken-tests.diff vc-1.3.0/debian/patches/kubuntu_disable-broken-tests.diff
--- vc-0.7.4/debian/patches/kubuntu_disable-broken-tests.diff	2014-08-11 07:49:08.000000000 -0500
+++ vc-1.3.0/debian/patches/kubuntu_disable-broken-tests.diff	1969-12-31 18:00:00.000000000 -0600
@@ -1,73 +0,0 @@
-Description: Disable failing tests
-Forwarded: Matthias Kretz <kretz@kde.org>
-Author: Jonathan Riddell <jr@jriddell.org>
-Last-Update: 2014-08-11
-Index: vc-0.7.4/tests/CMakeLists.txt
-===================================================================
---- vc-0.7.4.orig/tests/CMakeLists.txt	2014-05-15 11:38:24.000000000 +0000
-+++ vc-0.7.4/tests/CMakeLists.txt	2014-08-11 12:49:04.586337435 +0000
-@@ -160,40 +160,6 @@
- vc_add_test(casts)
- vc_add_test(swizzles)
- 
--if(USE_SSE2 AND NOT Vc_SSE_INTRINSICS_BROKEN)
--   list(FIND disabled_targets sse_blend _disabled)
--   if(_disabled EQUAL -1)
--      add_executable(sse2_blend EXCLUDE_FROM_ALL sse_blend.cpp)
--      add_target_property(sse2_blend COMPILE_FLAGS "-DVC_IMPL=SSE2")
--      add_target_property(sse2_blend LABELS "SSE")
--      add_dependencies(build_tests ${_target})
--      add_dependencies(SSE sse2_blend)
--      add_test(${Vc_TEST_TARGET_PREFIX}sse2_blend "${CMAKE_CURRENT_BINARY_DIR}/sse2_blend")
--      set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse2_blend PROPERTY LABELS "SSE")
--      target_link_libraries(sse2_blend Vc)
--
--      if(USE_SSE4_1)
--         add_executable(sse4_blend EXCLUDE_FROM_ALL sse_blend.cpp)
--         add_target_property(sse4_blend COMPILE_FLAGS "-DVC_IMPL=SSE4_1")
--         add_target_property(sse4_blend LABELS "SSE")
--         add_dependencies(build_tests ${_target})
--         add_dependencies(SSE sse4_blend)
--         add_test(${Vc_TEST_TARGET_PREFIX}sse4_blend "${CMAKE_CURRENT_BINARY_DIR}/sse4_blend")
--         set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse4_blend PROPERTY LABELS "SSE")
--         target_link_libraries(sse4_blend Vc)
--      endif()
--   endif()
--endif()
--
--add_executable(supportfunctions EXCLUDE_FROM_ALL supportfunctions.cpp)
--target_link_libraries(supportfunctions Vc)
--add_target_property(supportfunctions LABELS "other")
--add_dependencies(build_tests ${_target})
--add_dependencies(other supportfunctions)
--add_test(${Vc_TEST_TARGET_PREFIX}supportfunctions "${CMAKE_CURRENT_BINARY_DIR}/supportfunctions")
--set_property(TEST ${Vc_TEST_TARGET_PREFIX}supportfunctions PROPERTY LABELS "other")
--vc_add_run_target(supportfunctions)
--
- get_property(_incdirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
- set(incdirs)
- foreach(_d ${_incdirs})
-@@ -295,23 +261,3 @@
- target_link_libraries(linkTestLibStatic Vc)
- target_link_libraries(linkTest Vc linkTestLibDynamic1 linkTestLibDynamic2 linkTestLibStatic)
- 
--# Use the following program to generate the sincos-reference-*.dat files
--#add_executable(convert-sincos-reference EXCLUDE_FROM_ALL convert-sincos-reference.cpp)
--
--set(_deps)
--foreach(fun sincos asin acos atan ln log2 log10)
--   foreach(filename reference-${fun}-sp.dat reference-${fun}-dp.dat)
--      add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${filename}"
--         COMMAND ${CMAKE_COMMAND} -Dfilename=${filename} -P ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
--         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
--         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
--         COMMENT "Downloading Test Data: ${filename}"
--         VERBATIM
--         )
--      list(APPEND _deps "${CMAKE_CURRENT_BINARY_DIR}/${filename}")
--   endforeach()
--endforeach()
--add_custom_target(download-testdata ALL
--   DEPENDS ${_deps}
--   )
--add_dependencies(other download-testdata)
diff -Nru vc-0.7.4/debian/patches/series vc-1.3.0/debian/patches/series
--- vc-0.7.4/debian/patches/series	2014-08-11 07:00:23.000000000 -0500
+++ vc-1.3.0/debian/patches/series	1969-12-31 18:00:00.000000000 -0600
@@ -1 +0,0 @@
-kubuntu_disable-broken-tests.diff
diff -Nru vc-0.7.4/debian/rules vc-1.3.0/debian/rules
--- vc-0.7.4/debian/rules	2014-08-11 08:24:09.000000000 -0500
+++ vc-1.3.0/debian/rules	2017-02-11 18:54:07.000000000 -0600
@@ -1,15 +1,11 @@
 #!/usr/bin/make -f
 # -*- makefile -*-
-# Sample debian/rules that uses debhelper.
-# This file was originally written by Joey Hess and Craig Small.
-# As a special exception, when this file is copied by dh-make into a
-# dh-make output file, you may use that output file without restriction.
-# This special exception was added by Craig Small in version 0.37 of dh-make.
 
-# Uncomment this to turn on verbose mode.
 #export DH_VERBOSE=1
 
 %:
-	dh $@ 
+	dh $@
 
-.PHONY: override_dh_auto_test
+override_dh_auto_test:
+# Disable auto tests at build time
+	:
diff -Nru vc-0.7.4/debian/watch vc-1.3.0/debian/watch
--- vc-0.7.4/debian/watch	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/debian/watch	2017-02-11 18:54:07.000000000 -0600
@@ -0,0 +1,3 @@
+version=3
+opts=filenamemangle=s/.+\/v?(\d\S+)\.tar\.gz/Vc-$1\.tar\.gz/ \
+  https://github.com/VcDevel/Vc/releases .*/v?(\d\S+)\.tar\.gz
diff -Nru vc-0.7.4/doc/dox-common-mask-ops.h vc-1.3.0/doc/dox-common-mask-ops.h
--- vc-0.7.4/doc/dox-common-mask-ops.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/dox-common-mask-ops.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,146 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/**
- * default constructor
- *
- * Leaves the mask uninitialized.
- */
-MASK_TYPE();
-
-/**
- * Constructs a mask with the entries initialized to zero.
- */
-explicit MASK_TYPE(Vc::Zero);
-
-/**
- * Constructs a mask with the entries initialized to one.
- */
-explicit MASK_TYPE(Vc::One);
-
-/**
- * Constructs a mask with the entries initialized to
- * \li one if \p b is \p true
- * \li zero if \p b is \p false
- *
- * \param b Determines the initial state of the mask.
- */
-explicit MASK_TYPE(bool b);
-
-/**
- * Standard copy constructor
- */
-MASK_TYPE(const MASK_TYPE &);
-
-/**
- * Constructs a mask object from a mask of different size/type.
- */
-template<typename OtherMask> MASK_TYPE(const OtherMask &);
-
-/**
- * Returns whether the two masks are equal in all entries.
- */
-bool operator==(const MASK_TYPE &) const;
-
-/**
- * Returns whether the two masks differ in at least one entry.
- */
-bool operator!=(const MASK_TYPE &) const;
-
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) AND operation.
- */
-MASK_TYPE operator&&(const MASK_TYPE &) const;
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) AND operation.
- */
-MASK_TYPE operator& (const MASK_TYPE &) const;
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) OR operation.
- */
-MASK_TYPE operator||(const MASK_TYPE &) const;
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) OR operation.
- */
-MASK_TYPE operator| (const MASK_TYPE &) const;
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) XOR operation.
- */
-MASK_TYPE operator^ (const MASK_TYPE &) const;
-/**
- * Return the per-entry resulting mask of a logical (in this case same as bitwise) NOT operation.
- */
-MASK_TYPE operator! () const;
-/**
- * Modify the mask per-entry using a logical (in this case same as bitwise) AND operation.
- */
-MASK_TYPE operator&=(const MASK_TYPE &);
-/**
- * Modify the mask per-entry using a logical (in this case same as bitwise) OR operation.
- */
-MASK_TYPE operator|=(const MASK_TYPE &);
-
-/**
- * Return whether all entries of the mask are one.
- */
-bool isFull() const;
-/**
- * Return whether all entries of the mask are zero.
- */
-bool isEmpty() const;
-/**
- * Return whether the mask is neither full nor empty.
- */
-bool isMix() const;
-
-/**
- * Cast to bool operator. Returns the same as isFull().
- *
- * \warning Be careful with the cast to bool. Often it is better to write explicitly whether you
- * want isFull or !isEmpty or something else. If you define VC_NO_AUTOMATIC_BOOL_FROM_MASK this
- * operator will be disabled, requiring you to explicitly reduce masks to bools.
- */
-operator bool() const;
-
-/**
- * Read-only access to mask entries.
- *
- * \param i Determines the boolean to be accessed.
- * \return the \p i th entry of the mask as a bool.
- */
-bool operator[](int i) const;
-
-/**
- * Return how many entries of the mask are set to one.
- */
-int count() const;
-
-/**
- * Returns the index of the first one in the mask.
- */
-int firstOne() const;
-
-/**
- * Convert mask to an integer.
- *
- * \return An int where each bit corresponds to the boolean value in the mask.
- *
- * E.g. a mask like [true, false, false, true] would result in a 9 (in binary: 1001).
- */
-int toInt() const;
diff -Nru vc-0.7.4/doc/dox-common-ops.h vc-1.3.0/doc/dox-common-ops.h
--- vc-0.7.4/doc/dox-common-ops.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/dox-common-ops.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,609 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/**
- * The type of the vector used for indexes in gather and scatter operations.
- */
-typedef INDEX_TYPE IndexType;
-
-/**
- * The type of the entries in the vector.
- */
-typedef ENTRY_TYPE EntryType;
-
-/**
- * The type of the mask used for masked operations and returned from comparisons.
- */
-typedef MASK_TYPE Mask;
-
-enum {
-    /**
-     * The size of the vector. I.e. the number of scalar entries in the vector. Do not make any
-     * assumptions about the size of vectors. If you need a vector of float vs. integer of the same
-     * size make use of IndexType instead. Note that this still does not guarantee the same size
-     * (e.g. double_v on SSE has two entries but there exists no 64 bit integer vector type in Vc -
-     * which would have two entries; thus double_v::IndexType is uint_v).
-     *
-     * Also you can easily use if clauses that compare sizes. The
-     * compiler can statically evaluate and fully optimize dead code away (very much like \#ifdef,
-     * but with syntax checking).
-     */
-    Size
-};
-
-/**
- * Construct an uninitialized vector.
- */
-VECTOR_TYPE();
-
-/**
- * Construct a vector with the entries initialized to zero.
- *
- * \see Vc::Zero, Zero()
- */
-VECTOR_TYPE(Vc::Zero);
-
-/**
- * Returns a vector with the entries initialized to zero.
- */
-static VECTOR_TYPE Zero();
-
-/**
- * Construct a vector with the entries initialized to one.
- *
- * \see Vc::One
- */
-VECTOR_TYPE(Vc::One);
-
-/**
- * Returns a vector with the entries initialized to one.
- */
-static VECTOR_TYPE One();
-
-#ifdef INTEGER
-/**
- * Construct a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...
- *
- * \see Vc::IndexesFromZero, IndexesFromZero()
- */
-VECTOR_TYPE(Vc::IndexesFromZero);
-
-/**
- * Returns a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...
- */
-static VECTOR_TYPE IndexesFromZero();
-#endif
-
-/**
- * Returns a vector with pseudo-random entries.
- *
- * Currently the state of the random number generator cannot be modified and starts off with the
- * same state. Thus you will get the same sequence of numbers for the same sequence of calls.
- *
- * \return a new random vector. Floating-point values will be in the 0-1 range. Integers will use
- * the full range the integer representation allows.
- *
- * \note This function may use a very small amount of state and thus will be a weak random number generator.
- */
-static VECTOR_TYPE Random();
-
-/**
- * Construct a vector loading its entries from \p alignedMemory.
- *
- * \param alignedMemory A pointer to data. The pointer must be aligned on a
- *                      Vc::VectorAlignment boundary.
- */
-VECTOR_TYPE(ENTRY_TYPE *alignedMemory);
-
-/**
- * Convert from another vector type.
- */
-template<typename OtherVector> explicit VECTOR_TYPE(const OtherVector &);
-
-/**
- * Broadcast Constructor.
- *
- * Constructs a vector with all entries of the vector filled with the given value.
- *
- * \param x The scalar value to broadcast to all entries of the constructed vector.
- *
- * \note If you want to set it to 0 or 1 use the special initializer constructors above. Calling
- * this constructor with 0 will cause a compilation error because the compiler cannot know which
- * constructor you meant.
- */
-VECTOR_TYPE(ENTRY_TYPE x);
-
-/**
- * Construct a vector from an array of vectors with different Size.
- *
- * E.g. convert from two double_v to one float_v.
- *
- * \see expand
- */
-//VECTOR_TYPE(const OtherVector *array);
-
-/**
- * Expand the values into an array of vectors that have a different Size.
- *
- * E.g. convert from one float_v to two double_v.
- *
- * This is the reverse of the above constructor.
- */
-//void expand(OtherVector *array) const;
-
-/**
- * Load the vector entries from \p memory, overwriting the previous values.
- *
- * \param memory A pointer to data.
- * \param align  Determines whether \p memory is an aligned pointer or not.
- *
- * \see Memory
- */
-void load(const ENTRY_TYPE *memory, LoadStoreFlags align = Aligned);
-
-/**
- * Set all entries to zero.
- */
-void setZero();
-
-/**
- * Set all entries to zero where the mask is set. I.e. a 4-vector with a mask of 0111 would
- * set the last three entries to 0.
- *
- * \param mask Selects the entries to be set to zero.
- */
-void setZero(const MASK_TYPE &mask);
-
-/**
- * Store the vector data to \p memory.
- *
- * \param memory A pointer to memory, where to store.
- * \param align  Determines whether \p memory is an aligned pointer or not.
- *
- * \see Memory
- */
-void store(EntryType *memory, LoadStoreFlags align = Aligned) const;
-
-/**
- * This operator can be used to modify scalar entries of the vector.
- *
- * \param index A value between 0 and Size. This value is not checked internally so you must make/be
- *              sure it is in range.
- *
- * \return a reference to the vector entry at the given \p index.
- *
- * \warning This operator is known to miscompile with GCC 4.3.x.
- * \warning The use of this function may result in suboptimal performance. Please check whether you
- * can find a more vector-friendly way to do what you need.
- */
-ENTRY_TYPE &operator[](int index);
-
-/**
- * This operator can be used to read scalar entries of the vector.
- *
- * \param index A value between 0 and Size. This value is not checked internally so you must make/be
- *              sure it is in range.
- *
- * \return the vector entry at the given \p index.
- */
-ENTRY_TYPE operator[](int index) const;
-
-/**
- * Writemask the vector before an assignment.
- *
- * \param mask The writemask to be used.
- *
- * \return an object that can be used for any kind of masked assignment.
- *
- * The returned object is only to be used for assignments and should not be assigned to a variable.
- *
- * Examples:
- * \code
- * float_v v = float_v::Zero();         // v  = [0, 0, 0, 0]
- * int_v v2 = int_v::IndexesFromZero(); // v2 = [0, 1, 2, 3]
- * v(v2 < 2) = 1.f;                     // v  = [1, 1, 0, 0]
- * v(v2 < 3) += 1.f;                    // v  = [2, 2, 1, 0]
- * ++v2(v < 1.f);                       // v2 = [0, 1, 2, 4]
- * \endcode
- */
-MaskedVector operator()(const MASK_TYPE &mask);
-
-/**
- * \name Gather and Scatter Functions
- * The gather and scatter functions allow you to easily use vectors with structured data and random
- * accesses.
- *
- * There are several variants:
- * \li random access in arrays (a[i])
- * \li random access of members of structs in an array (a[i].member)
- * \li random access of members of members of structs in an array (a[i].member1.member2)
- *
- * All gather and scatter functions optionally take a mask as last argument. In that case only the
- * entries that are selected in the mask are read in memory and copied to the vector. This allows
- * you to have invalid indexes in the \p indexes vector if those are masked off in \p mask.
- *
- * \note If you use a constructor for a masked gather then the unmodified entries of the vector are
- * initilized to 0 before the gather. If you really want them uninitialized you can create a
- * uninitialized vector object first and then call the masked gather function on it.
- *
- * The index type (IndexT) can either be a pointer to integers (array) or a vector of integers.
- *
- * Accessing values of a struct works like this:
- * \code
- * struct MyData {
- *   float a;
- *   int b;
- * };
- *
- * void foo(MyData *data, uint_v indexes) {
- *   const float_v v1(data, &MyData::a, indexes);
- *   const int_v   v2(data, &MyData::b, indexes);
- *   v1.scatter(data, &MyData::a, indexes - float_v::Size);
- *   v2.scatter(data, &MyData::b, indexes - 1);
- * }
- * \endcode
- *
- * \param array   A pointer into memory (without alignment restrictions).
- * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
- *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
- *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
- *                (&(array->*member1))[i])
- * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
- *                struct (i.e. array[i].*member1.*member2 is read).
- * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
- *                to. The type of indexes can either be an integer vector or a type that supports
- *                operator[] access.
- * \param mask    If a mask is given only the active entries will be gathered/scattered.
- */
-//@{
-/// gather constructor
-template<typename IndexT> VECTOR_TYPE(const ENTRY_TYPE *array, const IndexT indexes);
-/// masked gather constructor, initialized to zero
-template<typename IndexT> VECTOR_TYPE(const ENTRY_TYPE *array, const IndexT indexes, const MASK_TYPE &mask);
-
-/// gather
-template<typename IndexT> void gather(const ENTRY_TYPE *array, const IndexT indexes);
-/// masked gather
-template<typename IndexT> void gather(const ENTRY_TYPE *array, const IndexT indexes, const MASK_TYPE &mask);
-
-/// scatter
-template<typename IndexT> void scatter(ENTRY_TYPE *array, const IndexT indexes) const;
-/// masked scatter
-template<typename IndexT> void scatter(ENTRY_TYPE *array, const IndexT indexes, const MASK_TYPE &mask) const;
-
-/////////////////////////
-
-/// struct member gather constructor
-template<typename S1, typename IndexT> VECTOR_TYPE(const S1 *array, const ENTRY_TYPE S1::* member1, const IndexT indexes);
-/// masked struct member gather constructor, initialized to zero
-template<typename S1, typename IndexT> VECTOR_TYPE(const S1 *array, const ENTRY_TYPE S1::* member1, const IndexT indexes, const MASK_TYPE &mask);
-
-/// struct member gather
-template<typename S1, typename IndexT> void gather(const S1 *array, const ENTRY_TYPE S1::* member1, const IndexT indexes);
-/// masked struct member gather
-template<typename S1, typename IndexT> void gather(const S1 *array, const ENTRY_TYPE S1::* member1, const IndexT indexes, const MASK_TYPE &mask);
-
-/// struct member scatter
-template<typename S1, typename IndexT> void scatter(S1 *array, ENTRY_TYPE S1::* member1, const IndexT indexes) const ;
-/// masked struct member scatter
-template<typename S1, typename IndexT> void scatter(S1 *array, ENTRY_TYPE S1::* member1, const IndexT indexes, const MASK_TYPE &mask) const ;
-
-/////////////////////////
-
-/// struct member of struct member gather constructor
-template<typename S1, typename S2, typename IndexT> VECTOR_TYPE(const S1 *array, const S2 S1::* member1, const ENTRY_TYPE S2::* member2, const IndexT indexes);
-/// masked struct member of struct member gather constructor, initialized to zero
-template<typename S1, typename S2, typename IndexT> VECTOR_TYPE(const S1 *array, const S2 S1::* member1, const ENTRY_TYPE S2::* member2, const IndexT indexes, const MASK_TYPE &mask);
-
-/// struct member of struct member gather
-template<typename S1, typename S2, typename IndexT> void gather(const S1 *array, const S2 S1::* member1, const ENTRY_TYPE S2::* member2, const IndexT indexes);
-/// masked struct member of struct member gather
-template<typename S1, typename S2, typename IndexT> void gather(const S1 *array, const S2 S1::* member1, const ENTRY_TYPE S2::* member2, const IndexT indexes, const MASK_TYPE &mask);
-
-/// struct member of struct member scatter
-template<typename S1, typename S2, typename IndexT> void scatter(S1 *array, S2 S1::* member1, ENTRY_TYPE S2::* member2, const IndexT indexes) const ;
-/// maksed struct member of struct member scatter
-template<typename S1, typename S2, typename IndexT> void scatter(S1 *array, S2 S1::* member1, ENTRY_TYPE S2::* member2, const IndexT indexes, const MASK_TYPE &mask) const ;
-//@}
-
-/**
- * \name Comparisons
- *
- * All comparison operators return a mask object.
- *
- * \code
- * void foo(const float_v &a, const float_v &b) {
- *   const float_m mask = a < b;
- *   ...
- * }
- * \endcode
- *
- * \param x The vector to compare with.
- */
-//@{
-/// Returns mask that is \c true where vector entries are equal and \c false otherwise.
-MASK_TYPE operator==(const VECTOR_TYPE &x) const;
-/// Returns mask that is \c true where vector entries are not equal and \c false otherwise.
-MASK_TYPE operator!=(const VECTOR_TYPE &x) const;
-/// Returns mask that is \c true where the left vector entries are greater than on the right and \c false otherwise.
-MASK_TYPE operator> (const VECTOR_TYPE &x) const;
-/// Returns mask that is \c true where the left vector entries are greater than on the right or equal and \c false otherwise.
-MASK_TYPE operator>=(const VECTOR_TYPE &x) const;
-/// Returns mask that is \c true where the left vector entries are less than on the right and \c false otherwise.
-MASK_TYPE operator< (const VECTOR_TYPE &x) const;
-/// Returns mask that is \c true where the left vector entries are less than on the right or equal and \c false otherwise.
-MASK_TYPE operator<=(const VECTOR_TYPE &x) const;
-//@}
-
-/**
- * \name Arithmetic Operations
- *
- * The vector classes implement all the arithmetic and (bitwise) logical operations as you know from
- * builtin types.
- *
- * \code
- * void foo(const float_v &a, const float_v &b) {
- *   const float_v product    = a * b;
- *   const float_v difference = a - b;
- * }
- * \endcode
- */
-//@{
-/// Returns a new vector with the sum of the respective entries of the left and right vector.
-VECTOR_TYPE operator+(VECTOR_TYPE x) const;
-/// Adds the respective entries of \p x to this vector.
-VECTOR_TYPE &operator+=(VECTOR_TYPE x);
-/// Returns a new vector with the difference of the respective entries of the left and right vector.
-VECTOR_TYPE operator-(VECTOR_TYPE x) const;
-/// Subtracts the respective entries of \p x from this vector.
-VECTOR_TYPE &operator-=(VECTOR_TYPE x);
-/// Returns a new vector with the product of the respective entries of the left and right vector.
-VECTOR_TYPE operator*(VECTOR_TYPE x) const;
-/// Multiplies the respective entries of \p x from to vector.
-VECTOR_TYPE &operator*=(VECTOR_TYPE x);
-/// Returns a new vector with the quotient of the respective entries of the left and right vector.
-VECTOR_TYPE operator/(VECTOR_TYPE x) const;
-/// Divides the respective entries of this vector by \p x.
-VECTOR_TYPE &operator/=(VECTOR_TYPE x);
-/// Returns a new vector with all entries negated.
-VECTOR_TYPE operator-() const;
-/// Returns a new vector with the binary or of the respective entries of the left and right vector.
-VECTOR_TYPE operator|(VECTOR_TYPE x) const;
-/// Returns a new vector with the binary and of the respective entries of the left and right vector.
-VECTOR_TYPE operator&(VECTOR_TYPE x) const;
-/// Returns a new vector with the binary xor of the respective entries of the left and right vector.
-VECTOR_TYPE operator^(VECTOR_TYPE x) const;
-#ifdef VECTOR_TYPE_HAS_SHIFTS
-/// Returns a new vector with each entry bitshifted to the left by \p x bits.
-VECTOR_TYPE operator<<(int x) const;
-/// Bitshift each entry to the left by \p x bits.
-VECTOR_TYPE &operator<<=(int x);
-/// Returns a new vector with each entry bitshifted to the right by \p x bits.
-VECTOR_TYPE operator>>(int x) const;
-/// Bitshift each entry to the right by \p x bits.
-VECTOR_TYPE &operator>>=(int x);
-/// Returns a new vector with each entry bitshifted to the left by \p x[i] bits.
-VECTOR_TYPE operator<<(VECTOR_TYPE x) const;
-/// Bitshift each entry to the left by \p x[i] bits.
-VECTOR_TYPE &operator<<=(VECTOR_TYPE x);
-/// Returns a new vector with each entry bitshifted to the right by \p x[i] bits.
-VECTOR_TYPE operator>>(VECTOR_TYPE x) const;
-/// Bitshift each entry to the right by \p x[i] bits.
-VECTOR_TYPE &operator>>=(VECTOR_TYPE x);
-#endif
-/**
- * Multiplies this vector with \p factor and then adds \p summand, without rounding between the
- * multiplication and the addition.
- *
- * \param factor The multiplication factor.
- * \param summand The summand that will be added after multiplication.
- *
- * \note This operation may have explicit hardware support, in which case it is normally faster to
- * use the FMA instead of separate multiply and add instructions.
- * \note If the target hardware does not have FMA support this function will be considerably slower
- * than a normal a * b + c. This is due to the increased precision fusedMultiplyAdd provides.
- */
-void fusedMultiplyAdd(VECTOR_TYPE factor, VECTOR_TYPE summand);
-//@}
-
-/**
- * \name Horizontal Reduction Operations
- *
- * There are four horizontal operations available to reduce the values of a vector to a scalar
- * value.
- *
- * \code
- * void foo(const float_v &v) {
- *   float min = v.min(); // smallest value in v
- *   float sum = v.sum(); // sum of all values in v
- * }
- * \endcode
- */
-//@{
-/// Returns the smallest entry in the vector.
-ENTRY_TYPE min() const;
-/// Returns the largest entry in the vector.
-ENTRY_TYPE max() const;
-/// Returns the product of all entries in the vector.
-ENTRY_TYPE product() const;
-/// Returns the sum of all entries in the vector.
-ENTRY_TYPE sum() const;
-//@}
-
-/**
- * \name Apply/Call/Fill Functions
- *
- * There are still many situations where the code needs to switch from SIMD operations to scalar
- * execution. In this case you can, of course rely on operator[]. But there are also a number of
- * functions that can help with common patterns.
- *
- * The apply functions expect a function that returns a scalar value, i.e. a function of the form "T f(T)".
- * The call functions do not return a value and thus the function passed does not need a return
- * value. The fill functions are used to serially set the entries of the vector from the return
- * values of a function.
- *
- * Example:
- * \code
- * void foo(float_v v) {
- *   float_v logarithm = v.apply(std::log);
- *   float_v exponential = v.apply(std::exp);
- * }
- * \endcode
- *
- * Of course, with C++11, you can also use lambdas here:
- * \code
- *   float_v power = v.apply([](float f) { return std::pow(f, 0.6f); })
- * \endcode
- *
- * \param f A functor: this can either be a function or an object that implements operator().
- */
-//@{
-/// Return a new vector where each entry is the return value of \p f called on the current value.
-template<typename Functor> VECTOR_TYPE apply(Functor &f) const;
-/// Const overload of the above function.
-template<typename Functor> VECTOR_TYPE apply(const Functor &f) const;
-/// As above, but skip the entries where \p mask is not set.
-template<typename Functor> VECTOR_TYPE apply(Functor &f, MASK_TYPE mask) const;
-/// Const overload of the above function.
-template<typename Functor> VECTOR_TYPE apply(const Functor &f, MASK_TYPE mask) const;
-/// Call \p f with the scalar entries of the vector.
-template<typename Functor> void call(Functor &f) const;
-/// Const overload of the above function.
-template<typename Functor> void call(const Functor &f) const;
-/// As above, but skip the entries where \p mask is not set.
-template<typename Functor> void call(Functor &f, MASK_TYPE mask) const;
-/// Const overload of the above function.
-template<typename Functor> void call(const Functor &f, MASK_TYPE mask) const;
-/// Fill the vector with the values [f(), f(), f(), ...].
-void fill(ENTRY_TYPE (&f)());
-/// Fill the vector with the values [f(0), f(1), f(2), ...].
-template<typename IndexT> void fill(ENTRY_TYPE (&f)(IndexT));
-//@}
-
-/**
- * \name Swizzles
- *
- * Swizzles are a special form of shuffles that, depending on the target hardware and swizzle type,
- * may be used without extra cost. The swizzles act on every successive four entries in the vector.
- * Thus the swizzle \verbatim [0, 1, 2, 3, 4, 5, 6, 7].dcba() \endverbatim results in
- * \verbatim [3, 2, 1, 0, 7, 6, 5, 4] \endverbatim.
- *
- * This implies a portability issue. The swizzles can only work on vectors where Size is a
- * multiple of four.
- * On Vc::Scalar all swizzles are implemented as no-ops. If a swizzle is used on a vector of Size ==
- * 2 compilation will fail.
- */
-//@{
-/// Identity.
-const VECTOR_TYPE abcd() const;
-/// Permute pairs.
-const VECTOR_TYPE badc() const;
-/// Permute pairs of two / Rotate twice.
-const VECTOR_TYPE cdab() const;
-/// Broadcast a.
-const VECTOR_TYPE aaaa() const;
-/// Broadcast b.
-const VECTOR_TYPE bbbb() const;
-/// Broadcast c.
-const VECTOR_TYPE cccc() const;
-/// Broadcast d.
-const VECTOR_TYPE dddd() const;
-/// Rotate three: cross-product swizzle.
-const VECTOR_TYPE bcad() const;
-/// Rotate left.
-const VECTOR_TYPE bcda() const;
-/// Rotate right.
-const VECTOR_TYPE dabc() const;
-/// Permute inner pair.
-const VECTOR_TYPE acbd() const;
-/// Permute outer pair.
-const VECTOR_TYPE dbca() const;
-/// Reverse.
-const VECTOR_TYPE dcba() const;
-//@}
-
-/**
- * \name Shift and Rotate
- *
- * These functions allow to shift or rotate the entries in a vector by the given \p amount. Both
- * functions support positive and negative numbers for the shift/rotate value.
- *
- * Example:
- * \code
- * using namespace Vc;
- * int_v foo = int_v::IndexesFromZero() + 1; // e.g. [1, 2, 3, 4] with SSE
- * int_v x;
- * x = foo.shifted( 1); // [2, 3, 4, 0]
- * x = foo.shifted( 2); // [3, 4, 0, 0]
- * x = foo.shifted( 3); // [4, 0, 0, 0]
- * x = foo.shifted( 4); // [0, 0, 0, 0]
- * x = foo.shifted(-1); // [0, 1, 2, 3]
- * x = foo.shifted(-2); // [0, 0, 1, 2]
- * x = foo.shifted(-3); // [0, 0, 0, 1]
- * x = foo.shifted(-4); // [0, 0, 0, 0]
- *
- * x = foo.rotated( 1); // [2, 3, 4, 1]
- * x = foo.rotated( 2); // [3, 4, 1, 2]
- * x = foo.rotated( 3); // [4, 1, 2, 3]
- * x = foo.rotated( 4); // [1, 2, 3, 4]
- * x = foo.rotated(-1); // [4, 1, 2, 3]
- * x = foo.rotated(-2); // [3, 4, 1, 2]
- * x = foo.rotated(-3); // [2, 3, 4, 1]
- * x = foo.rotated(-4); // [1, 2, 3, 4]
- * \endcode
- *
- * These functions are slightly related to the above swizzles. In any case, they are often useful for
- * communication between SIMD lanes or binary decoding operations.
- */
-//@{
-/// Shift vector entries to the left by \p amount; shifting in zeros.
-const VECTOR_TYPE shifted(int amount) const;
-/// Rotate vector entries to the left by \p amount.
-const VECTOR_TYPE rotated(int amount) const;
-//@}
-
-/**
- * Return a sorted copy of the vector.
- *
- * \return A sorted vector. The returned values are in ascending order:
-   \verbatim
-   v[0] <= v[1] <= v[2] <= v[3] ...
-   \endverbatim
- *
- * Example:
- * \code
- * int_v v = int_v::Random();
- * int_v s = v.sorted();
- * std::cout << v << '\n' << s << '\n';
- * \endcode
- *
- * With SSE the output would be:
- *
-   \verbatim
-   [1513634383, -963914658, 1763536262, -1285037745]
-   [-1285037745, -963914658, 1513634383, 1763536262]
-   \endverbatim
- *
- * With the Scalar implementation:
-   \verbatim
-   [1513634383]
-   [1513634383]
-   \endverbatim
- */
-VECTOR_TYPE sorted() const;
diff -Nru vc-0.7.4/doc/dox.h vc-1.3.0/doc/dox.h
--- vc-0.7.4/doc/dox.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/dox.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,1125 +1,652 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+/*!
+\mainpage
+\image html logo.png
+
+The %Vc library implements portable, zero-overhead C++ types for explicitly data-parallel
+programming.
+
+The 1.0 release ships implementations for x86 SIMD instruction sets: SSE, AVX, AVX2, and
+the Xeon Phi (MIC). A scalar implementation ensures full portability to any C++11 capable
+compiler and target system.
+
+This documentation is structured in three main areas:
+1. Several manually written documentation pages in the *Overview Documents*.
+   They cover an introduction to SIMD and data-parallelism, portability issues, macros,
+   how to set up the build system, and examples / tutorials.
+   \li \subpage intro
+   \li \subpage portability
+   \li \subpage vcmacros
+   \li \subpage featuremacros
+   \li \subpage buildsystem
+   \li \subpage examples
+
+2. The *API Reference* section contains a manually structured access to the API
+   documentation generated from the %Vc sources.
+   \li \ref Vectors
+   \li \ref Masks
+   \li \ref SimdArray
+   \li \ref Simdize
+   \li \ref Math
+   \li \ref Utilities
+
+3. The *Indexes* section contains automatically generated indexes to the same API
+   documentation.
+
+\page intro Introduction
+
+Recent generations of CPUs, and GPUs in particular, require data-parallel codes for full efficiency.
+Data parallelism requires that the same sequence of operations is applied to different input data.
+CPUs and GPUs can thus reduce the necessary hardware for instruction decoding and scheduling in favor of more arithmetic and logic units, which execute the same instructions synchronously.
+On CPU architectures this is implemented via SIMD registers and instructions.
+A single SIMD register can store N values and a single SIMD instruction can execute N operations on those values.
+On GPU architectures N threads run in perfect sync, fed by a single instruction decoder/scheduler.
+Each thread has local memory and a given index to calculate the offsets in memory for loads and stores.
+
+Current C++ compilers can do automatic transformation of scalar codes to SIMD instructions (auto-vectorization).
+However, the compiler must reconstruct an intrinsic property of the algorithm that was lost when the developer wrote a purely scalar implementation in C++.
+Consequently, C++ compilers cannot vectorize any given code to its most efficient data-parallel variant.
+Especially larger data-parallel loops, spanning over multiple functions or even translation units, will often not be transformed into efficient SIMD code.
+
+The %Vc library provides the missing link.
+Its types enable explicitly stating data-parallel operations on multiple values.
+The parallelism is therefore added via the type system.
+Competing approaches state the parallelism via new control structures and consequently new semantics inside the body of these control structures.
+
+If you are new to vectorization please read this following part and make sure you
+understand it:
+- The term *vector* used for data-parallel programming is not about the vectors you
+  studied in math classes.
+- Do not confuse *vector* with containers that also go by the same name. SIMD vectors
+  actually do implement some aspect of a container, but they are closer to a fixed-sized
+  `std::array` than to a dynamically resizable `std::vector`.
+- The *vector* type in %Vc is defined by the target hardware as a group of values with a
+  fixed number of entries (\VSize{T}).
+  Typically one Vc::Vector object then fits into a SIMD register on the target system.
+  Such a SIMD register consequently stores \VSize{T} scalar values; in contrast to a
+  general purpose register, which stores only one scalar value.
+  This value \VSize{T} is thus an unchangeable property of the hardware and not a variable
+  in the %Vc API.
+  You can access the \VSize{T} value via the static Vc::Vector::size() function.
+  Since this function is a constant expression you can also use it for template arguments.
+- Note that some hardware may use different vector register widths for different data
+  types.
+  For example, AVX has instructions for 256-bit floating point registers, but only 128-bit
+  integer instructions, which is why the integral Vc::Vector types use the SSE
+  implementation for AVX target systems.
+
+\par Example 1:
+
+You can modify a function to use vector types and thus implement a horizontal vectorization. The
+original scalar function could look like this (If you are confused about the adjective
+"scalar" in this context, note that the function mathematically does a vector to vector
+transformation. However, the computer computes it with \em scalar instructions, i.e. one
+value per operand.):
+\code
+void normalize(float &x, float &y, float &z)
+{
+  const float d = std::sqrt(x * x + y * y + z * z);
+  x /= d;
+  y /= d;
+  z /= d;
+}
+\endcode
+To vectorize the \c normalize function with %Vc, the types must be substituted by their %Vc counterparts and math functions
+must use the %Vc implementation (which is, per default, also imported into \c std namespace):
+\code
+using Vc::float_v;
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+void normalize(float_v &x, float_v &y, float_v &z)
+{
+  const float_v d = Vc::sqrt(x * x + y * y + z * z);
+  x /= d;
+  y /= d;
+  z /= d;
+}
+\endcode
+The latter function is able to normalize four 3D vectors when compiled for SSE in the same
+time the former function normalizes one 3D vector.
+
+For completeness, note that you can optimize the division in the normalize function further:
+\code
+  const float_v d_inv = float_v::One() / Vc::sqrt(x * x + y * y + z * z);
+  const float_v d_inv = Vc::rsqrt(x * x + y * y + z * z); // less accurate, but faster
+\endcode
+Then you can multiply \c x, \c y, and \c z with \c d_inv, which is considerably faster than three
+divisions.
+
+As you can probably see, the new challenge with %Vc is the use of good data-structures which
+support horizontal vectorization. Depending on your problem at hand this may become the main
+focus of design (it does not have to be, though).
+
+\section intro_alignment Alignment
+
+\subsection intro_alignment_background What is Alignment
+
+If you do not know what alignment is, and why it is important, read on, otherwise skip to \ref
+intro_alignment_tools. Normally the alignment of data is an implementation detail left to the
+compiler. Until C++11, the language did not even have any (official) means to query or modify
+alignment.
+
+Most data types require more than one Byte for storage. Thus, even most atomic data types span
+several locations in memory. E.g. if you have a pointer to \c float, the address stored in this
+pointer just determines the first of four Bytes of the \c float. Naively, one could think that
+any address (which belongs to the process) can be used to store such a float. While this is true
+for some architectures, some architectures may terminate the process when a misaligned pointer is
+dereferenced. The natural alignment for atomic data types typically is the same as their size.
+Thus the address of a \c float object should always be a multiple of 4 Bytes.
+
+Alignment becomes more important for SIMD data types.
+1. There are different instructions to load/store aligned and unaligned vectors. The unaligned
+load/stores recently were greatly improved in x86 CPUs. Still, the rule of thumb
+says that aligned loads/stores are faster.
+2. Access to an unaligned vector with an instruction that expects an aligned vector crashes the
+application. Once you write vectorized code you might want to make it a habit to check crashes
+for unaligned addresses.
+3. Memory allocation on the heap will return addresses aligned to some system specific alignment
+rule. E.g. Linux 32bit aligns on 8 Bytes, while Linux 64bit aligns on 16 Bytes. Both alignments
+are not strict enough for AVX vectors. Worse, if you develop on Linux 64bit with SSE you won't
+notice any problems until you switch to a 32bit build or AVX.
+4. Placement on the stack is determined at compile time and requires the compiler to know the
+alignment restrictions of the type.
+5. The size of a cache line is just two or four times larger than the SIMD types (if not equal).
+Thus, if you load several vectors consecutively from memory every fourth, second, or even every
+load will have to be read from two different cache lines. This is called a cache line split. They
+lead to degraded performance, which becomes very noticeable for memory intensive code.
+
+\subsection intro_alignment_tools Tools
+
+%Vc provides several classes and functions to get alignment right.
+\li Vc::VectorAlignment is a compile time constant that equals the largest alignment restriction
+                  (in Bytes) for the selected target architecture.
+\li Vc::AlignedBase, Vc::VectorAlignedBase, and Vc::MemoryAlignedBase implement the alignment
+                  restrictions needed for aligned vector loads and stores. They set the
+                  alignment attribute and reimplement the \c new and \c delete operators,
+                  returning correctly aligned pointers to the heap.
+\li Vc::malloc and Vc::free are meant as replacements for \c malloc and \c free. They can be used
+                  to allocate any type of memory with an abstract alignment restriction: \ref
+                  Vc::MallocAlignment. Note, that (like \c malloc) the memory is only allocated
+                  and not initialized. If you allocate memory for a type that has a constructor,
+                  use the placement new syntax to initialize the memory.
+\li Vc::Allocator is an STL compatible allocator class that behaves as specified in the C++
+                  specification, implementing the optional support for over-aligned types.
+                  Therefore, memory addresses returned from this allocator will always be
+                  aligned to at least the constraints attached to the type \c T. STL containers
+                  will already default to Vc::Allocator for Vc::Vector<T>. For all other
+                  composite types you want to use, you can take the \ref Vc_DECLARE_ALLOCATOR
+                  convenience macro to set is as default.
+\li Vc::Memory, Vc::Memory<V, Size, 0u>, Vc::Memory<V, 0u, 0u>
+                  The three different variants of the memory class can be used like a more
+                  convenient C-array. It supports two-dimensional statically sized arrays and
+                  one-dimensional statically and dynamically sized arrays. The memory can be
+                  accessed easily via aligned vectors, but also via unaligned vectors or
+                  gathers/scatters.
+
+
+
+\page portability Portability Issues
+
+One of the major goals of %Vc is to ease development of portable code, while achieving highest
+possible performance that requires target architecture specific instructions. This is possible
+through having just a single type use different implementations of the same API depending on the
+target architecture. Many of the details of the target architecture are often dependent on the
+compiler flags that were used. Also there can be subtle differences between the implementations
+that could lead to problems. This page aims to document all issues you might need to know about.
+
+\par Compiler Flags
+
+\li \e GCC: The compiler should be called with the -march=\<target\> flag. Take a look at the GCC
+manpage to find all possibilities for \<target\>. Additionally it is best to also add the -msse2
+-msse3 ... -mavx flags. If no SIMD instructions are enabled via compiler flags, %Vc must fall back
+to the scalar implementation.
+\li \e Clang: The same as for GCC applies.
+\li \e ICC: Same as GCC, but the flags are called -xAVX -xSSE4.2 -xSSE4.1 -xSSSE3 -xSSE3 -xSSE2.
+\li \e MSVC: On 32bit you can add the /arch:SSE2 flag. That's about all the MSVC documentation
+says. Still the MSVC compiler knows about the newer instructions in SSE3 and upwards. How you can
+determine what CPUs will be supported by the resulting binary is unclear.
+
+\par Where does the final executable run?
+
+You must be aware of the fact that a binary that is built for a given SIMD hardware may not run
+on a processor that does not have these instructions. The executable will work fine as long as no
+such instruction is actually executed and only crash at the place where such an instruction is
+used. Thus it is better to check at application start whether the compiled in SIMD hardware is
+really supported on the executing CPU. This can be determined with the
+currentImplementationSupported function.
+
+If you want to distribute a binary that runs correctly on many different systems you either must
+restrict it to the least common denominator (which often is SSE2), or you must compile the code
+several times, with the different target architecture compiler options. A simple way to combine
+the resulting executables would be via a wrapping script/executable that determines the correct
+executable to use. A more sophisticated option is the use of the ifunc attribute GCC provides.
+Other compilers might provide similar functionality.
+
+\par Guarantees
+
+It is guaranteed that:
+\li \code int_v::Size == uint_v::Size == float_v::Size \endcode
+\li \code short_v::Size == ushort_v::Size \endcode
+
+\par Important Differences between Implementations
+
+\li Obviously the number of entries in a vector depends on the target architecture.
+\li Hardware that does not support 16-Bit integer vectors can implement the short_v and ushort_v
+API via 32-Bit integer vectors. Thus, some of the overflow behavior might be slightly different,
+and truncation will only happen when the vector is stored to memory.
+
+\section portability_compilerquirks Compiler Quirks
+
+Since SIMD is not part of the C/C++ language standards %Vc abstracts more or less standardized
+compiler extensions. Sadly, not every issue can be transparently abstracted.
+Therefore this will be the place where differences are documented:
+\li MSVC is incapable of parameter passing by value, if the type has alignment restrictions. The
+consequence is that all %Vc vector types and any type derived from Vc::VectorAlignedBase cannot be
+used as function parameters, unless a pointer is used (this includes reference and
+const-reference). So \code
+void foo(Vc::float_v) {}\endcode does not compile, while \code
+void foo(Vc::float_v &) {}
+void foo(const Vc::float_v &) {}
+void foo(Vc::float_v *) {}
+\endcode all work.
+Normally you should prefer passing by value since a sane compiler will then pass the data in a
+register and does not have to store/load the data to/from the stack. %Vc defines \c
+Vc_PASSING_VECTOR_BY_VALUE_IS_BROKEN for such cases. Also the %Vc vector types contain a composite
+typedef \c AsArg which resolves to either const-ref or const-by-value. Thus, you can always use
+\code void foo(Vc::float_v::AsArg) {}\endcode.
+
+
+\page vcmacros Pre-defined Macros
+
+The %Vc library defines a few macros that you may rely on in your code:
+
+\section vc_impl Implementation Identification
+
+One or more of the following macros will be defined:
+\li \ref Vc_IMPL_Scalar
+\li \ref Vc_IMPL_SSE
+\li \ref Vc_IMPL_SSE2
+\li \ref Vc_IMPL_SSE3
+\li \ref Vc_IMPL_SSSE3
+\li \ref Vc_IMPL_SSE4_1
+\li \ref Vc_IMPL_SSE4_2
+\li \ref Vc_IMPL_AVX
+\li \ref Vc_IMPL_AVX2
+\li \ref Vc_IMPL_MIC
+
+You can use these macros to enable target-specific implementations.
+In general, it is better to rely on function overloading or template mechanisms, though.
+Per default, code compiled against the %Vc headers will use the instruction set that the compiler advertises as available.
+For example, compiling with "g++ -mssse3" chooses the SSE implementation (Vc::VectorAbi::Sse) with instructions from SSE, SSE2, SSE3 and SSSE3.
+After you include a %Vc header, you will have the following macros available, which you can (but normally should not) use to determine the implementation %Vc uses:
+
+\section vc_size Vector/Mask Sizes
+
+The macros \ref Vc_DOUBLE_V_SIZE, \ref Vc_FLOAT_V_SIZE, \ref Vc_INT_V_SIZE, \ref Vc_UINT_V_SIZE, \ref Vc_SHORT_V_SIZE, and \ref Vc_USHORT_V_SIZE make the default vector width accessible in the preprocessor.
+In most cases you should prefer the Vector::size() function, though.
+Since this function is \c constexpr you can use it for compile-time decisions (e.g. as template argument).
+
+\section vc_compiler Compiler Identification (and related)
+
+- \ref Vc_GCC
+- \ref Vc_CLANG
+- \ref Vc_APPLECLANG
+- \ref Vc_ICC
+- \ref Vc_MSVC
+- \ref Vc_PASSING_VECTOR_BY_VALUE_IS_BROKEN
+
+\section vc_version Version Macros
+
+- \ref Vc_VERSION_STRING
+- \ref Vc_VERSION_NUMBER
+- \ref Vc_VERSION_CHECK
+
+\section vc_boilerplate Boilerplate Code Generation
+
+- \ref Vc_SIMDIZE_INTERFACE
+
+
+\page featuremacros Feature Macros
+
+You can define the following macros to enable/disable specific features:
+
+\section set_vc_impl Vc_IMPL
+
+If you want to force compilation against a specific implementation of the vector classes you can set the macro Vc_IMPL to either
+\c Scalar, \c SSE, \c SSE2, \c SSE3, \c SSSE3, \c SSE4_1, \c SSE4_2, \c AVX, \c AVX2, or \c MIC.
+Additionally, you may (should) append \c +XOP, \c +FMA4, \c +FMA, \c +SSE4a, \c +F16C, \c +BMI2, and/or \c +POPCNT.
+For example, `-D Vc_IMPL=SSE+XOP+FMA4` tells the Vc library to use the best SSE instructions available for the target (according to the information provided by the compiler) and additionally use XOP and FMA4 instructions (this might be a good choice for some AMD processors, which support AVX but may perform slightly better if only SSE widths are used).
+Setting \c Vc_IMPL to \c SSE forces the SSE instruction set, but lets the headers figure out the exact SSE revision to use, or, if that fails, uses SSE4.1.
+
+If you do not specify \c Vc_IMPL the %Vc headers determine the implementation from compiler-specific pre-defined macros (which in turn are determined from compiler flags that determine the target micro-architecture, such as \c -mavx2).
+
+\section Vc_NO_STD_FUNCTIONS
+
+If this macro is defined, the %Vc math functions are not imported into the \c std namespace.
+They are still available in the %Vc namespace and through [ADL](http://en.cppreference.com/w/cpp/language/adl).
+
+\section Vc_NO_VERSION_CHECK
+
+Define this macro to disable the safety check for the libVc version.
+The check generates a small check for every object file, which is called at startup, i.e. before
+the main function.
+
+\section Vc_CHECK_ALIGNMENT
+
+If this macro is defined %Vc will assert correct alignment for all objects that require correct alignment.
+This can be very useful to debug crashes resulting from misaligned memory accesses.
+This check will introduce a significant overhead.
+
+\section Vc_ENABLE_FLOAT_BIT_OPERATORS
+
+Define this macro to enable bitwise operators (&, |, ^, ~) on floating-point vectors. Since these
+operators are not provided for the builtin floating-point types, the default is to not provide
+them for SIMD vector types as well.
+
+
+
+\page buildsystem Build System
+
+%Vc uses CMake as its buildsystem.
+It also provides much of the CMake logic it uses for itself for other projects that use CMake and %Vc.
+Here's an (incomplete) list of features you can get from the CMake scripts provided with %Vc:
+\li check for a required %Vc version
+\li locate libVc and %Vc includes
+\li compiler flags to work around %Vc related quirks/bugs in specific compilers
+\li compiler flags to enable/disable SIMD instruction sets (defaults to full support for the host system)
+
+\section buildsystem_variables CMake Variables
+
+To make use of these features simply copy the FindVc.cmake as installed by %Vc to your project.
+Add \code find_package(Vc [version] [REQUIRED]) \endcode to your CMakeLists.txt. After that you
+can use the following variables:
+\li \e Vc_FOUND: tells whether the package was found
+\li \e Vc_INCLUDE_DIR: you must add this to your include directories for the targets that you
+want to compile against %Vc: \code include_directories(${Vc_INCLUDE_DIR}) \endcode
+\li \e Vc_DEFINITIONS: recommended preprocessor definitions. You can use them via \c add_definitions.
+\li \e Vc_COMPILE_FLAGS: recommended compiler flags. You can use them via the
+\li \e Vc_ARCHITECTURE_FLAGS: recommended compiler flags for a selected target
+microarchitecture. You can use them via the \c COMPILE_OPTIONS property or via \c
+add_compile_options.
+\li \e Vc_ALL_FLAGS: a list combining the above three variables. Use it to conveniently
+set all required compiler flags in one place (e.g. via \c add_compile_options).
+
+The following variables might be of interest, too:
+\li \e Vc_SSE_INTRINSICS_BROKEN
+\li \e Vc_AVX_INTRINSICS_BROKEN
+\li \e Vc_XOP_INTRINSICS_BROKEN
+\li \e Vc_FMA4_INTRINSICS_BROKEN
+
+\section buildsystem_macros CMake Macros
+
+The macro vc_compile_for_all_implementations is provided to help with compiling a given source
+file multiple times with all different possible SIMD targets for the given architecture.
+Example:
+\verbatim
+vc_compile_for_all_implementations(objs src/trigonometric.cpp
+  FLAGS -DSOME_FLAG
+  EXCLUDE Scalar SSE2)
+\endverbatim
+You can specify an arbitrary number of additional compiler flags after the FLAGS argument. These
+flags will be used for all compiler calls. After an optional EXCLUDE argument you can specify targets
+that you want to exclude. After an optional ONLY argument you can specify targets that you want
+to compile for. (So either you exclude some, or you explicitly list the targets you want.)
+
+Often it suffices to have SSE2 or SSE3 as the least common denominator and provide SSE4_1 and
+AVX. Here is the currently complete list of possible targets the macro will compile for:
+\li Scalar
+\li SSE2
+\li SSE3
+\li SSSE3
+\li SSE4_1
+\li SSE4_2
+\li SSE3+SSE4a
+\li SSE+XOP+FMA4
+\li AVX
+\li AVX+XOP+FMA4
+
+\section buildsystem_other Using Vc without CMake
+
+If your project does not use CMake all you need to do is the following:
+\li Find the header file "Vc/Vc" and add its path to your include paths.
+\li Find the library libVc and link to it.
+\li Ensure you use the right compiler flags to enable the relevant SIMD instructions.
+
+
+\defgroup Vectors Vectors
+\defgroup Masks Masks
+\defgroup SimdArray SIMD Array
+\defgroup Simdize simdize<T>
+\defgroup Math Math
+\defgroup Utilities Utilities
+
+
+\addtogroup Vectors
+
+The vector classes abstract the SIMD registers and their according instructions into types that
+feel very familiar to C++ developers.
+
+Note that the documented types Vc::float_v, Vc::double_v, Vc::int_v, Vc::uint_v, Vc::short_v,
+and Vc::ushort_v are actually \c typedefs of the \c Vc::Vector<T> class:
+\code
+namespace Vc {
+  template<typename T> class Vector;
+  typedef Vector<double> double_v;
+  typedef Vector<float> float_v;
+  // ...
+}
+\endcode
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+\par Some general information on using the vector classes:
 
-*/
+Generally you can always mix scalar values with vectors as %Vc will automatically broadcast the
+scalar to a vector and then execute a vector operation. But, in order to ensure that implicit
+type conversions only happen as defined by the C standard, there is only a very strict implicit
+scalar to vector constructor:
+\code
+int_v a = 1;     // good:             int_v(int)
+uint_v b = 1u;   // good:             uint_v(unsigned int)
+uint_v c = 1;    // does not compile: uint_v(int)
+float_v d = 1;   // does not compile: float_v(int)
+float_v e = 1.;  // does not compile: float_v(double)
+float_v f = 1.f; // good:             float_v(float)
+\endcode
+
+The following ways of initializing a vector are not allowed:
+\code
+int_v v(3, 2, 8, 0); // constructor does not exist because it is not portable
+int_v v;
+v[0] = 3; v[1] = 2; v[2] = 8; v[3] = 0; // do not hardcode the number of entries!
+// You can not know whether somebody will compile with %Vc Scalar where int_v::Size == 1
+\endcode
+
+Instead, if really necessary you can do:
+\code
+Vc::int_v v;
+for (int i = 0; i < int_v::Size; ++i) {
+  v[i] = f(i);
+}
+// which is equivalent to:
+v.fill(f);
+// or:
+v = int_v::IndexesFromZero().apply(f);
+\endcode
 
-/**
- * \mainpage
- * \image html logo.png
- *
- * The %Vc library is a collection of SIMD vector classes with existing implementations for SSE, AVX,
- * and a scalar fallback. An implementation for the Intel Xeon Phi is expected to be ready for %Vc
- * 0.8.
- *
- * \section background Background information and learning material
- * \li \ref intro
- * \li \ref portability
- * \li \ref featuremacros
- * \li \ref buildsystem
- * \li \ref examples
- *
- * \section apidox API documentation
- * \li \ref Vectors
- * \li \ref Masks
- * \li \ref Utilities
- * \li \ref Math
- *
- * Per default, code compiled against the %Vc headers will use the instruction set that the compiler
- * says is available. For example compiling with "g++ -mssse3" will enable compilation against the
- * SSE implementation using SSE the instruction sets SSE, SSE2, SSE3 and SSSE3. If you want to force
- * compilation against a specific implementation of the vector classes you can set the macro
- * VC_IMPL to either "Scalar", "SSE", "SSE2", "SSE3", "SSSE3", "SSE4_1", "SSE4_2", or "AVX".
- * You may additionally append "+XOP", "+FMA4", "+SSE4a", "+F16C", and "+POPCNT", e.g. "-D VC_IMPL=SSE+XOP+FMA4"
- * Setting VC_IMPL to
- * "SSE" will force the SSE instruction set, but lets the headers figure out the version to use or,
- * if that fails, uses SSE4.1.
- * After you include a %Vc header, you will have the following macros available, which you can (but
- * normally should not) use to determine the implementation %Vc uses:
- * \li \c VC_IMPL_Scalar
- * \li \c VC_IMPL_SSE (shorthand for SSE2 || SSE3 || SSSE3 || SSE4_1. SSE1 alone is not supported.)
- * \li \c VC_IMPL_SSE2
- * \li \c VC_IMPL_SSE3
- * \li \c VC_IMPL_SSSE3
- * \li \c VC_IMPL_SSE4_1
- * \li \c VC_IMPL_SSE4_2
- * \li \c VC_IMPL_AVX
- *
- * Another set of macros you may use for target specific implementations are the \c VC_*_V_SIZE
- * macros: \ref Utilities
- */
 
-/**
- * \page intro Introduction
- *
- * If you are new to vectorization please read this following part and make sure you understand it:
- * \li Forget what you learned about vectors in math classes. SIMD vectors are a different concept!
- * \li Forget about containers that also go by the name of a vector. SIMD vectors are a different concept!
- * \li A vector is defined by the hardware as a special register which is wider than required for a
- * single value. Thus multiple values fit into one register. The width of this register and the
- * size of the scalar data type in use determine the number of entries in the vector.
- * Therefore this number is an unchangeable property of the hardware and not a variable in the
- * %Vc API.
- * \li Note that hardware is free to use different vector register widths for different data types.
- * For example AVX has instructions for 256-bit floating point registers, but only 128-bit integer
- * instructions.
- *
- * \par Example 1:
- *
- * You can modify a function to use vector types and thus implement a horizontal vectorization. The
- * original scalar function could look like this:
- * \code
- * void normalize(float &x, float &y, float &z)
- * {
- *   const float d = std::sqrt(x * x + y * y + z * z);
- *   x /= d;
- *   y /= d;
- *   z /= d;
- * }
- * \endcode
- * To vectorize the \c normalize function with %Vc, the types must be substituted by their %Vc counterparts and math functions
- * must use the %Vc implementation (which is, per default, also imported into \c std namespace):
- * \code
- * using Vc::float_v;
- *
- * void normalize(float_v &x, float_v &y, float_v &z)
- * {
- *   const float_v d = Vc::sqrt(x * x + y * y + z * z);
- *   x /= d;
- *   y /= d;
- *   z /= d;
- * }
- * \endcode
- * The latter function is able to normalize four 3D vectors when compiled for SSE in the same
- * time the former function normalizes one 3D vector.
- *
- * For completeness, note that you can optimize the division in the normalize function further:
- * \code
- *   const float_v d_inv = float_v::One() / Vc::sqrt(x * x + y * y + z * z);
- *   const float_v d_inv = Vc::rsqrt(x * x + y * y + z * z); // less accurate, but faster
- * \endcode
- * Then you can multiply \c x, \c y, and \c z with \c d_inv, which is considerably faster than three
- * divisions.
- *
- * As you can probably see, the new challenge with %Vc is the use of good data-structures which
- * support horizontal vectorization. Depending on your problem at hand this may become the main
- * focus of design (it does not have to be, though).
- *
- * \section intro_alignment Alignment
- *
- * \subsection intro_alignment_background What is Alignment
- *
- * If you do not know what alignment is, and why it is important, read on, otherwise skip to \ref
- * intro_alignment_tools. Normally the alignment of data is an implementation detail left to the
- * compiler. Until C++11, the language did not even have any (official) means to query or modify
- * alignment.
- *
- * Most data types require more than one Byte for storage. Thus, even most atomic data types span
- * several locations in memory. E.g. if you have a pointer to \c float, the address stored in this
- * pointer just determines the first of four Bytes of the \c float. Naively, one could think that
- * any address (which belongs to the process) can be used to store such a float. While this is true
- * for some architectures, some architectures may terminate the process when a misaligned pointer is
- * dereferenced. The natural alignment for atomic data types typically is the same as their size.
- * Thus the address of a \c float object should always be a multiple of 4 Bytes.
- *
- * Alignment becomes more important for SIMD data types.
- * 1. There are different instructions to load/store aligned and unaligned vectors. The unaligned
- * load/stores recently were greatly improved in x86 CPUs. Still, the rule of thumb
- * says that aligned loads/stores are faster.
- * 2. Access to an unaligned vector with an instruction that expects an aligned vector crashes the
- * application. Once you write vectorized code you might want to make it a habit to check crashes
- * for unaligned addresses.
- * 3. Memory allocation on the heap will return addresses aligned to some system specific alignment
- * rule. E.g. Linux 32bit aligns on 8 Bytes, while Linux 64bit aligns on 16 Bytes. Both alignments
- * are not strict enough for AVX vectors. Worse, if you develop on Linux 64bit with SSE you won't
- * notice any problems until you switch to a 32bit build or AVX.
- * 4. Placement on the stack is determined at compile time and requires the compiler to know the
- * alignment restrictions of the type.
- * 5. The size of a cache line is just two or four times larger than the SIMD types (if not equal).
- * Thus, if you load several vectors consecutively from memory every fourth, second, or even every
- * load will have to be read from two different cache lines. This is called a cache line split. They
- * lead to degraded performance, which becomes very noticeable for memory intensive code.
- *
- * \subsection intro_alignment_tools Tools
- *
- * %Vc provides several classes and functions to get alignment right.
- * \li Vc::VectorAlignment is a compile time constant that equals the largest alignment restriction
- *                   (in Bytes) for the selected target architecture.
- * \li Vc::VectorAlignedBase and Vc::VectorAlignedBaseT are helper classes that use compiler
- *                   specific extensions to annotate the alignment restrictions for vector types.
- *                   Additionally they reimplement \c new and \c delete to return correctly aligned
- *                   pointers to the heap.
- * \li Vc::malloc and Vc::free are meant as replacements for \c malloc and \c free. They can be used
- *                   to allocate any type of memory with an abstract alignment restriction: \ref
- *                   Vc::MallocAlignment. Note, that (like \c malloc) the memory is only allocated
- *                   and not initialized. If you allocate memory for a type that has a constructor,
- *                   use the placement new syntax to initialize the memory.
- * \li Vc::Allocator is an STL compatible allocator class that behaves as specified in the C++
- *                   specification, implementing the optional support for over-aligned types.
- *                   Therefore, memory addresses returned from this allocator will always be
- *                   aligned to at least the constraints attached to the type \c T. STL containers
- *                   will already default to Vc::Allocator for Vc::Vector<T>. For all other
- *                   composite types you want to use, you can take the \ref VC_DECLARE_ALLOCATOR
- *                   convenience macro to set is as default.
- * \li Vc::Memory, Vc::Memory<V, Size, 0u>, Vc::Memory<V, 0u, 0u>
- *                   The three different variants of the memory class can be used like a more
- *                   convenient C-array. It supports two-dimensional statically sized arrays and
- *                   one-dimensional statically and dynamically sized arrays. The memory can be
- *                   accessed easily via aligned vectors, but also via unaligned vectors or
- *                   gathers/scatters.
- */
 
-/**
- * \page portability Portability Issues
- *
- * One of the major goals of %Vc is to ease development of portable code, while achieving highest
- * possible performance that requires target architecture specific instructions. This is possible
- * through having just a single type use different implementations of the same API depending on the
- * target architecture. Many of the details of the target architecture are often dependent on the
- * compiler flags that were used. Also there can be subtle differences between the implementations
- * that could lead to problems. This page aims to document all issues you might need to know about.
- *
- * \par Compiler Flags
- *
- * \li \e GCC: The compiler should be called with the -march=\<target\> flag. Take a look at the GCC
- * manpage to find all possibilities for \<target\>. Additionally it is best to also add the -msse2
- * -msse3 ... -mavx flags. If no SIMD instructions are enabled via compiler flags, %Vc must fall back
- * to the scalar implementation.
- * \li \e Clang: The same as for GCC applies.
- * \li \e ICC: Same as GCC, but the flags are called -xAVX -xSSE4.2 -xSSE4.1 -xSSSE3 -xSSE3 -xSSE2.
- * \li \e MSVC: On 32bit you can add the /arch:SSE2 flag. That's about all the MSVC documentation
- * says. Still the MSVC compiler knows about the newer instructions in SSE3 and upwards. How you can
- * determine what CPUs will be supported by the resulting binary is unclear.
- *
- * \par Where does the final executable run?
- *
- * You must be aware of the fact that a binary that is built for a given SIMD hardware may not run
- * on a processor that does not have these instructions. The executable will work fine as long as no
- * such instruction is actually executed and only crash at the place where such an instruction is
- * used. Thus it is better to check at application start whether the compiled in SIMD hardware is
- * really supported on the executing CPU. This can be determined with the
- * currentImplementationSupported function.
- *
- * If you want to distribute a binary that runs correctly on many different systems you either must
- * restrict it to the least common denominator (which often is SSE2), or you must compile the code
- * several times, with the different target architecture compiler options. A simple way to combine
- * the resulting executables would be via a wrapping script/executable that determines the correct
- * executable to use. A more sophisticated option is the use of the ifunc attribute GCC provides.
- * Other compilers might provide similar functionality.
- *
- * \par Guarantees
- *
- * It is guaranteed that:
- * \li \code int_v::Size == uint_v::Size == float_v::Size \endcode
- * \li \code short_v::Size == ushort_v::Size == sfloat_v::Size \endcode
- *
- * \par Important Differences between Implementations
- *
- * \li Obviously the number of entries in a vector depends on the target architecture.
- * \li Because of the guarantees above, sfloat_v does not necessarily map to a single SIMD register
- * and thus there could be a higher register pressure when this type is used.
- * \li Hardware that does not support 16-Bit integer vectors can implement the short_v and ushort_v
- * API via 32-Bit integer vectors. Thus, some of the overflow behavior might be slightly different,
- * and truncation will only happen when the vector is stored to memory.
- *
- * \section portability_compilerquirks Compiler Quirks
- *
- * Since SIMD is not part of the C/C++ language standards %Vc abstracts more or less standardized
- * compiler extensions. Sadly, not every issue can be transparently abstracted.
- * Therefore this will be the place where differences are documented:
- * \li MSVC is incapable of parameter passing by value, if the type has alignment restrictions. The
- * consequence is that all %Vc vector types and any type derived from Vc::VectorAlignedBase cannot be
- * used as function parameters, unless a pointer is used (this includes reference and
- * const-reference). So \code
- * void foo(Vc::float_v) {}\endcode does not compile, while \code
- * void foo(Vc::float_v &) {}
- * void foo(const Vc::float_v &) {}
- * void foo(Vc::float_v *) {}
- * \endcode all work.
- * Normally you should prefer passing by value since a sane compiler will then pass the data in a
- * register and does not have to store/load the data to/from the stack. %Vc defines \c
- * VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN for such cases. Also the %Vc vector types contain a composite
- * typedef \c AsArg which resolves to either const-ref or const-by-value. Thus, you can always use
- * \code void foo(Vc::float_v::AsArg) {}\endcode.
- */
+\addtogroup Masks
 
-/**
- * \page featuremacros Feature Macros
- *
- * The following macros are available to enable/disable selected features:
- *
- * \par VC_NO_STD_FUNCTIONS
- *
- * If this macro is defined, the %Vc math functions are
- * not imported into the \c std namespace. They are still available in the %Vc namespace.
- *
- * \par VC_CLEAN_NAMESPACE
- *
- * If this macro is defined, any symbol or macro that does not have a %Vc
- * prefix will be disabled.
- *
- * \par VC_NO_AUTOMATIC_BOOL_FROM_MASK
- *
- * Define this macro to disable automatic conversion from %Vc
- * mask types to bool. The automatic conversion corresponds to the isFull() function. By disabling
- * the automatic conversion you can find places where the implicit isFull() conversion is not the
- * correct reduction.
- *
- * \par VC_NO_VERSION_CHECK
- *
- * Define this macro to disable the safety check for the libVc version.
- * The check generates a small check for every object file, which is called at startup, i.e. before
- * the main function.
- *
- * \par VC_CHECK_ALIGNMENT
- *
- * If this macro is defined %Vc will assert correct alignment for all
- *        objects that require correct alignment. This can be very useful to debug crashes resulting
- *        from misaligned memory accesses. This check will introduce a significant overhead.
- */
+Mask classes are abstractions for the results of vector comparisons. The actual implementation
+differs depending on the SIMD instruction set. On SSE they contain a full 128-bit datatype while
+on a different architecture they might be bit-fields.
 
-/**
- * \page buildsystem Build System
- *
- * %Vc uses CMake as its buildsystem. It also provides much of the CMake logic it
- * uses for itself for other projects that use CMake and %Vc. Here's an (incomplete) list of features
- * you can get from the CMake scripts provided with %Vc:
- * \li check for a required %Vc version
- * \li locate libVc and %Vc includes
- * \li compiler flags to workaround %Vc related quirks/bugs in specific compilers
- * \li compiler flags to enable/disable SIMD instruction sets, defaulting to full support for the
- * host system
- *
- * \section buildsystem_variables CMake Variables
- *
- * To make use of these features simply copy the FindVc.cmake as installed by %Vc to your project.
- * Add \code find_package(Vc [version] [REQUIRED]) \endcode to your CMakeLists.txt. After that you
- * can use the following variables:
- * \li \e Vc_FOUND: tells whether the package was found
- * \li \e Vc_INCLUDE_DIR: you must add this to your include directories for the targets that you
- * want to compile against %Vc: \code include_directories(${Vc_INCLUDE_DIR}) \endcode
- * \li \e Vc_DEFINITIONS: recommended compiler flags. You can use them via add_definitions or the
- * COMPILE_FLAGS property.
- *
- * The following variables might be of interest, too:
- * \li \e Vc_SSE_INTRINSICS_BROKEN
- * \li \e Vc_AVX_INTRINSICS_BROKEN
- * \li \e Vc_XOP_INTRINSICS_BROKEN
- * \li \e Vc_FMA4_INTRINSICS_BROKEN
- *
- * \section buildsystem_macros CMake Macros
- *
- * The macro vc_compile_for_all_implementations is provided to help with compiling a given source
- * file multiple times with all different possible SIMD targets for the given architecture.
- * Example:
-   \verbatim
-   vc_compile_for_all_implementations(objs src/trigonometric.cpp
-     FLAGS -DSOME_FLAG
-     EXCLUDE Scalar SSE2)
-   \endverbatim
- * You can specify an arbitrary number of additional compiler flags after the FLAGS argument. These
- * flags will be used for all compiler calls. After an optional EXCLUDE argument you can specify targets
- * that you want to exclude. After an optional ONLY argument you can specify targets that you want
- * to compile for. (So either you exclude some, or you explicitly list the targets you want.)
- *
- * Often it suffices to have SSE2 or SSE3 as the least common denominator and provide SSE4_1 and
- * AVX. Here is the currently complete list of possible targets the macro will compile for:
- * \li Scalar
- * \li SSE2
- * \li SSE3
- * \li SSSE3
- * \li SSE4_1
- * \li SSE4_2
- * \li SSE3+SSE4a
- * \li SSE+XOP+FMA4
- * \li AVX
- * \li AVX+XOP+FMA4
- *
- * \section buildsystem_other Using Vc without CMake
- *
- * If your project does not use CMake all you need to do is the following:
- * \li Find the header file "Vc/Vc" and add its path to your include paths.
- * \li Find the library libVc and link to it.
- * \li Ensure you use the right compiler flags to enable the relevant SIMD instructions.
- */
 
-/**
- * \defgroup Vectors Vectors
- *
- * The vector classes abstract the SIMD registers and their according instructions into types that
- * feel very familiar to C++ developers.
- *
- * Note that the documented types Vc::float_v, Vc::double_v, Vc::int_v, Vc::uint_v, Vc::short_v,
- * and Vc::ushort_v are actually \c typedefs of the \c Vc::Vector<T> class:
- * \code
- * namespace Vc {
- *   template<typename T> class Vector;
- *   typedef Vector<double> double_v;
- *   typedef Vector<float> float_v;
- *   // ...
- * }
- * \endcode
- *
- * \par Some general information on using the vector classes:
- *
- * Generally you can always mix scalar values with vectors as %Vc will automatically broadcast the
- * scalar to a vector and then execute a vector operation. But, in order to ensure that implicit
- * type conversions only happen as defined by the C standard, there is only a very strict implicit
- * scalar to vector constructor:
- * \code
- * int_v a = 1;     // good:             int_v(int)
- * uint_v b = 1u;   // good:             uint_v(unsigned int)
- * uint_v c = 1;    // does not compile: uint_v(int)
- * float_v d = 1;   // does not compile: float_v(int)
- * float_v e = 1.;  // does not compile: float_v(double)
- * float_v f = 1.f; // good:             float_v(float)
- * \endcode
- *
- * The following ways of initializing a vector are not allowed:
- * \code
- * int_v v(3, 2, 8, 0); // constructor does not exist because it is not portable
- * int_v v;
- * v[0] = 3; v[1] = 2; v[2] = 8; v[3] = 0; // do not hardcode the number of entries!
- * // You can not know whether somebody will compile with %Vc Scalar where int_v::Size == 1
- * \endcode
- *
- * Instead, if really necessary you can do:
- * \code
- * Vc::int_v v;
- * for (int i = 0; i < int_v::Size; ++i) {
- *   v[i] = f(i);
- * }
- * // which is equivalent to:
- * v.fill(f);
- * // or:
- * v = int_v::IndexesFromZero().apply(f);
- * \endcode
- */
+\addtogroup Utilities
 
-/**
- * \defgroup Masks Masks
- *
- * Mask classes are abstractions for the results of vector comparisons. The actual implementation
- * differs depending on the SIMD instruction set. On SSE they contain a full 128-bit datatype while
- * on a different architecture they might be bit-fields.
- */
+Additional classes, macros, and functions that help to work more easily with the main vector
+types.
 
-/**
- * \defgroup Utilities Utilities
- *
- * Additional classes, macros, and functions that help to work more easily with the main vector
- * types.
- */
 
-/**
- * \defgroup Math Math
- *
- * Functions that implement math functions. Take care that some of the implementations will return
- * results with less precision than what the FPU calculates.
- */
+\addtogroup Math
+
+Functions that implement math functions. Take care that some of the implementations will return
+results with less precision than what the FPU calculates.
+
+
+\addtogroup SimdArray
+
+This set of class templates and associated functions and operators enables
+data-parallel algorithms and data structures requiring a user-defined number of elements
+(fixed at compile time, in contrast to \c std::valarray where the number of elements is
+ only determined at run time).
+The main motivation for a user-defined number of elements is the need for type conversion
+and thus a guaranteed equal number of elements in data-parallel vectors for e.g. \c float
+and \c int.
+A typical pattern looks like this:
+\code
+using floatv = Vc::float_v;
+using doublev = Vc::SimdArray<double, floatv::size()>;
+using intv = Vc::SimdArray<int, floatv::size()>;
+using uintv = Vc::SimdArray<unsigned int, floatv::size()>;
+\endcode
+
+The second motivation for a user-defined number of elements is that many vertical
+vectorizations require a fixed number of elements (i.e. number known at development time
+and not chosen at compile time).
+The implementation can then choose how to support this number most efficiently with the
+available hardware resources.
+Consider, for example, a need for processing 12 values in parallel.
+On x86 with AVX, the implementation could build such a type from one AVX and one SSE register.
+
+In contrast to \c std::array the types behave like the Vc::Vector types, implementing the same
+operators and functions.
+The semantics with regard to implicit conversions differ slightly:
+The Vc::Vector conversion rules are safer with regard to source compatibility.
+The Vc::SimdArray conversion rules are less strict and could potentially lead to portability issues.
+Therefore, it is best to stick to the pattern of type aliases shown above.
+*/
 
 /**
  * \brief Vector Classes Namespace
  *
  * All functions and types of %Vc are defined inside the %Vc namespace.
  *
- * To be precise, most types are actually defined inside a second namespace, such as Vc::SSE. At
- * compile-time the correct implementation is simply imported into the %Vc namespace.
+ * \internal
+ * Internal types and functions should be defined either in the Vc::Detail namespace or in
+ * a `Vc::<Impl>` namespace such as Vc::SSE.
  */
 namespace Vc
 {
-    /**
-     * \class Vector dox.h <Vc/vector.h>
-     * \ingroup Vectors
-     *
-     * The main SIMD vector class.
-     *
-     * \li Vc::float_v
-     * \li Vc::sfloat_v
-     * \li Vc::double_v
-     * \li Vc::int_v
-     * \li Vc::uint_v
-     * \li Vc::short_v
-     * \li Vc::ushort_v
-     *
-     * are only specializations of this class. For the full documentation take a look at the
-     * specialized classes. For most cases there are no API differences for the specializations.
-     * Thus you can make use of \c Vector<T> for generic programming.
-     */
-    template<typename T> class Vector
-    {
-        public:
-#define INDEX_TYPE uint_v
-#define VECTOR_TYPE Vector<T>
+#define INDEX_TYPE Vc::SimdArray<int, size()>
+#define VECTOR_TYPE Vc::Vector<T>
 #define ENTRY_TYPE T
-#define MASK_TYPE float_m
-#define EXPONENT_TYPE int_v
-#include "dox-common-ops.h"
-#include "dox-real-ops.h"
-#undef INDEX_TYPE
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
-#undef EXPONENT_TYPE
-    };
-
-    /**
-     * \ingroup Vectors
-     *
-     * Enum to declare platform specific constants
-     */
-    enum PlatformConstants {
-        /**
-         * Specifies the byte boundary for memory alignments necessary for aligned loads and stores.
-         */
-        VectorAlignment
-    };
-
-    /**
-     * \ingroup Vectors
-     *
-     * Enum to declare special initializers for vector constructors.
-     */
-    enum SpecialInitializer {
-        /**
-         * Used for optimized construction of vectors initialized to zero.
-         */
-        Zero,
-
-        /**
-         * Used for optimized construction of vectors initialized to one.
-         */
-        One,
-
-        /**
-         * Parameter to create a vector with the entries 0, 1, 2,
-         * 3, 4, 5, ... (depending on the vector's size, of course).
-         */
-        IndexesFromZero
-    };
-
-    /**
-     * \ingroup Vectors
-     *
-     * Enum for load and store functions to select the optimizations that are safe to use.
-     */
-    enum LoadStoreFlags {
-        /**
-         * Tells %Vc that the load/store can expect a memory address that is aligned on the correct
-         * boundary.
-         *
-         * If you specify Aligned, but the memory address is not aligned the program will most
-         * likely crash.
-         */
-        Aligned,
-
-        /**
-         * Tells %Vc that the load/store can \em not expect a memory address that is aligned on the correct
-         * boundary.
-         *
-         * If you specify Unaligned, but the memory address is aligned the load/store will execute
-         * slightly slower than necessary.
-         */
-        Unaligned,
-
-        /**
-         * Tells %Vc to bypass the cache for the load/store. Whether this will actually be done
-         * depends on the instruction set in use.
-         *
-         * Streaming stores can be interesting when the code calculates values that, after being
-         * written to memory, will not be used for a long time or used by a different thread.
-         *
-         * \note Passing Streaming as only alignment flag implies Aligned! If you need unaligned
-         * memory access you can use
-         * \code
-         * v.store(mem, Vc::Unaligned | Vc::Streaming);
-         * \endcode
-         */
-        Streaming
-    };
-
-#define INDEX_TYPE uint_v
-#define VECTOR_TYPE float_v
-#define ENTRY_TYPE float
-#define MASK_TYPE float_m
-#define EXPONENT_TYPE int_v
-    /**
-     * \class float_v dox.h <Vc/float_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of single precision floats.
-     *
-     * \note This is the same type as Vc::Vector<float>.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-#include "dox-real-ops.h"
-    };
-    /**
-     * \class float_m dox.h <Vc/float_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with float_v objects.
-     *
-     * Of the same type as int_m and uint_m.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
-#include "dox-math.h"
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
+#define MASK_TYPE Vc::Mask<T>
+#define EXPONENT_TYPE Vc::SimdArray<int, size()>
 
-#define VECTOR_TYPE double_v
-#define ENTRY_TYPE double
-#define MASK_TYPE double_m
-    /**
-     * \class double_v dox.h <Vc/double_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of double precision floats.
-     *
-     * \note This is the same type as Vc::Vector<double>.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-#include "dox-real-ops.h"
-    };
-    /**
-     * \class double_m dox.h <Vc/double_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with double_v objects.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
 #include "dox-math.h"
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
-
-#define VECTOR_TYPE_HAS_SHIFTS 1
-#define VECTOR_TYPE int_v
-#define ENTRY_TYPE int
-#define MASK_TYPE int_m
-#define INTEGER
-    /**
-     * \class int_v dox.h <Vc/int_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of 32 bit signed integers.
-     *
-     * \note This is the same type as Vc::Vector<int>.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-    };
-    /**
-     * \class int_m dox.h <Vc/int_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with int_v objects.
-     *
-     * Of the same type as float_m and uint_m.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
 
-#define VECTOR_TYPE uint_v
-#define ENTRY_TYPE unsigned int
-#define MASK_TYPE uint_m
-    /**
-     * \class uint_v dox.h <Vc/uint_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of 32 bit unsigned integers.
-     *
-     * \note This is the same type as Vc::Vector<unsigned int>.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-    };
-    /**
-     * \class uint_m dox.h <Vc/uint_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with uint_v objects.
-     *
-     * Of the same type as int_m and float_m.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
 #undef INDEX_TYPE
-
-#define INDEX_TYPE ushort_v
-#define VECTOR_TYPE short_v
-#define ENTRY_TYPE short
-#define MASK_TYPE short_m
-    /**
-     * \class short_v dox.h <Vc/short_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of 16 bit signed integers.
-     *
-     * \note This is the same type as Vc::Vector<short>.
-     *
-     * \warning Vectors of this type are not supported on all platforms. In that case the vector
-     * class will silently fall back to a Vc::int_v.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-    };
-    /**
-     * \class short_m dox.h <Vc/short_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with short_v objects.
-     *
-     * Of the same type as ushort_m.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
-
-#define VECTOR_TYPE ushort_v
-#define ENTRY_TYPE unsigned short
-#define MASK_TYPE ushort_m
-    /**
-     * \class ushort_v dox.h <Vc/ushort_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of 16 bit unsigned integers.
-     *
-     * \note This is the same type as Vc::Vector<unsigned short>.
-     *
-     * \warning Vectors of this type are not supported on all platforms. In that case the vector
-     * class will silently fall back to a Vc::uint_v.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-    };
-    /**
-     * \class ushort_m dox.h <Vc/ushort_v>
-     * \ingroup Masks
-     *
-     * Mask object to use with ushort_v objects.
-     *
-     * Of the same type as short_m.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
 #undef VECTOR_TYPE
 #undef ENTRY_TYPE
 #undef MASK_TYPE
-#undef INTEGER
 #undef EXPONENT_TYPE
-#undef VECTOR_TYPE_HAS_SHIFTS
-
-#define EXPONENT_TYPE short_v
-#define VECTOR_TYPE sfloat_v
-#define ENTRY_TYPE float
-#define MASK_TYPE sfloat_m
-    /**
-     * \class sfloat_v dox.h <Vc/sfloat_v>
-     * \ingroup Vectors
-     *
-     * SIMD Vector of single precision floats that is guaranteed to have as many entries as a
-     * Vc::short_v and Vc::ushort_v.
-     */
-    class VECTOR_TYPE
-    {
-        public:
-#include "dox-common-ops.h"
-#include "dox-real-ops.h"
-    };
-    /**
-     * \class sfloat_m dox.h <Vc/sfloat_v>
-     * \ingroup Masks
-     * \ingroup Masks
-     *
-     * Mask object to use with sfloat_v objects.
-     */
-    class MASK_TYPE
-    {
-        public:
-#include "dox-common-mask-ops.h"
-    };
-#include "dox-math.h"
-#undef EXPONENT_TYPE
-#undef VECTOR_TYPE
-#undef ENTRY_TYPE
-#undef MASK_TYPE
-#undef INDEX_TYPE
-
-    /**
-     * \ingroup Math
-     * \note Often int_v::Size == double_v::Size * 2, then only every second value in \p *e is defined.
-     */
-    double_v frexp(const double_v &x, int_v *e);
-    /**
-     * \ingroup Math
-     * \note Often int_v::Size == double_v::Size * 2, then only every second value in \p *e is defined.
-     */
-    double_v ldexp(double_v x, int_v e);
-
-    /**
-     * \ingroup Utilities
-     *
-     * Force the vectors passed to the function into registers. This can be useful after looking at
-     * the emitted assembly to force the compiler to optimize properly.
-     *
-     * \note Currently only has an effect for SSE vectors.
-     * \note MSVC does not support this function at all.
-     *
-     * \warning Be careful with this function, especially since it can render the compiler unable to
-     * compile for 32 bit systems if it forces more than 8 vectors in registers.
-     */
-    void forceToRegisters(const vec &, ...);
-
-    /**
-     * \ingroup Utilities
-     *
-     * Helper class to ensure proper alignment.
-     *
-     * This class reimplements the \c new and \c delete operators to align the allocated object
-     * suitably for vector data. Additionally the type is annotated to require that same alignment
-     * when placed on the stack.
-     *
-     * \see Vc::VectorAlignedBaseT
-     */
-    class VectorAlignedBase
-    {
-    public:
-        void *operator new(size_t size);
-        void *operator new(size_t, void *p);
-        void *operator new[](size_t size);
-        void operator delete(void *ptr, size_t);
-        void operator delete[](void *ptr, size_t);
-    };
-
-    /**
-     * \ingroup Utilities
-     *
-     * Helper class to ensure proper alignment.
-     *
-     * This class reimplements the \c new and \c delete operators to align the allocated object
-     * suitably for vector data. Additionally the type is annotated to require that same alignment
-     * when placed on the stack.
-     *
-     * This class differs from Vc::VectorAlignedBase in that the template parameter determines the
-     * alignment. The alignment rules for different vector types might be different. If you use
-     * Vc::VectorAlignedBase you will get the most restrictive alignment (i.e. it will work for all
-     * vector types, but might lead to unnecessary padding).
-     *
-     * \tparam V One of the %Vc vector types.
-     *
-     * \see Vc::VectorAlignedBase
-     */
-    template<typename V>
-    class VectorAlignedBaseT
-    {
-    public:
-        void *operator new(size_t size);
-        void *operator new(size_t, void *p);
-        void *operator new[](size_t size);
-        void operator delete(void *ptr, size_t);
-        void operator delete[](void *ptr, size_t);
-    };
-}
-
-/**
- * \ingroup Utilities
- *
- * Loop over all set bits in the mask. The iterator variable will be set to the position of the set
- * bits. A mask of e.g. 00011010 would result in the loop being called with the iterator being set to
- * 1, 3, and 4.
- *
- * This allows you to write:
- * \code
- * float_v a = ...;
- * Vc_foreach_bit(int i, a < 0.f) {
- *   std::cout << a[i] << "\n";
- * }
- * \endcode
- * The example prints all the values in \p a that are negative, and only those.
- *
- * \param iterator  The iterator variable. For example "int i".
- * \param mask      The mask to iterate over. You can also just write a vector operation that returns a
- *                  mask.
- *
- * \note Since %Vc 0.7 break and continue are supported in foreach_bit loops.
- */
-#define Vc_foreach_bit(iterator, mask)
-
-/**
- * \ingroup Utilities
- *
- * Alias for Vc_foreach_bit unless VC_CLEAN_NAMESPACE is defined.
- */
-#define foreach_bit(iterator, mask)
-
-/**
- * \ingroup Vectors
- * \headerfile dox.h <Vc/IO>
- *
- * Prints the contents of a vector into a stream object.
- *
- * \code
- * const Vc::int_v v(Vc::IndexesFromZero);
- * std::cout << v << std::endl;
- * \endcode
- * will output (with SSE):
-\verbatim
-[0, 1, 2, 3]
-\endverbatim
- *
- * \param s Any standard C++ ostream object. For example std::cout or a std::stringstream object.
- * \param v Any Vc::Vector object.
- * \return  The ostream object: to chain multiple stream operations.
- *
- * \note With the GNU standard library this function will check, whether the output stream is a tty.
- * In that case it will colorize the output.
- */
-template<typename T>
-std::ostream &operator<<(std::ostream &s, const Vc::Vector<T> &v);
-
-/**
- * \ingroup Masks
- * \headerfile dox.h <Vc/IO>
- *
- * Prints the contents of a mask into a stream object.
- *
- * \code
- * const Vc::short_m m = Vc::short_v::IndexesFromZero() < 3;
- * std::cout << m << std::endl;
- * \endcode
- * will output (with SSE):
-\verbatim
-m[1110 0000]
-\endverbatim
- *
- * \param s Any standard C++ ostream object. For example std::cout or a std::stringstream object.
- * \param v Any %Vc mask object.
- * \return  The ostream object: to chain multiple stream operations.
- *
- * \note With the GNU standard library this function will check, whether the output stream is a tty.
- * In that case it will colorize the output.
- */
-template<typename T>
-std::ostream &operator<<(std::ostream &s, const typename Vc::Vector<T>::Mask &v);
-
-/**
- * \ingroup Utilities
- * \headerfile dox.h <Vc/IO>
- *
- * Prints the contents of a Memory object into a stream object.
- *
- * \code
- * Vc::Memory<int_v, 10> m;
- * for (int i = 0; i < m.entriesCount(); ++i) {
- *   m[i] = i;
- * }
- * std::cout << m << std::endl;
- * \endcode
- * will output (with SSE):
-\verbatim
-{[0, 1, 2, 3] [4, 5, 6, 7] [8, 9, 0, 0]}
-\endverbatim
- *
- * \param s Any standard C++ ostream object. For example std::cout or a std::stringstream object.
- * \param m Any Vc::Memory object.
- * \return  The ostream object: to chain multiple stream operations.
- *
- * \note With the GNU standard library this function will check, whether the output stream is a tty.
- * In that case it will colorize the output.
- *
- * \warning Please do not forget that printing a large memory object can take a long time.
- */
-template<typename V, typename Parent, typename Dimension, typename RM>
-inline std::ostream &operator<<(std::ostream &s, const Vc::MemoryBase<V, Parent, Dimension, RM> &m);
-
-namespace Vc
-{
-/**
- * \ingroup Utilities
- * \headerfile dox.h <Vc/version.h>
- *
- * \returns the version string of the %Vc headers.
- *
- * \note There exists a built-in check that ensures on application startup that the %Vc version of the
- * library (link time) and the headers (compile time) are equal. A mismatch between headers and
- * library could lead to errors that are very hard to debug.
- * \note If you need to disable the check (it costs a very small amount of application startup time)
- * you can define VC_NO_VERSION_CHECK at compile time.
- */
-const char *versionString();
-
-/**
- * \ingroup Utilities
- * \headerfile dox.h <Vc/version.h>
- *
- * \returns the version of the %Vc headers encoded in an integer.
- */
-unsigned int versionNumber();
 
 /**
  * \name SIMD Support Feature Macros
  * \ingroup Utilities
  */
 //@{
+///\addtogroup Utilities
+//@{
 /**
- * \ingroup Utilities
- * This macro is set to the value of \ref Vc::Implementation that the current translation unit is
- * compiled with.
- */
-#define VC_IMPL
-/**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with XOP instruction support.
  */
-#define VC_IMPL_XOP
+#define Vc_IMPL_XOP
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with FMA4 instruction support.
  */
-#define VC_IMPL_FMA4
+#define Vc_IMPL_FMA4
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with F16C instruction support.
  */
-#define VC_IMPL_F16C
+#define Vc_IMPL_F16C
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with POPCNT instruction support.
  */
-#define VC_IMPL_POPCNT
+#define Vc_IMPL_POPCNT
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSE4a instruction support.
  */
-#define VC_IMPL_SSE4a
+#define Vc_IMPL_SSE4a
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled without any SIMD support.
  */
-#define VC_IMPL_Scalar
+#define Vc_IMPL_Scalar
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with any version of SSE (but not
  * AVX).
  */
-#define VC_IMPL_SSE
+#define Vc_IMPL_SSE
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSE2 instruction support
  * (excluding SSE3 and up).
  */
-#define VC_IMPL_SSE2
+#define Vc_IMPL_SSE2
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSE3 instruction support (excluding SSSE3 and up).
  */
-#define VC_IMPL_SSE3
+#define Vc_IMPL_SSE3
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSSE3 instruction support (excluding SSE4.1 and up).
  */
-#define VC_IMPL_SSSE3
+#define Vc_IMPL_SSSE3
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSE4.1 instruction support (excluding SSE4.2 and up).
  */
-#define VC_IMPL_SSE4_1
+#define Vc_IMPL_SSE4_1
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with SSE4.2 instruction support (excluding AVX and up).
  */
-#define VC_IMPL_SSE4_2
+#define Vc_IMPL_SSE4_2
 /**
- * \ingroup Utilities
  * This macro is defined if the current translation unit is compiled with AVX instruction support (excluding AVX2 and up).
  */
-#define VC_IMPL_AVX
-//@}
-
+#define Vc_IMPL_AVX
 /**
- * \name Version Macros
- * \ingroup Utilities
+ * This macro is defined if the current translation unit is compiled with AVX2 instruction support.
  */
-//@{
+#define Vc_IMPL_AVX2
 /**
- * \ingroup Utilities
- * Contains the version string of the %Vc headers. Same as Vc::versionString().
+ * This macro is defined if the current translation unit is compiled for the Knights
+ * Corner Xeon Phi instruction set.
  */
-#define VC_VERSION_STRING
-
-/**
- * \ingroup Utilities
- * Contains the encoded version number of the %Vc headers. Same as Vc::versionNumber().
- */
-#define VC_VERSION_NUMBER
-
-/**
- * \ingroup Utilities
- *
- * Helper macro to compare against an encoded version number.
- * Example:
- * \code
- * #if VC_VERSION_CHECK(0.5.1) >= VC_VERSION_NUMBER
- * \endcode
- */
-#define VC_VERSION_CHECK(major, minor, patch)
+#define Vc_IMPL_MIC
+//@}
 //@}
 
 /**
@@ -1131,37 +658,34 @@
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a double_v.
  */
-#define VC_DOUBLE_V_SIZE
+#define Vc_DOUBLE_V_SIZE
 /**
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a float_v.
  */
-#define VC_FLOAT_V_SIZE
-/**
- * \ingroup Utilities
- * An integer (for use with the preprocessor) that gives the number of entries in a sfloat_v.
- */
-#define VC_SFLOAT_V_SIZE
+#define Vc_FLOAT_V_SIZE
 /**
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a int_v.
  */
-#define VC_INT_V_SIZE
+#define Vc_INT_V_SIZE
 /**
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a uint_v.
  */
-#define VC_UINT_V_SIZE
+#define Vc_UINT_V_SIZE
 /**
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a short_v.
  */
-#define VC_SHORT_V_SIZE
+#define Vc_SHORT_V_SIZE
 /**
  * \ingroup Utilities
  * An integer (for use with the preprocessor) that gives the number of entries in a ushort_v.
  */
-#define VC_USHORT_V_SIZE
+#define Vc_USHORT_V_SIZE
 //@}
 
 } // namespace Vc
+
+// vim: ft=doxygen
diff -Nru vc-0.7.4/doc/dox-math.h vc-1.3.0/doc/dox-math.h
--- vc-0.7.4/doc/dox-math.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/dox-math.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,21 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 
 /**
@@ -56,7 +64,8 @@
 /**
  * \ingroup Math
  *
- * Returns the natural logarithm of \p v.
+ * \param v The values to apply the logarithm on.
+ * \returns the natural logarithm of \p v.
  *
  * \note The single-precision implementation has an error of max. 1 ulp (mean 0.020 ulp) in the range ]0, 1000] (including denormals).
  * \note The double-precision implementation has an error of max. 1 ulp (mean 0.020 ulp) in the range ]0, 1000] (including denormals).
@@ -66,7 +75,8 @@
 /**
  * \ingroup Math
  *
- * Returns the base-2 logarithm of \p v.
+ * \param v The values to apply the logarithm on.
+ * \returns the base-2 logarithm of \p v.
  *
  * \note The single-precision implementation has an error of max. 1 ulp (mean 0.016 ulp) in the range ]0, 1000] (including denormals).
  * \note The double-precision implementation has an error of max. 1 ulp (mean 0.016 ulp) in the range ]0, 1000] (including denormals).
@@ -76,7 +86,8 @@
 /**
  * \ingroup Math
  *
- * Returns the base-10 logarithm of \p v.
+ * \param v The values to apply the logarithm on.
+ * \returns the base-10 logarithm of \p v.
  *
  * \note The single-precision implementation has an error of max. 2 ulp (mean 0.31 ulp) in the range ]0, 1000] (including denormals).
  * \note The double-precision implementation has an error of max. 2 ulp (mean 0.26 ulp) in the range ]0, 1000] (including denormals).
@@ -86,14 +97,16 @@
 /**
  * \ingroup Math
  *
- * Returns the exponential of \p v.
+ * \param v The values to apply the exponential function on.
+ * \returns the exponential of \p v.
  */
 VECTOR_TYPE exp(const VECTOR_TYPE &v);
 
 /**
  * \ingroup Math
  *
- * Returns the sine of \p v.
+ * \param v The values to apply the sine function on.
+ * \returns the sine of \p v.
  *
  * \note The single-precision implementation has an error of max. 2 ulp (mean 0.17 ulp) in the range [-8192, 8192].
  * \note The double-precision implementation has an error of max. 8e6 ulp (mean 1040 ulp) in the range [-8192, 8192].
@@ -104,7 +117,8 @@
 /**
  * \ingroup Math
  *
- * Returns the cosine of \p v.
+ * \param v The values to apply the cosine function on.
+ * \returns the cosine of \p v.
  *
  * \note The single-precision implementation has an error of max. 2 ulp (mean 0.18 ulp) in the range [-8192, 8192].
  * \note The double-precision implementation has an error of max. 8e6 ulp (mean 1160 ulp) in the range [-8192, 8192].
@@ -115,23 +129,8 @@
 /**
  * \ingroup Math
  *
- * Calculates the sine and cosine of \p v.
- * The values are returned in the \p sin and \p cos parameters.
- *
- * \param[in]  v input value to sin and cos
- * \param[out] sin Needs to be a non-null pointer which will be set to the sine of \p v.
- * \param[out] cos Needs to be a non-null pointer which will be set to the cosine of \p v.
- *
- * \note The single-precision implementation has an error of max. 2 ulp (mean 0.18 ulp) in the range [-8192, 8192].
- * \note The double-precision implementation has an error of max. 8e6 ulp (mean 1160 ulp) in the range [-8192, 8192].
- * \note Vc versions before 0.7 had much larger errors.
- */
-void sincos(const VECTOR_TYPE &v, VECTOR_TYPE *sin, VECTOR_TYPE *cos);
-
-/**
- * \ingroup Math
- *
- * Returns the arcsine of \p v.
+ * \param v The values to apply the arcsine function on.
+ * \returns the arcsine of \p v.
  *
  * \note The single-precision implementation has an error of max. 2 ulp (mean 0.3 ulp).
  * \note The double-precision implementation has an error of max. 36 ulp (mean 0.4 ulp).
@@ -141,7 +140,8 @@
 /**
  * \ingroup Math
  *
- * Returns the arctangent of \p v.
+ * \param v The values to apply the arctangent function on.
+ * \returns the arctangent of \p v.
  * \note The single-precision implementation has an error of max. 3 ulp (mean 0.4 ulp) in the range [-8192, 8192].
  * \note The double-precision implementation has an error of max. 2 ulp (mean 0.1 ulp) in the range [-8192, 8192].
  */
@@ -150,21 +150,29 @@
 /**
  * \ingroup Math
  *
- * Returns the arctangent of \p x / \p y.
+ * Calculates the angle given the lengths of the opposite and adjacent legs in a right
+ * triangle.
+ * \param y The opposite leg.
+ * \param x The adjacent leg.
+ * \returns the arctangent of \p y / \p x.
  */
-VECTOR_TYPE atan2(const VECTOR_TYPE &x, const VECTOR_TYPE &y);
+VECTOR_TYPE atan2(const VECTOR_TYPE &y, const VECTOR_TYPE &x);
 
 /**
  * \ingroup Math
  *
- * Returns the minimum of \p x and \p y.
+ * \param x \VSize{T} values to compare component-wise against \p y.
+ * \param y \VSize{T} values to compare component-wise against \p x.
+ * \returns the minimum of \p x and \p y.
  */
 VECTOR_TYPE min(const VECTOR_TYPE &x, const VECTOR_TYPE &y);
 
 /**
  * \ingroup Math
  *
- * Returns the maximum of \p x and \p y.
+ * \param x \VSize{T} values to compare component-wise against \p y.
+ * \param y \VSize{T} values to compare component-wise against \p x.
+ * \returns the maximum of \p x and \p y.
  */
 VECTOR_TYPE max(const VECTOR_TYPE &x, const VECTOR_TYPE &y);
 
@@ -206,13 +214,38 @@
 /**
  * \ingroup Math
  *
- * Returns a mask that tells whether the values in the vector are finite (i.e.\ not NaN or +/-inf).
+ * \param x The \VSize{T} values to check for finite values.
+ * \returns a mask that tells whether the values in the vector are finite (i.e.\ not NaN or +/-inf).
  */
 MASK_TYPE isfinite(const VECTOR_TYPE &x);
 
 /**
  * \ingroup Math
  *
- * Returns a mask that tells whether the values in the vector are NaN.
+ * \param x The \VSize{T} values to check for NaN values.
+ * \returns a mask that tells whether the values in the vector are NaN.
  */
 MASK_TYPE isnan(const VECTOR_TYPE &x);
+
+/**
+ * \ingroup Math
+ *
+ * Multiplies \p a with \p b and then adds \p c, without rounding between the
+ * multiplication and the addition.
+ *
+ * \param a First multiplication factor.
+ * \param b Second multiplication factor.
+ * \param c Summand that will be added after multiplication.
+ * \returns The \VSize{T} values of `a * b + c` with higher precision due to no rounding
+ *          between multiplication and addition.
+ *
+ * \note This operation may have explicit hardware support, in which case it is normally
+ *       faster to use the FMA instead of separate multiply and add instructions.
+ * \note If the target hardware does not have FMA support this function will be
+ *       considerably slower than a normal a * b + c. This is due to the increased
+ *       precision fusedMultiplyAdd provides.
+ * \note The compiler normally detects opportunities for using the hardware FMA
+ *       instructions from normal multiplication and addition/subtraction operators. Use
+ *       this function only if you \em require the additional precision.
+ */
+VECTOR_TYPE fma(VECTOR_TYPE a, VECTOR_TYPE b, VECTOR_TYPE c);
diff -Nru vc-0.7.4/doc/dox-real-ops.h vc-1.3.0/doc/dox-real-ops.h
--- vc-0.7.4/doc/dox-real-ops.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/dox-real-ops.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,65 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-/**
- * Copies the sign of \p reference.
- *
- * \param reference This values sign bit will be transferred.
- *
- * \return a value where the sign of the value equals the sign of \p reference. I.e.
- * sign(v.copySign(r)) == sign(r).
- */
-inline VECTOR_TYPE copySign(VECTOR_TYPE reference) const;
-
-/**
- * Extracts the exponent.
- *
- * \return the exponent to base 2.
- *
- * This function provides efficient access to the exponent of the floating point number. The
- * returned value is a fast approximation to the logarithm of base 2. The absolute error of that
- * approximation is between [0, 1[.
- *
- * Examples:
-\verbatim
- value | exponent | log2
-=======|==========|=======
-   1.0 |        0 | 0
-   2.0 |        1 | 1
-   3.0 |        1 | 1.585
-   3.9 |        1 | 1.963
-   4.0 |        2 | 2
-   4.1 |        2 | 2.036
-\endverbatim
- *
- * \warning This function assumes a positive value (non-zero). If the value is negative the sign bit will
- * modify the returned value. An input value of zero will return the bias of the floating-point
- * representation. If you compile with Vc runtime checks, the function will assert
- * values greater than or equal to zero.
- *
- * You may use abs to apply this function to negative values:
- * \code
- * abs(v).exponent()
- * \endcode
- */
-inline VECTOR_TYPE exponent() const;
+}}}*/
 
 /**
  * Check the sign bit of each vector entry.
diff -Nru vc-0.7.4/doc/Doxyfile vc-1.3.0/doc/Doxyfile
--- vc-0.7.4/doc/Doxyfile	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/Doxyfile	2016-10-27 02:05:02.000000000 -0500
@@ -1,122 +1,129 @@
-# Doxyfile 1.8.4
+# Doxyfile 1.8.10
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
 #
-# All text after a double hash (##) is considered a comment and is placed
-# in front of the TAG it is preceding .
-# All text after a hash (#) is considered a comment and will be ignored.
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
 # The format is:
-#       TAG = value [value, ...]
-# For lists items can also be appended using:
-#       TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (" ").
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
 # This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all
-# text before the first occurrence of this tag. Doxygen uses libiconv (or the
-# iconv built into libc) for the transcoding. See
-# http://www.gnu.org/software/libiconv for the list of possible encodings.
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
 
 DOXYFILE_ENCODING      = UTF-8
 
-# The PROJECT_NAME tag is a single word (or sequence of words) that should
-# identify the project. Note that if you do not use Doxywizard you need
-# to put quotes around the project name if it contains spaces.
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
 
 PROJECT_NAME           = "Vc"
 
-# The PROJECT_NUMBER tag can be used to enter a project or revision number.
-# This could be handy for archiving the generated documentation or
-# if some version control system is used.
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
 
-PROJECT_NUMBER         = 0.7.4
+PROJECT_NUMBER         = 1.3.0
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer
-# a quick idea about the purpose of the project. Keep the description short.
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
 
 PROJECT_BRIEF          = "SIMD Vector Classes for C++"
 
-# With the PROJECT_LOGO tag one can specify an logo or icon that is
-# included in the documentation. The maximum height of the logo should not
-# exceed 55 pixels and the maximum width should not exceed 200 pixels.
-# Doxygen will copy the logo to the output directory.
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
 
 PROJECT_LOGO           = logo_small.png
 
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
-# base path where the generated documentation will be put.
-# If a relative path is entered, it will be relative to the location
-# where doxygen was started. If left blank the current directory will be used.
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
 
 OUTPUT_DIRECTORY       = ./
 
-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
-# 4096 sub-directories (in 2 levels) under the output directory of each output
-# format and will distribute the generated files over these directories.
-# Enabling this option can be useful when feeding doxygen a huge amount of
-# source files, where putting all generated files in the same directory would
-# otherwise cause performance problems for the file system.
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
 
 CREATE_SUBDIRS         = NO
 
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
-# The default language is English, other supported languages are:
-# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
-# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
-# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
-# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,
-# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,
-# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
 
 OUTPUT_LANGUAGE        = English
 
-# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
-# include brief member descriptions after the members that are listed in
-# the file and class documentation (similar to JavaDoc).
-# Set to NO to disable this.
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
 
 BRIEF_MEMBER_DESC      = YES
 
-# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
-# the brief description of a member or function before the detailed description.
-# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
 # brief descriptions will be completely suppressed.
+# The default value is: YES.
 
 REPEAT_BRIEF           = YES
 
-# This tag implements a quasi-intelligent brief description abbreviator
-# that is used to form the text in various listings. Each string
-# in this list, if found as the leading text of the brief description, will be
-# stripped from the text and the result after processing the whole list, is
-# used as the annotated text. Otherwise, the brief description is used as-is.
-# If left blank, the following values are used ("$name" is automatically
-# replaced with the name of the entity): "The $name class" "The $name widget"
-# "The $name file" "is" "provides" "specifies" "contains"
-# "represents" "a" "an" "the"
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       =
 
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# Doxygen will generate a detailed section even if there is only a brief
+# doxygen will generate a detailed section even if there is only a brief
 # description.
+# The default value is: NO.
 
 ALWAYS_DETAILED_SEC    = NO
 
@@ -124,231 +131,276 @@
 # inherited members of a class in the documentation of that class as if those
 # members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
+# The default value is: NO.
 
 INLINE_INHERITED_MEMB  = YES
 
-# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
-# path before files name in the file list and in the header files. If set
-# to NO the shortest path that makes the file name unique will be used.
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
 
 FULL_PATH_NAMES        = YES
 
-# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
-# can be used to strip a user-defined part of the path. Stripping is
-# only done if one of the specified strings matches the left-hand part of
-# the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the
-# path to strip. Note that you specify absolute paths here, but also
-# relative paths, which will be relative from the directory where doxygen is
-# started.
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
 
 STRIP_FROM_PATH        = ./
 
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
-# the path mentioned in the documentation of a class, which tells
-# the reader which header file to include in order to use a class.
-# If left blank only the name of the header file containing the class
-# definition is used. Otherwise one should specify the include paths that
-# are normally passed to the compiler using the -I flag.
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
 
 STRIP_FROM_INC_PATH    =
 
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
-# (but less readable) file names. This can be useful if your file system
-# doesn't support long names like on DOS, Mac, or CD-ROM.
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
 
 SHORT_NAMES            = NO
 
-# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
-# will interpret the first line (until the first dot) of a JavaDoc-style
-# comment as the brief description. If set to NO, the JavaDoc
-# comments will behave just like regular Qt-style comments
-# (thus requiring an explicit @brief command for a brief description.)
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
 
 JAVADOC_AUTOBRIEF      = YES
 
-# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
-# interpret the first line (until the first dot) of a Qt-style
-# comment as the brief description. If set to NO, the comments
-# will behave just like regular Qt-style comments (thus requiring
-# an explicit \brief command for a brief description.)
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
 
 QT_AUTOBRIEF           = NO
 
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
-# treat a multi-line C++ special comment block (i.e. a block of //! or ///
-# comments) as a brief description. This used to be the default behaviour.
-# The new default is to treat a multi-line C++ comment block as a detailed
-# description. Set this tag to YES if you prefer the old behaviour instead.
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
 
 MULTILINE_CPP_IS_BRIEF = NO
 
-# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
-# member inherits the documentation from any documented member that it
-# re-implements.
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
 
 INHERIT_DOCS           = YES
 
-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
-# a new page for each member. If set to NO, the documentation of a member will
-# be part of the file/class/namespace that contains it.
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
 
 SEPARATE_MEMBER_PAGES  = NO
 
-# The TAB_SIZE tag can be used to set the number of spaces in a tab.
-# Doxygen uses this value to replace tabs by spaces in code fragments.
-
-TAB_SIZE               = 8
-
-# This tag can be used to specify a number of aliases that acts
-# as commands in the documentation. An alias has the form "name=value".
-# For example adding "sideeffect=\par Side Effects:\n" will allow you to
-# put the command \sideeffect (or @sideeffect) in the documentation, which
-# will result in a user-defined paragraph with heading "Side Effects:".
-# You can put \n's in the value part of an alias to insert newlines.
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
 
-ALIASES                =
+ALIASES                = "VSize{1}=\f$\mathcal{W}_\mathtt{\1}\f$"
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding
-# "class=itcl::class" will allow you to use the command class in the
-# itcl::class meaning.
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
 
 TCL_SUBST              =
 
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
-# sources only. Doxygen will then generate output that is more tailored for C.
-# For instance, some of the names that are used will be different. The list
-# of all members will be omitted, etc.
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
 
 OPTIMIZE_OUTPUT_FOR_C  = NO
 
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
-# sources only. Doxygen will then generate output that is more tailored for
-# Java. For instance, namespaces will be presented as packages, qualified
-# scopes will look different, etc.
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
 
 OPTIMIZE_OUTPUT_JAVA   = NO
 
 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources only. Doxygen will then generate output that is more tailored for
-# Fortran.
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
 
 OPTIMIZE_FOR_FORTRAN   = NO
 
 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for
-# VHDL.
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension,
-# and language is one of the parsers supported by doxygen: IDL, Java,
-# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
-# C++. For instance to make doxygen treat .inc files as Fortran files (default
-# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
-# that for custom extensions you also need to set FILE_PATTERNS otherwise the
-# files are not read by doxygen.
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+# Fortran. In the later case the parser tries to guess whether the code is fixed
+# or free formatted code, this is the default for Fortran type files), VHDL. For
+# instance to make doxygen treat .inc files as Fortran files (default is PHP),
+# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
 
-EXTENSION_MAPPING      =
+EXTENSION_MAPPING      = "no_extension=C++"
 
-# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
-# comments according to the Markdown format, which allows for more readable
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
 # documentation. See http://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you
-# can mix doxygen, HTML, and XML commands with Markdown formatting.
-# Disable only in case of backward compatibilities issues.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
 
-MARKDOWN_SUPPORT       = NO
+MARKDOWN_SUPPORT       = YES
 
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by by putting a % sign in front of the word
-# or globally by setting AUTOLINK_SUPPORT to NO.
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
 
 AUTOLINK_SUPPORT       = YES
 
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should
-# set this tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
-# func(std::string) {}). This also makes the inheritance and collaboration
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
 # diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
 
 BUILTIN_STL_SUPPORT    = NO
 
 # If you use Microsoft's C++/CLI language, you should set this option to YES to
 # enable parsing support.
+# The default value is: NO.
 
 CPP_CLI_SUPPORT        = NO
 
-# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
-# Doxygen will parse them like normal C++ but will assume all classes use public
-# instead of private inheritance when no explicit protection keyword is present.
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
 
 SIP_SUPPORT            = NO
 
 # For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES (the
-# default) will make doxygen replace the get and set methods by a property in
-# the documentation. This will only work if the methods are indeed getting or
-# setting a simple type. If this is not the case, or you want to show the
-# methods anyway, you should set this option to NO.
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
 
 IDL_PROPERTY_SUPPORT   = YES
 
 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
+# tag is set to YES then doxygen will reuse the documentation of the first
 # member in the group (if any) for the other members of the group. By default
 # all members of a group must be documented explicitly.
+# The default value is: NO.
 
 DISTRIBUTE_GROUP_DOC   = NO
 
-# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
-# the same type (for instance a group of public functions) to be put as a
-# subgroup of that type (e.g. under the Public Functions section). Set it to
-# NO to prevent subgrouping. Alternatively, this can be done per class using
-# the \nosubgrouping command.
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
 
 SUBGROUPING            = YES
 
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
-# unions are shown inside the group in which they are included (e.g. using
-# @ingroup) instead of on a separate page (for HTML and Man pages) or
-# section (for LaTeX and RTF).
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
 
 INLINE_GROUPED_CLASSES = NO
 
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
-# unions with only public data fields or simple typedef fields will be shown
-# inline in the documentation of the scope in which they are defined (i.e. file,
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
 # namespace, or group documentation), provided this scope is documented. If set
-# to NO (the default), structs, classes, and unions are shown on a separate
-# page (for HTML and Man pages) or section (for LaTeX and RTF).
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
 
 INLINE_SIMPLE_STRUCTS  = NO
 
-# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
-# is documented as struct, union, or enum with the name of the typedef. So
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 # with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically
-# be useful for C code in case the coding convention dictates that all compound
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
 # types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
 
 TYPEDEF_HIDES_STRUCT   = NO
 
 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can
-# be an expensive process and often the same symbol appear multiple times in
-# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too
-# small doxygen will become slower. If the cache is too large, memory is wasted.
-# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid
-# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536
-# symbols.
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
 
 LOOKUP_CACHE_SIZE      = 0
 
@@ -356,354 +408,408 @@
 # Build related configuration options
 #---------------------------------------------------------------------------
 
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available.
-# Private class members and static file members will be hidden unless
-# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
 
 EXTRACT_ALL            = NO
 
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
-# will be included in the documentation.
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
 
 EXTRACT_PRIVATE        = NO
 
-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
+# The default value is: NO.
 
 EXTRACT_PACKAGE        = NO
 
-# If the EXTRACT_STATIC tag is set to YES all static members of a file
-# will be included in the documentation.
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
 
 EXTRACT_STATIC         = NO
 
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
-# defined locally in source files will be included in the documentation.
-# If set to NO only classes defined in header files are included.
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
 
 EXTRACT_LOCAL_CLASSES  = NO
 
-# This flag is only useful for Objective-C code. When set to YES local
-# methods, which are defined in the implementation section but not in
-# the interface are included in the documentation.
-# If set to NO (the default) only methods in the interface are included.
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
 
 EXTRACT_LOCAL_METHODS  = NO
 
 # If this flag is set to YES, the members of anonymous namespaces will be
 # extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base
-# name of the file that contains the anonymous namespace. By default
-# anonymous namespaces are hidden.
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
 
 EXTRACT_ANON_NSPACES   = NO
 
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
-# undocumented members of documented classes, files or namespaces.
-# If set to NO (the default) these members will be included in the
-# various overviews, but no documentation section is generated.
-# This option has no effect if EXTRACT_ALL is enabled.
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
 
 HIDE_UNDOC_MEMBERS     = YES
 
-# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy.
-# If set to NO (the default) these classes will be included in the various
-# overviews. This option has no effect if EXTRACT_ALL is enabled.
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
 
 HIDE_UNDOC_CLASSES     = YES
 
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
-# friend (class|struct|union) declarations.
-# If set to NO (the default) these declarations will be included in the
-# documentation.
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO, these declarations will be
+# included in the documentation.
+# The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = YES
 
-# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
-# documentation blocks found inside the body of a function.
-# If set to NO (the default) these blocks will be appended to the
-# function's detailed documentation block.
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
 
 HIDE_IN_BODY_DOCS      = NO
 
-# The INTERNAL_DOCS tag determines if documentation
-# that is typed after a \internal command is included. If the tag is set
-# to NO (the default) then the documentation will be excluded.
-# Set it to YES to include the internal documentation.
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
-# file names in lower-case letters. If set to YES upper-case letters are also
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES, upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
 # and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
 
-# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
-# will show members with their full class and namespace scopes in the
-# documentation. If set to YES the scope will be hidden.
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
 
 HIDE_SCOPE_NAMES       = YES
 
-# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
-# will put a list of the files that are included by a file in the documentation
-# of that file.
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
 
 SHOW_INCLUDE_FILES     = YES
 
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
-# will list include files with double quotes in the documentation
-# rather than with sharp brackets.
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
 
 FORCE_LOCAL_INCLUDES   = NO
 
-# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
-# is inserted in the documentation for inline members.
-
-INLINE_INFO            = NO
-
-# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
-# will sort the (detailed) documentation of file and class members
-# alphabetically by member name. If set to NO the members will appear in
-# declaration order.
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
 
 SORT_MEMBER_DOCS       = NO
 
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
-# brief documentation of file, namespace and class members alphabetically
-# by member name. If set to NO (the default) the members will appear in
-# declaration order.
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
 
 SORT_BRIEF_DOCS        = NO
 
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
-# will sort the (brief and detailed) documentation of class members so that
-# constructors and destructors are listed first. If set to NO (the default)
-# the constructors will appear in the respective orders defined by
-# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
-# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
-# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
 
 SORT_MEMBERS_CTORS_1ST = NO
 
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
-# hierarchy of group names into alphabetical order. If set to NO (the default)
-# the group names will appear in their defined order.
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
 
 SORT_GROUP_NAMES       = NO
 
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
-# sorted by fully-qualified names, including namespaces. If set to
-# NO (the default), the class list will be sorted only by class name,
-# not including the namespace part.
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the
-# alphabetical list.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
 
 SORT_BY_SCOPE_NAME     = NO
 
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
-# do proper type resolution of all parameters of a function it will reject a
-# match between the prototype and the implementation of a member function even
-# if there is only one candidate or it is obvious which candidate to choose
-# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
-# will still accept a match between prototype and implementation in such cases.
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
 
 STRICT_PROTO_MATCHING  = NO
 
-# The GENERATE_TODOLIST tag can be used to enable (YES) or
-# disable (NO) the todo list. This list is created by putting \todo
-# commands in the documentation.
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
 
 GENERATE_TODOLIST      = NO
 
-# The GENERATE_TESTLIST tag can be used to enable (YES) or
-# disable (NO) the test list. This list is created by putting \test
-# commands in the documentation.
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
 
 GENERATE_TESTLIST      = YES
 
-# The GENERATE_BUGLIST tag can be used to enable (YES) or
-# disable (NO) the bug list. This list is created by putting \bug
-# commands in the documentation.
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
 
 GENERATE_BUGLIST       = YES
 
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
-# disable (NO) the deprecated list. This list is created by putting
-# \deprecated commands in the documentation.
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
 
 GENERATE_DEPRECATEDLIST= YES
 
-# The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if section-label ... \endif
-# and \cond section-label ... \endcond blocks.
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
 
 ENABLED_SECTIONS       =
 
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
-# the initial value of a variable or macro consists of for it to appear in
-# the documentation. If the initializer consists of more lines than specified
-# here it will be hidden. Use a value of 0 to hide initializers completely.
-# The appearance of the initializer of individual variables and macros in the
-# documentation can be controlled using \showinitializer or \hideinitializer
-# command in the documentation regardless of this setting.
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
 
 MAX_INITIALIZER_LINES  = 30
 
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
-# at the bottom of the documentation of classes and structs. If set to YES the
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
 # list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
 
-SHOW_USED_FILES        = NO
+SHOW_FILES             = YES
 
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
-# This will remove the Files entry from the Quick Index and from the
-# Folder Tree View (if specified). The default is YES.
-
-SHOW_FILES             = NO
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
-# Namespaces page.
-# This will remove the Namespaces entry from the Quick Index
-# and from the Folder Tree View (if specified). The default is YES.
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
 
 SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
 # the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command <command> <input-file>, where <command> is the value of
-# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
-# provided by doxygen. Whatever the program writes to standard output
-# is used as the file version. See the manual for examples.
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
 
 FILE_VERSION_FILTER    =
 
 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 # by doxygen. The layout file controls the global structure of the generated
 # output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option.
-# You can optionally specify a file name after the option, if omitted
-# DoxygenLayout.xml will be used as the name of the layout file.
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
 
 LAYOUT_FILE            =
 
-# The CITE_BIB_FILES tag can be used to specify one or more bib files
-# containing the references data. This must be a list of .bib files. The
-# .bib extension is automatically appended if omitted. Using this command
-# requires the bibtex tool to be installed. See also
-# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
-# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
-# feature you need bibtex and perl available in the search path. Do not use
-# file names with spaces, bibtex cannot handle them.
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
 
 CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
+# Configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 
-# The QUIET tag can be used to turn on/off the messages that are generated
-# by doxygen. Possible values are YES and NO. If left blank NO is used.
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
 
-QUIET                  = NO
+QUIET                  = YES
 
 # The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated by doxygen. Possible values are YES and NO. If left blank
-# NO is used.
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
 
 WARNINGS               = YES
 
-# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
-# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
-# automatically be disabled.
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
 
 WARN_IF_UNDOCUMENTED   = YES
 
-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some
-# parameters in a documented function, or documenting parameters that
-# don't exist or using markup commands wrongly.
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
-# The WARN_NO_PARAMDOC option can be enabled to get warnings for
-# functions that are documented, but have no documentation for their parameters
-# or return value. If set to NO (the default) doxygen will only warn about
-# wrong or incomplete parameter documentation, but not about the absence of
-# documentation.
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation.
+# The default value is: NO.
 
 WARN_NO_PARAMDOC       = YES
 
-# The WARN_FORMAT tag determines the format of the warning messages that
-# doxygen can produce. The string should contain the $file, $line, and $text
-# tags, which will be replaced by the file and line number from which the
-# warning originated and the warning text. Optionally the format may contain
-# $version, which will be replaced by the version of the file (if it could
-# be obtained via FILE_VERSION_FILTER)
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
 
 WARN_FORMAT            = "$file:$line: $text"
 
-# The WARN_LOGFILE tag can be used to specify a file to which warning
-# and error messages should be written. If left blank the output is written
-# to stderr.
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
 
 WARN_LOGFILE           =
 
 #---------------------------------------------------------------------------
-# configuration options related to the input files
+# Configuration options related to the input files
 #---------------------------------------------------------------------------
 
-# The INPUT tag can be used to specify the files and/or directories that contain
-# documented source files. You may enter file names like "myfile.cpp" or
-# directories like "/usr/src/myproject". Separate the files or directories
-# with spaces.
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
 
-INPUT                  = ../include/Vc/global.h \
-                         ../include/Vc/cpuid.h \
-                         ../include/Vc/support.h \
+INPUT                  = ../include/Vc \
+                         ../include/Vc/IO \
                          ../include/Vc/Allocator \
-                         ./ \
-                         ../common/
+                         ../include/Vc/array \
+                         ../include/Vc/vector \
+                         ./dox.h \
+                         ./examples.h \
+                         ../common \
+                         ../traits
 
 # This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
-# also the default input encoding. Doxygen uses libiconv (or the iconv built
-# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
-# the list of possible encodings.
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
 
 # If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank the following patterns are tested:
-# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
-# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
-# *.f90 *.f *.for *.vhd *.vhdl
-
-FILE_PATTERNS          = dox.h \
-                         examples.h \
-                         memory.h \
-                         memorybase.h \
-                         interleavedmemory.h \
-                         deinterleave.h \
-                         support.h
-
-# The RECURSIVE tag can be used to turn specify whether or not subdirectories
-# should be searched for input files as well. Possible values are YES and NO.
-# If left blank NO is used.
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
+# *.vhdl, *.ucf, *.qsf, *.as and *.js.
+
+FILE_PATTERNS          = *.h *.dox
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
 
 RECURSIVE              = NO
 
 # The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
@@ -712,14 +818,16 @@
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
 # from the input.
+# The default value is: NO.
 
 EXCLUDE_SYMLINKS       = NO
 
 # If the value of the INPUT tag contains directories, you can use the
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories. Note that the wildcards are matched
-# against the file with absolute path, so to exclude all test directories
-# for example use the pattern */test/*
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
 
 EXCLUDE_PATTERNS       =
 
@@ -728,42 +836,49 @@
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
 
 EXCLUDE_SYMBOLS        =
 
-# The EXAMPLE_PATH tag can be used to specify one or more files or
-# directories that contain example code fragments that are included (see
-# the \include command).
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
 
 EXAMPLE_PATH           = ../examples/
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank all files are included.
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
 
 EXAMPLE_PATTERNS       = *
 
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude
-# commands irrespective of the value of the RECURSIVE tag.
-# Possible values are YES and NO. If left blank NO is used.
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
 
 EXAMPLE_RECURSIVE      = NO
 
-# The IMAGE_PATH tag can be used to specify one or more files or
-# directories that contain image that are included in the documentation (see
-# the \image command).
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
 
 IMAGE_PATH             = ./
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command <filter> <input-file>, where <filter>
-# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
-# input file. Doxygen will then use the output that the filter program writes
-# to standard output.
-# If FILTER_PATTERNS is specified, this tag will be ignored.
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
 # Note that the filter must not add or remove lines; it is applied before the
 # code is scanned, but not when the output code is generated. If lines are added
 # or removed, the anchors will not be placed correctly.
@@ -771,172 +886,243 @@
 INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis.
-# Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match.
-# The filters are a list of the form:
-# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
-# info on how filters are used. If FILTER_PATTERNS is empty or if
-# non of the patterns match the file name, INPUT_FILTER is applied.
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        =
 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will be used to filter the input files when producing source
-# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
 
 FILTER_SOURCE_FILES    = NO
 
 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
-# and it is also possible to disable source filtering for a specific pattern
-# using *.ext= (so without naming a filter). This option only has effect when
-# FILTER_SOURCE_FILES is enabled.
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
 
 FILTER_SOURCE_PATTERNS =
 
-# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
 # is part of the input, its contents will be placed on the main page
 # (index.html). This can be useful if you have a project on for instance GitHub
-# and want reuse the introduction page also for the doxygen output.
+# and want to reuse the introduction page also for the doxygen output.
 
 USE_MDFILE_AS_MAINPAGE =
 
 #---------------------------------------------------------------------------
-# configuration options related to source browsing
+# Configuration options related to source browsing
 #---------------------------------------------------------------------------
 
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will
-# be generated. Documented entities will be cross-referenced with these sources.
-# Note: To get rid of all source code in the generated output, make sure also
-# VERBATIM_HEADERS is set to NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body
-# of functions and classes directly in the documentation.
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
 
 INLINE_SOURCES         = NO
 
-# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
-# doxygen to hide any special comment blocks from generated source code
-# fragments. Normal C, C++ and Fortran comments will always remain visible.
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
 
 STRIP_CODE_COMMENTS    = YES
 
-# If the REFERENCED_BY_RELATION tag is set to YES
-# then for each documented function all documented
-# functions referencing it will be listed.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES
-# then for each documented function all documented entities
-# called/used by that function will be listed.
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
 
 REFERENCES_RELATION    = NO
 
-# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
-# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
-# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
-# link to the source code.
-# Otherwise they will link to the documentation.
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
 
 REFERENCES_LINK_SOURCE = YES
 
-# If the USE_HTAGS tag is set to YES then the references to source code
-# will point to the HTML generated by the htags(1) tool instead of doxygen
-# built-in source browser. The htags tool is part of GNU's global source
-# tagging system (see http://www.gnu.org/software/global/global.html). You
-# will need version 4.8.6 or higher.
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
 
 USE_HTAGS              = NO
 
-# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
-# will generate a verbatim copy of the header file for each class for
-# which an include is specified. Set to NO to disable this.
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
 
 VERBATIM_HEADERS       = NO
 
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# compiled with the --with-libclang option.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
 #---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
+# Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
-# of all compounds will be generated. Enable this if the project
-# contains a lot of classes, structs, unions or interfaces.
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
 
-ALPHABETICAL_INDEX     = NO
+ALPHABETICAL_INDEX     = YES
 
-# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
-# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
-# in which this list will be split (can be a number in the range [1..20])
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 COLS_IN_ALPHA_INDEX    = 5
 
-# In case all classes in a project start with a common prefix, all
-# classes will be put under the same header in the alphabetical index.
-# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
-# should be ignored while generating the index headers.
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 IGNORE_PREFIX          =
 
 #---------------------------------------------------------------------------
-# configuration options related to the HTML output
+# Configuration options related to the HTML output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
-# generate HTML output.
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
 
 GENERATE_HTML          = YES
 
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `html' will be used as the default path.
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_OUTPUT            = html
 
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
-# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
-# doxygen will generate files with .html extension.
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_FILE_EXTENSION    = .html
 
-# The HTML_HEADER tag can be used to specify a personal HTML header for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard header. Note that when using a custom header you are responsible
-#  for the proper inclusion of any scripts and style sheets that doxygen
-# needs, which is dependent on the configuration options used.
-# It is advised to generate a default header using "doxygen -w html
-# header.html footer.html stylesheet.css YourConfigFile" and then modify
-# that header. Note that the header is subject to change so you typically
-# have to redo this when upgrading to a newer version of doxygen or when
-# changing the value of configuration settings such as GENERATE_TREEVIEW!
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_HEADER            =
 
-# The HTML_FOOTER tag can be used to specify a personal HTML footer for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard footer.
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_FOOTER            =
 
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
-# style sheet that is used by each HTML page. It can be used to
-# fine-tune the look of the HTML output. If left blank doxygen will
-# generate a default style sheet. Note that it is recommended to use
-# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
-# tag will in the future become obsolete.
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_STYLESHEET        =
 
-# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
-# user-defined cascading style sheet that is included after the standard
-# style sheets created by doxygen. Using this option one can overrule
-# certain style aspects. This is preferred over using HTML_STYLESHEET
-# since it does not replace the standard style sheet and is therefor more
-# robust against future updates. Doxygen will copy the style sheet file to
-# the output directory.
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_STYLESHEET  =
 
@@ -944,683 +1130,838 @@
 # other source files which should be copied to the HTML output directory. Note
 # that these files will be copied to the base HTML output directory. Use the
 # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that
-# the files will be copied as-is; there are no commands or markers available.
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_FILES       =
 
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
-# Doxygen will adjust the colors in the style sheet and background images
-# according to this color. Hue is specified as an angle on a colorwheel,
-# see http://en.wikipedia.org/wiki/Hue for more information.
-# For instance the value 0 represents red, 60 is yellow, 120 is green,
-# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
-# The allowed range is 0 to 359.
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_HUE    = 120
 
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
-# the colors in the HTML output. For a value of 0 the output will use
-# grayscales only. A value of 255 will produce the most vivid colors.
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_SAT    = 100
 
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
-# the luminance component of the colors in the HTML output. Values below
-# 100 gradually make the output lighter, whereas values above 100 make
-# the output darker. The value divided by 100 is the actual gamma applied,
-# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
-# and 100 does not change the gamma.
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_GAMMA  = 120
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting
-# this to NO can help when comparing the output of multiple runs.
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_TIMESTAMP         = NO
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_DYNAMIC_SECTIONS  = YES
 
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
-# entries shown in the various tree structured indices initially; the user
-# can expand and collapse entries dynamically later on. Doxygen will expand
-# the tree to such a level that at most the specified number of entries are
-# visible (unless a fully collapsed tree already exceeds this amount).
-# So setting the number of entries 1 will produce a full collapsed tree by
-# default. 0 is a special value representing an infinite number of entries
-# and will result in a full expanded tree by default.
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_INDEX_NUM_ENTRIES = 100
 
-# If the GENERATE_DOCSET tag is set to YES, additional index files
-# will be generated that can be used as input for Apple's Xcode 3
-# integrated development environment, introduced with OSX 10.5 (Leopard).
-# To create a documentation set, doxygen will generate a Makefile in the
-# HTML output directory. Running make will produce the docset in that
-# directory and running "make install" will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
-# it at startup.
-# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
 # for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_DOCSET        = NO
 
-# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
-# feed. A documentation feed provides an umbrella under which multiple
-# documentation sets from a single provider (such as a company or product suite)
-# can be grouped.
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
-# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
-# should uniquely identify the documentation set bundle. This should be a
-# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
-# will append .docset to the name.
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
-# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
-# identify the documentation publisher. This should be a reverse domain-name
-# style string, e.g. com.mycompany.MyDocSet.documentation.
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 
-# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_PUBLISHER_NAME  = Publisher
 
-# If the GENERATE_HTMLHELP tag is set to YES, additional index files
-# will be generated that can be used as input for tools like the
-# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
-# of the generated HTML documentation.
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_HTMLHELP      = NO
 
-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
-# be used to specify the file name of the resulting .chm file. You
-# can add a path in front of the file if the result should not be
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
 # written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 CHM_FILE               =
 
-# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
-# be used to specify the location (absolute path including file name) of
-# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
-# the HTML help compiler on the generated index.hhp.
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 HHC_LOCATION           =
 
-# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
-# controls if a separate .chi index file is generated (YES) or that
-# it should be included in the master .chm file (NO).
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 GENERATE_CHI           = NO
 
-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
-# is used to encode HtmlHelp index (hhk), content (hhc) and project file
-# content.
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 CHM_INDEX_ENCODING     =
 
-# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
-# controls whether a binary table of contents is generated (YES) or a
-# normal table of contents (NO) in the .chm file.
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 BINARY_TOC             = NO
 
-# The TOC_EXPAND flag can be set to YES to add extra items for group members
-# to the contents of the HTML help documentation and to the tree view.
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 TOC_EXPAND             = YES
 
 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
-# that can be used as input for Qt's qhelpgenerator to generate a
-# Qt Compressed Help (.qch) of the generated HTML documentation.
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_QHP           = YES
 
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
-# be used to specify the file name of the resulting .qch file.
-# The path specified is relative to the HTML output folder.
-
-QCH_FILE               = vc-0.7.qch
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating
-# Qt Help Project output. For more information please see
-# http://doc.trolltech.com/qthelpproject.html#namespace
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               = vc-master.qch
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_NAMESPACE          = de.uni-frankfurt.compeng.vc
 
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
-# Qt Help Project output. For more information please see
-# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_VIRTUAL_FOLDER     = "Vc (master)"
 
-# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
-# add. For more information please see
-# http://doc.trolltech.com/qthelpproject.html#custom-filters
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
-# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see
-# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
-# Qt Help Project / Custom Filters</a>.
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's
-# filter section matches.
-# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
-# Qt Help Project / Filter Attributes</a>.
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_SECT_FILTER_ATTRS  =
 
-# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
-# be used to specify the location of Qt's qhelpgenerator.
-# If non-empty doxygen will try to run qhelpgenerator on the generated
-# .qhp file.
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           = "../qhelpgenerator-wrapper"
 
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
-#  will be generated, which together with the HTML files, form an Eclipse help
-# plugin. To install this plugin and make it available under the help contents
-# menu in Eclipse, the contents of the directory containing the HTML and XML
-# files needs to be copied into the plugins directory of eclipse. The name of
-# the directory within the plugins directory should be the same as
-# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
-# the help appears.
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_ECLIPSEHELP   = NO
 
-# A unique identifier for the eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have
-# this name.
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
 
 ECLIPSE_DOC_ID         = org.doxygen.Project
 
-# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
-# at top of each HTML page. The value NO (the default) enables the index and
-# the value YES disables it. Since the tabs have the same information as the
-# navigation tree you can set this option to NO if you already set
-# GENERATE_TREEVIEW to YES.
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 DISABLE_INDEX          = YES
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information.
-# If the tag value is set to YES, a side panel will be generated
-# containing a tree-like index structure (just like the one that
-# is generated for HTML Help). For this to work a browser that supports
-# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
-# Windows users are probably better off using the HTML help feature.
-# Since the tree basically has the same information as the tab index you
-# could consider to set DISABLE_INDEX to NO when enabling this option.
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = YES
 
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
-# (range [0,1..20]) that doxygen will group on one line in the generated HTML
-# documentation. Note that a value of 0 will completely suppress the enum
-# values from appearing in the overview section.
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 ENUM_VALUES_PER_LINE   = 4
 
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
-# used to set the initial width (in pixels) of the frame in which the tree
-# is shown.
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 TREEVIEW_WIDTH         = 250
 
-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
-# links to external symbols imported via tag files in a separate window.
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 EXT_LINKS_IN_WINDOW    = NO
 
-# Use this tag to change the font size of Latex formulas included
-# as images in the HTML documentation. The default is 10. Note that
-# when you change the font size after a successful doxygen run you need
-# to manually remove any form_*.png images from the HTML output directory
-# to force them to be regenerated.
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_FONTSIZE       = 10
 
 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are
-# not supported properly for IE 6.0, but are supported on all modern browsers.
-# Note that when changing this option you need to delete any form_*.png files
-# in the HTML output before the changes have effect.
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_TRANSPARENT    = YES
 
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
-# (see http://www.mathjax.org) which uses client side Javascript for the
-# rendering instead of using prerendered bitmaps. Use this if you do not
-# have LaTeX installed or if you want to formulas look prettier in the HTML
-# output. When enabled you may also need to install MathJax separately and
-# configure the path to it using the MATHJAX_RELPATH option.
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
-USE_MATHJAX            = NO
+USE_MATHJAX            = YES
 
 # When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
-# SVG. The default value is HTML-CSS, which is slower, but has the best
-# compatibility.
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_FORMAT         = HTML-CSS
 
-# When MathJax is enabled you need to specify the location relative to the
-# HTML output directory using the MATHJAX_RELPATH option. The destination
-# directory should contain the MathJax.js script. For instance, if the mathjax
-# directory is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to
-# the MathJax Content Delivery Network so you can quickly see the result without
-# installing MathJax.
-# However, it is strongly recommended to install a local
-# copy of MathJax from http://www.mathjax.org before deployment.
-
-MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
-# names that should be enabled during MathJax rendering.
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_EXTENSIONS     =
 
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript
-# pieces of code that will be used on startup of the MathJax code.
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_CODEFILE       =
 
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box
-# for the HTML output. The underlying search engine uses javascript
-# and DHTML and should work on any modern browser. Note that when using
-# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
-# (GENERATE_DOCSET) there is already a search function so this one should
-# typically be disabled. For large projects the javascript based search engine
-# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
 
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript.
-# There are two flavours of web server based search depending on the
-# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
-# searching and an index file used by the script. When EXTERNAL_SEARCH is
-# enabled the indexing and searching needs to be provided by external tools.
-# See the manual for details.
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 SERVER_BASED_SEARCH    = YES
 
-# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
 # script for searching. Instead the search results are written to an XML file
 # which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain
-# the search results. Doxygen ships with an example indexer (doxyindexer) and
-# search engine (doxysearch.cgi) which are based on the open source search
-# engine library Xapian. See the manual for configuration details.
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTERNAL_SEARCH        = NO
 
 # The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will returned the search results when EXTERNAL_SEARCH is enabled.
-# Doxygen ships with an example search engine (doxysearch) which is based on
-# the open source search engine library Xapian. See the manual for configuration
-# details.
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
 
 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
 # search data is written to a file for indexing by an external tool. With the
 # SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHDATA_FILE        = searchdata.xml
 
-# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
 # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
 # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
 # projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTERNAL_SEARCH_ID     =
 
 # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
 # projects other than the one defined by this configuration file, but that are
 # all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
-# of to a relative location where the documentation can be found.
-# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTRA_SEARCH_MAPPINGS  =
 
 #---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
+# Configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
-# generate Latex output.
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
 
 GENERATE_LATEX         = NO
 
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `latex' will be used as the default path.
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_OUTPUT           = latex
 
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked. If left blank `latex' will be used as the default command name.
-# Note that when enabling USE_PDFLATEX this option is only used for
-# generating bitmaps for formulas in the HTML output, but not in the
-# Makefile that is written to the output directory.
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_CMD_NAME         = latex
 
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
-# generate index for LaTeX. If left blank `makeindex' will be used as the
-# default command name.
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
-# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
-# LaTeX documents. This may be useful for small projects and may help to
-# save some trees in general.
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 COMPACT_LATEX          = NO
 
-# The PAPER_TYPE tag can be used to set the paper type that is used
-# by the printer. Possible values are: a4, letter, legal and
-# executive. If left blank a4 will be used.
-
-PAPER_TYPE             = a4wide
-
-# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
-# packages that should be included in the LaTeX output.
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 EXTRA_PACKAGES         =
 
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
-# the generated latex document. The header should contain everything until
-# the first chapter. If it is left blank doxygen will generate a
-# standard header. Notice: only use this tag if you know what you are doing!
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HEADER           =
 
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
-# the generated latex document. The footer should contain everything after
-# the last chapter. If it is left blank doxygen will generate a
-# standard footer. Notice: only use this tag if you know what you are doing!
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_FOOTER           =
 
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images
-# or other source files which should be copied to the LaTeX output directory.
-# Note that the files will be copied as-is; there are no commands or markers
-# available.
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_EXTRA_FILES      =
 
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
-# is prepared for conversion to pdf (using ps2pdf). The pdf file will
-# contain links (just like the HTML output) instead of page references
-# This makes the output suitable for online browsing using a pdf viewer.
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
-# plain latex in the generated Makefile. Set this option to YES to get a
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
 # higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 USE_PDFLATEX           = YES
 
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
-# command to the generated LaTeX files. This will instruct LaTeX to keep
-# running if errors occur, instead of asking the user for help.
-# This option is also used when generating formulas in HTML.
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_BATCHMODE        = NO
 
-# If LATEX_HIDE_INDICES is set to YES then doxygen will not
-# include the index chapters (such as File Index, Compound Index, etc.)
-# in the output.
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HIDE_INDICES     = NO
 
-# If LATEX_SOURCE_CODE is set to YES then doxygen will include
-# source code with syntax highlighting in the LaTeX output.
-# Note that which sources are shown also depends on other settings
-# such as SOURCE_BROWSER.
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_SOURCE_CODE      = NO
 
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
-# http://en.wikipedia.org/wiki/BibTeX for more info.
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_BIB_STYLE        = plain
 
 #---------------------------------------------------------------------------
-# configuration options related to the RTF output
+# Configuration options related to the RTF output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
-# The RTF output is optimized for Word 97 and may not look very pretty with
-# other RTF readers or editors.
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
 
 GENERATE_RTF           = NO
 
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `rtf' will be used as the default path.
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_OUTPUT             = rtf
 
-# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
-# RTF documents. This may be useful for small projects and may help to
-# save some trees in general.
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
 
 COMPACT_RTF            = NO
 
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
-# will contain hyperlink fields. The RTF file will
-# contain links (just like the HTML output) instead of page references.
-# This makes the output suitable for online browsing using WORD or other
-# programs which support those fields.
-# Note: wordpad (write) and others do not support links.
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_HYPERLINKS         = NO
 
-# Load style sheet definitions from file. Syntax is similar to doxygen's
-# config file, i.e. a series of assignments. You only have to provide
-# replacements, missing definitions are set to their default value.
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_STYLESHEET_FILE    =
 
-# Set optional variables used in the generation of an rtf document.
-# Syntax is similar to doxygen's config file.
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_EXTENSIONS_FILE    =
 
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
 #---------------------------------------------------------------------------
-# configuration options related to the man page output
+# Configuration options related to the man page output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
-# generate man pages
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
 
 GENERATE_MAN           = NO
 
-# The MAN_OUTPUT tag is used to specify where the man pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `man' will be used as the default path.
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_OUTPUT             = man
 
-# The MAN_EXTENSION tag determines the extension that is added to
-# the generated man pages (default is the subroutine's section .3)
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_EXTENSION          = .3
 
-# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
-# then it will generate one additional man file for each entity
-# documented in the real man page(s). These additional files
-# only source the real man page, but without them the man command
-# would be unable to find the correct page. The default is NO.
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_LINKS              = NO
 
 #---------------------------------------------------------------------------
-# configuration options related to the XML output
+# Configuration options related to the XML output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_XML tag is set to YES Doxygen will
-# generate an XML file that captures the structure of
-# the code including all documentation.
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
 
 GENERATE_XML           = NO
 
-# The XML_OUTPUT tag is used to specify where the XML pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `xml' will be used as the default path.
-
-XML_OUTPUT             = xml
-
-# The XML_SCHEMA tag can be used to specify an XML schema,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_SCHEMA             =
-
-# The XML_DTD tag can be used to specify an XML DTD,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_DTD                =
-
-# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
-# dump the program listings (including syntax highlighting
-# and cross-referencing information) to the XML output. Note that
-# enabling this will significantly increase the size of the XML output.
-
-XML_PROGRAMLISTING     = YES
-
 #---------------------------------------------------------------------------
-# configuration options related to the DOCBOOK output
+# Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
 # that can be used to generate PDF.
+# The default value is: NO.
 
 GENERATE_DOCBOOK       = NO
 
-# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it. If left blank docbook will be used as the default path.
-
-DOCBOOK_OUTPUT         = docbook
-
 #---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
+# Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
-# generate an AutoGen Definitions (see autogen.sf.net) file
-# that captures the structure of the code including all
-# documentation. Note that this feature is still experimental
-# and incomplete at the moment.
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sf.net) file that captures the
+# structure of the code including all documentation. Note that this feature is
+# still experimental and incomplete at the moment.
+# The default value is: NO.
 
 GENERATE_AUTOGEN_DEF   = NO
 
 #---------------------------------------------------------------------------
-# configuration options related to the Perl module output
+# Configuration options related to the Perl module output
 #---------------------------------------------------------------------------
 
-# If the GENERATE_PERLMOD tag is set to YES Doxygen will
-# generate a Perl module file that captures the structure of
-# the code including all documentation. Note that this
-# feature is still experimental and incomplete at the
-# moment.
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
 
 GENERATE_PERLMOD       = NO
 
-# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
-# the necessary Makefile rules, Perl scripts and LaTeX code to be able
-# to generate PDF and DVI output from the Perl module output.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
-# nicely formatted so it can be parsed by a human reader.
-# This is useful
-# if you want to understand what is going on.
-# On the other hand, if this
-# tag is set to NO the size of the Perl module output will be much smaller
-# and Perl will parse it just the same.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file
-# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
-# This is useful so different doxyrules.make files included by the same
-# Makefile don't overwrite each other's variables.
-
-PERLMOD_MAKEVAR_PREFIX =
-
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 
-# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
-# evaluate all C-preprocessor directives found in the sources and include
-# files.
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
 
 ENABLE_PREPROCESSING   = YES
 
-# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
-# names in the source code. If set to NO (the default) only conditional
-# compilation will be performed. Macro expansion can be done in a controlled
-# way by setting EXPAND_ONLY_PREDEF to YES.
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 MACRO_EXPANSION        = YES
 
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
-# then the macro expansion is limited to the macros specified with the
-# PREDEFINED and EXPAND_AS_DEFINED tags.
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 EXPAND_ONLY_PREDEF     = NO
 
-# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
-# pointed to by INCLUDE_PATH will be searched when a #include is found.
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by
-# the preprocessor.
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
 INCLUDE_PATH           =
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will
-# be used.
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 INCLUDE_FILE_PATTERNS  =
 
-# The PREDEFINED tag can be used to specify one or more macro names that
-# are defined before the preprocessor is started (similar to the -D option of
-# gcc). The argument of the tag is a list of macros of the form: name
-# or name=definition (no spaces). If the definition and the = are
-# omitted =1 is assumed. To prevent a macro definition from being
-# undefined via #undef or recursively expanded use the := operator
-# instead of the = operator.
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 PREDEFINED             = DOXYGEN \
                          Vc_INTRINSIC=inline \
@@ -1635,13 +1976,15 @@
                          Vc_CONST \
                          Vc_CONST_L \
                          Vc_CONST_R \
-                         _VC_CONSTEXPR=constexpr
+                         Vc_VERSIONED_NAMESPACE=Vc \
+                         Vc_DEPRECATED(x)=
 
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
-# this tag can be used to specify a list of macro names that should be expanded.
-# The macro definition that is found in the sources will be used.
-# Use the PREDEFINED tag if you want to use a different macro definition that
-# overrules the definition found in the source code.
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 EXPAND_AS_DEFINED      = VECTOR_TYPE \
                          INDEX_TYPE \
@@ -1651,57 +1994,65 @@
                          EXPONENT_TYPE \
                          VECTOR_TYPE_HAS_SHIFTS
 
-# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
-# doxygen's preprocessor will remove all references to function-like macros
-# that are alone on a line, have an all uppercase name, and do not end with a
-# semicolon, because these will confuse the parser if not removed.
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 SKIP_FUNCTION_MACROS   = YES
 
 #---------------------------------------------------------------------------
-# Configuration::additions related to external references
+# Configuration options related to external references
 #---------------------------------------------------------------------------
 
-# The TAGFILES option can be used to specify one or more tagfiles. For each
-# tag file the location of the external documentation should be added. The
-# format of a tag file without this location is as follows:
-#
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
 # TAGFILES = file1 file2 ...
 # Adding location for the tag files is done as follows:
-#
 # TAGFILES = file1=loc1 "file2 = loc2" ...
-# where "loc1" and "loc2" can be relative or absolute paths
-# or URLs. Note that each tag file must have a unique name (where the name does
-# NOT include the path). If a tag file is not located in the directory in which
-# doxygen is run, you must also specify the path to the tagfile here.
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
 
 TAGFILES               =
 
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create
-# a tag file that is based on the input files it reads.
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
 
 GENERATE_TAGFILE       =
 
-# If the ALLEXTERNALS tag is set to YES all external classes will be listed
-# in the class index. If set to NO only the inherited external classes
-# will be listed.
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
 
 ALLEXTERNALS           = NO
 
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will
-# be listed.
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
 
 EXTERNAL_GROUPS        = YES
 
-# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed
-# in the related pages index. If set to NO, only the current project's
-# pages will be listed.
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
 
 EXTERNAL_PAGES         = YES
 
 # The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of `which perl').
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
 
 PERL_PATH              = /usr/bin/perl
 
@@ -1709,222 +2060,312 @@
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
-# or super classes. Setting the tag to NO turns the diagrams off. Note that
-# this option also works with HAVE_DOT disabled, but it is recommended to
-# install and use dot, since it yields more powerful graphs.
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
 
 CLASS_DIAGRAMS         = NO
 
 # You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see
-# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
 # documentation. The MSCGEN_PATH tag allows you to specify the directory where
 # the mscgen tool resides. If left empty the tool is assumed to be found in the
 # default search path.
 
 MSCGEN_PATH            =
 
-# If set to YES, the inheritance and collaboration graphs will hide
-# inheritance and usage relations if the target is undocumented
-# or is not a class.
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
 
 HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz, a graph visualization
-# toolkit from AT&T and Lucent Bell Labs. The other options in this section
-# have no effect if this option is set to NO (the default)
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
 
 HAVE_DOT               = NO
 
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
-# allowed to run in parallel. When set to 0 (the default) doxygen will
-# base this on the number of processors available in the system. You can set it
-# explicitly to a value larger than 0 to get control over the balance
-# between CPU load and processing speed.
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_NUM_THREADS        = 0
 
-# By default doxygen will use the Helvetica font for all dot files that
-# doxygen generates. When you want a differently looking font you can specify
-# the font name using DOT_FONTNAME. You need to make sure dot is able to find
-# the font, which can be done by putting it in a standard location or by setting
-# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
-# directory containing the font.
-
-DOT_FONTNAME           =
-
-# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
-# The default size is 10pt.
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTSIZE           = 10
 
-# By default doxygen will tell dot to use the Helvetica font.
-# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
-# set the path where dot can find it.
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTPATH           =
 
-# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect inheritance relations. Setting this tag to YES will force the
-# CLASS_DIAGRAMS tag to NO.
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 CLASS_GRAPH            = YES
 
-# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect implementation dependencies (inheritance, containment, and
-# class references variables) of the class with other documented classes.
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 COLLABORATION_GRAPH    = YES
 
-# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for groups, showing the direct groups dependencies
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 GROUP_GRAPHS           = YES
 
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 UML_LOOK               = NO
 
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside
-# the class node. If there are many fields or methods and many nodes the
-# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
-# threshold limits the number of items for each type to make the size more
-# manageable. Set this to 0 for no limit. Note that the threshold may be
-# exceeded by 50% before the limit is enforced.
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
-# If set to YES, the inheritance and collaboration graphs will show the
-# relations between templates and their instances.
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 TEMPLATE_RELATIONS     = NO
 
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
-# tags are set to YES then doxygen will generate a graph for each documented
-# file showing the direct and indirect include dependencies of the file with
-# other documented files.
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 INCLUDE_GRAPH          = YES
 
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
-# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
-# documented header file showing the documented files that directly or
-# indirectly include this file.
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 INCLUDED_BY_GRAPH      = YES
 
-# If the CALL_GRAPH and HAVE_DOT options are set to YES then
-# doxygen will generate a call dependency graph for every global function
-# or class method. Note that enabling this option will significantly increase
-# the time of a run. So in most cases it will be better to enable call graphs
-# for selected functions only using the \callgraph command.
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 CALL_GRAPH             = NO
 
-# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
-# doxygen will generate a caller dependency graph for every global function
-# or class method. Note that enabling this option will significantly increase
-# the time of a run. So in most cases it will be better to enable caller
-# graphs for selected functions only using the \callergraph command.
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 CALLER_GRAPH           = NO
 
-# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
-# will generate a graphical hierarchy of all classes instead of a textual one.
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 GRAPHICAL_HIERARCHY    = YES
 
-# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
-# then doxygen will show the dependencies a directory has on other directories
-# in a graphical way. The dependency relations are determined by the #include
-# relations between the files in the directories.
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. Possible values are svg, png, jpg, or gif.
-# If left blank png will be used. If you choose svg you need to set
-# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
-# visible in IE 9+ (other browsers do not have this requirement).
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_IMAGE_FORMAT       = png
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.
-# Note that this requires a modern browser other than Internet Explorer.
-# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
-# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
-# visible. Older versions of IE do not have SVG support.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 INTERACTIVE_SVG        = NO
 
-# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
 # found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_PATH               =
 
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the
-# \dotfile command).
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOTFILE_DIRS           =
 
 # The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the
-# \mscfile command).
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
 
 MSCFILE_DIRS           =
 
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
-# nodes that will be shown in the graph. If the number of nodes in a graph
-# becomes larger than this value, doxygen will truncate the graph, which is
-# visualized by representing a node as a red box. Note that doxygen if the
-# number of direct children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
-# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_GRAPH_MAX_NODES    = 50
 
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
-# graphs generated by dot. A depth value of 3 means that only nodes reachable
-# from the root by following a path via at most 3 edges will be shown. Nodes
-# that lay further from the root node will be omitted. Note that setting this
-# option to 1 or 2 may greatly reduce the computation time needed for large
-# code bases. Also note that the size of a graph can be further restricted by
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
-MAX_DOT_GRAPH_DEPTH    = 1000
+MAX_DOT_GRAPH_DEPTH    = 0
 
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not
-# seem to support this out of the box. Warning: Depending on the platform used,
-# enabling this option may lead to badly anti-aliased labels on the edges of
-# a graph (i.e. they become hard to read).
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_TRANSPARENT        = YES
 
-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10)
-# support this, this feature is disabled by default.
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_MULTI_TARGETS      = NO
 
-# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
-# generate a legend page explaining the meaning of the various boxes and
-# arrows in the dot generated graphs.
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
-# remove the intermediate dot files that are used to generate
-# the various graphs.
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES
diff -Nru vc-0.7.4/doc/DoxygenLayout.xml vc-1.3.0/doc/DoxygenLayout.xml
--- vc-0.7.4/doc/DoxygenLayout.xml	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/DoxygenLayout.xml	2016-10-27 02:05:02.000000000 -0500
@@ -1,13 +1,29 @@
 <doxygenlayout version="1.0">
+  <!-- Generated by doxygen 1.8.10 -->
   <!-- Navigation index tabs for HTML output -->
   <navindex>
-    <tab type="mainpage" visible="yes" title=""/>
-    <tab type="examples" visible="yes" title="" intro=""/>
-    <tab type="pages" visible="yes" title="" intro=""/>
-    <tab type="modules" visible="yes" title="Parts of Vc" intro=""/>
-    <tab type="namespacemembers" visible="yes" title="" intro=""/>
-    <tab type="classlist" visible="yes" title="" intro=""/>
-    <tab type="classindex" visible="yes" title=""/>
+    <tab type="usergroup" title="Overview Documents" url="[none]">
+      <tab type="mainpage" visible="no" title="Vc"/>
+    </tab>
+    <tab type="modules" visible="yes" title="API Reference" intro=""/>
+    <tab type="usergroup" title="Indexes" url="[none]">
+      <tab type="pages" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+      <tab type="namespaces" visible="no" title="">
+        <tab type="namespacelist" visible="no" title="" intro=""/>
+      </tab>
+      <tab type="classes" visible="yes" title="">
+        <tab type="classlist" visible="yes" title="" intro=""/>
+        <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
+        <tab type="hierarchy" visible="yes" title="" intro=""/>
+        <tab type="classmembers" visible="yes" title="" intro=""/>
+      </tab>
+      <tab type="files" visible="yes" title="">
+        <tab type="filelist" visible="yes" title="" intro=""/>
+        <tab type="globals" visible="yes" title="" intro=""/>
+      </tab>
+      <tab type="examples" visible="yes" title="" intro=""/>
+    </tab>
   </navindex>
 
   <!-- Layout definition for a class page -->
@@ -17,10 +33,11 @@
     <includes visible="$SHOW_INCLUDE_FILES"/>
     <inheritancegraph visible="$CLASS_GRAPH"/>
     <collaborationgraph visible="$COLLABORATION_GRAPH"/>
-    <allmemberslink visible="yes"/>
     <memberdecl>
       <nestedclasses visible="yes" title=""/>
       <publictypes title=""/>
+      <services title=""/>
+      <interfaces title=""/>
       <publicslots title=""/>
       <signals title=""/>
       <publicmethods title=""/>
@@ -54,6 +71,8 @@
       <inlineclasses title=""/>
       <typedefs title=""/>
       <enums title=""/>
+      <services title=""/>
+      <interfaces title=""/>
       <constructors title=""/>
       <functions title=""/>
       <related title=""/>
@@ -61,6 +80,7 @@
       <properties title=""/>
       <events title=""/>
     </memberdef>
+    <allmemberslink visible="yes"/>
     <usedfiles visible="$SHOW_USED_FILES"/>
     <authorsection visible="yes"/>
   </class>
@@ -71,6 +91,7 @@
     <detaileddescription title=""/>
     <memberdecl>
       <nestednamespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
       <classes visible="yes" title=""/>
       <typedefs title=""/>
       <enums title=""/>
@@ -98,6 +119,7 @@
     <memberdecl>
       <classes visible="yes" title=""/>
       <namespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
       <defines title=""/>
       <typedefs title=""/>
       <enums title=""/>
diff -Nru vc-0.7.4/doc/DoxyInternal vc-1.3.0/doc/DoxyInternal
--- vc-0.7.4/doc/DoxyInternal	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/doc/DoxyInternal	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,1927 @@
+# Doxyfile 1.8.4
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed
+# in front of the TAG it is preceding .
+# All text after a hash (#) is considered a comment and will be ignored.
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
+
+PROJECT_NAME           = "Vc"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER         = 0.99.71-dev
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "SIMD Vector Classes for C++"
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO           = logo_small.png
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = ./
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,
+# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,
+# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip. Note that you specify absolute paths here, but also
+# relative paths, which will be relative from the directory where doxygen is
+# started.
+
+STRIP_FROM_PATH        = ./
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension,
+# and language is one of the parsers supported by doxygen: IDL, Java,
+# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
+# C++. For instance to make doxygen treat .inc files as Fortran files (default
+# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
+# that for custom extensions you also need to set FILE_PATTERNS otherwise the
+# files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES (the
+# default) will make doxygen replace the get and set methods by a property in
+# the documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields or simple typedef fields will be shown
+# inline in the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO (the default), structs, classes, and unions are shown on a separate
+# page (for HTML and Man pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can
+# be an expensive process and often the same symbol appear multiple times in
+# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too
+# small doxygen will become slower. If the cache is too large, memory is wasted.
+# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid
+# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536
+# symbols.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+
+EXTRACT_PACKAGE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES   = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = NO
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS       = NO
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if section-label ... \endif
+# and \cond section-label ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
+# feature you need bibtex and perl available in the search path. Do not use
+# file names with spaces, bibtex cannot handle them.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT                  = ../include/ \
+                         ./dox.h \
+                         ../common/ \
+                         ../avx/ \
+                         ../sse/ \
+                         ../scalar/ \
+                         ../mic/ \
+                         ../traits
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS          =
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH           = ../examples/
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH             = ./
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be ignored.
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis.
+# Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match.
+# The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = YES
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C, C++ and Fortran comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.
+# Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = internal
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+#  for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is advised to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If left blank doxygen will
+# generate a default style sheet. Note that it is recommended to use
+# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
+# tag will in the future become obsolete.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
+# user-defined cascading style sheet that is included after the standard
+# style sheets created by doxygen. Using this option one can overrule
+# certain style aspects. This is preferred over using HTML_STYLESHEET
+# since it does not replace the standard style sheet and is therefor more
+# robust against future updates. Doxygen will copy the style sheet file to
+# the output directory.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the style sheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 120
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 120
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = NO
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+
+HTML_DYNAMIC_SECTIONS  = YES
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
+# entries shown in the various tree structured indices initially; the user
+# can expand and collapse entries dynamically later on. Doxygen will expand
+# the tree to such a level that at most the specified number of entries are
+# visible (unless a fully collapsed tree already exceeds this amount).
+# So setting the number of entries 1 will produce a full collapsed tree by
+# default. 0 is a special value representing an infinite number of entries
+# and will result in a full expanded tree by default.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
+# identify the documentation publisher. This should be a reverse domain-name
+# style string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE               =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING     =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = YES
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = de.uni-frankfurt.compeng.vc
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = "Vc (master)"
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION           = "../qhelpgenerator-wrapper"
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+#  will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
+# at top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it. Since the tabs have the same information as the
+# navigation tree you can set this option to NO if you already set
+# GENERATE_TREEVIEW to YES.
+
+DISABLE_INDEX          = YES
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+# Since the tree basically has the same information as the tab index you
+# could consider to set DISABLE_INDEX to NO when enabling this option.
+
+GENERATE_TREEVIEW      = YES
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you may also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = YES
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
+# SVG. The default value is HTML-CSS, which is slower, but has the best
+# compatibility.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to
+# the MathJax Content Delivery Network so you can quickly see the result without
+# installing MathJax.
+# However, it is strongly recommended to install a local
+# copy of MathJax from http://www.mathjax.org before deployment.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript
+# pieces of code that will be used on startup of the MathJax code.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript.
+# There are two flavours of web server based search depending on the
+# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
+# searching and an index file used by the script. When EXTERNAL_SEARCH is
+# enabled the indexing and searching needs to be provided by external tools.
+# See the manual for details.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain
+# the search results. Doxygen ships with an example indexer (doxyindexer) and
+# search engine (doxysearch.cgi) which are based on the open source search
+# engine library Xapian. See the manual for configuration details.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will returned the search results when EXTERNAL_SEARCH is enabled.
+# Doxygen ships with an example search engine (doxysearch) which is based on
+# the open source search engine library Xapian. See the manual for configuration
+# details.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
+# of to a relative location where the documentation can be found.
+# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4 will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images
+# or other source files which should be copied to the LaTeX output directory.
+# Note that the files will be copied as-is; there are no commands or markers
+# available.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE        = plain
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load style sheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA             =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD                =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files
+# that can be used to generate PDF.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it. If left blank docbook will be used as the default path.
+
+DOCBOOK_OUTPUT         = docbook
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED             = DOXYGEN \
+                         Vc_INTRINSIC=inline \
+                         Vc_INTRINSIC_L=inline \
+                         Vc_INTRINSIC_R \
+                         Vc_ALWAYS_INLINE=inline \
+                         Vc_ALWAYS_INLINE_L=inline \
+                         Vc_ALWAYS_INLINE_R \
+                         Vc_PURE \
+                         Vc_PURE_L \
+                         Vc_PURE_R \
+                         Vc_CONST \
+                         Vc_CONST_L \
+                         Vc_CONST_R \
+                         Vc_WARN_UNUSED_RESULT \
+                         Vc_VERSIONED_NAMESPACE=Vc
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED      = VECTOR_TYPE \
+                         INDEX_TYPE \
+                         ENTRY_TYPE \
+                         MASK_TYPE \
+                         INTEGER \
+                         EXPONENT_TYPE \
+                         VECTOR_TYPE_HAS_SHIFTS
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. For each
+# tag file the location of the external documentation should be added. The
+# format of a tag file without this location is as follows:
+#
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths
+# or URLs. Note that each tag file must have a unique name (where the name does
+# NOT include the path). If a tag file is not located in the directory in which
+# doxygen is run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed
+# in the related pages index. If set to NO, only the current project's
+# pages will be listed.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = NO
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside
+# the class node. If there are many fields or methods and many nodes the
+# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
+# threshold limits the number of items for each type to make the size more
+# manageable. Set this to 0 for no limit. Note that the threshold may be
+# exceeded by 50% before the limit is enforced.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH          = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = NO
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = NO
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
+
+DOT_IMAGE_FORMAT       = svg
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG        = YES
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS           =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 1000
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP            = YES
diff -Nru vc-0.7.4/doc/examples.h vc-1.3.0/doc/examples.h
--- vc-0.7.4/doc/examples.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/examples.h	2016-10-27 02:05:02.000000000 -0500
@@ -160,7 +160,7 @@
  * {
  *   Vc::float_v x, y;
  * }
- * VC_DECLARE_ALLOCATOR(CartesianCoordinate)
+ * Vc_DECLARE_ALLOCATOR(CartesianCoordinate)
  * std::vector<CartesianCoordinate> input((1000 + Vc::float_v::Size - 1) / Vc::float_v::Size);
  * \endcode
  *
@@ -242,7 +242,8 @@
  * Finally we arrive at the conversion of the Cartesian coordinates to polar coordinates.
  * The for loop is equivalent to the one above.
  *
- * Inside the loop we first assign the x and y values to local variables.
+ * \note
+ * Inside the loop we first assign the \c x and \c y values to local variables.
  * This is not necessary; but it can help the compiler with optimization. The issue is that when you
  * access values from some memory area, the compiler cannot always be sure that the pointers to
  * memory do not alias (i.e. point to the same location). Thus, the compiler might rather take the
@@ -251,14 +252,65 @@
  * register. This is a general issue, and not a special issue with SIMD. In this case mainly serves
  * to make the following code more readable.
  *
+ * The radius (\c r) is easily calculated as the square root of the sum of squares.
+ * It is then directly assigned to the right vector in \c r_mem.
  *
+ * \subsection ex_polarcoord_complete_masking Masked Assignment
  *
+ * The \c phi value, on the other hand, is determined as a value between -pi and pi.
+ * Since we want to have a value between 0 and 360, the value has to be scaled with 180/pi.
+ * Then, all \c phi values that are less than zero must be modified.
+ * This is where SIMD code differs significantly from the scalar code you are used to:
+ * An \c if statement cannot be used directly with a SIMD mask.
+ * Thus, <tt>if (phi < 0)</tt> would be ill-formed.
+ * This is obvious once you realize that <tt>phi < 0</tt> is an object that contains multiple boolean values.
+ * Therefore, the meaning of <tt>if (phi < 0)</tt> is ambiguous.
+ * You can make your intent clear by using a reduction function for the mask, such as one of:
+ * \code
+ *   if (all_of(phi < 0))  // ...
+ *   if (any_of(phi < 0))  // ...
+ *   if (none_of(phi < 0)) // ...
+ *   if (some_of(phi < 0)) // ...
+ * \endcode
+ *
+ * In most cases a reduction is useful as a shortcut, but not as a general solution.
+ * This is where masked assignment (or write-masking) comes into play.
+ * The idea is to assign only a subset of the values in a SIMD vector and leave the remaining ones
+ * unchanged.
+ * The %Vc syntax for this uses a predicate (mask) in parenthesis before the assignment operator.
+ * Thus, <tt>x(mask) = y;</tt> requests that \c x is assigned the values from \c y where the
+ * corresponding entries in \c mask are \c true.
+ * Read it as: "where mask is true, assign y to x".
+ *
+ * Therefore, the transformation of \c phi is written as <tt>phi(phi < 0.f) += 360.f</tt>.
+ * (Note that the assignment operator can be any compound assignment, as well.)
+ *
+ * \note
+ * %Vc also supports an alternative syntax using the \ref Vc::where function, which enables generic
+ * implementations that work for fundamental arithmetic types as well as the %Vc vector types.
+ *
+ * \subsection ex_polarcoord_complete_output Console Output
+ *
+ * At the end of the program the results are printed to \c stdout:
  * \snippet polarcoord/main.cpp output
  *
+ * The loop iterates over the Vc::Memory objects using Vc::Memory::entriesCount, thus iterating over scalar
+ * values, not SIMD vectors.
+ * The code therefore should be clear, as it doesn't use any SIMD functionality.
+ *
  *********************************************************************************
  *
  * \page ex-finitediff Finite Differences
  *
+ * Finite difference method example
+ *
+ * We calculate central differences for a given function and compare it to the analytical solution.
+ *
+ * \snippet finitediff/main.cpp includes
+ * \snippet finitediff/main.cpp constants
+ * \snippet finitediff/main.cpp functions
+ * \snippet finitediff/main.cpp cleanup
+ *
  *********************************************************************************
  *
  * \page ex-matrix Matrix Class
diff -Nru vc-0.7.4/doc/qhelpgenerator-wrapper vc-1.3.0/doc/qhelpgenerator-wrapper
--- vc-0.7.4/doc/qhelpgenerator-wrapper	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/doc/qhelpgenerator-wrapper	2016-10-27 02:05:02.000000000 -0500
@@ -1,20 +1,18 @@
 #!/bin/sh
-for retry in `seq 20`; do
-  output="`qhelpgenerator "$@" 2>&1`"
-  errors="`echo "$output"|grep "Error in line .*: Opening and ending tag mismatch."`"
-  if test -z "$errors"; then
-    echo "$output"
-    exit
-  fi
-  if echo "$1"|grep -q '\.qhp'; then
-    file="$1"
-  elif echo "$2"|grep -q '\.qhp'; then
-    file="$2"
-  elif echo "$3"|grep -q '\.qhp'; then
-    file="$3"
-  fi
-  for i in `echo "$errors"|tac|sed 's/^.* \([0-9]\+\):.*$/\1/'`; do
-    sed -i "${i}d" "$file"
-  done
+output="`qhelpgenerator "$@" 2>&1`"
+errors="`echo "$output"|grep "Error in line .*: Opening and ending tag mismatch."`"
+if echo "$1"|grep -q '\.qhp'; then
+  file="$1"
+elif echo "$2"|grep -q '\.qhp'; then
+  file="$2"
+elif echo "$3"|grep -q '\.qhp'; then
+  file="$3"
+fi
+while test -n "$errors"; do
+    for i in `echo "$errors"|tac|sed 's/^.* \([0-9]\+\):.*$/\1/'`; do
+      sed -i "${i}d" "$file"
+    done
+    output="`qhelpgenerator "$@" 2>&1`"
+    errors="`echo "$output"|grep "Error in line .*: Opening and ending tag mismatch."`"
 done
-qhelpgenerator "$@"
+echo "$output"
diff -Nru vc-0.7.4/examples/buddhabrot/CMakeLists.txt vc-1.3.0/examples/buddhabrot/CMakeLists.txt
--- vc-0.7.4/examples/buddhabrot/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/buddhabrot/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -1,16 +1,15 @@
 if(QT4_FOUND AND QT4_USABLE)
    include(${QT_USE_FILE})
-   include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-   add_executable(buddhabrot_sse main.cpp)
-   add_target_property(buddhabrot_sse COMPILE_FLAGS "-DVC_IMPL=SSE")
-   target_link_libraries(buddhabrot_sse ${QT_LIBRARIES} Vc)
+   build_example(buddhabrot main.cpp LIBS ${QT_LIBRARIES})
 
-   add_executable(buddhabrot_scalar main.cpp)
-   add_target_property(buddhabrot_scalar COMPILE_FLAGS "-DVC_IMPL=Scalar")
-   target_link_libraries(buddhabrot_scalar ${QT_LIBRARIES} Vc)
-
-   add_executable(buddhabrot_scalar2 main.cpp)
-   add_target_property(buddhabrot_scalar2 COMPILE_FLAGS "-DScalar")
-   target_link_libraries(buddhabrot_scalar2 ${QT_LIBRARIES})
+   # Special -DScalar target that uses fundamental types directly
+   add_executable(example_buddhabrot_scalar2 main.cpp)
+   add_target_property(example_buddhabrot_scalar2 COMPILE_DEFINITIONS "Scalar")
+   set_property(TARGET example_buddhabrot_scalar2 APPEND PROPERTY COMPILE_OPTIONS ${Vc_ARCHITECTURE_FLAGS})
+   add_target_property(example_buddhabrot_scalar2 LABELS "Scalar")
+   add_dependencies(Scalar example_buddhabrot_scalar2)
+   add_dependencies(Examples example_buddhabrot_scalar2)
+   target_link_libraries(example_buddhabrot_scalar2 Vc ${QT_LIBRARIES})
+   vc_add_run_target(example_buddhabrot_scalar2)
 endif()
diff -Nru vc-0.7.4/examples/buddhabrot/main.cpp vc-1.3.0/examples/buddhabrot/main.cpp
--- vc-0.7.4/examples/buddhabrot/main.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/buddhabrot/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2010-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -37,13 +37,18 @@
 typedef float float_v;
 typedef int int_v;
 typedef bool int_m;
+#ifdef _MSC_VER
+#define Vc_CDECL __cdecl
+#else
+#define Vc_CDECL
+#endif
 #else
 #include <Vc/Vc>
 
 using Vc::float_v;
 using Vc::float_m;
-using Vc::int_v;
-using Vc::int_m;
+using int_v = Vc::SimdArray<int, float_v::size()>;
+using int_m = int_v::mask_type;
 #endif
 
 ProgressWriter::ProgressWriter()
@@ -117,7 +122,20 @@
     m_filename = filename;
 }
 
-typedef std::complex<float_v> Z;
+struct Z
+{
+    using value_type = float_v;
+    value_type real, imag;
+};
+
+inline Z operator*(Z a, Z b)
+{
+    return {a.real * b.real - a.imag * b.imag, a.real * b.imag + a.imag * b.real};
+}
+inline Z operator+(Z a, Z b)
+{
+    return {a.real + b.real, a.imag + b.imag};
+}
 
 static inline Z P(Z z, Z c)
 {
@@ -126,7 +144,7 @@
 
 static inline Z::value_type fastNorm(const Z &z)
 {
-    return z.real() * z.real() + z.imag() * z.imag();
+    return z.real * z.real + z.imag * z.imag;
 }
 
 template<typename T> static inline T square(T a) { return a * a; }
@@ -432,7 +450,7 @@
     // Parameters End
 
     TimeStampCounter timer;
-    timer.Start();
+    timer.start();
 
     // helper constants
     const int overallUpperBound = maxOf(upperBound[0], maxOf(upperBound[1], upperBound[2]));
@@ -448,9 +466,10 @@
     for (float real = realMin; real <= realMax; real += realStep) {
         m_progress.setValue(99.f * (real - realMin) / (realMax - realMin));
         for (float imag = imagMin; imag <= imagMax; imag += imagStep) {
-            Z c(real, imag);
-            Z c2 = Z(1.08f * real + 0.15f, imag);
-            if (fastNorm(Z(real + 1.f, imag)) < 0.06f || (std::real(c2) < 0.42f && fastNorm(c2) < 0.417f)) {
+            Z c{real, imag};
+            Z c2{1.08f * real + 0.15f, imag};
+            if (fastNorm(Z{real + 1.f, imag}) < 0.06f ||
+                (c2.real < 0.42f && fastNorm(c2) < 0.417f)) {
                 continue;
             }
             Z z = c;
@@ -461,14 +480,14 @@
             if (n <= maxIterations && n >= overallLowerBound) {
                 // point is outside of the Mandelbrot set and required enough (overallLowerBound)
                 // iterations to reach the cut-off value S
-                Z cn(real, -imag);
+                Z cn{real, -imag};
                 Z zn = cn;
                 z = c;
                 for (int i = 0; i <= overallUpperBound; ++i) {
-                    const float y2 = (std::imag(z) - m_y) * yFact;
-                    const float yn2 = (std::imag(zn) - m_y) * yFact;
+                    const float y2 = (z.imag - m_y) * yFact;
+                    const float yn2 = (zn.imag - m_y) * yFact;
                     if (y2 >= 0.f && y2 < maxY && yn2 >= 0.f && yn2 < maxY) {
-                        const float x2 = (std::real(z) - m_x) * xFact;
+                        const float x2 = (z.real - m_x) * xFact;
                         if (x2 >= 0.f && x2 < maxX) {
                             const int red   = (i >= lowerBound[0] && i <= upperBound[0]) ? 1 : 0;
                             const int green = (i >= lowerBound[1] && i <= upperBound[1]) ? 1 : 0;
@@ -488,14 +507,15 @@
     }
 #else
     const float imagStep2 = imagStep * float_v::Size;
-    const float_v imagMin2 = imagMin + imagStep * static_cast<float_v>(int_v::IndexesFromZero());
+    const float_v imagMin2 = imagMin + imagStep * float_v::IndexesFromZero();
     for (float real = realMin; real <= realMax; real += realStep) {
         m_progress.setValue(99.f * (real - realMin) / (realMax - realMin));
-        for (float_v imag = imagMin2; imag <= imagMax; imag += imagStep2) {
+        for (float_v imag = imagMin2; all_of(imag <= imagMax); imag += imagStep2) {
             // FIXME: extra "tracks" if nSteps[1] is not a multiple of float_v::Size
-            Z c(float_v(real), imag);
-            Z c2 = Z(float_v(1.08f * real + 0.15f), imag);
-            if (fastNorm(Z(float_v(real + 1.f), imag)) < 0.06f || (std::real(c2) < 0.42f && fastNorm(c2) < 0.417f)) {
+            Z c{real, imag};
+            Z c2 = Z{1.08f * real + 0.15f, imag};
+            if (all_of(fastNorm(Z{real + 1.f, imag}) < 0.06f ||
+                       (c2.real < 0.42f && fastNorm(c2) < 0.417f))) {
                 continue;
             }
             Z z = c;
@@ -510,13 +530,13 @@
             if (inside.isFull()) {
                 continue;
             }
-            Z cn(float_v(real), -imag);
+            Z cn{real, -imag};
             Z zn = cn;
             z = c;
             for (int i = 0; i <= overallUpperBound; ++i) {
-                const float_v y2 = (std::imag(z) - m_y) * yFact;
-                const float_v yn2 = (std::imag(zn) - m_y) * yFact;
-                const float_v x2 = (std::real(z) - m_x) * xFact;
+                const float_v y2 = (z.imag - m_y) * yFact;
+                const float_v yn2 = (zn.imag - m_y) * yFact;
+                const float_v x2 = (z.real - m_x) * xFact;
                 z = P(z, c);
                 zn = P(zn, cn);
                 const float_m drawMask = !inside && y2 >= 0.f && x2 >= 0.f && y2 < maxY && x2 < maxX && yn2 >= 0.f && yn2 < maxY;
@@ -525,11 +545,11 @@
                 const int green = (i >= lowerBound[1] && i <= upperBound[1]) ? 1 : 0;
                 const int blue  = (i >= lowerBound[2] && i <= upperBound[2]) ? 1 : 0;
 
-                foreach_bit(int j, drawMask) {
+                for(int j : where(drawMask)) {
                     canvas.addDot(x2[j], y2 [j], red, green, blue);
                     canvas.addDot(x2[j], yn2[j], red, green, blue);
                 }
-                if (fastNorm(z) >= S) { // optimization: skip some useless looping
+                if (all_of(fastNorm(z) >= S)) {  // optimization: skip some useless looping
                     break;
                 }
             }
@@ -538,9 +558,9 @@
 #endif
     canvas.toQImage(&m_image);
 
-    timer.Stop();
+    timer.stop();
     m_progress.done();
-    qDebug() << timer.Cycles() << "cycles";
+    qDebug() << timer.cycles() << "cycles";
 
     if (m_filename.isEmpty()) {
         m_filename = QString("r%1-%2_g%3-%4_b%5-%6_s%7-%8_i%9-%10_%11x%12.png")
@@ -576,7 +596,7 @@
         ;
 }
 
-int main(int argc, char **argv)
+int Vc_CDECL main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
     const QStringList &args = QCoreApplication::arguments();
diff -Nru vc-0.7.4/examples/CMakeLists.txt vc-1.3.0/examples/CMakeLists.txt
--- vc-0.7.4/examples/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -9,43 +9,95 @@
 set(CMAKE_REQUIRED_INCLUDES "${SAFE_CMAKE_REQUIRED_INCLUDES}")
 set(CMAKE_REQUIRED_LIBRARIES "${SAFE_CMAKE_REQUIRED_LIBRARIES}")
 
-macro(build_example name)
+add_custom_target(Examples COMMENT "build all examples" VERBATIM)
+
+AddCompilerFlag(-ftemplate-depth=1024 CXX_FLAGS CMAKE_CXX_FLAGS MIC_CXX_FLAGS CMAKE_MIC_CXX_FLAGS)
+
+macro(vc_add_run_target _target)
+   if("${_target}" MATCHES "_mic$")
+      if(MIC_NATIVELOAD)
+         get_target_property(_exe "${_target}" OUTPUT_NAME)
+         add_custom_target(run_${_target}
+            ${MIC_NATIVELOAD} "${_exe}"
+            DEPENDS ${_target}
+            COMMENT "Execute ${_target} example"
+            VERBATIM
+            )
+      endif()
+   else()
+      add_custom_target(run_${_target}
+         ${_target}
+         DEPENDS ${_target}
+         COMMENT "Execute ${_target} example"
+         VERBATIM
+         )
+   endif()
+endmacro()
+
+macro(_build_one_example_target _name _impl)
+   set(_target "example_${_name}_${_impl}")
+   string(TOLOWER "${_target}" _target)
+   list(FIND _disabled_impl "${_impl}" _index1)
+   list(FIND disabled_targets "${_target}" _index2)
+   if(_index1 EQUAL -1 AND USE_${_impl} AND _index2 EQUAL -1)
+      add_executable(${_target} ${ARGN})
+      add_target_property(${_target} COMPILE_DEFINITIONS "Vc_IMPL=${_impl}")
+      set_property(TARGET ${_target} APPEND PROPERTY COMPILE_OPTIONS ${Vc_ARCHITECTURE_FLAGS})
+      add_target_property(${_target} LABELS "${_impl}")
+      add_dependencies(${_impl} ${_target})
+      add_dependencies(Examples ${_target})
+      target_link_libraries(${_target} Vc ${_LIBS})
+      vc_add_run_target(${_target})
+   endif()
+endmacro()
+
+function(build_example name)
    set(_SRCS)
    set(_LIBS)
+   set(_disabled_impl)
    set(_state 1)
+   set(USE_Scalar TRUE)
+   set(USE_SSE ${USE_SSE2})
    foreach(ARG ${ARGN})
       if(ARG STREQUAL "LIBS")
          set(_state 2)
+      elseif(ARG STREQUAL "DISABLE")
+         set(_state 3)
       elseif(_state EQUAL 1)
          set(_SRCS ${_SRCS} ${ARG})
       elseif(_state EQUAL 2)
          set(_LIBS ${_LIBS} ${ARG})
+      elseif(_state EQUAL 3)
+         list(APPEND _disabled_impl ${ARG})
       endif()
    endforeach()
    add_executable("example_${name}_default" ${_SRCS})
+   set_property(TARGET "example_${name}_default" APPEND PROPERTY COMPILE_OPTIONS ${Vc_ARCHITECTURE_FLAGS})
    target_link_libraries("example_${name}_default" Vc ${_LIBS})
+   add_dependencies(Examples "example_${name}_default")
 
-   add_executable("example_${name}_scalar" ${_SRCS})
-   add_target_property("example_${name}_scalar" COMPILE_FLAGS "-DVC_IMPL=Scalar")
-   add_target_property("example_${name}_scalar" LABELS "Scalar")
-   add_dependencies(Scalar "example_${name}_scalar")
-   target_link_libraries("example_${name}_scalar" Vc ${_LIBS})
-
-   if(USE_SSE2)
-      add_executable("example_${name}_sse" ${_SRCS})
-      add_target_property("example_${name}_sse" COMPILE_FLAGS "-DVC_IMPL=SSE")
-      add_target_property("example_${name}_sse" LABELS "SSE")
-      add_dependencies(SSE "example_${name}_sse")
-      target_link_libraries("example_${name}_sse" Vc ${_LIBS})
+   _build_one_example_target("${name}" Scalar ${_SRCS})
+   _build_one_example_target("${name}" SSE ${_SRCS})
+   _build_one_example_target("${name}" AVX ${_SRCS})
+   _build_one_example_target("${name}" AVX2 ${_SRCS})
+
+   set(_target "example_${name}_mic")
+   list(FIND _disabled_impl "MIC" _index1)
+   list(FIND disabled_targets "${_target}" _index2)
+   if(MIC_NATIVE_FOUND AND "${_LIBS}" STREQUAL "" AND _index1 EQUAL -1 AND _index2 EQUAL -1)
+      mic_add_executable(${_target}
+         SOURCES ${_SRCS}
+         LINK_LIBRARIES Vc_MIC
+         )
+      add_target_property(${_target} LABELS "MIC")
+      add_dependencies(MIC ${_target})
+      vc_add_run_target(${_target})
    endif()
 
-   if(USE_AVX)
-      add_executable("example_${name}_avx" ${_SRCS})
-      add_target_property("example_${name}_avx" COMPILE_FLAGS "-DVC_IMPL=AVX")
-      add_target_property("example_${name}_avx" LABELS "AVX")
-      add_dependencies(AVX "example_${name}_avx")
-      target_link_libraries("example_${name}_avx" Vc ${_LIBS})
-
+   if(USE_AVX2)
+      add_target_property("example_${name}_default" LABELS "AVX2")
+      add_dependencies(AVX2 "example_${name}_default")
+   elseif(USE_AVX)
       add_target_property("example_${name}_default" LABELS "AVX")
       add_dependencies(AVX "example_${name}_default")
    elseif(USE_SSE2)
@@ -55,7 +107,8 @@
       add_target_property("example_${name}_default" LABELS "Scalar")
       add_dependencies(Scalar "example_${name}_default")
    endif()
-endmacro(build_example)
+   vc_add_run_target("example_${name}_default")
+endfunction(build_example)
 
 macro(my_add_subdirectory _name)
    list(FIND disabled_targets "example_${_name}" _disabled)
@@ -68,4 +121,10 @@
 my_add_subdirectory(matrix)
 my_add_subdirectory(mandelbrot)
 my_add_subdirectory(buddhabrot)
+my_add_subdirectory(cpuid)
 my_add_subdirectory(finitediff)
+my_add_subdirectory(scaling)
+my_add_subdirectory(test_inside)
+my_add_subdirectory(linear_find)
+my_add_subdirectory(spline)
+my_add_subdirectory(simdize)
diff -Nru vc-0.7.4/examples/cpuid/CMakeLists.txt vc-1.3.0/examples/cpuid/CMakeLists.txt
--- vc-0.7.4/examples/cpuid/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/cpuid/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,2 @@
+add_executable(cpuid main.cpp)
+target_link_libraries(cpuid Vc)
diff -Nru vc-0.7.4/examples/cpuid/main.cpp vc-1.3.0/examples/cpuid/main.cpp
--- vc-0.7.4/examples/cpuid/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/cpuid/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,115 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <Vc/cpuid.h>
+#include <iostream>
+
+int Vc_CDECL main()
+{
+    using Vc::CpuId;
+    std::cout << "        cacheLineSize: " << CpuId::cacheLineSize() << '\n';
+    std::cout << "        processorType: " << CpuId::processorType() << '\n';
+    std::cout << "      processorFamily: " << CpuId::processorFamily() << '\n';
+    std::cout << "       processorModel: " << CpuId::processorModel() << '\n';
+    std::cout << "    logicalProcessors: " << CpuId::logicalProcessors() << '\n';
+    std::cout << "                isAmd: " << CpuId::isAmd   () << '\n';
+    std::cout << "              isIntel: " << CpuId::isIntel () << '\n';
+    std::cout << "              hasSse3: " << CpuId::hasSse3 () << '\n';
+    std::cout << "         hasPclmulqdq: " << CpuId::hasPclmulqdq() << '\n';
+    std::cout << "           hasMonitor: " << CpuId::hasMonitor() << '\n';
+    std::cout << "               hasVmx: " << CpuId::hasVmx  () << '\n';
+    std::cout << "               hasSmx: " << CpuId::hasSmx  () << '\n';
+    std::cout << "              hasEist: " << CpuId::hasEist () << '\n';
+    std::cout << "               hasTm2: " << CpuId::hasTm2  () << '\n';
+    std::cout << "             hasSsse3: " << CpuId::hasSsse3() << '\n';
+    std::cout << "               hasFma: " << CpuId::hasFma  () << '\n';
+    std::cout << "        hasCmpXchg16b: " << CpuId::hasCmpXchg16b() << '\n';
+    std::cout << "              hasPdcm: " << CpuId::hasPdcm () << '\n';
+    std::cout << "               hasDca: " << CpuId::hasDca()   << '\n';
+    std::cout << "             hasSse41: " << CpuId::hasSse41() << '\n';
+    std::cout << "             hasSse42: " << CpuId::hasSse42() << '\n';
+    std::cout << "             hasMovbe: " << CpuId::hasMovbe() << '\n';
+    std::cout << "            hasPopcnt: " << CpuId::hasPopcnt()<< '\n';
+    std::cout << "               hasAes: " << CpuId::hasAes  () << '\n';
+    std::cout << "           hasOsxsave: " << CpuId::hasOsxsave() << '\n';
+    std::cout << "               hasAvx: " << CpuId::hasAvx  () << '\n';
+    std::cout << "              hasBmi1: " << CpuId::hasBmi1 () << '\n';
+    std::cout << "               hasHle: " << CpuId::hasHle  () << '\n';
+    std::cout << "              hasAvx2: " << CpuId::hasAvx2 () << '\n';
+    std::cout << "              hasBmi2: " << CpuId::hasBmi2 () << '\n';
+    std::cout << "               hasRtm: " << CpuId::hasRtm  () << '\n';
+    std::cout << "           hasAvx512f: " << CpuId::hasAvx512f   () << '\n';
+    std::cout << "          hasAvx512dq: " << CpuId::hasAvx512dq  () << '\n';
+    std::cout << "        hasAvx512ifma: " << CpuId::hasAvx512ifma() << '\n';
+    std::cout << "          hasAvx512pf: " << CpuId::hasAvx512pf  () << '\n';
+    std::cout << "          hasAvx512er: " << CpuId::hasAvx512er  () << '\n';
+    std::cout << "          hasAvx512cd: " << CpuId::hasAvx512cd  () << '\n';
+    std::cout << "          hasAvx512bw: " << CpuId::hasAvx512bw  () << '\n';
+    std::cout << "          hasAvx512vl: " << CpuId::hasAvx512vl  () << '\n';
+    std::cout << "        hasAvx512vbmi: " << CpuId::hasAvx512vbmi() << '\n';
+    std::cout << "              hasF16c: " << CpuId::hasF16c () << '\n';
+    std::cout << "            hasRdrand: " << CpuId::hasRdrand()<< '\n';
+    std::cout << "               hasFpu: " << CpuId::hasFpu  () << '\n';
+    std::cout << "               hasVme: " << CpuId::hasVme  () << '\n';
+    std::cout << "                hasDe: " << CpuId::hasDe   () << '\n';
+    std::cout << "               hasPse: " << CpuId::hasPse  () << '\n';
+    std::cout << "               hasTsc: " << CpuId::hasTsc  () << '\n';
+    std::cout << "               hasMsr: " << CpuId::hasMsr  () << '\n';
+    std::cout << "               hasPae: " << CpuId::hasPae  () << '\n';
+    std::cout << "               hasCx8: " << CpuId::hasCx8  () << '\n';
+    std::cout << "              hasMtrr: " << CpuId::hasMtrr () << '\n';
+    std::cout << "              hasCmov: " << CpuId::hasCmov () << '\n';
+    std::cout << "             hasClfsh: " << CpuId::hasClfsh() << '\n';
+    std::cout << "              hasAcpi: " << CpuId::hasAcpi () << '\n';
+    std::cout << "               hasMmx: " << CpuId::hasMmx  () << '\n';
+    std::cout << "               hasSse: " << CpuId::hasSse  () << '\n';
+    std::cout << "              hasSse2: " << CpuId::hasSse2 () << '\n';
+    std::cout << "               hasHtt: " << CpuId::hasHtt  () << '\n';
+    std::cout << "             hasSse4a: " << CpuId::hasSse4a() << '\n';
+    std::cout << "       hasMisAlignSse: " << CpuId::hasMisAlignSse() << '\n';
+    std::cout << "       hasAmdPrefetch: " << CpuId::hasAmdPrefetch() << '\n';
+    std::cout << "               hasXop: " << CpuId::hasXop ()        << '\n';
+    std::cout << "              hasFma4: " << CpuId::hasFma4 ()       << '\n';
+    std::cout << "            hasRdtscp: " << CpuId::hasRdtscp()      << '\n';
+    std::cout << "             has3DNow: " << CpuId::has3DNow()       << '\n';
+    std::cout << "          has3DNowExt: " << CpuId::has3DNowExt()    << '\n';
+    std::cout << "        L1Instruction: " << CpuId::L1Instruction() << '\n';
+    std::cout << "               L1Data: " << CpuId::L1Data() << '\n';
+    std::cout << "               L2Data: " << CpuId::L2Data() << '\n';
+    std::cout << "               L3Data: " << CpuId::L3Data() << '\n';
+    std::cout << "L1InstructionLineSize: " << CpuId::L1InstructionLineSize() << '\n';
+    std::cout << "       L1DataLineSize: " << CpuId::L1DataLineSize() << '\n';
+    std::cout << "       L2DataLineSize: " << CpuId::L2DataLineSize() << '\n';
+    std::cout << "       L3DataLineSize: " << CpuId::L3DataLineSize() << '\n';
+    std::cout << "      L1Associativity: " << CpuId::L1Associativity() << '\n';
+    std::cout << "      L2Associativity: " << CpuId::L2Associativity() << '\n';
+    std::cout << "      L3Associativity: " << CpuId::L3Associativity() << '\n';
+    std::cout << "             prefetch: " << CpuId::prefetch() << '\n';
+    return 0;
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/examples/finitediff/CMakeLists.txt vc-1.3.0/examples/finitediff/CMakeLists.txt
--- vc-0.7.4/examples/finitediff/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/finitediff/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -1 +1 @@
-build_example(finitediff main.cpp)
+build_example(finitediff main.cpp DISABLE Scalar)
diff -Nru vc-0.7.4/examples/finitediff/main.cpp vc-1.3.0/examples/finitediff/main.cpp
--- vc-0.7.4/examples/finitediff/main.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/finitediff/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,6 +1,6 @@
 /*
     Copyright (C) 2010 Jochen Gerhard <gerhard@compeng.uni-frankfurt.de>
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2010-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -30,6 +30,7 @@
 
 */
 
+//! [includes]
 #include <Vc/Vc>
 #include <iostream>
 #include <iomanip>
@@ -37,18 +38,21 @@
 #include "../tsc.h"
 #include <common/macros.h>
 
+using Vc::float_v;
+//! [includes]
+
 #define USE_SCALAR_SINCOS
 
-enum {
-  N = 10240000,
-  PrintStep = 1000000
-};
-
-static const float epsilon = 1e-7f;
-static const float lower = 0.f;
-static const float upper = 40000.f;
-static const float h = (upper - lower) / N;
+//! [constants]
+static constexpr std::size_t N = 10240000, PrintStep = 1000000;
+
+static constexpr float epsilon = 1e-7f;
+static constexpr float lower = 0.f;
+static constexpr float upper = 40000.f;
+static constexpr float h = (upper - lower) / N;
+//! [constants]
 
+//! [functions]
 // dfu is the derivative of fu. This is really easy for sine and cosine:
 static inline float  fu(float x) { return ( std::sin(x) ); }
 static inline float dfu(float x) { return ( std::cos(x) ); }
@@ -56,7 +60,7 @@
 static inline Vc::float_v fu(Vc::float_v::AsArg x) {
 #ifdef USE_SCALAR_SINCOS
   Vc::float_v r;
-  for (int i = 0; i < Vc::float_v::Size; ++i) {
+  for (size_t i = 0; i < Vc::float_v::Size; ++i) {
     r[i] = std::sin(x[i]);
   }
   return r;
@@ -68,7 +72,7 @@
 static inline Vc::float_v dfu(Vc::float_v::AsArg x) {
 #ifdef USE_SCALAR_SINCOS
   Vc::float_v r;
-  for (int i = 0; i < Vc::float_v::Size; ++i) {
+  for (size_t i = 0; i < Vc::float_v::Size; ++i) {
     r[i] = std::cos(x[i]);
   }
   return r;
@@ -76,15 +80,14 @@
   return Vc::cos(x);
 #endif
 }
-
-using Vc::float_v;
+//! [functions]
 
 // It is important for this example that the following variables (especially dy_points) are global
 // variables. Else the compiler can optimze all calculations of dy away except for the few places
 // where the value is used in printResults.
 Vc::Memory<float_v, N> x_points;
 Vc::Memory<float_v, N> y_points;
-float *VC_RESTRICT dy_points;
+float *Vc_RESTRICT dy_points;
 
 void printResults()
 {
@@ -94,7 +97,7 @@
         << std::setw(15) << "FD fu'(x_i)"
         << std::setw(15) << "SYM fu'(x)"
         << std::setw(15) << "error %\n";
-    for (int i = 0; i < N; i += PrintStep) {
+    for (std::size_t i = 0; i < N; i += PrintStep) {
         std::cout
             << std::setw(15) << y_points[i]
             << std::setw(15) << dy_points[i]
@@ -110,10 +113,10 @@
         << std::endl;
 }
 
-int main()
+int Vc_CDECL main()
 {
     {
-      float_v x_i(float_v::IndexType::IndexesFromZero());
+      float_v x_i(Vc::IndexesFromZero);
       for ( unsigned int i = 0; i < x_points.vectorsCount(); ++i, x_i += float_v::Size ) {
         const float_v x = x_i * h;
         x_points.vector(i) = x;
@@ -133,7 +136,7 @@
         dy_points[0] = (y_points[1] - y_points[0]) / h;
         // GCC auto-vectorizes the following loop. It is interesting to see that both Vc::Scalar and
         // Vc::SSE are faster, though.
-        for ( int i = 1; i < N - 1; ++i) {
+        for (std::size_t i = 1; i < N - 1; ++i) {
             dy_points[i] = (y_points[i + 1] - y_points[i - 1]) * oneOver2h;
         }
         dy_points[N - 1] = (y_points[N - 1] - y_points[N - 2]) / h;
@@ -141,7 +144,7 @@
 
     {
         std::cout << "\n" << std::setw(60) << "Classical finite difference method" << std::endl;
-        timer.Start();
+        timer.start();
 
         const float oneOver2h = 0.5f / h;
 
@@ -149,23 +152,23 @@
         dy_points[0] = (y_points[1] - y_points[0]) / h;
         // GCC auto-vectorizes the following loop. It is interesting to see that both Vc::Scalar and
         // Vc::SSE are faster, though.
-        for ( int i = 1; i < N - 1; ++i) {
+        for (std::size_t i = 1; i < N - 1; ++i) {
             dy_points[i] = (y_points[i + 1] - y_points[i - 1]) * oneOver2h;
         }
         dy_points[N - 1] = (y_points[N - 1] - y_points[N - 2]) / h;
 
-        timer.Stop();
+        timer.stop();
         printResults();
-        std::cout << "cycle count: " << timer.Cycles()
-            << " | " << static_cast<double>(N * 2) / timer.Cycles() << " FLOP/cycle"
-            << " | " << static_cast<double>(N * 2 * sizeof(float)) / timer.Cycles() << " Byte/cycle"
+        std::cout << "cycle count: " << timer.cycles()
+            << " | " << static_cast<double>(N * 2) / timer.cycles() << " FLOP/cycle"
+            << " | " << static_cast<double>(N * 2 * sizeof(float)) / timer.cycles() << " Byte/cycle"
             << "\n";
     }
 
-    speedup = timer.Cycles();
+    speedup = timer.cycles();
     {
         std::cout << std::setw(60) << "Vectorized finite difference method" << std::endl;
-        timer.Start();
+        timer.start();
 
         // All the differentials require to calculate (r - l) / 2h, where we calculate 1/2h as a
         // constant before the loop to avoid unnecessary calculations. Note that a good compiler can
@@ -189,31 +192,52 @@
         // prefetching on architectures where four vectors fill one cache line. (Note that this
         // unrolling breaks auto-vectorization of the Vc::Scalar implementation when compiling with
         // GCC.)
-        for (unsigned int i = 0; i < (y_points.entriesCount() - 2) / float_v::Size; i += 4) {
-            // Prefetches make sure the data which is going to be used in 24/4 iterations is already
-            // in the L1 cache. The prefetchForOneRead additionally instructs the CPU to not evict
-            // these cache lines to L2/L3.
-            Vc::prefetchForOneRead(&y_points[(i + 24) * float_v::Size]);
 
+        // Use streaming stores to reduce the required memory bandwidth. Without streaming
+        // stores the CPU would first have to load the cache line, where the store occurs, from
+        // memory into L1, then overwrite the data, and finally write it back to memory. But
+        // since we never actually need the data that the CPU fetched from memory we'd like to
+        // keep that bandwidth free for real work. Streaming stores allow us to issue stores
+        // which the CPU gathers in store buffers to form full cache lines, which then get
+        // written back to memory directly without the costly read. Thus we make better use of
+        // the available memory bandwidth.
+        auto dy = Vc::makeIterator<float_v>(&dy_points[1], Vc::Streaming);
+
+        // Prefetches make sure the data which is going to be used in the next iterations is already
+        // in the L1 cache. The Vc::Prefetch<>() flag provides some sensible default for loops where no
+        // elements are skipped. You can use Vc::Prefetch<L1, L2, Shared/Exclusive>() instead to set the stride of
+        // L1 and L2 prefetches manually.
+        auto y = y_points.begin(Vc::Prefetch<>());
+        float_v y0 = *y++;
+        const auto y_it_last = y_points.end();
+#ifdef Vc_ICC
+#pragma noprefetch
+#endif
+        for (; y < y_it_last; y += 4 , dy += 4) {
             // calculate float_v::Size differentials per (left - right) / 2h
-            const float_v dy0 = (y_points.vector(i + 0, 2) - y_points.vector(i + 0)) * oneOver2h;
-            const float_v dy1 = (y_points.vector(i + 1, 2) - y_points.vector(i + 1)) * oneOver2h;
-            const float_v dy2 = (y_points.vector(i + 2, 2) - y_points.vector(i + 2)) * oneOver2h;
-            const float_v dy3 = (y_points.vector(i + 3, 2) - y_points.vector(i + 3)) * oneOver2h;
-
-            // Use streaming stores to reduce the required memory bandwidth. Without streaming
-            // stores the CPU would first have to load the cache line, where the store occurs, from
-            // memory into L1, then overwrite the data, and finally write it back to memory. But
-            // since we never actually need the data that the CPU fetched from memory we'd like to
-            // keep that bandwidth free for real work. Streaming stores allow us to issue stores
-            // which the CPU gathers in store buffers to form full cache lines, which then get
-            // written back to memory directly without the costly read. Thus we make better use of
-            // the available memory bandwidth.
-            dy0.store(&dy_points[(i + 0) * float_v::Size + 1], Vc::Streaming);
-            dy1.store(&dy_points[(i + 1) * float_v::Size + 1], Vc::Streaming);
-            dy2.store(&dy_points[(i + 2) * float_v::Size + 1], Vc::Streaming);
-            dy3.store(&dy_points[(i + 3) * float_v::Size + 1], Vc::Streaming);
+            float_v y1 = y[0];
+            float_v y2 = y[1];
+            float_v y3 = y[2];
+            static_assert(float_v::Size >= 2, "This code requires a SIMD vector with at least two entries.");
+            dy[0] = (y0.shifted(2, y1) - y0) * oneOver2h;
+            y0 = y[3];
+            dy[1] = (y1.shifted(2, y2) - y1) * oneOver2h;
+            dy[2] = (y2.shifted(2, y3) - y2) * oneOver2h;
+            dy[3] = (y3.shifted(2, y0) - y3) * oneOver2h;
         }
+        /* Alternative:
+         * use the STL transform algorithm. We have to rely on the compiler for unrolling, though.
+         * At least ICC doesn't produce the best code from this...
+         *
+        std::transform(Vc::makeIterator(y_points.vector(1), Vc::Prefetch<>()),
+                y_points.end(Vc::Prefetch<>()),
+                Vc::makeIterator<float_v>(&dy_points[1], Vc::Streaming),
+                [&y0,oneOver2h](float_v y1) -> float_v {
+                    const auto r = (y0.shifted(2, y1) - y0) * oneOver2h;
+                    y0 = y1;
+                    return r;
+                });
+        */
 
         // Process the last vector. Note that this works for any N because Vc::Memory adds padding
         // to y_points and dy_points such that the last scalar value is somewhere inside lastVector.
@@ -234,16 +258,18 @@
         // ... and finally the right border
         dy_points[N - 1] = (y_points[N - 1] - y_points[N - 2]) / h;
 
-        timer.Stop();
+        timer.stop();
         printResults();
-        std::cout << "cycle count: " << timer.Cycles()
-            << " | " << static_cast<double>(N * 2) / timer.Cycles() << " FLOP/cycle"
-            << " | " << static_cast<double>(N * 2 * sizeof(float)) / timer.Cycles() << " Byte/cycle"
+        std::cout << "cycle count: " << timer.cycles()
+            << " | " << static_cast<double>(N * 2) / timer.cycles() << " FLOP/cycle"
+            << " | " << static_cast<double>(N * 2 * sizeof(float)) / timer.cycles() << " Byte/cycle"
             << "\n";
     }
-    speedup /= timer.Cycles();
+    speedup /= timer.cycles();
     std::cout << "Speedup: " << speedup << "\n";
+//! [cleanup]
 
     Vc::free(dy_points - float_v::Size + 1);
     return 0;
 }
+//! [cleanup]
diff -Nru vc-0.7.4/examples/linear_find/CMakeLists.txt vc-1.3.0/examples/linear_find/CMakeLists.txt
--- vc-0.7.4/examples/linear_find/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/linear_find/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1 @@
+build_example(linear_find main.cpp)
diff -Nru vc-0.7.4/examples/linear_find/main.cpp vc-1.3.0/examples/linear_find/main.cpp
--- vc-0.7.4/examples/linear_find/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/linear_find/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,298 @@
+/*{{{
+    Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#include <Vc/Vc>
+#include <iomanip>
+#include <random>
+#include <vector>
+#include <algorithm>
+#include "../tsc.h"
+
+using Vc::float_v;
+typedef Vc::SimdArray<double, float_v::size()> double_v;
+typedef Vc::SimdArray<std::int32_t, float_v::size()> int32_v;
+typedef Vc::SimdArray<std::uint32_t, float_v::size()> uint32_v;
+
+typedef typename float_v::mask_type float_m;
+typedef typename double_v::mask_type double_m;
+typedef typename int32_v::mask_type int32_m;
+typedef typename uint32_v::mask_type uint32_m;
+
+namespace std
+{
+template <typename T>
+struct less<Vc::Vector<T>>
+    : public binary_function<Vc::Vector<T>, Vc::Vector<T>, Vc::Mask<T>>
+{
+    Vc::Mask<T> operator()(const Vc::Vector<T> &x, const Vc::Vector<T> &y) const
+    {
+        return x < y;
+    }
+};
+
+template <typename T, std::size_t N>
+struct less<Vc::SimdArray<T, N>>
+    : public binary_function<Vc::SimdArray<T, N>, Vc::SimdArray<T, N>,
+                             typename Vc::SimdArray<T, N>::mask_type>
+{
+    typename Vc::SimdArray<T, N>::mask_type operator()(const Vc::SimdArray<T, N> &x,
+                                                       const Vc::SimdArray<T, N> &y) const
+    {
+        return x < y;
+    }
+};
+}  // namespace std
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+template <class Iterator, class T, class C>
+inline Iterator lower_bound(Iterator first, Iterator last,
+                                   const T &value, C comp)
+{
+    typedef simdize<T> V;
+    constexpr auto Size = V::size();
+    typedef simdize<C, Size> CV;
+    CV comp_v;
+
+#if 1
+    const V value_v = value;
+    while (first < last) {
+        const auto l2 = (std::size_t(last - first) / 2) & ~(Size - 1);
+        const auto m = first + l2;
+        const auto mask = comp_v(V(&*m, Vc::Aligned), value_v);
+        if (all_of(mask)) {
+            first = m + Size;
+        } else if (none_of(mask)) {
+            last = m;
+        } else {
+            return m + mask.count();
+        }
+    }
+#else
+    auto len = std::distance(first, last);
+    while (len >= Size) {
+        const auto l2 = len / 2;
+        Iterator m = first;
+        std::advance(m, l2);
+        if (comp(*m, value)) {
+            first = ++m;
+            len -= l2 + 1;
+        } else {
+            len = l2;
+        }
+    }
+    const auto mask = comp_v(V(&*first), value);
+    std::advance(first, all_of(mask) ? Size : (!mask).firstOne());
+#endif
+    return first;
+}
+
+template <class Iterator, class T>
+inline Iterator find(Iterator first, Iterator last, const T &value)
+{
+    typename simdize<Iterator>::value_type value_v = value;
+    for (simdize<Iterator> it = first; it < last; ++it) {
+        const auto mask = *it == value_v;
+        if (any_of(mask)) {
+            return static_cast<Iterator>(it) + mask.firstOne();
+        }
+    }
+    return last;
+}
+
+template <class Iterator, class V>
+inline std::array<Iterator, V::size()> find_parallel(Iterator first, Iterator last,
+                                                     const V &value)
+{
+    std::array<Iterator, V::size()> matches;
+    for (auto &x : matches) {
+        x = last;
+    }
+    typename V::mask_type found(false);
+    for (; first < last; ++first) {
+        const auto mask = *first == value && !found;
+        if (any_of(mask)) {
+            found |= mask;
+            for (std::size_t i : where(mask)) {
+                matches[i] = first;
+            }
+            if (all_of(found)) {
+                break;
+            }
+        }
+    }
+    return matches;
+}
+}  // namespace Vc
+
+template <typename _InputIterator, typename _Tp>
+inline _InputIterator simple_find(_InputIterator first, _InputIterator last,
+                           const _Tp &val) {
+  for (; first != last; ++first) {
+    if (*first == val) {
+      break;
+    }
+  }
+  return first;
+}
+
+int Vc_CDECL main()
+{
+    std::cout << std::setw(15) << "N";
+    std::cout << std::setw(15) << "std" << std::setw(15) << "stddev";
+    std::cout << std::setw(15) << "Vc" << std::setw(15) << "stddev";
+    std::cout << std::setw(15) << "par" << std::setw(15) << "stddev";
+    //std::cout << std::setw(15) << "binary" << std::setw(15) << "stddev";
+    std::cout << std::setw(15) << "std/Vc" << std::setw(15) << "stddev";
+    std::cout << std::setw(15) << "std/par" << std::setw(15) << "stddev" << '\n';
+
+    // create data
+    std::vector<float, Vc::Allocator<float>> data;
+    constexpr std::size_t NMax = 1024 * 128 * float_v::size();
+    data.reserve(NMax);
+    std::default_random_engine rne;
+    std::uniform_real_distribution<float> uniform_dist(-1000.f, 1000.f);
+    for (auto n = data.capacity(); n > 0; --n) {
+        data.push_back(uniform_dist(rne));
+    }
+
+    auto sorted = data;
+    std::sort(sorted.begin(), sorted.end());
+
+    for (std::size_t N = float_v::size() * 2; N <= NMax; N *= 2) {
+        const std::size_t Repetitions = 100 + 1024 * 32 / N;
+
+        // create search values
+        std::vector<float> search_values;
+        search_values.reserve(10000);
+        for (auto n = search_values.capacity(); n > 0; --n) {
+            search_values.push_back(
+                data[std::uniform_int_distribution<std::size_t>(0, N - 1)(rne)]);
+        }
+
+        enum { std, vec, par };
+
+        std::vector<decltype(data.begin())> iterators[3];
+        iterators[std].resize(search_values.size());
+        iterators[vec].resize(search_values.size());
+        iterators[par].resize(search_values.size());
+
+        double mean[3] = {};
+        double stddev[3] = {};
+        do {
+            for (int i : {std, vec, par}) {
+                mean[i] = 0;
+                stddev[i] = 0;
+            }
+            TimeStampCounter tsc;
+
+            // search (std)
+            for (auto n = Repetitions; n; --n) {
+                tsc.start();
+                for (std::size_t i = 0; i < search_values.size(); ++i) {
+                    iterators[std][i] =
+                        simple_find(data.begin(), data.begin() + N, search_values[i]);
+                }
+                tsc.stop();
+                double x = tsc.cycles();
+                mean[std] += x;
+                stddev[std] += x * x;
+            }
+
+            // search (vec)
+            for (auto n = Repetitions; n; --n) {
+                tsc.start();
+                for (std::size_t i = 0; i < search_values.size(); ++i) {
+                    iterators[vec][i] =
+                        Vc::find(data.begin(), data.begin() + N, search_values[i]);
+                }
+                tsc.stop();
+                double x = tsc.cycles();
+                mean[vec] += x;
+                stddev[vec] += x * x;
+            }
+
+            // seach (par)
+            for (auto n = Repetitions; n; --n) {
+                tsc.start();
+                for (std::size_t i = 0; i < search_values.size();) {
+                    for (const auto &it :
+                         Vc::find_parallel(data.begin(), data.begin() + N,
+                                           float_v(&search_values[i]))) {
+                        iterators[par][i++] = it;
+                    }
+                }
+                tsc.stop();
+                double x = tsc.cycles();
+                mean[par] += x;
+                stddev[par] += x * x;
+            }
+
+            // search (bin)
+            /*for (auto n = Repetitions; n; --n) {
+                tsc.start();
+                for (std::size_t i = 0; i < search_values.size(); ++i) {
+                    iterators[bin][i] =
+                        std::lower_bound(data.begin(), data.begin() + N, search_values[i]);
+                }
+                tsc.stop();
+                double x = tsc.cycles();
+                mean[bin] += x;
+                stddev[bin] += x * x;
+            }*/
+
+            // test that the results are equal
+            for (std::size_t i = 0; i < iterators[vec].size(); ++i) {
+                assert(iterators[std][i] == iterators[vec][i]);
+                assert(iterators[std][i] == iterators[par][i]);
+            }
+
+            // output results
+            std::cout << std::setw(15) << N;
+            for (int i : {std, vec, par}) {
+                mean[i] /= Repetitions;
+                stddev[i] /= Repetitions;
+                stddev[i] = std::sqrt(stddev[i] - mean[i] * mean[i]);
+
+                std::cout << std::setw(15) << mean[i] / search_values.size();
+                std::cout << std::setw(15) << stddev[i] / search_values.size();
+            }
+            std::cout << std::setw(15) << std::setprecision(4) << mean[std] / mean[vec];
+            std::cout << std::setw(15)
+                      << mean[std] / mean[vec] *
+                             std::sqrt(
+                                 stddev[std] * stddev[std] / (mean[std] * mean[std]) +
+                                 stddev[vec] * stddev[vec] / (mean[vec] * mean[vec]));
+            std::cout << std::setw(15) << std::setprecision(4) << mean[std] / mean[par];
+            std::cout << std::setw(15)
+                      << mean[std] / mean[par] *
+                             std::sqrt(
+                                 stddev[std] * stddev[std] / (mean[std] * mean[std]) +
+                                 stddev[par] * stddev[par] / (mean[par] * mean[par]));
+            std::cout << std::endl;
+        } while (stddev[std] * 20 > mean[std] || stddev[vec] * 20 > mean[vec] ||
+                 stddev[par] * 20 > mean[par]);
+    }
+
+    return 0;
+}
diff -Nru vc-0.7.4/examples/mandelbrot/CMakeLists.txt vc-1.3.0/examples/mandelbrot/CMakeLists.txt
--- vc-0.7.4/examples/mandelbrot/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/mandelbrot/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -8,49 +8,4 @@
       ${CMAKE_CURRENT_BINARY_DIR}/moc_mandel.cpp)
 
    build_example(mandelbrot ${SOURCES} LIBS ${QT_LIBRARIES})
-
-   # It is an interesting test if we can compare against the autovect
-   # capabilities of Open64 and ICC, so we try to find those and compile extra
-   # binaries with them
-   find_program(O64_CXX openCC HINTS /opt/x86_open64-4.2.4/bin /opt/open64/bin)
-   find_program(ICC_CXX icpc HINTS
-      /opt/intel/bin
-      $ENV{HOME}/intel/Compiler/11.1/072/bin/intel64)
-
-   if(FALSE AND O64_CXX)
-      add_custom_command(OUTPUT mandelbrot_open64
-         COMMAND ${O64_CXX} -O3 -Wall -msse3
-         -o ${CMAKE_CURRENT_BINARY_DIR}/mandelbrot_open64
-         -I ${CMAKE_CURRENT_BINARY_DIR} -I ${QT_INCLUDE_DIR}
-         -I ${QT_QTCORE_INCLUDE_DIR} -I ${QT_QTGUI_INCLUDE_DIR}
-         -I ${CMAKE_SOURCE_DIR} -I ${CMAKE_SOURCE_DIR}/include
-         -L ${QT_LIBRARY_DIR} -lQtGui ${SOURCES}
-         -DVC_IMPL=Scalar
-         DEPENDS ${SOURCES} Vc
-         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-         COMMENT "Bulding mandelbrot_open64"
-         VERBATIM)
-      add_custom_target(build_mandelbrot_open64 ALL DEPENDS mandelbrot_open64)
-      add_target_property(build_mandelbrot_open64 LABELS "other")
-      add_dependencies(other build_mandelbrot_open64)
-   endif()
-
-   if(FALSE AND ICC_CXX)
-      get_target_property(VcLocation Vc LOCATION)
-      add_custom_command(OUTPUT mandelbrot_icc
-         COMMAND ${ICC_CXX} -O3 -xSSE3
-         -o ${CMAKE_CURRENT_BINARY_DIR}/mandelbrot_icc
-         -I ${CMAKE_CURRENT_BINARY_DIR} -I ${QT_INCLUDE_DIR}
-         -I ${QT_QTCORE_INCLUDE_DIR} -I ${QT_QTGUI_INCLUDE_DIR}
-         -I ${CMAKE_SOURCE_DIR} -I ${CMAKE_SOURCE_DIR}/include
-         -L ${QT_LIBRARY_DIR} -lQtGui ${SOURCES} ${VcLocation}
-         -DVC_IMPL=Scalar
-         DEPENDS ${SOURCES} Vc
-         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-         COMMENT "Bulding mandelbrot_icc"
-         VERBATIM)
-      add_custom_target(build_mandelbrot_icc ALL DEPENDS mandelbrot_icc)
-      add_target_property(build_mandelbrot_icc LABELS "other")
-      add_dependencies(other build_mandelbrot_icc)
-   endif()
 endif()
diff -Nru vc-0.7.4/examples/mandelbrot/main.cpp vc-1.3.0/examples/mandelbrot/main.cpp
--- vc-0.7.4/examples/mandelbrot/main.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/mandelbrot/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2010 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2010-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -22,6 +22,7 @@
 */
 
 #include "main.h"
+#include <common/macros.h>
 
 #include <QApplication>
 #include <QPainter>
@@ -150,7 +151,7 @@
     m_mandelVc.brot(m_rect1.size(), m_x, m_y, m_scale);
 }
 
-int main(int argc, char **argv)
+int Vc_CDECL main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     MainWindow w;
diff -Nru vc-0.7.4/examples/mandelbrot/mandel.cpp vc-1.3.0/examples/mandelbrot/mandel.cpp
--- vc-0.7.4/examples/mandelbrot/mandel.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/mandelbrot/mandel.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2010-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -31,8 +31,8 @@
 
 using Vc::float_v;
 using Vc::float_m;
-using Vc::uint_v;
-using Vc::uint_m;
+using uint_v = Vc::SimdArray<unsigned int, float_v::size()>;
+using uint_m = uint_v::mask_type;
 
 template<MandelImpl Impl>
 Mandel<Impl>::Mandel(QObject *_parent)
@@ -88,16 +88,16 @@
 
         // benchmark the number of cycles it takes
         TimeStampCounter timer;
-        timer.Start();
+        timer.start();
 
         // calculate the mandelbrot set/image
         mandelMe(image, x, y, scale, 255);
 
-        timer.Stop();
+        timer.stop();
 
         // if no new set was requested in the meantime - return the finished image
         if (!m_restart) {
-            emit ready(image, timer.Cycles());
+            emit ready(image, timer.cycles());
         }
 
         // wait for more work
@@ -166,21 +166,21 @@
     const unsigned int width = image.width();
     const float_v colorScale = 0xff / static_cast<float>(maxIt);
     for (unsigned int y = 0; y < height; ++y) {
-        unsigned int *VC_RESTRICT line = reinterpret_cast<unsigned int *>(image.scanLine(y));
+        unsigned int *Vc_RESTRICT line = reinterpret_cast<unsigned int *>(image.scanLine(y));
         const float_v c_imag = y0 + y * scale;
         uint_m toStore;
         for (uint_v x = uint_v::IndexesFromZero(); !(toStore = x < width).isEmpty();
                 x += float_v::Size) {
-            const float_v c_real = x0 + x * scale;
+            const float_v c_real = x0 + simd_cast<float_v>(x) * scale;
             Z z(c_real, c_imag);
-            float_v n = 0.f;
+            float_v n = float_v::Zero();
             float_m inside = z.norm() < S;
             while (!(inside && n < maxIt).isEmpty()) {
                 z = P(z, c_real, c_imag);
                 ++n(inside);
                 inside = z.norm() < S;
             }
-            uint_v colorValue = static_cast<uint_v>((maxIt - n) * colorScale) * 0x10101;
+            uint_v colorValue = simd_cast<uint_v>((maxIt - n) * colorScale) * 0x10101;
             if (toStore.isFull()) {
                 colorValue.store(line, Vc::Unaligned);
                 line += uint_v::Size;
@@ -203,7 +203,7 @@
     const int width = image.width();
     const float colorScale = 0xff / static_cast<float>(maxIt);
     for (int y = 0; y < height; ++y) {
-        unsigned int *VC_RESTRICT line = reinterpret_cast<unsigned int *>(image.scanLine(y));
+        unsigned int *Vc_RESTRICT line = reinterpret_cast<unsigned int *>(image.scanLine(y));
         const float c_imag = y0 + y * scale;
         for (int x = 0; x < width; ++x) {
             const float c_real = x0 + x * scale;
diff -Nru vc-0.7.4/examples/matrix/main.cpp vc-1.3.0/examples/matrix/main.cpp
--- vc-0.7.4/examples/matrix/main.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/matrix/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*  This file is part of the Vc project
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2009-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -25,56 +25,333 @@
 #include <Vc/IO>
 #include <iostream>
 #include <iomanip>
+#include <valarray>
+#include "../tsc.h"
+#include "common/macros.h"
 
-template<typename T, unsigned int Size> class Matrix;
-template<typename T, unsigned int Size> std::ostream &operator<<(std::ostream &, const Matrix<T, Size> &);
+static constexpr int UnrollOuterloop = 4;
 
-template<typename T, unsigned int Size>
-class Matrix
+template <typename T, size_t N> class MatrixValarray
 {
-    friend std::ostream &operator<< <>(std::ostream &, const Matrix<T, Size> &);
-    private:
-        typedef Vc::Vector<T> V;
-        Vc::Memory<V, Size * Size> m_mem;
-    public:
-        Matrix &operator=(const T &val) {
-            V vec(val);
-            for (unsigned int i = 0; i < m_mem.vectorsCount(); ++i) {
-                m_mem.vector(i) = vec;
-            }
-            return *this;
-        }
-
-        Matrix &operator+=(const Matrix &rhs) {
-            for (unsigned int i = 0; i < m_mem.vectorsCount(); ++i) {
-                V v1(m_mem.vector(i));
-                v1 += V(rhs.m_mem.vector(i));
-                m_mem.vector(i) = v1;
+    using V = std::valarray<T>;
+    V data[N];
+
+public:
+    MatrixValarray()
+    {
+        for (auto &v : data) {
+            v.resize(N);
+        }
+    }
+    std::valarray<T> &operator[](std::size_t i) { return data[i]; }
+    const std::valarray<T> &operator[](std::size_t i) const { return data[i]; }
+};
+
+template <typename T, size_t N>
+inline MatrixValarray<T, N> operator*(const MatrixValarray<T, N> &a,
+                                      const MatrixValarray<T, N> &b)
+{
+    MatrixValarray<T, N> c;
+    for (size_t i = 0; i < N; ++i) {
+        c[i] = a[i][0] * b[0];
+        for (size_t k = 1; k < N; ++k) {
+            c[i] += a[i][k] * b[k];
+        }
+    }
+    return c;
+}
+
+template <typename T, size_t N> class Matrix
+{
+    using V = Vc::Vector<T>;
+
+    // round up to the next multiple of V::size()
+    static constexpr size_t NPadded = (N + V::size() - 1) / V::size() * V::size();
+
+    // the inner array stores one row of values and is padded
+    using RowArray = std::array<T, NPadded>;
+
+    // The following function is a workaround for GCC 4.8, which fails to recognize
+    // V::MemoryAlignment as a constant expression inside the alignas operator.
+    static constexpr size_t dataAlignment() { return V::MemoryAlignment; }
+    // The outer array stores N rows and does not require further padding. It must be
+    // aligned correctly for Vc::Aligned loads and stores, though.
+    alignas(dataAlignment()) std::array<RowArray, N> data;
+
+public:
+    Matrix()
+    {
+        for (int i = 0; i < int(N); ++i) {
+            for (int j = N; j < int(NPadded); ++j) {
+                data[i][j] = 0;
             }
-            return *this;
         }
+    }
+    // returns a reference to the i-th row
+    RowArray &operator[](size_t i) { return data[i]; }
+    // const overload of the above
+    const RowArray &operator[](size_t i) const { return data[i]; }
 };
 
-template<typename T, unsigned int Size>
-std::ostream &operator<<(std::ostream &out, const Matrix<T, Size> &m)
+// vectorized matrix multiplication
+template <typename T, size_t N>
+inline Matrix<T, N> operator*(const Matrix<T, N> &a, const Matrix<T, N> &b)
+{
+    constexpr int NN = N;
+    using V = Vc::Vector<T>;
+    // resulting matrix c
+    Matrix<T, N> c;
+
+    // The row index (for a and c) is unrolled using the UnrollOuterloop stride. Therefore
+    // the last rows may need special treatment if N is not a multiple of UnrollOuterloop.
+    // N0 is the number of rows that can safely be iterated with a stride of
+    // UnrollOuterloop.
+    constexpr int N0 = N / UnrollOuterloop * UnrollOuterloop;
+    for (int i = 0; i < N0; i += UnrollOuterloop) {
+        // The iteration over the column index of b and c uses a stride of V::size(). This
+        // enables row-vector loads (from b) and stores (to c). The matrix storage is
+        // padded accordingly, ensuring correct bounds and alignment.
+        for (int j = 0; j < NN; j += int(V::size())) {
+            // This temporary variables are used to accumulate the results of the products
+            // producing the new values for the c matrix. This variable is necessary
+            // because we need a V object for data-parallel accumulation. Storing to c
+            // directly stores to scalar objects and thus would drop the ability for
+            // data-parallel (SIMD) addition.
+            V c_ij[UnrollOuterloop];
+            for (int n = 0; n < UnrollOuterloop; ++n) {
+                c_ij[n] = a[i + n][0] * V(&b[0][j], Vc::Aligned);
+            }
+            for (int k = 1; k < NN - 1; ++k) {
+                for (int n = 0; n < UnrollOuterloop; ++n) {
+                    c_ij[n] += a[i + n][k] * V(&b[k][j], Vc::Aligned);
+                }
+            }
+            for (int n = 0; n < UnrollOuterloop; ++n) {
+                c_ij[n] += a[i + n][NN - 1] * V(&b[NN - 1][j], Vc::Aligned);
+                c_ij[n].store(&c[i + n][j], Vc::Aligned);
+            }
+        }
+    }
+    // This final loop treats the remaining NN - N0 rows.
+    for (int j = 0; j < NN; j += int(V::size())) {
+        V c_ij[UnrollOuterloop];
+        for (int n = N0; n < NN; ++n) {
+            c_ij[n - N0] = a[n][0] * V(&b[0][j], Vc::Aligned);
+        }
+        for (int k = 1; k < NN - 1; ++k) {
+            for (int n = N0; n < NN; ++n) {
+                c_ij[n - N0] += a[n][k] * V(&b[k][j], Vc::Aligned);
+            }
+        }
+        for (int n = N0; n < NN; ++n) {
+            c_ij[n - N0] += a[n][NN - 1] * V(&b[N - 1][j], Vc::Aligned);
+            c_ij[n - N0].store(&c[n][j], Vc::Aligned);
+        }
+    }
+    return c;
+}
+
+// scalar matrix multiplication
+template <typename T, size_t N>
+Matrix<T, N> scalar_mul(const Matrix<T, N> &a, const Matrix<T, N> &b)
+{
+    constexpr int NN = N;
+    Matrix<T, N> c;
+    for (int i = 0; i < NN; ++i) {
+        for (int j = 0; j < NN; ++j) {
+            c[i][j] = a[i][0] * b[0][j];
+            for (int k = 1; k < NN; ++k) {
+                c[i][j] += a[i][k] * b[k][j];
+            }
+        }
+    }
+    return c;
+}
+
+// scalar matrix multiplication
+template <typename T, size_t N>
+Matrix<T, N> scalar_mul_blocked(const Matrix<T, N> &a, const Matrix<T, N> &b)
+{
+    constexpr int NN = N;
+    Matrix<T, N> c;
+    constexpr int N0 = N / UnrollOuterloop * UnrollOuterloop;
+    for (int i = 0; i < N0; i += UnrollOuterloop) {
+        for (int j = 0; j < NN; ++j) {
+            for (int n = 0; n < UnrollOuterloop; ++n) {
+                c[i + n][j] = a[i + n][0] * b[0][j];
+            }
+            for (int k = 1; k < NN; ++k) {
+                for (int n = 0; n < UnrollOuterloop; ++n) {
+                    c[i + n][j] += a[i + n][k] * b[k][j];
+                }
+            }
+        }
+    }
+    for (int j = 0; j < NN; ++j) {
+        for (int n = N0; n < NN; ++n) {
+            c[n][j] = a[n][0] * b[0][j];
+        }
+        for (int k = 1; k < NN; ++k) {
+            for (int n = N0; n < NN; ++n) {
+                c[n][j] += a[n][k] * b[k][j];
+            }
+        }
+    }
+    return c;
+}
+
+// valarray matrix multiplication
+template <typename T, size_t N>
+Matrix<T, N> valarray_mul(const Matrix<T, N> &a, const Matrix<T, N> &b)
+{
+    Matrix<T, N> c;
+    using V = std::valarray<T>;
+    for (size_t i = 0; i < N; ++i) {
+        V c_i = a[i][0] * V(&b[0][0], N);
+        for (size_t k = 1; k < N; ++k) {
+            c_i += a[i][k] * V(&b[k][0], N);
+        }
+        std::copy(std::begin(c_i), std::end(c_i), &c[i][0]);
+    }
+    return c;
+}
+
+template <template <typename, size_t> class M, typename T, size_t N,
+          typename = Vc::enable_if<(std::is_same<M<T, N>, Matrix<T, N>>::value ||
+                                    std::is_same<M<T, N>, MatrixValarray<T, N>>::value)>>
+std::ostream &operator<<(std::ostream &out, const M<T, N> &m)
+{
+    out.precision(3);
+    auto &&w = std::setw(6);
+    out << "⎡" << w << m[0][0];
+    for (size_t j = 1; j < N; ++j) {
+        out << ", " << w << m[0][j];
+    }
+    out << " ⎤\n";
+    for (size_t i = 1; i + 1 < N; ++i) {
+        out << "⎢" << w << m[i][0];
+        for (size_t j = 1; j < N; ++j) {
+            out << ", " << w << m[i][j];
+        }
+        out << " ⎥\n";
+    }
+    out << "⎣" << w << m[N - 1][0];
+    for (size_t j = 1; j < N; ++j) {
+        out << ", " << w << m[N - 1][j];
+    }
+    return out << " ⎦\n";
+}
+
+#ifdef Vc_MSVC
+#pragma optimize("", off)
+template <typename T> void unused(T &&x) { x = x; }
+#pragma optimize("", on)
+#else
+template <typename T> void unused(T &&x) { asm("" ::"m"(x)); }
+#endif
+
+template <size_t N, typename F> Vc_ALWAYS_INLINE void benchmark(F &&f)
+{
+    TimeStampCounter tsc;
+    auto cycles = tsc.cycles();
+    cycles = 0x7fffffff;
+    for (int i = 0; i < 100; ++i) {
+        tsc.start();
+        for (int j = 0; j < 10; ++j) {
+            auto C = f();
+            unused(C);
+        }
+        tsc.stop();
+        cycles = std::min(cycles, tsc.cycles());
+    }
+    //std::cout << cycles << " Cycles for " << N *N *(N + N - 1) << " FLOP => ";
+    std::cout << std::setw(19) << std::setprecision(3)
+              << double(N * N * (N + N - 1) * 10) / cycles;
+    //<< " FLOP/cycle (" << variant << ")\n";
+}
+
+template <size_t N> void run()
 {
-    for (unsigned int i = 0; i < Size; ++i) {
-        std::cout << "[" << std::setw(6) << m.m_mem[i * Size];
-        for (unsigned int j = 1; j < Size; ++j) {
-            std::cout << std::setw(6) << m.m_mem[i * Size + j];
+    Matrix<float, N> A;
+    Matrix<float, N> B;
+    MatrixValarray<float, N> AV;
+    MatrixValarray<float, N> BV;
+    for (size_t i = 0; i < N; ++i) {
+        for (size_t j = 0; j < N; ++j) {
+            A[i][j] = 0.01 * (i + j);
+            B[i][j] = 0.01 * (N + i - j);
+            AV[i][j] = 0.01 * (i + j);
+            BV[i][j] = 0.01 * (N + i - j);
         }
-        std::cout << " ]\n";
     }
-    return out;
+    std::cout << std::setw(2) << N;
+#if defined Vc_MSVC
+    auto &&fakeModify = [](Matrix<float, N> &a, Matrix<float, N> &b) {
+        unused(a);
+        unused(b);
+    };
+#else
+    auto &&fakeModify = [](Matrix<float, N> &a, Matrix<float, N> &b) {
+#ifdef Vc_ICC
+        asm("" ::"r"(&a), "r"(&b));
+#else
+        asm("" : "+m"(a), "+m"(b));
+#endif
+    };
+#endif
+    benchmark<N>([&] {
+        fakeModify(A, B);
+        return scalar_mul(A, B);
+    });
+    benchmark<N>([&] {
+        fakeModify(A, B);
+        return scalar_mul_blocked(A, B);
+    });
+    benchmark<N>([&] {
+        fakeModify(A, B);
+        return A * B;
+    });
+    benchmark<N>([&] {
+        fakeModify(A, B);
+        return AV * BV;
+    });
+    std::cout << std::endl;
 }
 
-int main()
+int Vc_CDECL main()
 {
-    Matrix<float, 15> m1;
-    m1 = 1.f;
-    Matrix<float, 15> m2;
-    m2 = 2.f;
-    m1 += m2;
-    std::cout << m1 << std::endl;
+    std::cout << " N             scalar   scalar & blocked          Vector<T>           valarray\n";
+    run< 4>();
+    run< 5>();
+    run< 6>();
+    run< 7>();
+    run< 8>();
+    run< 9>();
+    run<10>();
+    run<11>();
+    run<12>();
+    run<13>();
+    run<14>();
+    run<15>();
+    run<16>();
+    run<17>();
+    run<18>();
+    run<19>();
+    run<20>();
+    run<21>();
+    run<22>();
+    run<23>();
+    run<24>();
+    run<25>();
+    run<26>();
+    run<27>();
+    run<28>();
+    run<29>();
+    run<30>();
+    run<31>();
+    run<32>();
+    run<33>();
+    run<34>();
+    run<35>();
     return 0;
 }
diff -Nru vc-0.7.4/examples/polarcoord/main.cpp vc-1.3.0/examples/polarcoord/main.cpp
--- vc-0.7.4/examples/polarcoord/main.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/polarcoord/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -31,7 +31,7 @@
 //! [includes]
 
 //! [memory allocation]
-int main()
+int Vc_CDECL main()
 {
     // allocate memory for our initial x and y coordinates. Note that you can also put it into a
     // normal float C-array but that you then must ensure alignment to Vc::VectorAlignment!
diff -Nru vc-0.7.4/examples/scaling/CMakeLists.txt vc-1.3.0/examples/scaling/CMakeLists.txt
--- vc-0.7.4/examples/scaling/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/scaling/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1 @@
+build_example(scaling main.cpp)
diff -Nru vc-0.7.4/examples/scaling/main.cpp vc-1.3.0/examples/scaling/main.cpp
--- vc-0.7.4/examples/scaling/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/scaling/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,158 @@
+/*{{{
+    Copyright (C) 2013 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#include <array>
+#include <memory>
+
+#include <Vc/Vc>
+#include "../tsc.h"
+
+using Vc::float_v;
+
+/*
+ * This example shows how an arbitrary problem scales depending on working-set size and FLOPs per
+ * load/store. Understanding this can help to create better implementations.
+ */
+
+/*
+ * The Runner is a method to generate the different scenarios with all parameters to the Work
+ * available as constant expressions.
+ * The idea is to have the compiler able to optimize as much as possible so that the actual workload
+ * alone is benchmarked.
+ *
+ * The Runner recursively calls operator() on the Work template class with varying arguments for N
+ * and FLOPs.
+ */
+template<template<std::size_t N, std::size_t M, int, int> class Work, std::size_t N = 256, std::size_t M = 4, int FLOPs = 2> struct Runner
+{
+    static void run() {
+        Work<N, M, (N > 4096 ? 1 : 4096 / N), FLOPs>()();
+        Runner<Work, N, M, int(FLOPs * 1.5)>::run();
+    }
+};
+
+template<template<std::size_t N, std::size_t M, int, int> class Work, std::size_t N, std::size_t M> struct Runner<Work, N, M, 211>
+{
+    static void run() {
+        Runner<Work, N * 2, M>::run();
+    }
+};
+template<template<std::size_t N, std::size_t M, int, int> class Work, std::size_t M, int FLOPs> struct Runner<Work, 256 * 1024 * 1024, M, FLOPs>
+{
+    static void run() {
+    }
+};
+
+/*
+ * The Flops helper struct generates code that executes FLOPs many floating-point SIMD instructions
+ * (add, sub, and mul)
+ */
+template<int FLOPs> struct Flops
+{
+    inline float_v operator()(float_v a, float_v b, float_v c)
+    {
+        typedef Flops<(FLOPs - 5) / 2> F1;
+        typedef Flops<(FLOPs - 4) / 2> F2;
+        return F1()(a + b, a * b, c) + F2()(a * c, b + c, a);
+    }
+};
+
+template<> inline float_v Flops<2>::operator()(float_v a, float_v b, float_v c)
+{
+    return a * b + c;
+}
+template<> inline float_v Flops<3>::operator()(float_v a, float_v b, float_v c)
+{
+    return a * b + (c - a);
+}
+template<> inline float_v Flops<4>::operator()(float_v a, float_v b, float_v c)
+{
+    return (a * b + c) + a * c;
+}
+template<> inline float_v Flops<5>::operator()(float_v a, float_v b, float_v c)
+{
+    return a * b + (a + c) + a * c;
+}
+template<> inline float_v Flops<6>::operator()(float_v a, float_v b, float_v c)
+{
+    return (a * b + (a + c)) + (a * c - b);
+}
+template<> inline float_v Flops<7>::operator()(float_v a, float_v b, float_v c)
+{
+    return (a * b + (a + c)) + (a * c - (b + c));
+}
+template<> inline float_v Flops<8>::operator()(float_v a, float_v b, float_v c)
+{
+    return (a * b + (a + c) + b) + (a * c - (b + c));
+}
+
+/*
+ * This is the benchmark code. It is called from Runner and uses Flops to do the work.
+ */
+template<std::size_t _N, std::size_t M, int Repetitions, int FLOPs>
+struct ScaleWorkingSetSize
+{
+    void operator()()
+    {
+        constexpr std::size_t N = _N / sizeof(float_v) + 3 * 16 / float_v::Size;
+        typedef std::array<std::array<float_v, N>, M> Cont;
+        auto data = Vc::make_unique<Cont, Vc::AlignOnPage>();
+        for (auto &arr : *data) {
+            for (auto &value : arr) {
+                value = float_v::Random();
+            }
+        }
+
+        TimeStampCounter tsc;
+        double throughput = 0.;
+        for (std::size_t i = 0; i < 2 + 512 / N; ++i) {
+            tsc.start();
+            // ------------- start of the benchmarked code ---------------
+            for (int repetitions = 0; repetitions < Repetitions; ++repetitions) {
+                for (std::size_t m = 0; m < M; ++m) {
+                    for (std::size_t n = 0; n < N; ++n) {
+                        (*data)[m][n] = Flops<FLOPs>()((*data)[(m + 1) % M][n],
+                                (*data)[(m + 2) % M][n],
+                                (*data)[(m + 3) % M][n]);
+                    }
+                }
+            }
+            // -------------- end of the benchmarked code ----------------
+            tsc.stop();
+
+            throughput = std::max(throughput, (Repetitions * M * N * float_v::Size * FLOPs) / static_cast<double>(tsc.cycles()));
+        }
+
+        const long bytes = N * M * sizeof(float_v);
+        printf("%10lu Byte | %4.2f FLOP/Byte | %4.1f FLOP/cycle\n", bytes, static_cast<double>(float_v::Size * FLOPs) / (4 * sizeof(float_v)), throughput
+                );
+    }
+};
+
+int Vc_CDECL main()
+{
+    ScaleWorkingSetSize<256, 4, 10, 2>()();
+    printf("%10s | %4s | %4s\n", "Working-Set Size", "FLOPs per Byte", "Throughput (FLOPs/Cycle)");
+    Runner<ScaleWorkingSetSize>::run();
+    return 0;
+}
diff -Nru vc-0.7.4/examples/simdize/CMakeLists.txt vc-1.3.0/examples/simdize/CMakeLists.txt
--- vc-0.7.4/examples/simdize/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/simdize/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1 @@
+build_example(simdize main.cpp)
diff -Nru vc-0.7.4/examples/simdize/main.cpp vc-1.3.0/examples/simdize/main.cpp
--- vc-0.7.4/examples/simdize/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/simdize/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,37 @@
+#include <Vc/simdize>
+#include <Vc/IO>
+
+template <typename T> struct PointTemplate {
+    T x, y, z;
+
+    Vc_SIMDIZE_INTERFACE((x, y, z));
+};
+
+using Point = PointTemplate<float>;
+
+template <typename T> class Vectorizer
+{
+public:
+    using value_type = Vc::simdize<T>;
+
+    void append(const T &x) { decorate(data)[count++] = x; }
+    bool isFull() const { return count == data.size(); }
+    const value_type &contents() const { return data; }
+
+private:
+    value_type data;
+    int count = 0;
+};
+
+int Vc_CDECL main()
+{
+    Vectorizer<Point> v;
+    float x = 0.f;
+    while (!v.isFull()) {
+        v.append(Point{x, x + 1, x + 2});
+        x += 10;
+    }
+    const auto &vec = v.contents();
+    std::cout << vec.x << '\n' << vec.y << '\n' << vec.z << '\n';
+    return 0;
+}
diff -Nru vc-0.7.4/examples/spline/CMakeLists.txt vc-1.3.0/examples/spline/CMakeLists.txt
--- vc-0.7.4/examples/spline/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,3 @@
+AddCompilerFlag(-fno-stack-protector) # Ubuntu adds -fstack-protector-strong / it's not a GCC default
+AddCompilerFlag(-mno-vzeroupper)
+build_example(spline main.cpp spline.cpp)
diff -Nru vc-0.7.4/examples/spline/main.cpp vc-1.3.0/examples/spline/main.cpp
--- vc-0.7.4/examples/spline/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,465 @@
+/*{{{
+    Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+// includes {{{1
+#include <array>
+#include <iostream>
+#include <iomanip>
+#include <random>
+#include "../tsc.h"
+#include "spline.h"
+#include "spline2.h"
+#include "spline3.h"
+
+// settings {{{1
+constexpr int NumberOfEvaluations = 10000;
+constexpr int FirstMapSize = 4;
+constexpr int MaxMapSize = 256;
+constexpr int Repetitions = 100;
+constexpr auto StepMultiplier = 1.25;
+
+enum DisabledTests {
+    DisabledTestsBegin = -999999,
+    Horizontal3,
+    DisabledTestsEnd
+};
+enum EnabledTests {
+    Scalar,
+    Alice,
+    Float4,
+    Float16,
+    Float12,
+    Float12Interleaved,
+    Horizontal1,
+    Horizontal2,
+    Autovectorized,
+    NBenchmarks
+};
+
+std::string testName(int i)
+{
+    switch (i) {
+    case Scalar:             return "Scalar";
+    case Alice:              return "Alice";
+    case Float4:             return "Float4";
+    case Float16:            return "Float16";
+    case Float12:            return "Float12";
+    case Float12Interleaved: return "F12Interl.";
+    case Horizontal1:        return "Horiz.1";
+    case Horizontal2:        return "Horiz.2";
+    case Horizontal3:        return "Horiz.3";
+    case Autovectorized:     return "Autovec";
+    default:                 return "<unknown>";
+    }
+}
+
+// EnabledTests::operator++ {{{1
+EnabledTests &operator++(EnabledTests &x)
+{
+    return x = static_cast<EnabledTests>(static_cast<int>(x) + 1);
+}
+
+// operator<< overloads {{{1
+std::ostream &operator<<(std::ostream &s, const Point2 &xyz)
+{
+    using std::setw;
+    return s << '[' << setw(7) << xyz[0] << ", " << setw(7) << xyz[1] << ']';
+}
+std::ostream &operator<<(std::ostream &s, const Point2V &xyz)
+{
+    return s << '[' << xyz[0] << ", " << xyz[1] << ']';
+}
+std::ostream &operator<<(std::ostream &s, const Point3 &xyz)
+{
+    using std::setw;
+    return s << '[' << setw(7) << xyz[0] << ", " << setw(7) << xyz[1] << ", " << setw(7)
+             << xyz[2] << ']';
+}
+std::ostream &operator<<(std::ostream &s, const Point3V &xyz)
+{
+    return s << '[' << xyz[0] << ", " << xyz[1] << ", " << xyz[2] << ']';
+}
+
+// VectorizeBuffer {{{1
+template <typename Input> struct VectorizeBuffer
+{
+    typedef Vc::simdize<Input> InputV;
+    InputV input;
+    int entries = 0;
+    int operator()(Input x)
+    {
+        assign(input, entries, x);
+        entries = (entries + 1) % InputV::size();
+        return entries;
+    }
+};
+
+// TestInfo {{{1
+struct TestInfo
+{
+    bool enabled = false;
+    int id = -1;
+    TestInfo(EnabledTests t) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, EnabledTests) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, EnabledTests, EnabledTests) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, EnabledTests, DisabledTests) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, DisabledTests) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, DisabledTests, EnabledTests) : enabled(true), id(t) {}
+    TestInfo(EnabledTests t, DisabledTests, DisabledTests) : enabled(true), id(t) {}
+
+    TestInfo(DisabledTests) : enabled(false) {}
+    TestInfo(DisabledTests, EnabledTests t) : enabled(true), id(t) {}
+    TestInfo(DisabledTests, DisabledTests) : enabled(false) {}
+    TestInfo(DisabledTests, EnabledTests t, EnabledTests) : enabled(true), id(t) {}
+    TestInfo(DisabledTests, DisabledTests, EnabledTests t) : enabled(true), id(t) {}
+    TestInfo(DisabledTests, DisabledTests, DisabledTests) : enabled(false) {}
+
+    TestInfo(DisabledTests, EnabledTests t, DisabledTests) : enabled(true), id(t) {}
+
+    operator bool() const { return enabled; }
+    operator int() const { return id; }
+    operator long() const { return id; }
+    operator long long() const { return id; }
+};
+// Runner Lambda {{{1
+struct Runner
+{
+    // data members{{{2
+    TimeStampCounter tsc;
+    double mean[NBenchmarks] = {};
+    double stddev[NBenchmarks] = {};
+    const std::vector<Point2> &searchPoints;
+
+    // Runner::Runner{{{2
+    Runner(const std::vector<Point2> &p) : searchPoints(p) {}
+
+    void recordTsc(int Test, double norm)  //{{{2
+    {
+        const double x = tsc.cycles() / norm;
+        mean[Test] += x;
+        stddev[Test] += x * x;
+    }
+    template <typename I, typename J> void printRatio(I i, J j)  //{{{2
+    {
+        if (TestInfo(i) && TestInfo(j)) {
+            const auto ratio = mean[i] / mean[j];
+            std::cout << std::setprecision(3) << std::setw(9) << ratio;
+            std::cout << std::setprecision(3) << std::setw(9)
+                      << ratio * std::sqrt(stddev[i] * stddev[i] / (mean[i] * mean[i]) +
+                                           stddev[j] * stddev[j] / (mean[j] * mean[j]));
+        }
+    }
+    // benchmarkSearch{{{2
+    template <typename F> void benchmark(const TestInfo Test, F &&fun, double err = 20)
+    {
+        do {
+            mean[Test] = 0;
+            stddev[Test] = 0;
+
+            for (const auto &p : searchPoints) {
+                fun(p);
+            }  // one cache warm-up run to remove one outlier
+            for (auto rep = Repetitions; rep; --rep) {
+                tsc.start();
+                for (const auto &p : searchPoints) {
+                    fun(p);
+                }
+                tsc.stop();
+                recordTsc(Test, NumberOfEvaluations);
+            }
+
+            mean[Test] /= Repetitions;
+            stddev[Test] /= Repetitions;
+            stddev[Test] = std::sqrt(stddev[Test] - mean[Test] * mean[Test]);
+        } while (stddev[Test] * err > mean[Test]);
+        std::cout << std::setw(9) << std::setprecision(3) << mean[Test];
+        std::cout << std::setw(9) << std::setprecision(3) << stddev[Test];
+        std::cout << std::flush;
+    }
+    //}}}2
+};
+template <typename T> void fakeRead(T &&x)
+{
+#ifdef Vc_GNU_ASM
+    asm("" ::"m"(x));
+#else
+    (void)(&x == &x);
+#endif
+}
+int Vc_CDECL main()  // {{{1
+{
+    // output header {{{2
+    using std::cout;
+    using std::setw;
+    using std::setprecision;
+    cout << "NumberOfEvaluations: " << NumberOfEvaluations << '\n';
+    cout << "Repetitions: " << Repetitions << '\n';
+    cout << setw(8) << "MapSize";
+    for (int i = 0; i < NBenchmarks; ++i) {
+        cout << setw(18) << testName(i);
+    }
+    if (TestInfo(Scalar)) {
+        for (int i = 0; i < NBenchmarks; ++i) {
+            if (i != Scalar) {
+                cout << setw(18) << "Scalar/" + testName(i);
+            }
+        }
+    }
+    cout << std::endl;
+
+    // random number generator {{{2
+    std::default_random_engine randomEngine(1);
+    std::uniform_real_distribution<float> uniform(-1.f, 1.f);
+
+    // random search points {{{2
+    std::vector<Point2> searchPoints;
+    searchPoints.reserve(NumberOfEvaluations);
+    searchPoints.emplace_back(Point2{{-1.f, -1.f}});
+    searchPoints.emplace_back(Point2{{+1.f, +1.f}});
+    for (int i = 2; i < NumberOfEvaluations; ++i) {
+        searchPoints.emplace_back(Point2{{uniform(randomEngine), uniform(randomEngine)}});
+    }
+
+    // MapSize loop {{{2
+    for (int MapSize = FirstMapSize; MapSize <= MaxMapSize; MapSize *= StepMultiplier) {
+        Runner runner(searchPoints);
+        cout << setw(8) << MapSize * MapSize << std::flush;
+
+        // initialize map with random values {{{2
+        Spline spline(-1.f, 1.f, MapSize, -1.f, 1.f, MapSize);
+        Spline2 spline2(-1.f, 1.f, MapSize, -1.f, 1.f, MapSize);
+        Spline3 spline3(-1.f, 1.f, MapSize, -1.f, 1.f, MapSize);
+        for (int i = 0; i < spline.GetNPoints(); ++i) {
+            const float xyz[3] = {uniform(randomEngine), uniform(randomEngine),
+                                  uniform(randomEngine)};
+            spline.Fill(i, xyz);
+            spline2.Fill(i, xyz);
+            spline3.Fill(i, xyz);
+        }
+
+        // run Benchmarks {{{2
+        for (EnabledTests i = EnabledTests(0); i < NBenchmarks; ++i) {
+            VectorizeBuffer<Point2> vectorizer;
+            switch (int(i)) {
+            case Scalar:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline.GetValueScalar(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Alice:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline.GetValueAlice(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Autovectorized:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline.GetValueAutovec(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Float4:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline.GetValue(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Float16:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline.GetValue16(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Float12:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline2.GetValue(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Float12Interleaved:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    const auto &p2 = spline3.GetValue(p);
+                    fakeRead(p2);
+                });
+                break;
+            case Horizontal1:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    if (0 == vectorizer(p)) {
+                        const auto &p2 = spline.GetValue(vectorizer.input);
+                        fakeRead(p2);
+                    }
+                });
+                break;
+            case Horizontal2:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    if (0 == vectorizer(p)) {
+                        const auto &p2 = spline2.GetValue(vectorizer.input);
+                        fakeRead(p2);
+                    }
+                });
+                break;
+            case Horizontal3:  // {{{3
+                runner.benchmark(i, [&](const Point2 &p) {
+                    if (0 == vectorizer(p)) {
+                        const auto &p2 = spline3.GetValue(vectorizer.input);
+                        fakeRead(p2);
+                    }
+                });
+                break;
+            default:  // {{{3
+                break;
+            }
+        }
+        // print search timings {{{2
+        if (TestInfo(Scalar)) {
+            for (EnabledTests i = EnabledTests(0); i < NBenchmarks; ++i) {
+                if (i != Scalar) {
+                    runner.printRatio(Scalar, i);
+                }
+            }
+        }
+        cout << std::flush;
+
+        // verify equivalence {{{2
+        {
+            bool failed = false;
+            VectorizeBuffer<Point2> vectorizer2;
+            VectorizeBuffer<Point3> vectorizer3;
+            for (const auto &p : searchPoints) {
+                const auto &ps = spline.GetValueScalar(p);
+                if (TestInfo(Alice)) {  //{{{3
+                    const auto &pv = spline.GetValueAlice(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nAlice not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                if (TestInfo(Autovectorized)) {  //{{{3
+                    const auto &pv = spline.GetValueAutovec(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nAutovectorized not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                if (TestInfo(Float4)) {  //{{{3
+                    const auto &pv = spline.GetValue(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nFloat4 not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                if (TestInfo(Float16)) {  //{{{3
+                    const auto &pv = spline.GetValue16(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nFloat16 not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                if (TestInfo(Float12)) {  //{{{3
+                    const auto &pv = spline2.GetValue(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nFloat12 not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                if (TestInfo(Float12Interleaved)) {  //{{{3
+                    const auto &pv = spline3.GetValue(p);
+                    for (int i = 0; i < 3; ++i) {
+                        if (std::abs(ps[i] - pv[i]) > 0.00001f) {
+                            std::cout << "\nFloat12Interleaved not equal at " << p << ": " << ps
+                                      << " vs. " << pv;
+                            failed = true;
+                            break;
+                        }
+                    }
+                }
+                vectorizer3(ps);
+                if (0 == vectorizer2(p)) {
+                    if (TestInfo(Horizontal1)) {  //{{{3
+                        const auto &pv = spline.GetValue(vectorizer2.input);
+                        for (int i = 0; i < 3; ++i) {
+                            if (any_of(abs(vectorizer3.input[i] - pv[i]) > 0.00001f)) {
+                                cout << "\nHorizontal1 not equal at " << vectorizer2.input
+                                     << ": " << vectorizer3.input << " vs. " << pv;
+                                failed = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (TestInfo(Horizontal2)) {  //{{{3
+                        const auto &pv = spline2.GetValue(vectorizer2.input);
+                        for (int i = 0; i < 3; ++i) {
+                            if (any_of(abs(vectorizer3.input[i] - pv[i]) > 0.00001f)) {
+                                cout << "\nHorizontal2 not equal at \n" << vectorizer2.input
+                                     << ":\n" << vectorizer3.input << " vs.\n" << pv;
+                                failed = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (TestInfo(Horizontal3)) {  //{{{3
+                        const auto &pv = spline3.GetValue(vectorizer2.input);
+                        for (int i = 0; i < 3; ++i) {
+                            if (any_of(abs(vectorizer3.input[i] - pv[i]) > 0.00001f)) {
+                                cout << "\nHorizontal3 not equal at \n" << vectorizer2.input
+                                     << ":\n" << vectorizer3.input << " vs.\n" << pv;
+                                failed = true;
+                                break;
+                            }
+                        }
+                    }
+                }  //{{{3
+            }
+            if (failed) {
+                //std::cout << '\n' << spline. << '\n';
+                return 1;
+            } else {
+                cout << " ✓";
+            }
+        }
+        cout << std::endl;
+    }
+    return 0;
+}  // }}}1
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/examples/spline/spline2.h vc-1.3.0/examples/spline/spline2.h
--- vc-0.7.4/examples/spline/spline2.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/spline2.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,250 @@
+/*{{{
+    Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+
+This work is derived from a class in ALICE with the following copyright notice:
+    **************************************************************************
+    * This file is property of and copyright by the ALICE HLT Project        *
+    * ALICE Experiment at CERN, All rights reserved.                         *
+    *                                                                        *
+    * Primary Authors: Sergey Gorbunov <sergey.gorbunov@cern.ch>             *
+    *                  for The ALICE HLT Project.                            *
+    *                                                                        *
+    * Permission to use, copy, modify and distribute this software and its   *
+    * documentation strictly for non-commercial purposes is hereby granted   *
+    * without fee, provided that the above copyright notice appears in all   *
+    * copies and that both the copyright notice and this permission notice   *
+    * appear in the supporting documentation. The authors make no claims     *
+    * about the suitability of this software for any purpose. It is          *
+    * provided "as is" without express or implied warranty.                  *
+    **************************************************************************
+}}}*/
+
+#ifndef SPLINE2_H_
+#define SPLINE2_H_
+
+#include <utility>
+#include <array>
+#include <tuple>
+#include <Vc/Vc>
+#include <Vc/vector>
+#include "spline.h"
+
+//* This file is property of and copyright by the ALICE HLT Project        *
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+class Spline2
+{
+public:
+    typedef std::array<float, 2> Point2;
+    typedef std::array<float, 3> Point3;
+
+    typedef Vc::simdize<Point2> Point2V;
+    typedef Vc::simdize<Point3> Point3V;
+
+    Spline2(float minA, float maxA, int nBinsA, float minB, float maxB, int nBinsB);
+
+    /**  Filling of points */
+    template <typename F> void Fill(F &&func);
+    /**  Filling of points */
+    void Fill(int ind, float x, float y, float z);
+    /**  Filling of points */
+    void Fill(int ind, const float XYZ[]);
+
+    /**  Get A,B by the point index */
+    std::pair<float, float> GetAB(int ind) const;
+
+    /** Calculate interpolated value at the given point(s) */
+    Point3 GetValue(Point2) const;
+    Point3V GetValue(Point2V ab) const;
+
+    /**  Get size of the grid */
+    int GetMapSize() const;
+
+    /**  Get N of point on the grid */
+    int GetNPoints() const;
+
+private:
+    /** copy constructor prohibited */
+    Spline2(const Spline2 &);
+    /** assignment operator prohibited */
+    Spline2 &operator=(const Spline2 &);
+
+    /** spline 2-nd order, 3 points, da = a - point 1 */
+    static float GetSpline2(float *v, float da);
+
+    const int fNA;        // N points A axis
+    const int fNB;        // N points A axis
+    const int fN;         // N points total
+    const float fMinA;    // min A axis
+    const float fMinB;    // min B axis
+    const float fStepA;   // step between points A axis
+    const float fStepB;   // step between points B axis
+    const float fScaleA;  // scale A axis
+    const float fScaleB;  // scale B axis
+    Vc::vector<float, Vc::Allocator<float>> fXYZ;  // array of points, {X,Y,Z,0} values
+};
+
+inline void Spline2::Fill(int ind, float x, float y, float z)
+{
+    ind = ind / fNB + fNA * (ind % fNB);
+    fXYZ[ind] = x;
+    fXYZ[ind + fN] = y;
+    fXYZ[ind + 2 * fN] = z;
+}
+
+inline void Spline2::Fill(int ind, const float XYZ[])
+{
+    Fill(ind, XYZ[0], XYZ[1], XYZ[2]);
+}
+
+template <typename F> inline void Spline2::Fill(F &&func)
+{
+    for (int i = 0; i < GetNPoints(); i++) {
+        float a, b;
+        std::tie(a, b) = GetAB(i);
+        std::array<float, 3> xyz = func(a, b);
+        Fill(i, xyz[0], xyz[1], xyz[2]);
+    }
+}
+
+inline std::pair<float, float> Spline2::GetAB(int ind) const
+{
+    return std::make_pair(fMinA + (ind / fNA) * fStepA, fMinB + (ind % fNB) * fStepB);
+}
+
+inline int Spline2::GetMapSize() const { return 4 * sizeof(float) * fN; }
+
+inline int Spline2::GetNPoints() const { return fN; }
+
+inline float Spline2::GetSpline2(float *v, float x)
+{
+    return 0.5f * x * ((v[0] + v[2] - v[1] - v[1]) * x + v[2] - v[0]) + v[1];
+}
+
+// spline 3-st order,  4 points, da = a - point 1 {{{1
+template <typename T> static Vc_ALWAYS_INLINE T GetSpline3(T v0, T v1, T v2, T v3, T x)
+{
+    const T dv = v2 - v1;
+    const T z0 = 0.5f * (v2 - v0);
+    const T z1 = 0.5f * (v3 - v1);
+    return (x * x) * ((z1 - dv) * (x - 1) + (z0 - dv) * (x - 2)) + (z0 * x + v1);
+}
+
+template <typename T> static Vc_ALWAYS_INLINE T GetSpline3(const T v[], T x)
+{
+    return GetSpline3(v[0], v[1], v[2], v[3], x);
+}
+
+inline Point3 Spline2::GetValue(Point2 ab) const  //{{{1
+{
+    float da1, db1;
+    int iA, iB;
+    std::tie(iA, iB, da1, db1) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    typedef Vc::SimdArray<float, 4> float4;
+    typedef Vc::SimdArray<float, 12> float12;
+    const float4 da = da1;
+    const float12 db = db1;
+
+    const float *m0 = &fXYZ[iA + iB * fNA];
+    const float *m1 = m0 + fNA;
+    const float *m2 = m1 + fNA;
+    const float *m3 = m2 + fNA;
+
+    const float12 xyz = GetSpline3(
+        Vc::simd_cast<float12>(float4(m0), float4(m0 + fN), float4(m0 + 2 * fN)),
+        Vc::simd_cast<float12>(float4(m1), float4(m1 + fN), float4(m1 + 2 * fN)),
+        Vc::simd_cast<float12>(float4(m2), float4(m2 + fN), float4(m2 + 2 * fN)),
+        Vc::simd_cast<float12>(float4(m3), float4(m3 + fN), float4(m3 + 2 * fN)), db);
+
+    float4 v[4];
+    Vc::tie(v[0], v[1], v[2], v[3]) =
+        Vc::transpose(Vc::simd_cast<float4, 0>(xyz), Vc::simd_cast<float4, 1>(xyz),
+                      Vc::simd_cast<float4, 2>(xyz), float4::Zero());
+
+    float4 res = GetSpline3(v[0], v[1], v[2], v[3], da);
+    return {{res[0], res[1], res[2]}};
+}
+
+inline Spline2::Point3V Spline2::GetValue(Point2V ab) const  //{{{1
+{
+    index_v iA, iB;
+    float_v da, db;
+    std::tie(iA, iB, da, db) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    auto ind = iA + iB * fNA;
+    Point3V xyz;
+
+    {
+        float_v x[4][4];
+        Vc::tie(x[0][0], x[1][0], x[2][0], x[3][0]) = fXYZ[ind];
+        Vc::tie(x[0][1], x[1][1], x[2][1], x[3][1]) = fXYZ[ind + fNA];
+        Vc::tie(x[0][2], x[1][2], x[2][2], x[3][2]) = fXYZ[ind + 2 * fNA];
+        Vc::tie(x[0][3], x[1][3], x[2][3], x[3][3]) = fXYZ[ind + 3 * fNA];
+        xyz[0] = GetSpline3(GetSpline3(x[0], db), GetSpline3(x[1], db),
+                            GetSpline3(x[2], db), GetSpline3(x[3], db), da);
+    }
+    ind += fN;
+    {
+        float_v y[4][4];
+        Vc::tie(y[0][0], y[1][0], y[2][0], y[3][0]) = fXYZ[ind];
+        Vc::tie(y[0][1], y[1][1], y[2][1], y[3][1]) = fXYZ[ind + fNA];
+        Vc::tie(y[0][2], y[1][2], y[2][2], y[3][2]) = fXYZ[ind + 2 * fNA];
+        Vc::tie(y[0][3], y[1][3], y[2][3], y[3][3]) = fXYZ[ind + 3 * fNA];
+        xyz[1] = GetSpline3(GetSpline3(y[0], db), GetSpline3(y[1], db),
+                            GetSpline3(y[2], db), GetSpline3(y[3], db), da);
+    }
+    ind += fN;
+    {
+        float_v z[4][4];
+        Vc::tie(z[0][0], z[1][0], z[2][0], z[3][0]) = fXYZ[ind];
+        Vc::tie(z[0][1], z[1][1], z[2][1], z[3][1]) = fXYZ[ind + fNA];
+        Vc::tie(z[0][2], z[1][2], z[2][2], z[3][2]) = fXYZ[ind + 2 * fNA];
+        Vc::tie(z[0][3], z[1][3], z[2][3], z[3][3]) = fXYZ[ind + 3 * fNA];
+        xyz[2] = GetSpline3(GetSpline3(z[0], db), GetSpline3(z[1], db),
+                            GetSpline3(z[2], db), GetSpline3(z[3], db), da);
+    }
+    return xyz;
+}
+
+inline Spline2::Spline2(float minA, float maxA, int nBinsA, float minB,  //{{{1
+                        float maxB, int nBinsB)
+    : fNA(nBinsA < 4 ? 4 : nBinsA)
+    , fNB(nBinsB < 4 ? 4 : nBinsB)
+    , fN(fNA * fNB)
+    , fMinA(minA)
+    , fMinB(minB)
+    , fStepA(((maxA <= minA ? minA + 1 : maxA) - minA) / (fNA - 1))
+    , fStepB(((maxB <= minB ? minB + 1 : maxB) - minB) / (fNB - 1))
+    , fScaleA(1.f / fStepA)
+    , fScaleB(1.f / fStepB)
+    , fXYZ(3 * fN, 0.f)
+{
+}
+//}}}1
+
+#endif  // SPLINE2_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/examples/spline/spline3.h vc-1.3.0/examples/spline/spline3.h
--- vc-0.7.4/examples/spline/spline3.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/spline3.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,206 @@
+/*{{{
+    Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+
+This work is derived from a class in ALICE with the following copyright notice:
+    **************************************************************************
+    * This file is property of and copyright by the ALICE HLT Project        *
+    * ALICE Experiment at CERN, All rights reserved.                         *
+    *                                                                        *
+    * Primary Authors: Sergey Gorbunov <sergey.gorbunov@cern.ch>             *
+    *                  for The ALICE HLT Project.                            *
+    *                                                                        *
+    * Permission to use, copy, modify and distribute this software and its   *
+    * documentation strictly for non-commercial purposes is hereby granted   *
+    * without fee, provided that the above copyright notice appears in all   *
+    * copies and that both the copyright notice and this permission notice   *
+    * appear in the supporting documentation. The authors make no claims     *
+    * about the suitability of this software for any purpose. It is          *
+    * provided "as is" without express or implied warranty.                  *
+    **************************************************************************
+}}}*/
+
+#ifndef SPLINE3_H_
+#define SPLINE3_H_
+
+#include <utility>
+#include <array>
+#include <tuple>
+#include <Vc/Vc>
+#include <Vc/vector>
+#include "spline2.h"
+
+//* This file is property of and copyright by the ALICE HLT Project        *
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+class Spline3
+{
+public:
+    Spline3(float minA, float maxA, int nBinsA, float minB, float maxB, int nBinsB);
+
+    /**  Filling of points */
+    template <typename F> void Fill(F &&func);
+    /**  Filling of points */
+    void Fill(int ind, float x, float y, float z);
+    /**  Filling of points */
+    void Fill(int ind, const float XYZ[]);
+
+    /**  Get A,B by the point index */
+    std::pair<float, float> GetAB(int ind) const;
+
+    /** Calculate interpolated value at the given point(s) */
+    Point3 GetValue(Point2) const;
+    Point3V GetValue(const Point2V &ab) const;
+
+    /**  Get size of the grid */
+    int GetMapSize() const;
+
+    /**  Get N of point on the grid */
+    int GetNPoints() const;
+
+private:
+    /** copy constructor prohibited */
+    Spline3(const Spline3 &);
+    /** assignment operator prohibited */
+    Spline3 &operator=(const Spline3 &);
+
+    const int fNA;        // N points A axis
+    const int fNB;        // N points A axis
+    const int fN;         // N points total
+    const float fMinA;    // min A axis
+    const float fMinB;    // min B axis
+    const float fStepA;   // step between points A axis
+    const float fStepB;   // step between points B axis
+    const float fScaleA;  // scale A axis
+    const float fScaleB;  // scale B axis
+    Vc::vector<Point3> fXYZ;
+};
+
+inline void Spline3::Fill(int ind, float x, float y, float z)
+{
+    ind = ind / fNB + fNA * (ind % fNB);
+    fXYZ[ind][0] = x;
+    fXYZ[ind][1] = y;
+    fXYZ[ind][2] = z;
+}
+
+inline void Spline3::Fill(int ind, const float XYZ[])
+{
+    Fill(ind, XYZ[0], XYZ[1], XYZ[2]);
+}
+
+template <typename F> inline void Spline3::Fill(F &&func)
+{
+    for (int i = 0; i < GetNPoints(); i++) {
+        float a, b;
+        std::tie(a, b) = GetAB(i);
+        std::array<float, 3> xyz = func(a, b);
+        Fill(i, xyz[0], xyz[1], xyz[2]);
+    }
+}
+
+inline std::pair<float, float> Spline3::GetAB(int ind) const
+{
+    return std::make_pair(fMinA + (ind / fNA) * fStepA, fMinB + (ind % fNB) * fStepB);
+}
+
+inline int Spline3::GetMapSize() const { return 4 * sizeof(float) * fN; }
+
+inline int Spline3::GetNPoints() const { return fN; }
+
+inline Point3 Spline3::GetValue(Point2 ab) const  //{{{1
+{
+    float da1, db1;
+    int iA, iB;
+    std::tie(iA, iB, da1, db1) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    typedef Vc::SimdArray<float, 4> float4;
+    typedef Vc::SimdArray<float, 12> float12;
+    const float4 da = da1;
+    const float12 db = db1;
+
+    const float *m0 = &fXYZ[iA + iB * fNA][0];
+    const float *m1 = m0 + fNA * 3;
+    const float *m2 = m1 + fNA * 3;
+    const float *m3 = m2 + fNA * 3;
+
+    const float12 xyz = GetSpline3(float12(m0),  // x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3
+                                   float12(m1), float12(m2), float12(m3), db);
+
+    const float4 t0 = Vc::simd_cast<float4, 0>(xyz);  // x0 y0 z0 x1
+    const float4 t1 = Vc::simd_cast<float4, 1>(xyz);  // y1 z1 x2 y2
+    const float4 t2 = Vc::simd_cast<float4, 2>(xyz);  // z2 x3 y3 z3
+
+    const float4 res =
+        GetSpline3(t0, t0.shifted(3, t1), t1.shifted(2, t2), t2.shifted(1), da);
+    return {{res[0], res[1], res[2]}};
+}
+
+Point3V Spline3::GetValue(const Point2V &ab) const  //{{{1
+{
+    index_v iA, iB;
+    float_v da, db;
+    std::tie(iA, iB, da, db) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    float_v vx[4];
+    float_v vy[4];
+    float_v vz[4];
+    auto ind = iA + iB * fNA;
+    for (int i = 0; i < 4; i++) {
+        float_v x[4], y[4], z[4];
+        Vc::tie(x[0], y[0], z[0]) = fXYZ[ind][0];
+        Vc::tie(x[1], y[1], z[1]) = fXYZ[ind + fNA][0];
+        Vc::tie(x[2], y[2], z[2]) = fXYZ[ind + 2 * fNA][0];
+        Vc::tie(x[3], y[3], z[3]) = fXYZ[ind + 3 * fNA][0];
+        vx[i] = GetSpline3<float_v>(x[0], x[1], x[2], x[3], db);
+        vy[i] = GetSpline3<float_v>(y[0], y[1], y[2], y[3], db);
+        vz[i] = GetSpline3<float_v>(z[0], z[1], z[2], z[3], db);
+        ind += 1;
+    }
+    Point3V XYZ;
+    XYZ[0] = GetSpline3<float_v>(vx, da);
+    XYZ[1] = GetSpline3<float_v>(vy, da);
+    XYZ[2] = GetSpline3<float_v>(vz, da);
+    return XYZ;
+}
+
+inline Spline3::Spline3(float minA, float maxA, int nBinsA, float minB,  //{{{1
+                        float maxB, int nBinsB)
+    : fNA(nBinsA < 4 ? 4 : nBinsA)
+    , fNB(nBinsB < 4 ? 4 : nBinsB)
+    , fN(fNA * fNB)
+    , fMinA(minA)
+    , fMinB(minB)
+    , fStepA(((maxA <= minA ? minA + 1 : maxA) - minA) / (fNA - 1))
+    , fStepB(((maxB <= minB ? minB + 1 : maxB) - minB) / (fNB - 1))
+    , fScaleA(1.f / fStepA)
+    , fScaleB(1.f / fStepB)
+    , fXYZ(fN)
+{
+}
+//}}}1
+
+#endif  // SPLINE3_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/examples/spline/spline.cpp vc-1.3.0/examples/spline/spline.cpp
--- vc-0.7.4/examples/spline/spline.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/spline.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,260 @@
+/*{{{
+    Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+
+This work is derived from a class in ALICE with the following copyright notice:
+    **************************************************************************
+    * This file is property of and copyright by the ALICE HLT Project        *
+    * ALICE Experiment at CERN, All rights reserved.                         *
+    *                                                                        *
+    * Primary Authors: Sergey Gorbunov <sergey.gorbunov@cern.ch>             *
+    *                  for The ALICE HLT Project.                            *
+    *                                                                        *
+    * Permission to use, copy, modify and distribute this software and its   *
+    * documentation strictly for non-commercial purposes is hereby granted   *
+    * without fee, provided that the above copyright notice appears in all   *
+    * copies and that both the copyright notice and this permission notice   *
+    * appear in the supporting documentation. The authors make no claims     *
+    * about the suitability of this software for any purpose. It is          *
+    * provided "as is" without express or implied warranty.                  *
+    **************************************************************************
+}}}*/
+
+#include "spline.h"
+#include <Vc/Vc>
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+Spline::Spline(float minA, float maxA, int nBinsA, float minB, float maxB,  //{{{1
+               int nBinsB)
+    : fNA(nBinsA < 4 ? 4 : nBinsA)
+    , fNB(nBinsB < 4 ? 4 : nBinsB)
+    , fN(fNA * fNB)
+    , fMinA(minA)
+    , fMinB(minB)
+    , fStepA(((maxA <= minA ? minA + 1 : maxA) - minA) / (fNA - 1))
+    , fStepB(((maxB <= minB ? minB + 1 : maxB) - minB) / (fNB - 1))
+    , fScaleA(1.f / fStepA)
+    , fScaleB(1.f / fStepB)
+    , fXYZ(fN, DataPoint::Zero())
+{
+}
+
+// spline 3-st order,  4 points, da = a - point 1 {{{1
+template <typename T> static inline T GetSpline3(T v0, T v1, T v2, T v3, T x)
+{
+    const T dv = v2 - v1;
+    const T z0 = 0.5f * (v2 - v0);
+    const T z1 = 0.5f * (v3 - v1);
+    return (x * x) * ((z1 - dv) * (x - 1) + (z0 - dv) * (x - 2)) + (z0 * x + v1);
+    //return x * x * ((z1 - dv + z0 - dv) * (x - 1) - (z0 - dv)) + z0 * x + v1;
+}
+
+template <typename T> static inline T GetSpline3(const T *v, T x)
+{
+    return GetSpline3(v[0], v[1], v[2], v[3], x);
+}
+
+Point3 Spline::GetValue(Point2 ab) const  //{{{1
+{
+    float da1, db1;
+    int iA, iB;
+    std::tie(iA, iB, da1, db1) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+    int ind = iA * fNB + iB;
+
+    typedef Vc::SimdArray<float, 4> float4;
+    const float4 da = da1;
+    const float4 db = db1;
+
+    float4 v[4];
+    const float4 *m = &fXYZ[0];
+
+    for (int i = 0; i < 4; i++) {
+        v[i] = GetSpline3(m[ind + 0], m[ind + 1], m[ind + 2], m[ind + 3], db);
+        ind += fNB;
+    }
+    float4 res = GetSpline3(v[0], v[1], v[2], v[3], da);
+    return {{res[0], res[1], res[2]}};
+}
+
+Point3 Spline::GetValue16(Point2 ab) const  //{{{1
+{
+    float da1, db1;
+    int iA, iB;
+    std::tie(iA, iB, da1, db1) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    typedef Vc::SimdArray<float, 4> float4;
+    typedef Vc::SimdArray<float, 16> float16;
+    const float4 da = da1;
+    const float16 db = db1;
+
+    const float4 *m0 = &fXYZ[iA * fNB + iB];
+    const float4 *m1 = m0 + fNB;
+    const float4 *m2 = m1 + fNB;
+    const float4 *m3 = m2 + fNB;
+    const float16 v0123 =
+        GetSpline3(Vc::simd_cast<float16>(m0[0], m1[0], m2[0], m3[0]),
+                   Vc::simd_cast<float16>(m0[1], m1[1], m2[1], m3[1]),
+                   Vc::simd_cast<float16>(m0[2], m1[2], m2[2], m3[2]),
+                   Vc::simd_cast<float16>(m0[3], m1[3], m2[3], m3[3]), db);
+    const float4 res =
+        GetSpline3(Vc::simd_cast<float4, 0>(v0123), Vc::simd_cast<float4, 1>(v0123),
+                   Vc::simd_cast<float4, 2>(v0123), Vc::simd_cast<float4, 3>(v0123), da);
+    return {{res[0], res[1], res[2]}};
+}
+
+Point3 Spline::GetValueScalar(Point2 ab) const  //{{{1
+{
+    float da, db;
+    int iA, iB;
+    std::tie(iA, iB, da, db) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+    int ind = iA * fNB + iB;
+
+    float vx[4];
+    float vy[4];
+    float vz[4];
+    for (int i = 0; i < 4; i++) {
+        vx[i] = GetSpline3(fXYZ[ind][0], fXYZ[ind + 1][0], fXYZ[ind + 2][0],
+                           fXYZ[ind + 3][0], db);
+        vy[i] = GetSpline3(fXYZ[ind][1], fXYZ[ind + 1][1], fXYZ[ind + 2][1],
+                           fXYZ[ind + 3][1], db);
+        vz[i] = GetSpline3(fXYZ[ind][2], fXYZ[ind + 1][2], fXYZ[ind + 2][2],
+                           fXYZ[ind + 3][2], db);
+        ind += fNB;
+    }
+    return {{GetSpline3(vx, da), GetSpline3(vy, da), GetSpline3(vz, da)}};
+}
+
+Point3 Spline::GetValueAutovec(Point2 ab) const  //{{{1
+{
+    float da, db;
+    int iA, iB;
+    std::tie(iA, iB, da, db) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+    int ind = iA * fNB + iB;
+
+    float vx[4];
+    float vy[4];
+    float vz[4];
+    const float *m = reinterpret_cast<const float *>(&fXYZ[0]);
+    for (int i = 0; i < 4; i++) {
+        int ind4 = ind * 4;
+        vx[i] = GetSpline3(m[ind4 + 0], m[ind4 + 4], m[ind4 + 8], m[ind4 + 12], db);
+        vy[i] = GetSpline3(m[ind4 + 1], m[ind4 + 5], m[ind4 + 9], m[ind4 + 13], db);
+        vz[i] = GetSpline3(m[ind4 + 2], m[ind4 + 6], m[ind4 + 10], m[ind4 + 14], db);
+        ind += fNB;
+    }
+    return {{GetSpline3(vx, da), GetSpline3(vy, da), GetSpline3(vz, da)}};
+}
+
+Point3V Spline::GetValue(const Point2V &ab) const  //{{{1
+{
+    index_v iA, iB;
+    float_v da, db;
+    std::tie(iA, iB, da, db) =
+        evaluatePosition(ab, {{fMinA, fMinB}}, {{fScaleA, fScaleB}}, fNA, fNB);
+
+    float_v vx[4];
+    float_v vy[4];
+    float_v vz[4];
+    auto ind = iA * fNB + iB;
+    const auto map = Vc::make_interleave_wrapper<float_v>(&fXYZ[0]);
+    for (int i = 0; i < 4; i++) {
+        float_v x[4], y[4], z[4];
+        Vc::tie(x[0], y[0], z[0]) = map[ind];
+        Vc::tie(x[1], y[1], z[1]) = map[ind + 1];
+        Vc::tie(x[2], y[2], z[2]) = map[ind + 2];
+        Vc::tie(x[3], y[3], z[3]) = map[ind + 3];
+        vx[i] = GetSpline3<float_v>(x[0], x[1], x[2], x[3], db);
+        vy[i] = GetSpline3<float_v>(y[0], y[1], y[2], y[3], db);
+        vz[i] = GetSpline3<float_v>(z[0], z[1], z[2], z[3], db);
+        ind += fNB;
+    }
+    Point3V XYZ;
+    XYZ[0] = GetSpline3<float_v>(vx, da);
+    XYZ[1] = GetSpline3<float_v>(vy, da);
+    XYZ[2] = GetSpline3<float_v>(vz, da);
+    return XYZ;
+}
+
+// Point3 Spline::GetValueAlice(Point2 ab) const {{{1
+#ifdef Vc_GCC
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+__attribute__((optimize("no-tree-vectorize")))
+#endif
+Point3 Spline::GetValueAlice(Point2 ab) const
+{
+    float lA = (ab[0] - fMinA) * fScaleA - 1.f;
+    int iA = (int)lA;
+    if (lA < 0) iA = 0;
+    else if (iA > fNA - 4) iA = fNA - 4;
+
+    float lB = (ab[1] - fMinB) * fScaleB - 1.f;
+    int iB = (int)lB;
+    if (lB < 0) iB = 0;
+    else if (iB > fNB - 4) iB = fNB - 4;
+
+    Point3 XYZ;
+    if (Vc::float_v::Size == 4) {
+        Vc::float_v da = lA - iA;
+        Vc::float_v db = lB - iB;
+
+        Vc::float_v v[4];
+        int ind = iA * fNB + iB;
+        const Vc::float_v *m = reinterpret_cast<const Vc::float_v *>(&fXYZ[0]);
+
+        for (int i = 0; i < 4; i++) {
+            v[i] = GetSpline3(m[ind + 0], m[ind + 1], m[ind + 2], m[ind + 3], db);
+            ind += fNB;
+        }
+        Vc::float_v res = GetSpline3(v[0], v[1], v[2], v[3], da);
+        XYZ[0] = res[0];
+        XYZ[1] = res[1];
+        XYZ[2] = res[2];
+    } else {
+        float da = lA - iA;
+        float db = lB - iB;
+
+        float vx[4];
+        float vy[4];
+        float vz[4];
+        int ind = iA * fNB + iB;
+        const float *m = reinterpret_cast<const float *>(&fXYZ[0]);
+        for (int i = 0; i < 4; i++) {
+            int ind4 = ind * 4;
+            vx[i] = GetSpline3(m[ind4 + 0], m[ind4 + 4], m[ind4 + 8], m[ind4 + 12], db);
+            vy[i] = GetSpline3(m[ind4 + 1], m[ind4 + 5], m[ind4 + 9], m[ind4 + 13], db);
+            vz[i] = GetSpline3(m[ind4 + 2], m[ind4 + 6], m[ind4 + 10], m[ind4 + 14], db);
+            ind += fNB;
+        }
+        XYZ[0] = GetSpline3(vx, da);
+        XYZ[1] = GetSpline3(vy, da);
+        XYZ[2] = GetSpline3(vz, da);
+    }
+    return XYZ;
+}
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/examples/spline/spline.h vc-1.3.0/examples/spline/spline.h
--- vc-0.7.4/examples/spline/spline.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/spline/spline.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,181 @@
+/*{{{
+    Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+
+This work is derived from a class in ALICE with the following copyright notice:
+    **************************************************************************
+    * This file is property of and copyright by the ALICE HLT Project        *
+    * ALICE Experiment at CERN, All rights reserved.                         *
+    *                                                                        *
+    * Primary Authors: Sergey Gorbunov <sergey.gorbunov@cern.ch>             *
+    *                  for The ALICE HLT Project.                            *
+    *                                                                        *
+    * Permission to use, copy, modify and distribute this software and its   *
+    * documentation strictly for non-commercial purposes is hereby granted   *
+    * without fee, provided that the above copyright notice appears in all   *
+    * copies and that both the copyright notice and this permission notice   *
+    * appear in the supporting documentation. The authors make no claims     *
+    * about the suitability of this software for any purpose. It is          *
+    * provided "as is" without express or implied warranty.                  *
+    **************************************************************************
+}}}*/
+
+#ifndef SPLINE_H_
+#define SPLINE_H_
+
+#include <utility>
+#include <array>
+#include <tuple>
+#include <Vc/simdize>
+#include <Vc/vector>
+
+//* This file is property of and copyright by the ALICE HLT Project        *
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+typedef std::array<float, 2> Point2;
+typedef std::array<float, 3> Point3;
+
+typedef Vc::simdize<Point2> Point2V;
+typedef Vc::simdize<Point3> Point3V;
+
+class Spline
+{
+public:
+    Spline(float minA, float maxA, int nBinsA, float minB, float maxB, int nBinsB);
+
+    /**  Filling of points */
+    template <typename F> void Fill(F &&func);
+    /**  Filling of points */
+    void Fill(int ind, float x, float y, float z);
+    /**  Filling of points */
+    void Fill(int ind, const float XYZ[]);
+
+    /**  Get A,B by the point index */
+    std::pair<float, float> GetAB(int ind) const;
+
+    /** Calculate interpolated value at the given point(s) */
+    Point3 GetValue(Point2) const;
+    Point3 GetValue16(Point2 ab) const;
+    Point3 GetValueScalar(Point2) const;
+    Point3 GetValueAutovec(Point2 ab) const;
+    Point3V GetValue(const Point2V &) const;
+    Point3 GetValueAlice(Point2 ab) const;
+
+    /**  Get size of the grid */
+    int GetMapSize() const;
+
+    /**  Get N of point on the grid */
+    int GetNPoints() const;
+
+private:
+    /** copy constructor prohibited */
+    Spline(const Spline &);
+    /** assignment operator prohibited */
+    Spline &operator=(const Spline &);
+
+    /** spline 2-nd order, 3 points, da = a - point 1 */
+    static float GetSpline2(float *v, float da);
+
+    const int fNA;        // N points A axis
+    const int fNB;        // N points A axis
+    const int fN;         // N points total
+    const float fMinA;    // min A axis
+    const float fMinB;    // min B axis
+    const float fStepA;   // step between points A axis
+    const float fStepB;   // step between points B axis
+    const float fScaleA;  // scale A axis
+    const float fScaleB;  // scale B axis
+    typedef Vc::SimdArray<float, 4> DataPoint;
+    Vc::vector<DataPoint> fXYZ;  // array of points, {X,Y,Z,0} values
+};
+
+inline void Spline::Fill(int ind, float x, float y, float z)
+{
+    fXYZ[ind][0] = x;
+    fXYZ[ind][1] = y;
+    fXYZ[ind][2] = z;
+}
+
+inline void Spline::Fill(int ind, const float XYZ[])
+{
+    Fill(ind, XYZ[0], XYZ[1], XYZ[2]);
+}
+
+template <typename F> inline void Spline::Fill(F &&func)
+{
+    for (int i = 0; i < GetNPoints(); i++) {
+        float a, b;
+        std::tie(a, b) = GetAB(i);
+        std::array<float, 3> xyz = func(a, b);
+        Fill(i, xyz[0], xyz[1], xyz[2]);
+    }
+}
+
+inline std::pair<float, float> Spline::GetAB(int ind) const
+{
+    return std::make_pair(fMinA + (ind / fNA) * fStepA, fMinB + (ind % fNB) * fStepB);
+}
+
+inline int Spline::GetMapSize() const { return 4 * sizeof(float) * fN; }
+
+inline int Spline::GetNPoints() const { return fN; }
+
+inline float Spline::GetSpline2(float *v, float x)
+{
+    return 0.5f * x * ((v[0] + v[2] - v[1] - v[1]) * x + v[2] - v[0]) + v[1];
+}
+
+inline std::tuple<int, int, float, float> evaluatePosition(Point2 ab, Point2 min,
+                                                           Point2 scale, int na, int nb)
+{
+    const float lA = (ab[0] - min[0]) * scale[0] - 1.f;
+    const int iA = std::min(na - 4.f, std::max(lA, 0.f));
+
+    const float lB = (ab[1] - min[1]) * scale[1] - 1.f;
+    const int iB = std::min(nb - 4.f, std::max(lB, 0.f));
+
+    const float da = lA - iA;
+    const float db = lB - iB;
+
+    return std::make_tuple(iA, iB, da, db);
+}
+
+using Vc::float_v;
+typedef float_v::IndexType index_v;
+inline std::tuple<index_v, index_v, float_v, float_v> evaluatePosition(Point2V ab,
+                                                                       Point2 min,
+                                                                       Point2 scale,
+                                                                       int na, int nb)
+{
+    const float_v lA = (ab[0] - min[0]) * scale[0] - 1.f;
+    const auto iA = static_cast<index_v>(std::min(na - 4.f, std::max(lA, 0.f)));
+
+    const float_v lB = (ab[1] - min[1]) * scale[1] - 1.f;
+    const auto iB = static_cast<index_v>(std::min(nb - 4.f, std::max(lB, 0.f)));
+
+    const float_v da = lA - Vc::simd_cast<float_v>(iA);
+    const float_v db = lB - Vc::simd_cast<float_v>(iB);
+
+    return std::make_tuple(iA, iB, da, db);
+}
+
+#endif  // SPLINE_H_
diff -Nru vc-0.7.4/examples/test_inside/CMakeLists.txt vc-1.3.0/examples/test_inside/CMakeLists.txt
--- vc-0.7.4/examples/test_inside/CMakeLists.txt	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/test_inside/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1 @@
+build_example(test_inside main.cpp)
diff -Nru vc-0.7.4/examples/test_inside/main.cpp vc-1.3.0/examples/test_inside/main.cpp
--- vc-0.7.4/examples/test_inside/main.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/examples/test_inside/main.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,79 @@
+/*{{{
+    Copyright (C) 2013 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#include <Vc/Vc>
+
+#include <array>
+#include <algorithm>
+
+#include "../tsc.h"
+
+using Vc::double_v;
+using Vc::double_m;
+
+constexpr size_t ArraySize = 10240;
+
+using Point = std::array<double_v, 3>;
+using PointArray = std::array<Point, ArraySize / double_v::Size>;
+
+static const std::array<double_v, 3> origin  = {{ 0.2, 0.3, 0.4 }};
+static const std::array<double_v, 3> boxsize = {{ 0.5, 0.3, 0.1 }};
+
+double_m contains(const Point &point)
+{
+    double_m inside[3];
+    for (int dir = 0; dir < 3; ++dir) {
+        inside[dir] = abs(point[dir] - origin[dir]) < boxsize[dir];
+    }
+    return inside[0] && inside[1] && inside[2];
+}
+
+std::array<bool, ArraySize> contains(const PointArray &points)
+{
+    std::array<bool, ArraySize> inside;
+    auto storeIt = inside.begin();
+    for (const auto &p : points) {
+        contains(p).store(&*storeIt);
+        storeIt += double_v::Size;
+    }
+    return inside;
+}
+
+std::array<bool, ArraySize> g_inside;
+
+int Vc_CDECL main()
+{
+    PointArray points;
+    std::generate(points.begin(), points.end(), []() -> Point {
+        return {{ double_v::Random(), double_v::Random(), double_v::Random() }};
+    });
+
+    TimeStampCounter tsc;
+    tsc.start();
+    const auto &tmp = contains(points);
+    tsc.stop();
+    g_inside = tmp;
+    std::cout << tsc.cycles() << std::endl;
+
+    return 0;
+}
diff -Nru vc-0.7.4/examples/tsc.h vc-1.3.0/examples/tsc.h
--- vc-0.7.4/examples/tsc.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/examples/tsc.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,37 +1,49 @@
-/*
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    This program is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) version 3.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-*/
+}}}*/
 
-#ifndef TSC_H
-#define TSC_H
+#ifndef VC_TSC_H_
+#define VC_TSC_H_
 
 #ifdef _MSC_VER
 #include <intrin.h>
 #pragma intrinsic(__rdtsc)
 #endif
 
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
 class TimeStampCounter
 {
     public:
-        void Start();
-        void Stop();
-        unsigned long long Cycles() const;
+        void start();
+        void stop();
+        unsigned long long cycles() const;
 
     private:
         union Data {
@@ -40,9 +52,11 @@
         } m_start, m_end;
 };
 
-inline void TimeStampCounter::Start()
+inline void TimeStampCounter::start()
 {
-#ifdef _MSC_VER
+#if defined Vc_IMPL_MIC || defined __MIC__
+    asm volatile("xor %%eax,%%eax\n\tcpuid\n\trdtsc" : "=a"(m_start.b[0]), "=d"(m_start.b[1]) :: "ebx", "ecx" );
+#elif defined _MSC_VER
 	unsigned int tmp;
     m_start.a = __rdtscp(&tmp);
 #else
@@ -50,9 +64,11 @@
 #endif
 }
 
-inline void TimeStampCounter::Stop()
+inline void TimeStampCounter::stop()
 {
-#ifdef _MSC_VER
+#if defined Vc_IMPL_MIC || defined __MIC__
+    asm volatile("xor %%eax,%%eax\n\tcpuid\n\trdtsc" : "=a"(m_end.b[0]), "=d"(m_end.b[1]) :: "ebx", "ecx" );
+#elif defined _MSC_VER
 	unsigned int tmp;
     m_end.a = __rdtscp(&tmp);
 #else
@@ -60,9 +76,32 @@
 #endif
 }
 
-inline unsigned long long TimeStampCounter::Cycles() const
+inline unsigned long long TimeStampCounter::cycles() const
 {
     return m_end.a - m_start.a;
 }
 
-#endif // TSC_H
+inline std::ostream &operator<<(std::ostream &out, const TimeStampCounter &tsc)
+{
+    std::ostringstream o;
+    auto c = tsc.cycles();
+    int blocks[10];
+    int n = 0;
+    for (int digits = std::ceil(std::log10(c)); digits > 0; digits -= 3) {
+        blocks[n++] = c % 1000;
+        c /= 1000;
+    }
+    if (n == 0) {
+        return out;
+    }
+    o.fill('0');
+    o << blocks[--n];
+    while (n > 0) {
+        o << '\'' << std::setw(3) << blocks[--n];
+    }
+    return out << o.str();
+}
+
+#endif  // VC_TSC_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/generateForceToRegisters.rb vc-1.3.0/generateForceToRegisters.rb
--- vc-0.7.4/generateForceToRegisters.rb	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/generateForceToRegisters.rb	1969-12-31 18:00:00.000000000 -0600
@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-
-puts '#ifdef VC_GNU_ASM'
-
-1.upto 8 do |max|
-	print 'template<'
-	max.downto 2 do |i|
-		print "typename T#{i}, "
-	end
-	print "typename T1>\nstatic inline void ALWAYS_INLINE forceToRegisters("
-	max.downto 2 do |i|
-		print "const Vector<T#{i}> &x#{i}, "
-	end
-	print "const Vector<T1> &x1) {\n"
-	print "  __asm__ __volatile__(\"\"::"
-	max.downto 2 do |i|
-		print "\"x\"(x#{i}.data()), "
-	end
-	print "\"x\"(x1.data()));\n}\n"
-
-	print 'template<'
-	max.downto 2 do |i|
-		print "typename T#{i}, "
-	end
-	print "typename T1>\nstatic inline void ALWAYS_INLINE forceToRegistersDirty("
-	max.downto 2 do |i|
-		print "Vector<T#{i}> &x#{i}, "
-	end
-	print "Vector<T1> &x1) {\n"
-	print "  __asm__ __volatile__(\"\":"
-	max.downto 2 do |i|
-		print "\"+x\"(x#{i}.data()), "
-	end
-	print "\"+x\"(x1.data()));\n}\n"
-end
-
-puts '#elif defined(VC_MSVC)'
-
-1.upto 8 do |max|
-	puts '#pragma optimize("g", off)'
-	print 'template<'
-	max.downto 2 do |i|
-		print "typename T#{i}, "
-	end
-	print "typename T1>\nstatic inline void ALWAYS_INLINE forceToRegisters("
-	max.downto 2 do |i|
-		print "const Vector<T#{i}> &/*x#{i}*/, "
-	end
-	print "const Vector<T1> &/*x1*/) {\n"
-	print "}\n"
-
-	puts '#pragma optimize("g", off)'
-	print 'template<'
-	max.downto 2 do |i|
-		print "typename T#{i}, "
-	end
-	print "typename T1>\nstatic inline void ALWAYS_INLINE forceToRegistersDirty("
-	max.downto 2 do |i|
-		print "Vector<T#{i}> &/*x#{i}*/, "
-	end
-	print "Vector<T1> &/*x1*/) {\n"
-	print "}\n"
-	puts '#pragma optimize("g", on)'
-end
-
-puts '#else'
-puts '#error "forceToRegisters unsupported on this compiler"'
-puts '#endif'
diff -Nru vc-0.7.4/.github/CONTRIBUTING.md vc-1.3.0/.github/CONTRIBUTING.md
--- vc-0.7.4/.github/CONTRIBUTING.md	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/.github/CONTRIBUTING.md	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,77 @@
+## Copyright and License
+
+Vc is licensed with the [3-clause BSD license](http://opensource.org/licenses/BSD-3-Clause).
+Your contributions to Vc must be released under the same license. You must add
+your copyright information to the files you modified/added.
+
+## Code Formatting & Style
+
+The recommended way is to format the code according to `clang-format` using the
+`.clang-format` file in the repository.
+
+In addition to the `clang-format` style, `if`, `else`, `for`, `while`, and `do`
+*must* use braces.
+
+If, for some reason, you cannot use `clang-format`, here's a quick overview of
+the style rules:
+* Constrain the code to no more than 90 characters per line.
+* Use four spaces for indent. No tabs.
+* Opening braces attach to the preceding expression, except for functions,
+  namespaces, and classes/structs/unions/enums.
+* Namespaces introduce no additional indent
+* `case` labels are aligned with the `switch` statement
+* No more than one empty line.
+* No spaces in parentheses, but spaces between keywords and opening paren, i.e.
+  `if (foo) { bar(); }`
+
+### Naming Rules
+
+* Naming is very important. Take time to choose a name that clearly explains the
+  intended functionality & usage of the entity.
+* Type names typically use `CamelCase`. No underscores.
+* Function and variable names use `camelCase`. No underscores.
+* Acronyms that appear in camel case names must use lowercase letters for all
+  characters after the first characters. (e.g. `SimdArray`, `simdFunction`)
+* Traits use `lower_case_with_underscores`.
+* Macros are prefixed with `Vc_` and use `Vc_ALL_CAPITALS_WITH_UNDERSCORES`.
+  Macro arguments use a single underscore suffix.
+  Include guards are prefixed with `VC_` instead.
+* File names use `alllowercasewithoutunderscores`. Basically, it is the type name
+  declared/defined in the file with all letters in lower case.
+* There are exceptions and inconsistencies in the code. Don't bother.
+
+### Design Guidelines
+
+* *Avoid out parameters.* Use the return value insted. Use `std::tuple` if you
+  need to return multiple values.
+* *Look for alternatives to in-out parameters.* An obvious exception (and thus
+  design alternative) is the implicit `this` parameter to non-static member
+  functions.
+* Consequently, *pass function parameters by const-ref or by value.*
+  Use const-ref for types that (potentially) require more than two CPU
+  registers. (Consider fundamental types and the fundamental `Vector<T>` types
+  to require one register, each.)
+  By value otherwise.
+* *Ensure const-correctness.* Member functions use the `const` qualifier if they
+  do not modify observable state. Use `mutable` members for unobservable state.
+* *Avoid macros.* Possible alternatives are constexpr variables and template
+  code.
+
+## Git History
+
+Git history should be flat, if feasible. Feel free to use merges on your private
+branch. However, once you submit a pull request, the history should apply
+cleanly on top of master. Use `git rebase [-i]` to straighten the history.
+
+Use different branches for different issues.
+
+## Git Commit Logs
+
+1. Write meaningful summaries and strive to use no more than 50 characters
+1. Use imperative mood in the subject line (and possibly in bullet points in the
+   summary)
+1. Wrap the body at 72 characters
+1. Use the body to explain *what* and *why* (normally it is irrelevant *how* you
+   did it)
+
+See also [Chris Beams article](http://chris.beams.io/posts/git-commit/).
diff -Nru vc-0.7.4/.github/ISSUE_TEMPLATE.md vc-1.3.0/.github/ISSUE_TEMPLATE.md
--- vc-0.7.4/.github/ISSUE_TEMPLATE.md	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/.github/ISSUE_TEMPLATE.md	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,11 @@
+Vc version / revision | Operating System | Compiler & Version | Compiler Flags | Assembler & Version | CPU
+----------------------|------------------|--------------------|----------------|---------------------|----
+                      |                  |                    |                |                     |
+
+## Testcase
+```cpp
+```
+
+## Actual Results
+
+## Expected Results
diff -Nru vc-0.7.4/.gitignore vc-1.3.0/.gitignore
--- vc-0.7.4/.gitignore	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/.gitignore	2016-10-27 02:05:02.000000000 -0500
@@ -4,3 +4,5 @@
 vc-benchmarks
 *.swp
 *~
+.makeApidox.stamp
+.makeApidox.stamp.new
diff -Nru vc-0.7.4/include/Vc/Allocator vc-1.3.0/include/Vc/Allocator
--- vc-0.7.4/include/Vc/Allocator	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/Allocator	2016-10-27 02:05:02.000000000 -0500
@@ -1,74 +1,85 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_ALLOCATOR_H
-#define VC_ALLOCATOR_H
+#ifndef VC_ALLOCATOR_H_
+#define VC_ALLOCATOR_H_
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
-#include "global.h"
-#ifdef VC_CXX11
 #include <utility>
-#endif
-#include "common/macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-    using std::size_t;
-    using std::ptrdiff_t;
+#include "global.h"
+#include "common/macros.h"
 
-    /**
-     * \headerfile Allocator <Vc/Allocator>
-     * \ingroup Utilities
-     *
-     * Convenience macro to set the default allocator for a given \p Type to Vc::Allocator.
-     *
-     * \param Type Your type that you want to use with STL containers.
-     *
-     * \note You have to use this macro in the global namespace.
-     */
-#define VC_DECLARE_ALLOCATOR(Type) \
-namespace std \
-{ \
-    template<> class allocator<Type> : public ::Vc::Allocator<Type> \
-    { \
-    public: \
-        template<typename U> struct rebind { typedef ::std::allocator<U> other; }; \
-    }; \
+/**
+ * \ingroup Utilities
+ *
+ * Convenience macro to set the default allocator for a given \p Type to
+ * Vc::Allocator.
+ *
+ * \param Type Your type that you want to use with STL containers.
+ *
+ * \note You have to use this macro in the global namespace.
+ */
+#ifdef Vc_MSVC
+#define Vc_DECLARE_ALLOCATOR(Type)                                                   \
+namespace std                                                                        \
+{                                                                                    \
+template <> class allocator<Type> : public ::Vc::Allocator<Type>                     \
+{                                                                                    \
+public:                                                                              \
+    template <typename U> struct rebind {                                            \
+        typedef ::std::allocator<U> other;                                           \
+    };                                                                               \
+    /* MSVC brokenness: the following function is optional - just doesn't compile    \
+     * without it */                                                                 \
+    const allocator &select_on_container_copy_construction() const { return *this; } \
+};                                                                                   \
 }
-#ifdef VC_MSVC
-#undef Vc_DECLARE_ALLOCATOR
-#define Vc_DECLARE_ALLOCATOR(Type) \
-namespace std \
-{ \
-    template<> class allocator<Type> : public ::Vc::Allocator<Type> \
-    { \
-    public: \
-        template<typename U> struct rebind { typedef ::std::allocator<U> other; }; \
-        /* MSVC brokenness: the following function is optional - just doesn't compile without it */ \
-        const allocator &select_on_container_copy_construction() const { return *this; } \
-    }; \
+#else
+#define Vc_DECLARE_ALLOCATOR(Type)                                                   \
+namespace std                                                                        \
+{                                                                                    \
+template <> class allocator<Type> : public ::Vc::Allocator<Type>                     \
+{                                                                                    \
+public:                                                                              \
+    template <typename U> struct rebind {                                            \
+        typedef ::std::allocator<U> other;                                           \
+    };                                                                               \
+};                                                                                   \
 }
 #endif
 
+namespace Vc_VERSIONED_NAMESPACE
+{
+    using std::size_t;
+    using std::ptrdiff_t;
+
     /**
      * \headerfile Allocator <Vc/Allocator>
      * An allocator that uses global new and supports over-aligned types, as per [C++11 20.6.9].
@@ -104,7 +115,7 @@
      * struct Data {
      *   Vc::float_v x, y, z;
      * };
-     * VC_DECLARE_ALLOCATOR(Data)
+     * Vc_DECLARE_ALLOCATOR(Data)
      *
      * void fun()
      * {
@@ -118,22 +129,24 @@
     {
     private:
         enum Constants {
-#ifdef VC_HAVE_STD_MAX_ALIGN_T
+#ifdef Vc_HAVE_STD_MAX_ALIGN_T
             NaturalAlignment = alignof(std::max_align_t),
-#elif defined(VC_HAVE_MAX_ALIGN_T)
+#elif defined(Vc_HAVE_MAX_ALIGN_T)
             NaturalAlignment = alignof(::max_align_t),
 #else
-            NaturalAlignment = sizeof(void *) > Vc_ALIGNOF(long double) ? sizeof(void *) :
-                (Vc_ALIGNOF(long double) > Vc_ALIGNOF(long long) ? Vc_ALIGNOF(long double) : Vc_ALIGNOF(long long)),
+            NaturalAlignment = sizeof(void *) > alignof(long double) ? sizeof(void *) :
+                (alignof(long double) > alignof(long long) ? alignof(long double) : alignof(long long)),
 #endif
-#ifdef VC_IMPL_AVX
+#ifdef Vc_IMPL_MIC
+            SimdAlignment = 64,
+#elif defined Vc_IMPL_AVX
             SimdAlignment = 32,
-#elif defined VC_IMPL_SSE
+#elif defined Vc_IMPL_SSE
             SimdAlignment = 16,
 #else
             SimdAlignment = 1,
 #endif
-            Alignment = Vc_ALIGNOF(T) > SimdAlignment ? Vc_ALIGNOF(T) : SimdAlignment,
+            Alignment = alignof(T) > SimdAlignment ? alignof(T) : SimdAlignment,
             /* The number of extra bytes allocated must be large enough to put a pointer right
              * before the adjusted address. This pointer stores the original address, which is
              * required to call ::operator delete in deallocate.
@@ -198,36 +211,31 @@
 
         size_type max_size() const throw() { return size_t(-1) / sizeof(T); }
 
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
         // MSVC brokenness: the following function is optional - just doesn't compile without it
         const Allocator &select_on_container_copy_construction() const { return *this; }
 
         // MSVC also requires a function that neither C++98 nor C++11 mention
-        // but it doesn't support variadic templates... otherwise the VC_CXX11 clause would be nice
+        // but it doesn't support variadic templates... otherwise the Vc_CXX11 clause would be nice
         void construct(pointer p) { ::new(p) T(); }
 
         // we still need the C++98 version:
-        void construct(pointer p, const T& __val) { ::new(p) T(__val); }
+        void construct(pointer p, const T& val) { ::new(p) T(val); }
         void destroy(pointer p) { p->~T(); }
-#elif defined(VC_CXX11)
+#else
         template<typename U, typename... Args> void construct(U* p, Args&&... args)
         {
             ::new(p) U(std::forward<Args>(args)...);
         }
         template<typename U> void destroy(U* p) { p->~U(); }
-#else
-        void construct(pointer p, const T& __val) { ::new(p) T(__val); }
-        void destroy(pointer p) { p->~T(); }
 #endif
     };
 
     template<typename T> inline bool operator==(const Allocator<T>&, const Allocator<T>&) { return true;  }
     template<typename T> inline bool operator!=(const Allocator<T>&, const Allocator<T>&) { return false; }
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}
 
-#include "common/undomacros.h"
 #include "vector.h"
 namespace std
 {
@@ -235,13 +243,43 @@
     {
     public:
         template<typename U> struct rebind { typedef ::std::allocator<U> other; };
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
+        // MSVC brokenness: the following function is optional - just doesn't compile without it
+        const allocator &select_on_container_copy_construction() const { return *this; }
+#endif
+    };
+    template <typename T>
+    class allocator<Vc::Mask<T>> : public ::Vc::Allocator<Vc::Mask<T>>
+    {
+    public:
+        template<typename U> struct rebind { typedef ::std::allocator<U> other; };
+#ifdef Vc_MSVC
+        // MSVC brokenness: the following function is optional - just doesn't compile without it
+        const allocator &select_on_container_copy_construction() const { return *this; }
+#endif
+    };
+    template <typename T, std::size_t N, typename V, std::size_t M>
+    class allocator<Vc::SimdArray<T, N, V, M>> : public ::Vc::Allocator<Vc::SimdArray<T, N, V, M>>
+    {
+    public:
+        template<typename U> struct rebind { typedef ::std::allocator<U> other; };
+#ifdef Vc_MSVC
+        // MSVC brokenness: the following function is optional - just doesn't compile without it
+        const allocator &select_on_container_copy_construction() const { return *this; }
+#endif
+    };
+    template <typename T, std::size_t N, typename V, std::size_t M>
+    class allocator<Vc::SimdMaskArray<T, N, V, M>> : public ::Vc::Allocator<Vc::SimdMaskArray<T, N, V, M>>
+    {
+    public:
+        template<typename U> struct rebind { typedef ::std::allocator<U> other; };
+#ifdef Vc_MSVC
         // MSVC brokenness: the following function is optional - just doesn't compile without it
         const allocator &select_on_container_copy_construction() const { return *this; }
 #endif
     };
 }
 
-#endif // VC_ALLOCATOR_H
+#endif // VC_ALLOCATOR_H_
 
 // vim: ft=cpp et sw=4 sts=4
diff -Nru vc-0.7.4/include/Vc/array vc-1.3.0/include/Vc/array
--- vc-0.7.4/include/Vc/array	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/array	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,289 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+//===---------------------------- array -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef VC_INCLUDE_VC_ARRAY_
+#define VC_INCLUDE_VC_ARRAY_
+
+#include <type_traits>
+#include <utility>
+#include <iterator>
+#include <algorithm>
+#include <stdexcept>
+
+#include "common/subscript.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+template <class T, size_t Size> struct array {
+    // types:
+    typedef array self_;
+    typedef T value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef value_type* iterator;
+    typedef const value_type* const_iterator;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    value_type elems_[Size > 0 ? Size : 1];
+
+    // No explicit construct/copy/destroy for aggregate type
+    void fill(const value_type& u_) { std::fill_n(elems_, Size, u_); }
+    void swap(array& a_) noexcept(std::swap(std::declval<T &>(), std::declval<T &>()))
+    {
+        std::swap_ranges(elems_, elems_ + Size, a_.elems_);
+    }
+
+    // iterators:
+    iterator begin() noexcept { return iterator(elems_); }
+    const_iterator begin() const noexcept { return const_iterator(elems_); }
+    iterator end() noexcept { return iterator(elems_ + Size); }
+    const_iterator end() const noexcept { return const_iterator(elems_ + Size); }
+    reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+    reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+    const_reverse_iterator rend() const noexcept
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    const_iterator cbegin() const noexcept { return begin(); }
+    const_iterator cend() const noexcept { return end(); }
+    const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+    const_reverse_iterator crend() const noexcept { return rend(); }
+    // capacity:
+    constexpr size_type size() const noexcept { return Size; }
+    constexpr size_type max_size() const noexcept { return Size; }
+    constexpr bool empty() const noexcept { return Size == 0; }
+    // element access:
+    reference operator[](size_type n_) { return elems_[n_]; }
+    constexpr const_reference operator[](size_type n_) const { return elems_[n_]; }
+
+    /**
+     * \name Data-Parallel Subscripting for Gather & Scatter
+     */
+    ///@{
+    template <typename I>
+    Vc_ALWAYS_INLINE auto operator[](I&& arg_)
+        -> decltype(subscript_operator(*this, std::forward<I>(arg_)))
+    {
+        return subscript_operator(*this, std::forward<I>(arg_));
+    }
+
+    template <typename I>
+    Vc_ALWAYS_INLINE auto operator[](I&& arg_) const
+        -> decltype(subscript_operator(*this, std::forward<I>(arg_)))
+    {
+        return subscript_operator(*this, std::forward<I>(arg_));
+    }
+    ///@}
+
+    reference at(size_type n_);
+    constexpr const_reference at(size_type n_) const;
+
+    reference front() { return elems_[0]; }
+    constexpr const_reference front() const { return elems_[0]; }
+    reference back() { return elems_[Size > 0 ? Size - 1 : 0]; }
+    constexpr const_reference back() const { return elems_[Size > 0 ? Size - 1 : 0]; }
+    value_type* data() noexcept { return elems_; }
+    const value_type* data() const noexcept { return elems_; }
+};
+
+template <class T, size_t Size>
+typename array<T, Size>::reference array<T, Size>::at(size_type n_)
+{
+    if (n_ >= Size) {
+        throw std::out_of_range("array::at");
+    }
+    return elems_[n_];
+}
+
+template <class T, size_t Size>
+constexpr typename array<T, Size>::const_reference array<T, Size>::at(size_type n_) const
+{
+    return n_ >= Size ? (throw std::out_of_range("array::at"), elems_[0]) : elems_[n_];
+}
+
+template <class T, size_t Size>
+inline bool operator==(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return std::equal(x_.elems_, x_.elems_ + Size, y_.elems_);
+}
+
+template <class T, size_t Size>
+inline bool operator!=(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return !(x_ == y_);
+}
+
+template <class T, size_t Size>
+inline bool operator<(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return std::lexicographical_compare(x_.elems_, x_.elems_ + Size, y_.elems_,
+                                        y_.elems_ + Size);
+}
+
+template <class T, size_t Size>
+inline bool operator>(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return y_ < x_;
+}
+
+template <class T, size_t Size>
+inline bool operator<=(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return !(y_ < x_);
+}
+
+template <class T, size_t Size>
+inline bool operator>=(const array<T, Size>& x_, const array<T, Size>& y_)
+{
+    return !(x_ < y_);
+}
+
+/**\name non-member begin & end
+ * Implement the non-member begin & end functions in the %Vc namespace so that ADL works
+ * and `begin(some_vc_array)` always works.
+ */
+///@{
+template <typename T, std::size_t N>
+inline auto begin(array<T, N>& arr) -> decltype(arr.begin())
+{
+    return arr.begin();
+}
+template <typename T, std::size_t N>
+inline auto begin(const array<T, N>& arr) -> decltype(arr.begin())
+{
+    return arr.begin();
+}
+template <typename T, std::size_t N>
+inline auto end(array<T, N>& arr) -> decltype(arr.end())
+{
+    return arr.end();
+}
+template <typename T, std::size_t N>
+inline auto end(const array<T, N>& arr) -> decltype(arr.end())
+{
+    return arr.end();
+}
+///@}
+
+namespace Traits
+{
+template <typename T, std::size_t N>
+struct has_no_allocated_data_impl<Vc::array<T, N>> : public std::true_type
+{
+};
+template <typename T, std::size_t N>
+struct has_contiguous_storage_impl<Vc::array<T, N>> : public std::true_type
+{
+};
+
+static_assert(has_no_allocated_data<const volatile Vc::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<const volatile Vc::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<volatile Vc::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<volatile Vc::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<const Vc::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<const Vc::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<Vc::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<Vc::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<Vc::array<int, 256> &&>::value, "");
+
+}  // namespace Traits
+}  // namespace Vc
+
+namespace std
+{
+template <class T, size_t Size>
+inline
+#ifdef Vc_MSVC
+    // MSVC fails to do SFINAE correctly and gets totally confused:
+    // error C2433: 'type': 'inline' not permitted on data declarations
+    // error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+    // error C2061: syntax error: identifier 'swap'
+    void
+#else
+    typename enable_if<is_same<void, decltype(swap(declval<T&>(), declval<T&>()))>::value,
+                       void>::type
+#endif
+    swap(const Vc::array<T, Size>& x_,
+         const Vc::array<T, Size>& y_) noexcept(swap(declval<T&>(), declval<T&>()))
+{
+    x_.swap(y_);
+}
+
+template <class T, size_t Size>
+class tuple_size<Vc::array<T, Size>> : public integral_constant<size_t, Size>
+{
+};
+
+template <size_t I, class T, size_t Size> class tuple_element<I, Vc::array<T, Size>>
+{
+public:
+    typedef T type;
+};
+
+template <size_t I, class T, size_t Size>
+inline constexpr typename std::enable_if<(I < Size), T&>::type get(
+    Vc::array<T, Size>& a_) noexcept
+{
+    return a_.elems_[I];
+}
+
+template <size_t I, class T, size_t Size>
+inline constexpr typename std::enable_if<(I < Size), const T&>::type get(
+    const Vc::array<T, Size>& a_) noexcept
+{
+    return a_.elems_[I];
+}
+
+template <size_t I, class T, size_t Size>
+inline constexpr typename std::enable_if<(I < Size), T&&>::type get(
+    Vc::array<T, Size>&& a_) noexcept
+{
+    return std::move(a_.elems_[I]);
+}
+}  // namespace std
+
+#endif  // VC_INCLUDE_VC_ARRAY_
+
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/cpuid.h vc-1.3.0/include/Vc/cpuid.h
--- vc-0.7.4/include/Vc/cpuid.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/cpuid.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,27 +1,35 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_CPUID_H_
+#define VC_CPUID_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef CPUID_H
-#define CPUID_H
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#include "common/macros.h"
+namespace Vc_VERSIONED_NAMESPACE
 {
 
 /**
@@ -115,6 +123,36 @@
         static inline bool hasOsxsave() { return (s_processorFeaturesC & (1 << 27)) != 0; }
         //! Return whether the CPU supports AVX.
         static inline bool hasAvx  () { return (s_processorFeaturesC & (1 << 28)) != 0; }
+        //! Return whether the CPU supports BMI1.
+        static inline bool hasBmi1 () { return (s_processorFeatures7B& (1 << 3)) != 0; }
+        //! Return whether the CPU supports transactional synchronization extensions.
+        static inline bool hasHle  () { return (s_processorFeatures7B& (1 << 4)) != 0; }
+        //! Return whether the CPU supports AVX2.
+        static inline bool hasAvx2 () { return (s_processorFeatures7B& (1 << 5)) != 0; }
+        //! Return whether the CPU supports BMI2.
+        static inline bool hasBmi2 () { return (s_processorFeatures7B& (1 << 8)) != 0; }
+        //! Return whether the CPU supports transactional synchronization extensions.
+        static inline bool hasRtm  () { return (s_processorFeatures7B& (1 << 11)) != 0; }
+
+        //! Return whether the CPU supports AVX512f.
+        static inline bool hasAvx512f   () { return (s_processorFeatures7B & (1u << 16)) != 0; }
+        //! Return whether the CPU supports AVX512dq.
+        static inline bool hasAvx512dq  () { return (s_processorFeatures7B & (1u << 17)) != 0; }
+        //! Return whether the CPU supports AVX512ifma.
+        static inline bool hasAvx512ifma() { return (s_processorFeatures7B & (1u << 21)) != 0; }
+        //! Return whether the CPU supports AVX512pf.
+        static inline bool hasAvx512pf  () { return (s_processorFeatures7B & (1u << 26)) != 0; }
+        //! Return whether the CPU supports AVX512er.
+        static inline bool hasAvx512er  () { return (s_processorFeatures7B & (1u << 27)) != 0; }
+        //! Return whether the CPU supports AVX512cd.
+        static inline bool hasAvx512cd  () { return (s_processorFeatures7B & (1u << 28)) != 0; }
+        //! Return whether the CPU supports AVX512bw.
+        static inline bool hasAvx512bw  () { return (s_processorFeatures7B & (1u << 30)) != 0; }
+        //! Return whether the CPU supports AVX512vl.
+        static inline bool hasAvx512vl  () { return (s_processorFeatures7B & (1u << 31)) != 0; }
+        //! Return whether the CPU supports AVX512vbmi.
+        static inline bool hasAvx512vbmi() { return (s_processorFeatures7C & (1u <<  1)) != 0; }
+
         //! Return whether the CPU supports 16-bit floating-point conversion instructions.
         static inline bool hasF16c () { return (s_processorFeaturesC & (1 << 29)) != 0; }
         //! Return whether the CPU supports the RDRAND instruction.
@@ -187,6 +225,8 @@
         static uint   s_logicalProcessors;
         static uint   s_processorFeaturesC;
         static uint   s_processorFeaturesD;
+        static uint   s_processorFeatures7B;
+        static uint   s_processorFeatures7C;
         static uint   s_processorFeatures8C;
         static uint   s_processorFeatures8D;
         static uint   s_L1Instruction;
@@ -208,7 +248,22 @@
         static ProcessorType s_processorType;
         static bool   s_noL2orL3;
 };
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
 
-#endif // CPUID_H
+#ifndef Vc_COMPILE_LIB
+namespace detail
+{
+template <int = 0> struct RunCpuIdInit {
+    RunCpuIdInit() { CpuId::init(); }
+    static RunCpuIdInit tmp;
+};
+template <int N> RunCpuIdInit<N> RunCpuIdInit<N>::tmp;
+namespace
+{
+static auto ctor = RunCpuIdInit<>::tmp;
+}  // unnamed namespace
+}  // namespace detail
+#endif
+
+}
+
+#endif // VC_CPUID_H_
diff -Nru vc-0.7.4/include/Vc/global.h vc-1.3.0/include/Vc/global.h
--- vc-0.7.4/include/Vc/global.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/global.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,83 +1,142 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_GLOBAL_H_
+#define VC_GLOBAL_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+#include <cstdint>
 
-*/
+#ifdef DOXYGEN
 
-#ifndef VC_GLOBAL_H
-#define VC_GLOBAL_H
+/**
+ * \name Compiler Identification Macros
+ * \ingroup Utilities
+ */
+//@{
+/**
+ * \ingroup Utilities
+ * This macro is defined to a number identifying the ICC version if the current
+ * translation unit is compiled with the Intel compiler.
+ *
+ * For any other compiler this macro is not defined.
+ */
+#define Vc_ICC __INTEL_COMPILER_BUILD_DATE
+#undef Vc_ICC
+/**
+ * \ingroup Utilities
+ * This macro is defined to a number identifying the Clang version if the current
+ * translation unit is compiled with the Clang compiler.
+ *
+ * For any other compiler this macro is not defined.
+ */
+#define Vc_CLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
+#undef Vc_CLANG
+/**
+ * \ingroup Utilities
+ * This macro is defined to a number identifying the Apple Clang version if the current
+ * translation unit is compiled with the Apple Clang compiler.
+ *
+ * For any other compiler this macro is not defined.
+ */
+#define Vc_APPLECLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
+#undef Vc_APPLECLANG
+/**
+ * \ingroup Utilities
+ * This macro is defined to a number identifying the GCC version if the current
+ * translation unit is compiled with the GCC compiler.
+ *
+ * For any other compiler this macro is not defined.
+ */
+#define Vc_GCC (__GNUC__ * 0x10000 + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
+/**
+ * \ingroup Utilities
+ * This macro is defined to a number identifying the Microsoft Visual C++ version if
+ * the current translation unit is compiled with the Visual C++ (MSVC) compiler.
+ *
+ * For any other compiler this macro is not defined.
+ */
+#define Vc_MSVC _MSC_FULL_VER
+#undef Vc_MSVC
+//@}
 
-#ifndef DOXYGEN
+#else  // DOXYGEN
 
 // Compiler defines
 #ifdef __INTEL_COMPILER
-#define VC_ICC __INTEL_COMPILER_BUILD_DATE
+#define Vc_ICC __INTEL_COMPILER_BUILD_DATE
 #elif defined(__OPENCC__)
-#define VC_OPEN64 1
+#define Vc_OPEN64 1
+#elif defined(__clang__) && defined(__APPLE__) && __clang_major__ >= 6
+// this is going to break :-(
+#define Vc_APPLECLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
 #elif defined(__clang__)
-#define VC_CLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
+#define Vc_CLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
 #elif defined(__GNUC__)
-#define VC_GCC (__GNUC__ * 0x10000 + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
+#define Vc_GCC (__GNUC__ * 0x10000 + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
 #elif defined(_MSC_VER)
-#define VC_MSVC _MSC_FULL_VER
+#define Vc_MSVC _MSC_FULL_VER
 #else
-#define VC_UNSUPPORTED_COMPILER 1
+#define Vc_UNSUPPORTED_COMPILER 1
 #endif
 
-// Features/Quirks defines
-#if defined VC_MSVC && defined _WIN32
-// the Win32 ABI can't handle function parameters with alignment >= 16
-#define VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN 1
-#endif
-#if defined(__GNUC__) && !defined(VC_NO_INLINE_ASM)
-#define VC_GNU_ASM 1
+#if __cplusplus < 201103 && (!defined Vc_MSVC || _MSC_VER < 1900)
+# error "Vc requires support for C++11."
+#elif __cplusplus >= 201402L
+# define Vc_CXX14 1
+# if __cplusplus > 201700L
+#  define Vc_CXX17 1
+# endif
 #endif
-#if defined(VC_GCC) && (VC_GCC <= 0x40405 || (VC_GCC >= 0x40500 && VC_GCC <= 0x40502)) && !(VC_GCC == 0x40502 && defined(__GNUC_UBUNTU_VERSION__) && __GNUC_UBUNTU_VERSION__ == 0xb0408)
-// GCC 4.6.0 / 4.5.3 / 4.4.6 switched to the interface as defined by ICC
-// (Ubuntu 11.04 ships a GCC 4.5.2 with the new interface)
-#define VC_MM256_MASKSTORE_WRONG_MASK_TYPE 1
+
+#if defined(__GNUC__) && !defined(Vc_NO_INLINE_ASM)
+#define Vc_GNU_ASM 1
 #endif
-#if defined(VC_GCC) && VC_GCC >= 0x40300
-#define VC_HAVE_ATTRIBUTE_ERROR 1
-#define VC_HAVE_ATTRIBUTE_WARNING 1
+
+#ifdef Vc_GCC
+#  define Vc_HAVE_MAX_ALIGN_T 1
+#elif !defined(Vc_CLANG) && !defined(Vc_ICC)
+//   Clang/ICC don't provide max_align_t at all
+#  define Vc_HAVE_STD_MAX_ALIGN_T 1
 #endif
 
-#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && VC_GCC >= 0x40600) || __cplusplus >= 201103
-#  define VC_CXX11 1
-#  ifdef VC_GCC
-#    if VC_GCC >= 0x40700 // && VC_GCC < 0x408000)
-//     ::max_align_t was introduced with GCC 4.7. std::max_align_t took a bit longer.
-#      define VC_HAVE_MAX_ALIGN_T 1
-#    endif
-#  elif defined(VC_ICC)
-#      define VC_HAVE_MAX_ALIGN_T 1
-#  elif !defined(VC_CLANG)
-//   Clang doesn't provide max_align_t at all
-#    define VC_HAVE_STD_MAX_ALIGN_T 1
-#  endif
+#if defined(Vc_GCC) || defined(Vc_CLANG) || defined Vc_APPLECLANG
+#define Vc_USE_BUILTIN_VECTOR_TYPES 1
 #endif
 
-// ICC ships the AVX2 intrinsics inside the AVX1 header.
-// FIXME: the number 20120731 is too large, but I don't know which one is the right one
-#if (defined(VC_ICC) && VC_ICC >= 20120731) || (defined(VC_MSVC) && VC_MSVC >= 170000000)
-#define VC_UNCONDITIONAL_AVX2_INTRINSICS 1
+#ifdef Vc_MSVC
+#  define Vc_CDECL __cdecl
+#  define Vc_VDECL __vectorcall
+#else
+#  define Vc_CDECL
+#  define Vc_VDECL
 #endif
 
 /* Define the following strings to a unique integer, which is the only type the preprocessor can
- * compare. This allows to use -DVC_IMPL=SSE3. The preprocessor will then consider VC_IMPL and SSE3
+ * compare. This allows to use -DVc_IMPL=SSE3. The preprocessor will then consider Vc_IMPL and SSE3
  * to be equal. Of course, it is important to undefine the strings later on!
  */
 #define Scalar 0x00100000
@@ -88,6 +147,8 @@
 #define SSE4_1 0x00600000
 #define SSE4_2 0x00700000
 #define AVX    0x00800000
+#define AVX2   0x00900000
+#define MIC    0x00A00000
 
 #define XOP    0x00000001
 #define FMA4   0x00000002
@@ -95,11 +156,12 @@
 #define POPCNT 0x00000008
 #define SSE4a  0x00000010
 #define FMA    0x00000020
+#define BMI2   0x00000040
 
 #define IMPL_MASK 0xFFF00000
 #define EXT_MASK  0x000FFFFF
 
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
 # ifdef _M_IX86_FP
 #  if _M_IX86_FP >= 1
 #   ifndef __SSE__
@@ -122,165 +184,193 @@
 # endif
 #endif
 
-#ifndef VC_IMPL
+#if defined Vc_ICC && !defined __POPCNT__
+# if defined __SSE4_2__ || defined __SSE4A__
+#  define __POPCNT__ 1
+# endif
+#endif
 
-#  if defined(__AVX__)
-#    define VC_IMPL_AVX 1
+#ifdef VC_IMPL
+#error "You are using the old VC_IMPL macro. Since Vc 1.0 all Vc macros start with Vc_, i.e. a lower-case 'c'"
+#endif
+
+#ifndef Vc_IMPL
+
+#  if defined(__MIC__)
+#    define Vc_IMPL_MIC 1
+#  elif defined(__AVX2__)
+#    define Vc_IMPL_AVX2 1
+#    define Vc_IMPL_AVX 1
+#  elif defined(__AVX__)
+#    define Vc_IMPL_AVX 1
 #  else
 #    if defined(__SSE4_2__)
-#      define VC_IMPL_SSE 1
-#      define VC_IMPL_SSE4_2 1
+#      define Vc_IMPL_SSE 1
+#      define Vc_IMPL_SSE4_2 1
 #    endif
 #    if defined(__SSE4_1__)
-#      define VC_IMPL_SSE 1
-#      define VC_IMPL_SSE4_1 1
+#      define Vc_IMPL_SSE 1
+#      define Vc_IMPL_SSE4_1 1
 #    endif
 #    if defined(__SSE3__)
-#      define VC_IMPL_SSE 1
-#      define VC_IMPL_SSE3 1
+#      define Vc_IMPL_SSE 1
+#      define Vc_IMPL_SSE3 1
 #    endif
 #    if defined(__SSSE3__)
-#      define VC_IMPL_SSE 1
-#      define VC_IMPL_SSSE3 1
+#      define Vc_IMPL_SSE 1
+#      define Vc_IMPL_SSSE3 1
 #    endif
 #    if defined(__SSE2__)
-#      define VC_IMPL_SSE 1
-#      define VC_IMPL_SSE2 1
+#      define Vc_IMPL_SSE 1
+#      define Vc_IMPL_SSE2 1
 #    endif
 
-#    if defined(VC_IMPL_SSE)
+#    if defined(Vc_IMPL_SSE)
        // nothing
 #    else
-#      define VC_IMPL_Scalar 1
+#      define Vc_IMPL_Scalar 1
 #    endif
 #  endif
-#  if defined(VC_IMPL_AVX) || defined(VC_IMPL_SSE)
+#  if !defined(Vc_IMPL_Scalar)
 #    ifdef __FMA4__
-#      define VC_IMPL_FMA4 1
+#      define Vc_IMPL_FMA4 1
 #    endif
 #    ifdef __XOP__
-#      define VC_IMPL_XOP 1
+#      define Vc_IMPL_XOP 1
 #    endif
 #    ifdef __F16C__
-#      define VC_IMPL_F16C 1
+#      define Vc_IMPL_F16C 1
 #    endif
 #    ifdef __POPCNT__
-#      define VC_IMPL_POPCNT 1
+#      define Vc_IMPL_POPCNT 1
 #    endif
 #    ifdef __SSE4A__
-#      define VC_IMPL_SSE4a 1
+#      define Vc_IMPL_SSE4a 1
 #    endif
 #    ifdef __FMA__
-#      define VC_IMPL_FMA 1
+#      define Vc_IMPL_FMA 1
+#    endif
+#    ifdef __BMI2__
+#      define Vc_IMPL_BMI2 1
 #    endif
 #  endif
 
-#else // VC_IMPL
+#else // Vc_IMPL
 
-#  if (VC_IMPL & IMPL_MASK) == AVX // AVX supersedes SSE
-#    define VC_IMPL_AVX 1
-#  elif (VC_IMPL & IMPL_MASK) == Scalar
-#    define VC_IMPL_Scalar 1
-#  elif (VC_IMPL & IMPL_MASK) == SSE4_2
-#    define VC_IMPL_SSE4_2 1
-#    define VC_IMPL_SSE4_1 1
-#    define VC_IMPL_SSSE3 1
-#    define VC_IMPL_SSE3 1
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
-#  elif (VC_IMPL & IMPL_MASK) == SSE4_1
-#    define VC_IMPL_SSE4_1 1
-#    define VC_IMPL_SSSE3 1
-#    define VC_IMPL_SSE3 1
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
-#  elif (VC_IMPL & IMPL_MASK) == SSSE3
-#    define VC_IMPL_SSSE3 1
-#    define VC_IMPL_SSE3 1
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
-#  elif (VC_IMPL & IMPL_MASK) == SSE3
-#    define VC_IMPL_SSE3 1
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
-#  elif (VC_IMPL & IMPL_MASK) == SSE2
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
-#  elif (VC_IMPL & IMPL_MASK) == SSE
-#    define VC_IMPL_SSE 1
+#  if (Vc_IMPL & IMPL_MASK) == MIC // MIC supersedes everything else
+#    define Vc_IMPL_MIC 1
+#    ifdef __POPCNT__
+#      define Vc_IMPL_POPCNT 1
+#    endif
+#  elif (Vc_IMPL & IMPL_MASK) == AVX2 // AVX2 supersedes SSE
+#    define Vc_IMPL_AVX2 1
+#    define Vc_IMPL_AVX 1
+#  elif (Vc_IMPL & IMPL_MASK) == AVX // AVX supersedes SSE
+#    define Vc_IMPL_AVX 1
+#  elif (Vc_IMPL & IMPL_MASK) == Scalar
+#    define Vc_IMPL_Scalar 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSE4_2
+#    define Vc_IMPL_SSE4_2 1
+#    define Vc_IMPL_SSE4_1 1
+#    define Vc_IMPL_SSSE3 1
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSE4_1
+#    define Vc_IMPL_SSE4_1 1
+#    define Vc_IMPL_SSSE3 1
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSSE3
+#    define Vc_IMPL_SSSE3 1
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSE3
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSE2
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  elif (Vc_IMPL & IMPL_MASK) == SSE
+#    define Vc_IMPL_SSE 1
 #    if defined(__SSE4_2__)
-#      define VC_IMPL_SSE4_2 1
+#      define Vc_IMPL_SSE4_2 1
 #    endif
 #    if defined(__SSE4_1__)
-#      define VC_IMPL_SSE4_1 1
+#      define Vc_IMPL_SSE4_1 1
 #    endif
 #    if defined(__SSE3__)
-#      define VC_IMPL_SSE3 1
+#      define Vc_IMPL_SSE3 1
 #    endif
 #    if defined(__SSSE3__)
-#      define VC_IMPL_SSSE3 1
+#      define Vc_IMPL_SSSE3 1
 #    endif
 #    if defined(__SSE2__)
-#      define VC_IMPL_SSE2 1
+#      define Vc_IMPL_SSE2 1
 #    endif
-#  elif (VC_IMPL & IMPL_MASK) == 0 && (VC_IMPL & SSE4a)
+#  elif (Vc_IMPL & IMPL_MASK) == 0 && (Vc_IMPL & SSE4a)
      // this is for backward compatibility only where SSE4a was included in the main
      // line of available SIMD instruction sets
-#    define VC_IMPL_SSE3 1
-#    define VC_IMPL_SSE2 1
-#    define VC_IMPL_SSE 1
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#  endif
+#  if (Vc_IMPL & XOP)
+#    define Vc_IMPL_XOP 1
 #  endif
-#  if (VC_IMPL & XOP)
-#    define VC_IMPL_XOP 1
+#  if (Vc_IMPL & FMA4)
+#    define Vc_IMPL_FMA4 1
 #  endif
-#  if (VC_IMPL & FMA4)
-#    define VC_IMPL_FMA4 1
+#  if (Vc_IMPL & F16C)
+#    define Vc_IMPL_F16C 1
 #  endif
-#  if (VC_IMPL & F16C)
-#    define VC_IMPL_F16C 1
+#  if (!defined(Vc_IMPL_Scalar) && defined(__POPCNT__)) || (Vc_IMPL & POPCNT)
+#    define Vc_IMPL_POPCNT 1
 #  endif
-#  if (VC_IMPL & POPCNT)
-#    define VC_IMPL_POPCNT 1
+#  if (Vc_IMPL & SSE4a)
+#    define Vc_IMPL_SSE4a 1
 #  endif
-#  if (VC_IMPL & SSE4a)
-#    define VC_IMPL_SSE4a 1
+#  if (Vc_IMPL & FMA)
+#    define Vc_IMPL_FMA 1
 #  endif
-#  if (VC_IMPL & FMA)
-#    define VC_IMPL_FMA 1
+#  if (Vc_IMPL & BMI2)
+#    define Vc_IMPL_BMI2 1
 #  endif
-#  undef VC_IMPL
+#  undef Vc_IMPL
 
-#endif // VC_IMPL
+#endif // Vc_IMPL
 
 // If AVX is enabled in the compiler it will use VEX coding for the SIMD instructions.
 #ifdef __AVX__
-#  define VC_USE_VEX_CODING 1
+#  define Vc_USE_VEX_CODING 1
 #endif
 
-#if defined(VC_GCC) && VC_GCC < 0x40300 && !defined(VC_IMPL_Scalar)
-#    ifndef VC_DONT_WARN_OLD_GCC
-#      warning "GCC < 4.3 does not have full support for SSE2 intrinsics. Using scalar types/operations only. Define VC_DONT_WARN_OLD_GCC to silence this warning."
-#    endif
-#    undef VC_IMPL_SSE
-#    undef VC_IMPL_SSE2
-#    undef VC_IMPL_SSE3
-#    undef VC_IMPL_SSE4_1
-#    undef VC_IMPL_SSE4_2
-#    undef VC_IMPL_SSSE3
-#    undef VC_IMPL_AVX
-#    undef VC_IMPL_FMA4
-#    undef VC_IMPL_XOP
-#    undef VC_IMPL_F16C
-#    undef VC_IMPL_POPCNT
-#    undef VC_IMPL_SSE4a
-#    undef VC_IMPL_FMA
-#    undef VC_USE_VEX_CODING
-#    define VC_IMPL_Scalar 1
-#endif
-
-# if !defined(VC_IMPL_Scalar) && !defined(VC_IMPL_SSE) && !defined(VC_IMPL_AVX)
-#  error "No suitable Vc implementation was selected! Probably VC_IMPL was set to an invalid value."
-# elif defined(VC_IMPL_SSE) && !defined(VC_IMPL_SSE2)
+#ifdef Vc_IMPL_AVX
+// if we have AVX then we also have all SSE intrinsics
+#    define Vc_IMPL_SSE4_2 1
+#    define Vc_IMPL_SSE4_1 1
+#    define Vc_IMPL_SSSE3 1
+#    define Vc_IMPL_SSE3 1
+#    define Vc_IMPL_SSE2 1
+#    define Vc_IMPL_SSE 1
+#endif
+
+#if defined(Vc_CLANG) && Vc_CLANG >= 0x30600 && Vc_CLANG < 0x30700
+#    if defined(Vc_IMPL_AVX)
+#        warning "clang 3.6.x miscompiles AVX code, frequently losing 50% of the data. Vc will fall back to SSE4 instead."
+#        undef Vc_IMPL_AVX
+#        if defined(Vc_IMPL_AVX2)
+#            undef Vc_IMPL_AVX2
+#        endif
+#    endif
+#endif
+
+# if !defined(Vc_IMPL_Scalar) && !defined(Vc_IMPL_SSE) && !defined(Vc_IMPL_AVX) && !defined(Vc_IMPL_MIC)
+#  error "No suitable Vc implementation was selected! Probably Vc_IMPL was set to an invalid value."
+# elif defined(Vc_IMPL_SSE) && !defined(Vc_IMPL_SSE2)
 #  error "SSE requested but no SSE2 support. Vc needs at least SSE2!"
 # endif
 
@@ -292,6 +382,8 @@
 #undef SSE4_1
 #undef SSE4_2
 #undef AVX
+#undef AVX2
+#undef MIC
 
 #undef XOP
 #undef FMA4
@@ -299,26 +391,44 @@
 #undef POPCNT
 #undef SSE4a
 #undef FMA
+#undef BMI2
 
 #undef IMPL_MASK
 #undef EXT_MASK
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc {
-enum AlignedFlag {
-    Aligned = 0
-};
-enum UnalignedFlag {
-    Unaligned = 1
-};
-enum StreamingAndAlignedFlag { // implies Aligned
-    Streaming = 2
-};
-enum StreamingAndUnalignedFlag {
-    StreamingAndUnaligned = 3
-};
+#ifdef Vc_IMPL_MIC
+#define Vc_DEFAULT_IMPL_MIC
+#elif defined Vc_IMPL_AVX2
+#define Vc_DEFAULT_IMPL_AVX2
+#elif defined Vc_IMPL_AVX
+#define Vc_DEFAULT_IMPL_AVX
+#elif defined Vc_IMPL_SSE
+#define Vc_DEFAULT_IMPL_SSE
+#elif defined Vc_IMPL_Scalar
+#define Vc_DEFAULT_IMPL_Scalar
+#else
+#error "Preprocessor logic broken. Please report a bug."
+#endif
+
+#define Vc_VERSIONED_NAMESPACE Vc_1
+
+namespace Vc_VERSIONED_NAMESPACE {}
+namespace Vc = Vc_VERSIONED_NAMESPACE;
+
 #endif // DOXYGEN
 
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+typedef   signed char        int8_t;
+typedef unsigned char       uint8_t;
+typedef   signed short      int16_t;
+typedef unsigned short     uint16_t;
+typedef   signed int        int32_t;
+typedef unsigned int       uint32_t;
+typedef   signed long long  int64_t;
+typedef unsigned long long uint64_t;
+
 /**
  * \ingroup Utilities
  *
@@ -346,35 +456,16 @@
     AlignOnPage
 };
 
-#if __cplusplus >= 201103 /*C++11*/
-#define Vc_CONSTEXPR constexpr
-#elif defined(__GNUC__)
-#define Vc_CONSTEXPR inline __attribute__((__always_inline__, __const__))
-#elif defined(VC_MSVC)
-#define Vc_CONSTEXPR inline __forceinline
-#else
-#define Vc_CONSTEXPR inline
-#endif
-Vc_CONSTEXPR StreamingAndUnalignedFlag operator|(UnalignedFlag, StreamingAndAlignedFlag) { return StreamingAndUnaligned; }
-Vc_CONSTEXPR StreamingAndUnalignedFlag operator|(StreamingAndAlignedFlag, UnalignedFlag) { return StreamingAndUnaligned; }
-Vc_CONSTEXPR StreamingAndUnalignedFlag operator&(UnalignedFlag, StreamingAndAlignedFlag) { return StreamingAndUnaligned; }
-Vc_CONSTEXPR StreamingAndUnalignedFlag operator&(StreamingAndAlignedFlag, UnalignedFlag) { return StreamingAndUnaligned; }
-
-Vc_CONSTEXPR StreamingAndAlignedFlag operator|(AlignedFlag, StreamingAndAlignedFlag) { return Streaming; }
-Vc_CONSTEXPR StreamingAndAlignedFlag operator|(StreamingAndAlignedFlag, AlignedFlag) { return Streaming; }
-Vc_CONSTEXPR StreamingAndAlignedFlag operator&(AlignedFlag, StreamingAndAlignedFlag) { return Streaming; }
-Vc_CONSTEXPR StreamingAndAlignedFlag operator&(StreamingAndAlignedFlag, AlignedFlag) { return Streaming; }
-
 /**
  * \ingroup Utilities
  *
  * Enum to identify a certain SIMD instruction set.
  *
- * You can use \ref VC_IMPL for the currently active implementation.
+ * You can use \ref CurrentImplementation for the currently active implementation.
  *
  * \see ExtraInstructions
  */
-enum Implementation {
+enum Implementation : std::uint_least32_t { // TODO: make enum class
     /// uses only fundamental types
     ScalarImpl,
     /// x86 SSE + SSE2
@@ -391,6 +482,8 @@
     AVXImpl,
     /// x86 AVX + AVX2
     AVX2Impl,
+    /// Intel Xeon Phi
+    MICImpl,
     ImplementationMask = 0xfff
 };
 
@@ -404,7 +497,7 @@
  * But there are additional instructions that are not necessarily required by this list. These are
  * covered in this enum.
  */
-enum ExtraInstructions {
+enum ExtraInstructions : std::uint_least32_t { // TODO: make enum class
     //! Support for float16 conversions in hardware
     Float16cInstructions  = 0x01000,
     //! Support for FMA4 instructions
@@ -417,93 +510,107 @@
     Sse4aInstructions     = 0x10000,
     //! Support for FMA instructions (3 operand variant)
     FmaInstructions       = 0x20000,
+    //! Support for ternary instruction coding (VEX)
+    VexInstructions       = 0x40000,
+    //! Support for BMI2 instructions
+    Bmi2Instructions      = 0x80000,
     // PclmulqdqInstructions,
     // AesInstructions,
     // RdrandInstructions
     ExtraInstructionsMask = 0xfffff000u
 };
 
-#ifndef DOXYGEN
-
-#ifdef VC_IMPL_Scalar
-#define VC_IMPL ::Vc::ScalarImpl
-#elif defined(VC_IMPL_AVX)
-#define VC_IMPL ::Vc::AVXImpl
-#elif defined(VC_IMPL_SSE4_2)
-#define VC_IMPL ::Vc::SSE42Impl
-#elif defined(VC_IMPL_SSE4_1)
-#define VC_IMPL ::Vc::SSE41Impl
-#elif defined(VC_IMPL_SSSE3)
-#define VC_IMPL ::Vc::SSSE3Impl
-#elif defined(VC_IMPL_SSE3)
-#define VC_IMPL ::Vc::SSE3Impl
-#elif defined(VC_IMPL_SSE2)
-#define VC_IMPL ::Vc::SSE2Impl
-#endif
-
-template<unsigned int Features> struct ImplementationT { enum _Value {
-    Value = Features,
-    Implementation = Features & Vc::ImplementationMask,
-    ExtraInstructions = Features & Vc::ExtraInstructionsMask
-}; };
-
-typedef ImplementationT<
-#ifdef VC_USE_VEX_CODING
-    // everything will use VEX coding, so the system has to support AVX even if VC_IMPL_AVX is not set
-    // but AFAIU the OSXSAVE and xgetbv tests do not have to positive (unless, of course, the
-    // compiler decides to insert an instruction that uses the full register size - so better be on
-    // the safe side)
+/**
+ * \ingroup Utilities
+ * This class identifies the specific implementation %Vc uses in the current translation
+ * unit in terms of a type.
+ *
+ * Most importantantly, the type \ref CurrentImplementation instantiates the class
+ * template with the bitmask identifying the current implementation. The contents of the
+ * bitmask can be queried with the static member functions of the class.
+ */
+template <unsigned int Features> struct ImplementationT {
+    /// Returns the currently used Vc::Implementation.
+    static constexpr Implementation current()
+    {
+        return static_cast<Implementation>(Features & ImplementationMask);
+    }
+    /// Returns whether \p impl is the current Vc::Implementation.
+    static constexpr bool is(Implementation impl)
+    {
+        return static_cast<unsigned int>(impl) == current();
+    }
+    /**
+     * Returns whether the current Vc::Implementation implements at least \p low and at
+     * most \p high.
+     */
+    static constexpr bool is_between(Implementation low, Implementation high)
+    {
+        return static_cast<unsigned int>(low) <= current() &&
+               static_cast<unsigned int>(high) >= current();
+    }
+    /**
+     * Returns whether the current code would run on a CPU providing \p extraInstructions.
+     */
+    static constexpr bool runs_on(unsigned int extraInstructions)
+    {
+        return (extraInstructions & Features & ExtraInstructionsMask) ==
+               (Features & ExtraInstructionsMask);
+    }
+};
+/**
+ * \ingroup Utilities
+ * Identifies the %Vc implementation used in the current translation unit.
+ *
+ * \see ImplementationT
+ */
+using CurrentImplementation = ImplementationT<
+#ifdef Vc_IMPL_Scalar
+    ScalarImpl
+#elif defined(Vc_IMPL_MIC)
+    MICImpl
+#elif defined(Vc_IMPL_AVX2)
+    AVX2Impl
+#elif defined(Vc_IMPL_AVX)
     AVXImpl
-#else
-    VC_IMPL
+#elif defined(Vc_IMPL_SSE4_2)
+    SSE42Impl
+#elif defined(Vc_IMPL_SSE4_1)
+    SSE41Impl
+#elif defined(Vc_IMPL_SSSE3)
+    SSSE3Impl
+#elif defined(Vc_IMPL_SSE3)
+    SSE3Impl
+#elif defined(Vc_IMPL_SSE2)
+    SSE2Impl
 #endif
-#ifdef VC_IMPL_SSE4a
+#ifdef Vc_IMPL_SSE4a
     + Vc::Sse4aInstructions
-#ifdef VC_IMPL_XOP
+#ifdef Vc_IMPL_XOP
     + Vc::XopInstructions
-#ifdef VC_IMPL_FMA4
+#ifdef Vc_IMPL_FMA4
     + Vc::Fma4Instructions
 #endif
 #endif
 #endif
-#ifdef VC_IMPL_POPCNT
+#ifdef Vc_IMPL_POPCNT
     + Vc::PopcntInstructions
 #endif
-#ifdef VC_IMPL_FMA
+#ifdef Vc_IMPL_FMA
     + Vc::FmaInstructions
 #endif
-    > CurrentImplementation;
-
-namespace Internal {
-    template<Implementation Impl> struct HelperImpl;
-    typedef HelperImpl<VC_IMPL> Helper;
-
-    template<typename A> struct FlagObject;
-    template<> struct FlagObject<AlignedFlag> { static Vc_CONSTEXPR AlignedFlag the() { return Aligned; } };
-    template<> struct FlagObject<UnalignedFlag> { static Vc_CONSTEXPR UnalignedFlag the() { return Unaligned; } };
-    template<> struct FlagObject<StreamingAndAlignedFlag> { static Vc_CONSTEXPR StreamingAndAlignedFlag the() { return Streaming; } };
-    template<> struct FlagObject<StreamingAndUnalignedFlag> { static Vc_CONSTEXPR StreamingAndUnalignedFlag the() { return StreamingAndUnaligned; } };
-} // namespace Internal
-
-namespace Warnings
-{
-    void _operator_bracket_warning()
-#ifdef VC_HAVE_ATTRIBUTE_WARNING
-        __attribute__((warning("\n\tUse of Vc::Vector::operator[] to modify scalar entries is known to miscompile with GCC 4.3.x.\n\tPlease upgrade to a more recent GCC or avoid operator[] altogether.\n\t(This warning adds an unnecessary function call to operator[] which should work around the problem at a little extra cost.)")))
+#ifdef Vc_IMPL_BMI2
+    + Vc::Bmi2Instructions
 #endif
-        ;
-} // namespace Warnings
+#ifdef Vc_USE_VEX_CODING
+    + Vc::VexInstructions
+#endif
+    >;
 
-namespace Error
-{
-    template<typename L, typename R> struct invalid_operands_of_types {};
-} // namespace Error
+}  // namespace Vc
 
-#endif // DOXYGEN
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#undef Vc_CONSTEXPR
 #include "version.h"
 
-#endif // VC_GLOBAL_H
+#endif // VC_GLOBAL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/internal/namespace.h vc-1.3.0/include/Vc/internal/namespace.h
--- vc-0.7.4/include/Vc/internal/namespace.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/internal/namespace.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,28 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifdef VC_IMPL_Scalar
-# define VECTOR_NAMESPACE Vc::Scalar
-#elif defined(VC_IMPL_AVX)
-# define VECTOR_NAMESPACE Vc::AVX
-#elif defined(VC_IMPL_SSE)
-# define VECTOR_NAMESPACE Vc::SSE
-#else
-# error "No known Vc implementation was selected. This should not happen. The logic in Vc/global.h failed."
-#endif
diff -Nru vc-0.7.4/include/Vc/IO vc-1.3.0/include/Vc/IO
--- vc-0.7.4/include/Vc/IO	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/IO	2016-10-27 02:05:02.000000000 -0500
@@ -1,179 +1,225 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VECIO_H
-#define VECIO_H
-
-#include "vector.h"
-#include "Memory"
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_IO_
+#define VC_IO_
+
+#include "common/types.h"
+#include "common/simdarrayfwd.h"
+#include "common/memoryfwd.h"
 #include <iostream>
 
 #if defined(__GNUC__) && !defined(_WIN32) && defined(_GLIBCXX_OSTREAM)
-#define VC_HACK_OSTREAM_FOR_TTY 1
+#define Vc_HACK_OSTREAM_FOR_TTY 1
 #endif
 
-#ifdef VC_HACK_OSTREAM_FOR_TTY
+#ifdef Vc_HACK_OSTREAM_FOR_TTY
 #include <unistd.h>
 #include <ext/stdio_sync_filebuf.h>
 #endif
 
-#include "internal/namespace.h"
-
+namespace Vc_VERSIONED_NAMESPACE
+{
 namespace
 {
-    namespace AnsiColor
-    {
-        struct Type { const char *data; };
-        static const Type green  = { "\033[1;40;32m" };
-        static const Type yellow = { "\033[1;40;33m" };
-        static const Type blue   = { "\033[1;40;34m" };
-        static const Type normal = { "\033[0m" };
-    } // namespace AnsiColor
-
-#ifdef VC_HACK_OSTREAM_FOR_TTY
-    class hacked_ostream : public std::ostream
-    {
-        public:
-            using std::ostream::_M_streambuf;
-    };
-    __attribute__((__const__)) bool mayUseColor(const std::ostream &os)
-    {
-        std::basic_streambuf<char> *hack1 = const_cast<std::basic_streambuf<char> *>(os.*(&hacked_ostream::_M_streambuf));
-        __gnu_cxx::stdio_sync_filebuf<char> *hack = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char> *>(hack1);
-        if (!hack) {
-            return false;
-        }
-        FILE *file = hack->file();
-        return 1 == isatty(fileno(file));
+#ifdef Vc_HACK_OSTREAM_FOR_TTY
+class hacked_ostream : public std::ostream
+{
+public:
+    using std::ostream::_M_streambuf;
+};
+bool mayUseColor(const std::ostream &os) __attribute__((__const__));
+bool mayUseColor(const std::ostream &os)
+{
+    std::basic_streambuf<char> *hack1 =
+        const_cast<std::basic_streambuf<char> *>(os.*(&hacked_ostream::_M_streambuf));
+    __gnu_cxx::stdio_sync_filebuf<char> *hack =
+        dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char> *>(hack1);
+    if (!hack) {
+        return false;
     }
+    FILE *file = hack->file();
+    return 1 == isatty(fileno(file));
+}
 #else
-    inline bool mayUseColor(const std::ostream &) { return false; }
+bool mayUseColor(const std::ostream &) { return false; }
 #endif
-} // anonymous namespace
+}  // anonymous namespace
 
-namespace std
+namespace AnsiColor
 {
-inline std::ostream &operator<<(std::ostream &out, const AnsiColor::Type &c)
+struct Type
 {
-    if (mayUseColor(out)) {
-        out << c.data;
-    }
-    return out;
-}
+    const char *data;
+};
+static const Type green = {"\033[1;40;32m"};
+static const Type yellow = {"\033[1;40;33m"};
+static const Type blue = {"\033[1;40;34m"};
+static const Type normal = {"\033[0m"};
 
-template<typename T>
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Vector<T> &v)
+inline std::ostream &operator<<(std::ostream &out, const Type &c)
 {
-    out << AnsiColor::green << "[";
-    out << v[0];
-    for (int i = 1; i < v.Size; ++i) {
-        out << ", " << v[i];
+    if (mayUseColor(out)) {
+        out << c.data;
     }
-    out << "]" << AnsiColor::normal;
     return out;
 }
+}  // namespace AnsiColor
 
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Vector<char> &v)
-{
-    out << AnsiColor::green << "[";
-    out << int(v[0]);
-    for (int i = 1; i < v.Size; ++i) {
-        out << ", " << int(v[i]);
-    }
-    out << "]" << AnsiColor::normal;
-    return out;
-}
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Vector<unsigned char> &v)
-{
-    out << AnsiColor::green << "[";
-    out << int(v[0]);
-    for (int i = 1; i < v.Size; ++i) {
-        out << ", " << int(v[i]);
+/**
+ * \ingroup Vectors
+ * \headerfile IO <Vc/IO>
+ *
+ * Prints the contents of a vector into a stream object.
+ *
+ * \code
+ * const Vc::int_v v(Vc::IndexesFromZero);
+ * std::cout << v << std::endl;
+ * \endcode
+ * will output (with SSE):
+\verbatim
+[0, 1, 2, 3]
+\endverbatim
+ *
+ * \param out Any standard C++ ostream object. For example std::cout or a
+ *            std::stringstream object.
+ * \param v Any Vc::Vector object.
+ * \return  The ostream object: to chain multiple stream operations.
+ *
+ * \note With the GNU standard library this function will check whether the
+ *       output stream is a tty in which case it colorizes the output.
+ */
+template <typename T, typename Abi>
+inline std::ostream &operator<<(std::ostream &out, const Vc::Vector<T, Abi> &v)
+{
+    using TT = typename std::conditional<std::is_same<T, char>::value ||
+                                             std::is_same<T, unsigned char>::value ||
+                                             std::is_same<T, signed char>::value,
+                                         int,
+                                         T>::type;
+    out << AnsiColor::green << '[';
+    out << TT(v[0]);
+    for (size_t i = 1; i < v.Size; ++i) {
+        out << ", " << TT(v[i]);
     }
-    out << "]" << AnsiColor::normal;
+    out << ']' << AnsiColor::normal;
     return out;
 }
 
-#ifdef VC_HAVE_FMA
-template<typename T>
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::VectorMultiplication<T> &v)
-{
-    return out << VECTOR_NAMESPACE::Vector<T>(v);
-}
-#endif
-
-#ifdef VC_IMPL_AVX
-template<unsigned int VectorSize, size_t RegisterWidth>
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Mask<VectorSize, RegisterWidth> &m)
-#else
-template<unsigned int VectorSize>
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Mask<VectorSize> &m)
-#endif
+/**
+ * \ingroup Masks
+ * \headerfile IO <Vc/IO>
+ *
+ * Prints the contents of a mask into a stream object.
+ *
+ * \code
+ * const Vc::short_m m = Vc::short_v::IndexesFromZero() < 3;
+ * std::cout << m << std::endl;
+ * \endcode
+ * will output (with SSE):
+\verbatim
+m[1110 0000]
+\endverbatim
+ *
+ * \param out Any standard C++ ostream object. For example std::cout or a
+ *            std::stringstream object.
+ * \param m Any Vc::Mask object.
+ * \return  The ostream object: to chain multiple stream operations.
+ *
+ * \note With the GNU standard library this function will check whether the
+ *       output stream is a tty in which case it colorizes the output.
+ */
+template <typename T, typename Abi>
+inline std::ostream &operator<<(std::ostream &out, const Vc::Mask<T, Abi> &m)
 {
     out << AnsiColor::blue << "m[";
-    for (unsigned int i = 0; i < VectorSize; ++i) {
+    for (unsigned int i = 0; i < m.Size; ++i) {
         if (i > 0 && (i % 4) == 0) {
-            out << " ";
+            out << ' ';
         }
-        if ( m[i] ) {
-          out << AnsiColor::yellow << '1';
+        if (m[i]) {
+            out << AnsiColor::yellow << '1';
         } else {
-          out << AnsiColor::blue << '0';
+            out << AnsiColor::blue << '0';
         }
     }
-    out << AnsiColor::blue << "]" << AnsiColor::normal;
+    out << AnsiColor::blue << ']' << AnsiColor::normal;
     return out;
 }
-#ifdef VC_IMPL_SSE
-inline std::ostream &operator<<(std::ostream &out, const VECTOR_NAMESPACE::Float8Mask &m)
+
+namespace Common
 {
-    out << AnsiColor::blue << "m[";
-    for (unsigned int i = 0; i < 8; ++i) {
-        if (i > 0 && (i % 4) == 0) {
-            out << " ";
-        }
-        if ( m[i] ) {
-          out << AnsiColor::yellow << '1';
-        } else {
-          out << AnsiColor::blue << '0';
-        }
-    }
-    out << AnsiColor::blue << "]" << AnsiColor::normal;
-    return out;
-}
+#ifdef DOXYGEN
+/**
+ * \ingroup Utilities
+ * \headerfile dox.h <Vc/IO>
+ *
+ * Prints the contents of a Memory object into a stream object.
+ *
+ * \code
+ * Vc::Memory<int_v, 10> m;
+ * for (int i = 0; i < m.entriesCount(); ++i) {
+ *   m[i] = i;
+ * }
+ * std::cout << m << std::endl;
+ * \endcode
+ * will output (with SSE):
+\verbatim
+{[0, 1, 2, 3] [4, 5, 6, 7] [8, 9, 0, 0]}
+\endverbatim
+ *
+ * \param s Any standard C++ ostream object. For example std::cout or a std::stringstream object.
+ * \param m Any Vc::Memory object.
+ * \return  The ostream object: to chain multiple stream operations.
+ *
+ * \note With the GNU standard library this function will check whether the
+ *       output stream is a tty in which case it colorizes the output.
+ *
+ * \warning Please do not forget that printing a large memory object can take a long time.
+ */
+template<typename V, typename Parent, typename Dimension, typename RM>
+inline std::ostream &operator<<(std::ostream &s, const Vc::MemoryBase<V, Parent, Dimension, RM> &m);
 #endif
 
 template<typename V, typename Parent, typename RM>
-inline std::ostream &operator<<(std::ostream &out, const Vc::MemoryBase<V, Parent, 1, RM> &m )
+inline std::ostream &operator<<(std::ostream &out, const MemoryBase<V, Parent, 1, RM> &m )
 {
-    out << AnsiColor::blue << "{" << AnsiColor::normal;
+    out << AnsiColor::blue << '{' << AnsiColor::normal;
     for (unsigned int i = 0; i < m.vectorsCount(); ++i) {
         out << V(m.vector(i));
     }
-    out << AnsiColor::blue << "}" << AnsiColor::normal;
+    out << AnsiColor::blue << '}' << AnsiColor::normal;
     return out;
 }
 
 template<typename V, typename Parent, typename RM>
-inline std::ostream &operator<<(std::ostream &out, const Vc::MemoryBase<V, Parent, 2, RM> &m )
+inline std::ostream &operator<<(std::ostream &out, const MemoryBase<V, Parent, 2, RM> &m )
 {
-    out << AnsiColor::blue << "{" << AnsiColor::normal;
+    out << AnsiColor::blue << '{' << AnsiColor::normal;
     for (size_t i = 0; i < m.rowsCount(); ++i) {
         if (i > 0) {
             out << "\n ";
@@ -183,13 +229,40 @@
             out << V(m[i].vector(j));
         }
     }
-    out << AnsiColor::blue << "}" << AnsiColor::normal;
+    out << AnsiColor::blue << '}' << AnsiColor::normal;
     return out;
 }
-} // namespace std
+}  // namespace Common
 
-#undef VECTOR_NAMESPACE
+template<typename T, std::size_t N>
+inline std::ostream &operator<<(std::ostream &out, const SimdArray<T, N> &v)
+{
+    out << AnsiColor::green << '<' << v[0];
+    for (size_t i = 1; i < N; ++i) {
+        if (i % 4 == 0) out << " |";
+        out << ' ' << v[i];
+    }
+    return out << '>' << AnsiColor::normal;
+}
+
+template<typename T, std::size_t N>
+inline std::ostream &operator<<(std::ostream &out, const SimdMaskArray<T, N> &m)
+{
+    out << AnsiColor::blue << "«";
+    for (size_t i = 0; i < N; ++i) {
+        if (i > 0 && (i % 4) == 0) {
+            out << ' ';
+        }
+        if ( m[i] ) {
+          out << AnsiColor::yellow << '1';
+        } else {
+          out << AnsiColor::blue << '0';
+        }
+    }
+    return out << AnsiColor::blue << "»" << AnsiColor::normal;
+}
+}
 
-#endif // VECIO_H
+#endif // VC_IO_
 
-// vim: ft=cpp
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/iterators vc-1.3.0/include/Vc/iterators
--- vc-0.7.4/include/Vc/iterators	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/iterators	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,41 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_INCLUDE_VC_ITERATORS_H_
+#define VC_INCLUDE_VC_ITERATORS_H_
+
+#include "common/iterators.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+    using ::Vc::Common::begin;
+    using ::Vc::Common::end;
+    using ::Vc::Common::makeIterator;
+}
+
+#endif // VC_INCLUDE_VC_ITERATORS_H_
+
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/limits vc-1.3.0/include/Vc/limits
--- vc-0.7.4/include/Vc/limits	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/limits	2016-10-27 02:05:02.000000000 -0500
@@ -1,25 +1,34 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef INCLUDE_VC_LIMITS
-#define INCLUDE_VC_LIMITS
+#ifndef VC_LIMITS_
+#define VC_LIMITS_
 
+#include <limits>
 #include "vector.h"
 #include "common/macros.h"
 #include <limits>
@@ -43,15 +52,16 @@
 };
 } // namespace std
 
-#include "common/undomacros.h"
-#ifdef VC_IMPL_Scalar
+#ifdef Vc_IMPL_Scalar
 # include "scalar/limits.h"
-#elif defined(VC_IMPL_AVX)
+#elif defined(Vc_IMPL_AVX)
 # include "avx/limits.h"
-#elif defined(VC_IMPL_SSE)
+#elif defined(Vc_IMPL_SSE)
 # include "sse/limits.h"
+#elif defined(Vc_IMPL_MIC)
+# include "mic/limits.h"
 #endif
 
-#endif // INCLUDE_VC_LIMITS
+#endif // VC_LIMITS_
 
-// vim: ft=cpp
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/Memory vc-1.3.0/include/Vc/Memory
--- vc-0.7.4/include/Vc/Memory	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/Memory	2016-10-27 02:05:02.000000000 -0500
@@ -1,37 +1,43 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-/*  This file is part of the Vc library.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Copyright (C) 2009 Matthias Kretz <kretz@kde.org>
+}}}*/
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef INCLUDE_VC_MEMORY
-#define INCLUDE_VC_MEMORY
+#ifndef VC_MEMORY_
+#define VC_MEMORY_
 
 #include "vector.h"
 #include "common/memory.h"
 #include "common/interleavedmemory.h"
-#ifdef VC_IMPL_Scalar
-# include "scalar/interleavedmemory.tcc"
-#elif defined(VC_IMPL_AVX)
-# include "avx/interleavedmemory.tcc"
-#elif defined(VC_IMPL_SSE)
-# include "sse/interleavedmemory.tcc"
-#endif
 
-#endif // INCLUDE_VC_MEMORY
+#include "common/make_unique.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+using Common::make_unique;
+}
+
+#endif // VC_MEMORY_
 
-// vim: ft=cpp
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/SimdArray vc-1.3.0/include/Vc/SimdArray
--- vc-0.7.4/include/Vc/SimdArray	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/SimdArray	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,35 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SIMDARRAY_
+#define VC_SIMDARRAY_
+
+#include "common/simdarray.h"
+
+#endif // VC_SIMDARRAY_
+
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/simdize vc-1.3.0/include/Vc/simdize
--- vc-0.7.4/include/Vc/simdize	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/simdize	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,5 @@
+#include "vector.h"
+#include "Allocator"
+#include "common/simdize.h"
+
+// vim: ft=cpp
diff -Nru vc-0.7.4/include/Vc/support.h vc-1.3.0/include/Vc/support.h
--- vc-0.7.4/include/Vc/support.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/support.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,39 +1,47 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_COMMON_SUPPORT_H_
+#define VC_COMMON_SUPPORT_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_COMMON_SUPPORT_H
-#define VC_COMMON_SUPPORT_H
-
-#ifndef VC_GLOBAL_H
+#ifndef VC_GLOBAL_H_
 #error "Vc/global.h must be included first!"
 #endif
 
 #include <Vc/cpuid.h>
 
-#if defined(VC_GCC) && VC_GCC >= 0x40400
-#define VC_TARGET_NO_SIMD __attribute__((target("no-sse2,no-avx")))
+#if defined(Vc_GCC) && Vc_GCC >= 0x40400 && defined __SSE__
+#define Vc_TARGET_NO_SIMD __attribute__((target("no-sse2,no-avx")))
 #else
-#define VC_TARGET_NO_SIMD
+#define Vc_TARGET_NO_SIMD
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#include "common/macros.h"
+namespace Vc_VERSIONED_NAMESPACE
 {
 
 /**
@@ -47,7 +55,7 @@
  *
  * \return A combination of flags from Vc::ExtraInstructions that the current CPU supports.
  */
-VC_TARGET_NO_SIMD
+Vc_TARGET_NO_SIMD
 unsigned int extraInstructionsSupported();
 
 /**
@@ -61,7 +69,7 @@
  *
  * \param impl The SIMD target to test for.
  */
-VC_TARGET_NO_SIMD
+Vc_TARGET_NO_SIMD
 bool isImplementationSupported(Vc::Implementation impl);
 
 /**
@@ -84,11 +92,11 @@
  * \tparam Impl The SIMD target to test for.
  */
 template<typename Impl>
-VC_TARGET_NO_SIMD
+Vc_TARGET_NO_SIMD
 static inline bool isImplementationSupported()
 {
-    return isImplementationSupported(static_cast<Vc::Implementation>(Impl::Implementation)) &&
-        (extraInstructionsSupported() & Impl::ExtraInstructions) == Impl::ExtraInstructions;
+    return isImplementationSupported(Impl::current()) &&
+           Impl::runs_on(extraInstructionsSupported());
 }
 
 /**
@@ -99,10 +107,10 @@
  *
  * \return The enum value for the best implementation.
  */
-VC_TARGET_NO_SIMD
+Vc_TARGET_NO_SIMD
 Vc::Implementation bestImplementationSupported();
 
-#ifndef VC_COMPILE_LIB
+#ifndef Vc_COMPILE_LIB
 /**
  * \ingroup Utilities
  * \headerfile support.h <Vc/support.h>
@@ -131,7 +139,7 @@
  *                 instructions.
  * \return \c false otherwise
  */
-VC_TARGET_NO_SIMD
+Vc_TARGET_NO_SIMD
 #ifndef DOXYGEN
 static
 #endif
@@ -139,12 +147,11 @@
 {
     return isImplementationSupported<Vc::CurrentImplementation>();
 }
-#endif // VC_COMPILE_LIB
+#endif // Vc_COMPILE_LIB
 //@}
 
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}
 
-#undef VC_TARGET_NO_SIMD
+#undef Vc_TARGET_NO_SIMD
 
-#endif // VC_COMMON_SUPPORT_H
+#endif // VC_COMMON_SUPPORT_H_
diff -Nru vc-0.7.4/include/Vc/type_traits vc-1.3.0/include/Vc/type_traits
--- vc-0.7.4/include/Vc/type_traits	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/type_traits	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,55 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TYPE_TRAITS_
+#define VC_TYPE_TRAITS_
+
+#include <type_traits>
+
+#include "traits/type_traits.h"
+#include "common/macros.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+using Traits::is_simd_mask;
+using Traits::is_simd_vector;
+using Traits::is_integral;
+using Traits::is_floating_point;
+using Traits::is_arithmetic;
+using Traits::is_signed;
+using Traits::is_unsigned;
+
+template<typename T>
+struct memory_alignment : public std::integral_constant<size_t, alignof(T)> {};
+
+template<> struct memory_alignment<short_v> : public std::integral_constant<size_t, short_v::MemoryAlignment> {};
+template<> struct memory_alignment<ushort_v> : public std::integral_constant<size_t, ushort_v::MemoryAlignment> {};
+
+}
+
+#endif // VC_TYPE_TRAITS_
+
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/Utils vc-1.3.0/include/Vc/Utils
--- vc-0.7.4/include/Vc/Utils	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/Utils	2016-10-27 02:05:02.000000000 -0500
@@ -1,33 +1,44 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_UTILS
-#define VC_UTILS
+#ifndef VC_UTILS_
+#define VC_UTILS_
 
 #include "global.h"
 
-#ifdef VC_IMPL_Scalar
+#ifdef Vc_IMPL_Scalar
 # define VECTOR_NAMESPACE Scalar
 #else
 # define VECTOR_NAMESPACE SSE
 #endif
 
 #include "common/deinterleave.h"
+#include "common/makeContainer.h"
+
+#endif // VC_UTILS_
 
-#endif // VC_UTILS
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/Vc vc-1.3.0/include/Vc/Vc
--- vc-0.7.4/include/Vc/Vc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/Vc	2016-10-27 02:05:02.000000000 -0500
@@ -1,29 +1,40 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_VC
-#define VC_VC
+#ifndef VC_VC_
+#define VC_VC_
 #include "vector.h"
 #include "IO"
 #include "Memory"
 #include "Utils"
 #include "Allocator"
-#endif // VC_VC
+#include "iterators"
+#include "SimdArray"
+#include "simdize"
+#endif // VC_VC_
 
-// vim: ft=cpp
+// vim: ft=cpp foldmethod=marker
diff -Nru vc-0.7.4/include/Vc/vector vc-1.3.0/include/Vc/vector
--- vc-0.7.4/include/Vc/vector	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/include/Vc/vector	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,62 @@
+/*{{{
+    Copyright © 2013 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#ifndef VC_VECTOR_
+#define VC_VECTOR_
+
+#include "common/subscript.h"
+#include <vector>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * \ingroup Utilities
+ * An adapted `std::vector` container with an additional subscript operator which
+ * implements gather and scatter operations.
+ *
+ * Example:
+ * \code
+ * struct Point {
+ *   float x, y;
+ * };
+ * Vc::vector<Point> data;
+ * data.resize(100);
+ * // initialize values in data
+ * float_v::IndexType indexes = ...;  // values between 0-99
+ * float_v x = data[indexes][&Point::x];
+ * float_v y = data[indexes][&Point::y];
+ * \endcode
+ */
+template <typename T, typename Allocator = std::allocator<T>>
+using vector = Common::AdaptSubscriptOperator<std::vector<T, Allocator>>;
+
+namespace Traits
+{
+template <typename T, typename A>
+struct has_contiguous_storage_impl<Vc::vector<T, A>> : public std::true_type {};
+}  // namespace Traits
+
+}  // namespace
+
+#endif  // VC_VECTOR_
+// vim: ft=cpp
diff -Nru vc-0.7.4/include/Vc/vector.h vc-1.3.0/include/Vc/vector.h
--- vc-0.7.4/include/Vc/vector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,38 +1,245 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+#ifndef VC_VECTOR_H_
+#define VC_VECTOR_H_
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+// 1. define all of Vc::Scalar - this one is always present, so it makes sense to put it first
+#include "scalar/vector.h"
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+#ifdef Vc_IMPL_AVX
+# include "avx/vector.h"
+#elif defined(Vc_IMPL_SSE)
+# include "sse/vector.h"
+#endif
+
+#if defined(Vc_IMPL_MIC)
+# include "mic/vector.h"
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+/**
+ * \name Vector Type Aliases
+ * \ingroup Vectors
+ */
+///@{
+/**\addtogroup Vectors
+ * @{
+ */
+/// vector of double precision
+using double_v = Vector<double>;
+/// vector of single precision
+using float_v = Vector<float>;
+/// vector of signed integers
+using int_v = Vector<int>;
+/// vector of unsigned integers
+using uint_v = Vector<uint>;
+/// vector of signed short integers
+using short_v = Vector<short>;
+/// vector of unsigned short integers
+using ushort_v = Vector<ushort>;
+///\internal vector of signed long long integers
+using llong_v = Vector<llong>;
+///\internal vector of unsigned long long integers
+using ullong_v = Vector<ullong>;
+///\internal vector of signed long integers
+using long_v = Vector<long>;
+///\internal vector of unsigned long integers
+using ulong_v = Vector<ulong>;
+///\internal vector of signed char-sized integers
+using schar_v = Vector<schar>;
+///\internal vector of unsigned char-sized integers
+using uchar_v = Vector<uchar>;
+///@}
+///@}
+
+/**
+ * \name Mask Type Aliases
+ * \ingroup Masks
+ */
+///@{
+/**\addtogroup Masks
+ * @{
+ */
+/// mask type for double_v vectors
+using double_m = Mask<double>;
+/// mask type for float_v vectors
+using  float_m = Mask< float>;
+///\internal mask type for llong_v vectors
+using  llong_m = Mask< llong>;
+///\internal mask type for ullong_v vectors
+using ullong_m = Mask<ullong>;
+///\internal mask type for long_v vectors
+using   long_m = Mask<  long>;
+///\internal mask type for ulong_v vectors
+using  ulong_m = Mask< ulong>;
+/// mask type for int_v vectors
+using    int_m = Mask<   int>;
+/// mask type for uint_v vectors
+using   uint_m = Mask<  uint>;
+/// mask type for short_v vectors
+using  short_m = Mask< short>;
+/// mask type for ushort_v vectors
+using ushort_m = Mask<ushort>;
+///\internal mask type for schar_v vectors
+using  schar_m = Mask< schar>;
+///\internal mask type for uchar_v vectors
+using  uchar_m = Mask< uchar>;
+///@}
+///@}
+
+  typedef Vector<std:: int_least64_t>  int_least64_v;
+  typedef Vector<std::uint_least64_t> uint_least64_v;
+  typedef Vector<std:: int_least32_t>  int_least32_v;
+  typedef Vector<std::uint_least32_t> uint_least32_v;
+  typedef Vector<std:: int_least16_t>  int_least16_v;
+  typedef Vector<std::uint_least16_t> uint_least16_v;
+  typedef Vector<std::  int_least8_t>   int_least8_v;
+  typedef Vector<std:: uint_least8_t>  uint_least8_v;
+
+  typedef Mask<std:: int_least64_t>  int_least64_m;
+  typedef Mask<std::uint_least64_t> uint_least64_m;
+  typedef Mask<std:: int_least32_t>  int_least32_m;
+  typedef Mask<std::uint_least32_t> uint_least32_m;
+  typedef Mask<std:: int_least16_t>  int_least16_m;
+  typedef Mask<std::uint_least16_t> uint_least16_m;
+  typedef Mask<std::  int_least8_t>   int_least8_m;
+  typedef Mask<std:: uint_least8_t>  uint_least8_m;
+
+  typedef Vector<std:: int_fast64_t>  int_fast64_v;
+  typedef Vector<std::uint_fast64_t> uint_fast64_v;
+  typedef Vector<std:: int_fast32_t>  int_fast32_v;
+  typedef Vector<std::uint_fast32_t> uint_fast32_v;
+  typedef Vector<std:: int_fast16_t>  int_fast16_v;
+  typedef Vector<std::uint_fast16_t> uint_fast16_v;
+  typedef Vector<std::  int_fast8_t>   int_fast8_v;
+  typedef Vector<std:: uint_fast8_t>  uint_fast8_v;
+
+  typedef Mask<std:: int_fast64_t>  int_fast64_m;
+  typedef Mask<std::uint_fast64_t> uint_fast64_m;
+  typedef Mask<std:: int_fast32_t>  int_fast32_m;
+  typedef Mask<std::uint_fast32_t> uint_fast32_m;
+  typedef Mask<std:: int_fast16_t>  int_fast16_m;
+  typedef Mask<std::uint_fast16_t> uint_fast16_m;
+  typedef Mask<std::  int_fast8_t>   int_fast8_m;
+  typedef Mask<std:: uint_fast8_t>  uint_fast8_m;
+
+#if defined INT64_MAX && defined UINT64_MAX
+  typedef Vector<std:: int64_t>  int64_v;
+  typedef Vector<std::uint64_t> uint64_v;
+  typedef Mask<std:: int64_t>  int64_m;
+  typedef Mask<std::uint64_t> uint64_m;
+#endif
+#if defined INT32_MAX && defined UINT32_MAX
+  typedef Vector<std:: int32_t>  int32_v;
+  typedef Vector<std::uint32_t> uint32_v;
+  typedef Mask<std:: int32_t>  int32_m;
+  typedef Mask<std::uint32_t> uint32_m;
+#endif
+#if defined INT16_MAX && defined UINT16_MAX
+  typedef Vector<std:: int16_t>  int16_v;
+  typedef Vector<std::uint16_t> uint16_v;
+  typedef Mask<std:: int16_t>  int16_m;
+  typedef Mask<std::uint16_t> uint16_m;
+#endif
+#if defined INT8_MAX && defined UINT8_MAX
+  typedef Vector<std:: int8_t>  int8_v;
+  typedef Vector<std::uint8_t> uint8_v;
+  typedef Mask<std:: int8_t>  int8_m;
+  typedef Mask<std::uint8_t> uint8_m;
+#endif
 
-*/
+  namespace {
+    static_assert(double_v::Size == Vc_DOUBLE_V_SIZE, "Vc_DOUBLE_V_SIZE macro defined to an incorrect value");
+    static_assert(float_v::Size  == Vc_FLOAT_V_SIZE , "Vc_FLOAT_V_SIZE macro defined to an incorrect value ");
+    static_assert(int_v::Size    == Vc_INT_V_SIZE   , "Vc_INT_V_SIZE macro defined to an incorrect value   ");
+    static_assert(uint_v::Size   == Vc_UINT_V_SIZE  , "Vc_UINT_V_SIZE macro defined to an incorrect value  ");
+    static_assert(short_v::Size  == Vc_SHORT_V_SIZE , "Vc_SHORT_V_SIZE macro defined to an incorrect value ");
+    static_assert(ushort_v::Size == Vc_USHORT_V_SIZE, "Vc_USHORT_V_SIZE macro defined to an incorrect value");
+  }
+}
 
-#ifndef VECTOR_H
-#define VECTOR_H
 
-#include "global.h"
-#include "internal/namespace.h"
+// finally define the non-member operators
+#include "common/operators.h"
 
-#ifdef VC_IMPL_Scalar
-# include "scalar/vector.h"
-# include "scalar/helperimpl.h"
-#elif defined(VC_IMPL_AVX)
-# include "avx/vector.h"
-# include "avx/helperimpl.h"
-#elif defined(VC_IMPL_SSE)
-# include "sse/vector.h"
+#include "common/simdarray.h"
+// XXX See bottom of common/simdmaskarray.h:
+//#include "common/simd_cast_caller.tcc"
+
+#include "common/alignedbase.h"
+namespace Vc_VERSIONED_NAMESPACE {
+/**
+ * \ingroup Vectors
+ *
+ * Specifies the most conservative memory alignment necessary for Vector<T> objects with
+ * default VectorAbi. Use this value e.g. with an \c alignas expression or when allocating
+ * aligned memory dynamically (\ref Vc::malloc).
+ *
+ * \see Vc::MemoryAlignment
+ * \see Vc::VectorAlignedBase
+ */
+constexpr std::size_t VectorAlignment = alignof(VectorAlignedBase);
+/**
+ * \ingroup Vectors
+ *
+ * Specifies the most conservative memory alignment necessary for aligned loads and stores
+ * of Vector types. Use this value e.g. with an \c alignas expression or when allocating
+ * aligned memory dynamically (\ref Vc::malloc).
+ *
+ * \see Vc::VectorAlignment
+ * \see Vc::Vector<T, Abi>::MemoryAlignment
+ */
+constexpr std::size_t MemoryAlignment = alignof(MemoryAlignedBase);
+} // namespace Vc_VERSIONED_NAMESPACE
+
+#define Vc_VECTOR_DECLARED_ 1
+
+#include "scalar/helperimpl.h"
+#include "scalar/math.h"
+#include "scalar/simd_cast_caller.tcc"
+#if defined(Vc_IMPL_SSE)
 # include "sse/helperimpl.h"
+# include "sse/math.h"
+# include "sse/simd_cast_caller.tcc"
 #endif
+#if defined(Vc_IMPL_AVX)
+# include "avx/helperimpl.h"
+# include "avx/math.h"
+# include "avx/simd_cast_caller.tcc"
+#endif
+#if defined(Vc_IMPL_MIC)
+# include "mic/helperimpl.h"
+# include "mic/math.h"
+# include "mic/simd_cast_caller.tcc"
+#endif
+
+#include "common/math.h"
 
 #ifdef isfinite
 #undef isfinite
@@ -41,80 +248,12 @@
 #undef isnan
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-  using VECTOR_NAMESPACE::VectorAlignment;
-  using VECTOR_NAMESPACE::VectorAlignedBaseT;
-  typedef VectorAlignedBaseT<> VectorAlignedBase;
-  using namespace VectorSpecialInitializerZero;
-  using namespace VectorSpecialInitializerOne;
-  using namespace VectorSpecialInitializerIndexesFromZero;
-  using VECTOR_NAMESPACE::min;
-  using VECTOR_NAMESPACE::max;
-  using VECTOR_NAMESPACE::sqrt;
-  using VECTOR_NAMESPACE::rsqrt;
-  using VECTOR_NAMESPACE::abs;
-  using VECTOR_NAMESPACE::sin;
-  using VECTOR_NAMESPACE::asin;
-  using VECTOR_NAMESPACE::cos;
-  using VECTOR_NAMESPACE::sincos;
-  using VECTOR_NAMESPACE::trunc;
-  using VECTOR_NAMESPACE::floor;
-  using VECTOR_NAMESPACE::ceil;
-  using VECTOR_NAMESPACE::exp;
-  using VECTOR_NAMESPACE::log;
-  using VECTOR_NAMESPACE::log2;
-  using VECTOR_NAMESPACE::log10;
-  using VECTOR_NAMESPACE::reciprocal;
-  using VECTOR_NAMESPACE::atan;
-  using VECTOR_NAMESPACE::atan2;
-  using VECTOR_NAMESPACE::frexp;
-  using VECTOR_NAMESPACE::ldexp;
-  using VECTOR_NAMESPACE::round;
-  using VECTOR_NAMESPACE::isfinite;
-  using VECTOR_NAMESPACE::isnan;
-  using VECTOR_NAMESPACE::forceToRegisters;
-  using VECTOR_NAMESPACE::Vector;
-
-  typedef VECTOR_NAMESPACE::double_v double_v;
-  typedef double_v::Mask double_m;
-  typedef VECTOR_NAMESPACE::sfloat_v sfloat_v;
-  typedef sfloat_v::Mask sfloat_m;
-  typedef VECTOR_NAMESPACE::float_v float_v;
-  typedef float_v::Mask float_m;
-  typedef VECTOR_NAMESPACE::int_v int_v;
-  typedef int_v::Mask int_m;
-  typedef VECTOR_NAMESPACE::uint_v uint_v;
-  typedef uint_v::Mask uint_m;
-  typedef VECTOR_NAMESPACE::short_v short_v;
-  typedef short_v::Mask short_m;
-  typedef VECTOR_NAMESPACE::ushort_v ushort_v;
-  typedef ushort_v::Mask ushort_m;
-
-  namespace {
-#if defined(VC_IMPL_SSE) || defined(VC_IMPL_AVX)
-    using VECTOR_NAMESPACE::Const;
-#endif
-    VC_STATIC_ASSERT_NC(double_v::Size == VC_DOUBLE_V_SIZE, VC_DOUBLE_V_SIZE_MACRO_WRONG);
-    VC_STATIC_ASSERT_NC(float_v::Size  == VC_FLOAT_V_SIZE , VC_FLOAT_V_SIZE_MACRO_WRONG );
-    VC_STATIC_ASSERT_NC(sfloat_v::Size == VC_SFLOAT_V_SIZE, VC_SFLOAT_V_SIZE_MACRO_WRONG);
-    VC_STATIC_ASSERT_NC(int_v::Size    == VC_INT_V_SIZE   , VC_INT_V_SIZE_MACRO_WRONG   );
-    VC_STATIC_ASSERT_NC(uint_v::Size   == VC_UINT_V_SIZE  , VC_UINT_V_SIZE_MACRO_WRONG  );
-    VC_STATIC_ASSERT_NC(short_v::Size  == VC_SHORT_V_SIZE , VC_SHORT_V_SIZE_MACRO_WRONG );
-    VC_STATIC_ASSERT_NC(ushort_v::Size == VC_USHORT_V_SIZE, VC_USHORT_V_SIZE_MACRO_WRONG);
-  }
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
 #include "common/vectortuple.h"
+#include "common/algorithms.h"
+#include "common/where.h"
 #include "common/iif.h"
 
-#ifndef VC_NO_NAMESPACE_ALIAS
-/*NAMESPACE_ALIAS*/
-#endif
-
-#ifndef VC_NO_STD_FUNCTIONS
+#ifndef Vc_NO_STD_FUNCTIONS
 namespace std
 {
   using Vc::min;
@@ -127,6 +266,8 @@
   using Vc::ceil;
   using Vc::cos;
   using Vc::exp;
+  using Vc::fma;
+  using Vc::trunc;
   using Vc::floor;
   using Vc::frexp;
   using Vc::ldexp;
@@ -142,10 +283,4 @@
 } // namespace std
 #endif
 
-#ifndef VC_CLEAN_NAMESPACE
-#define foreach_bit(_it_, _mask_) Vc_foreach_bit(_it_, _mask_)
-#endif
-
-#undef VECTOR_NAMESPACE
-
-#endif // VECTOR_H
+#endif // VC_VECTOR_H_
diff -Nru vc-0.7.4/include/Vc/version.h vc-1.3.0/include/Vc/version.h
--- vc-0.7.4/include/Vc/version.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/include/Vc/version.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,53 +1,123 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_VERSION_H_
+#define VC_VERSION_H_
+
+/**
+ * \name Version Macros
+ * \ingroup Utilities
+ */
+//@{
+/**
+ * \ingroup Utilities
+ * Contains the version string of the %Vc headers. Same as Vc::versionString().
+ */
+#define Vc_VERSION_STRING "1.3.0"
+
+/**
+ * \ingroup Utilities
+ * Contains the encoded version number of the %Vc headers. Same as Vc::versionNumber().
+ */
+#define Vc_VERSION_NUMBER 0x010300
+
+/**
+ * \ingroup Utilities
+ *
+ * Helper macro to compare against an encoded version number.
+ * Example:
+ * \code
+ * #if Vc_VERSION_NUMBER >= Vc_VERSION_CHECK(1, 0, 0)
+ * \endcode
+ */
+#define Vc_VERSION_CHECK(major, minor, patch) ((major << 16) | (minor << 8) | (patch << 1))
+//@}
+
+#define Vc_LIBRARY_ABI_VERSION 5
+
+///\internal identify Vc 2.0
+#define Vc_IS_VERSION_2 (Vc_VERSION_NUMBER >= Vc_VERSION_CHECK(1, 70, 0))
+///\internal identify Vc 1.x
+#define Vc_IS_VERSION_1 (Vc_VERSION_NUMBER < Vc_VERSION_CHECK(1, 70, 0))
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_VERSION_H
-#define VC_VERSION_H
-
-#define VC_VERSION_STRING "0.7.4"
-#define VC_VERSION_NUMBER 0x000708
-#define VC_VERSION_CHECK(major, minor, patch) ((major << 16) | (minor << 8) | (patch << 1))
-#define VC_LIBRARY_ABI_VERSION 3
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-    static inline const char *versionString() {
-        return VC_VERSION_STRING;
-    }
-
-    static inline unsigned int versionNumber() {
-        return VC_VERSION_NUMBER;
-    }
+/**
+ * \ingroup Utilities
+ * \headerfile version.h <Vc/version.h>
+ *
+ * \returns the version string of the %Vc headers.
+ *
+ * \note There exists a built-in check that ensures on application startup that the %Vc version of the
+ * library (link time) and the headers (compile time) are equal. A mismatch between headers and
+ * library could lead to errors that are very hard to debug.
+ * \note If you need to disable the check (it costs a very small amount of application startup time)
+ * you can define Vc_NO_VERSION_CHECK at compile time.
+ */
+inline const char *versionString() { return Vc_VERSION_STRING; }
+
+/**
+ * \ingroup Utilities
+ * \headerfile version.h <Vc/version.h>
+ *
+ * \returns the version of the %Vc headers encoded in an integer.
+ */
+constexpr unsigned int versionNumber() { return Vc_VERSION_NUMBER; }
+}
 
-#if !defined(VC_NO_VERSION_CHECK) && !defined(VC_COMPILE_LIB)
-    void checkLibraryAbi(unsigned int compileTimeAbi, unsigned int versionNumber, const char *versionString);
-    namespace {
-        static struct runLibraryAbiCheck
-        {
-            runLibraryAbiCheck() {
-                checkLibraryAbi(VC_LIBRARY_ABI_VERSION, VC_VERSION_NUMBER, VC_VERSION_STRING);
-            }
-        } _runLibraryAbiCheck;
+#if !defined(Vc_NO_VERSION_CHECK) && !defined(Vc_COMPILE_LIB)
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+/**\internal
+ * This function is implemented in the libVc library and checks whether the library is
+ * compatible with the version information passed via the function parameters. If it is
+ * incompatible the function prints a warning and aborts.
+ */
+void Vc_CDECL checkLibraryAbi(unsigned int compileTimeAbi, unsigned int versionNumber,
+                              const char *versionString);
+namespace
+{
+/**\internal
+ * This constructor function is compiled into every translation unit and thus executed on
+ * startup (before main) for as many TUs as are linked into the executable. It calls
+ * Vc::Common::checkLibraryAbi to ensure the TU was compiled with Vc headers that are
+ * compatible to the linked libVc.
+ */
+static struct runLibraryAbiCheck {
+    runLibraryAbiCheck()
+    {
+        checkLibraryAbi(Vc_LIBRARY_ABI_VERSION, Vc_VERSION_NUMBER, Vc_VERSION_STRING);
     }
+} _runLibraryAbiCheck;
+}  // unnamed namespace
+}  // namespace Common
+}  // namespace Vc
 #endif
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
 
-#endif // VC_VERSION_H
+#endif // VC_VERSION_H_
diff -Nru vc-0.7.4/INSTALL vc-1.3.0/INSTALL
--- vc-0.7.4/INSTALL	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/INSTALL	2016-10-27 02:05:02.000000000 -0500
@@ -1,27 +1 @@
-Build Requirements
-==================
-
-cmake >= 2.8.3
-
-C++11 Compiler:
- * GCC >= 4.6
- * clang >= 3.2
- * ICC >= 13
- * Visual Studio >= 2012
-
-Building and Installing Vc
-==========================
-
-* Create a build directory:
-
-$ mkdir build
-$ cd build
-
-* Call cmake with the relevant options:
-
-$ cmake -DCMAKE_INSTALL_PREFIX=/opt/Vc -DBUILD_TESTING=OFF <srcdir>
-
-* Build and install:
-
-$ make -j16
-$ make install
+See README.md.
diff -Nru vc-0.7.4/LGPL vc-1.3.0/LGPL
--- vc-0.7.4/LGPL	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/LGPL	1969-12-31 18:00:00.000000000 -0600
@@ -1,165 +0,0 @@
-		   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
diff -Nru vc-0.7.4/LICENSE vc-1.3.0/LICENSE
--- vc-0.7.4/LICENSE	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/LICENSE	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,23 @@
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff -Nru vc-0.7.4/makeApidoxLoop.sh vc-1.3.0/makeApidoxLoop.sh
--- vc-0.7.4/makeApidoxLoop.sh	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/makeApidoxLoop.sh	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,11 @@
+#!/bin/sh
+test -f .makeApidox.stamp || touch .makeApidox.stamp
+while true; do
+  ls -l -t include/Vc/* doc/dox.h doc/examples.h common/*|head -n1 > .makeApidox.stamp.new
+  if ! diff -q .makeApidox.stamp.new .makeApidox.stamp; then
+    ./makeApidox.sh
+    mv -f .makeApidox.stamp.new .makeApidox.stamp
+  else
+    sleep 1s
+  fi
+done
diff -Nru vc-0.7.4/makeInternalDox.sh vc-1.3.0/makeInternalDox.sh
--- vc-0.7.4/makeInternalDox.sh	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/makeInternalDox.sh	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+cd "`dirname "$0"`/doc"
+
+rm -rf internal
+doxygen DoxyInternal
diff -Nru vc-0.7.4/makeRelease.sh vc-1.3.0/makeRelease.sh
--- vc-0.7.4/makeRelease.sh	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/makeRelease.sh	2016-10-27 02:05:02.000000000 -0500
@@ -3,7 +3,7 @@
 cd "`dirname "$0"`"
 
 # Read version number
-eval `awk '/VC_VERSION_NUMBER 0x[0-9]+/ { h=$3 }
+eval `awk '/Vc_VERSION_NUMBER 0x[0-9]+/ { h=$3 }
 END {
 major=strtonum(substr(h, 1, 4))
 minor=strtonum("0x" substr(h, 5, 2))
@@ -24,15 +24,13 @@
 	-e "s/^HTML_TIMESTAMP         = YES/HTML_TIMESTAMP         = NO/" \
 	doc/Doxyfile
 sed -i \
-	-e "s/VC_VERSION_STRING \".*\"\$/VC_VERSION_STRING \"$versionString\"/" \
-	-e "s/VC_VERSION_NUMBER 0x.*\$/VC_VERSION_NUMBER $versionNumber/" \
+	-e "s/Vc_VERSION_STRING \".*\"\$/Vc_VERSION_STRING \"$versionString\"/" \
+	-e "s/Vc_VERSION_NUMBER 0x.*\$/Vc_VERSION_NUMBER $versionNumber/" \
 	include/Vc/version.h
 cat include/Vc/version.h
 
 # Don't build tests with make all
-sed -i \
-  -e 's/add_custom_target(build_tests ALL VERBATIM)/add_custom_target(build_tests VERBATIM)/' \
-  CMakeLists.txt
+sed -i -e 's/#Release# //' CMakeLists.txt
 git commit CMakeLists.txt doc/Doxyfile include/Vc/version.h -s -F- <<EOF
 release: version $versionString
 
@@ -52,6 +50,9 @@
 mv doc/html "Vc-docs-$versionString" && tar -czf "../Vc-docs-$versionString".tar.gz "Vc-docs-$versionString"
 rm -rf "Vc-docs-$versionString"
 
+# Get back to the state before the tag and fix up the version numbers afterwards
+git revert -n HEAD
+
 # Update the version number of the after-release code
 versionString="$versionString-dev"
 versionNumber=`echo $versionNumber | awk '{ printf "0x%06x", (strtonum($0) + 1) }'`
@@ -61,13 +62,9 @@
 	-e "s/^HTML_TIMESTAMP         = YES/HTML_TIMESTAMP         = NO/" \
 	doc/Doxyfile
 sed -i \
-	-e "s/VC_VERSION_STRING \".*\"\$/VC_VERSION_STRING \"$versionString\"/" \
-	-e "s/VC_VERSION_NUMBER 0x.*\$/VC_VERSION_NUMBER $versionNumber/" \
+	-e "s/Vc_VERSION_STRING \".*\"\$/Vc_VERSION_STRING \"$versionString\"/" \
+	-e "s/Vc_VERSION_NUMBER 0x.*\$/Vc_VERSION_NUMBER $versionNumber/" \
 	include/Vc/version.h
-# Revert the build_tests change
-sed -i \
-  -e 's/add_custom_target(build_tests VERBATIM)/add_custom_target(build_tests ALL VERBATIM)/' \
-  CMakeLists.txt
 git commit CMakeLists.txt doc/Doxyfile include/Vc/version.h -s -F- <<EOF
 after release: version $versionString
 
diff -Nru vc-0.7.4/makeRootRelease.sh vc-1.3.0/makeRootRelease.sh
--- vc-0.7.4/makeRootRelease.sh	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/makeRootRelease.sh	1969-12-31 18:00:00.000000000 -0600
@@ -1,190 +0,0 @@
-#!/bin/zsh
-
-scriptName="${0##*/}"
-function usage() {
-  echo "Usage: $scriptName [--root <ROOT Prefix>]"
-}
-
-function fatal() {
-  echo "${1:-Error. Quit.}" >&2
-  exit 1
-}
-
-function readWithDefault() {
-  local default="${(P)1}"
-  test -n "$2" && echo -n "$2 " || echo -n "$1 "
-  test -n "$default" && echo -n "[$default] "
-  read $1
-  test -z "${(P)1}" && eval ${1}="${default}" || eval ${1}="${(e)${(P)1}}"
-}
-
-function sourcesFor() {
-  local pattern=$1
-  local file=$2
-  local output=$3
-  list=()
-  local inside=false
-  for i in `grep -A20 "$pattern\>" "$file"`; do
-    case "$i" in
-      STATIC|SHARED|MODULE|EXCLUDE_FROM_ALL)
-        ;;
-      "$pattern")
-        inside=true
-        ;;
-      *')')
-        $inside && test -n "${i%)}" && list=(${list} ${i%)})
-        inside=false
-        ;;
-      *)
-        $inside && list=(${list} ${i})
-        ;;
-    esac
-  done
-  eval "${output}=("${(u)list[@]}")"
-}
-
-rootDir=
-while [[ $# > 0 ]]; do
-  case "$1" in
-    -h|--help)
-      usage
-      exit
-      ;;
-    -r|--root)
-      if ! test -f "$2/core/base/inc/TObject.h"; then
-        echo "$2/core/base/inc/TObject.h not found" >&2
-        usage >&2
-        exit 1
-      fi
-      rootDir="$2"
-      shift
-      ;;
-  esac
-  shift
-done
-
-if [[ -z "$rootDir" ]]; then
-  rootDir="$HOME/src/root"
-  readWithDefault rootDir "ROOT Sources"
-fi
-rootVcDir="$rootDir/misc/vc"
-
-echo "Clean up $rootVcDir"
-rm -r "$rootVcDir"
-
-vcDir="`dirname "$0"`"
-sourcesFor "add_library(Vc"    "$vcDir/CMakeLists.txt" libVc_files
-pushd $vcDir
-includes=({scalar,sse,avx}{,/*.{h,tcc}} common{,/*.h} include/Vc/**/*)
-popd
-
-mkdir -p $rootVcDir/{inc/Vc,src,test} || fatal "Failed to create directories inside ROOT"
-for file in $includes; do
-  src="$vcDir/$file"
-  dst="$rootVcDir/inc/Vc/${file/include\/Vc\//}"
-  if [[ -d "$src" ]]; then
-    echo "mkdir $dst"
-    mkdir -p "$dst" || fatal
-  else
-    echo "copying $dst"
-    cp "$src" "$dst" || fatal
-  fi
-done
-
-function copy() {
-  while [[ $# > 0 ]]; do
-    file="$1"; shift
-    dstfile="src/${file//\//-}"
-    src="$vcDir/$file"
-    dst="$rootVcDir/$dstfile"
-    echo "copying $dst"
-    cp "$src" "$dst" || fatal
-  done
-}
-
-copy "${libVc_files[@]}"
-
-# TODO: copy cmake files for installation
-
-# Read version number
-eval `awk '/VC_VERSION_NUMBER 0x[0-9]+/ { h=$3 }
-END {
-major=strtonum(substr(h, 1, 4))
-minor=strtonum("0x" substr(h, 5, 2))
-patch=strtonum("0x" substr(h, 7, 2)) / 2
-printf "vcVersion=\"%d.%d.%d\"\n", major, minor, patch
-}' $vcDir/include/Vc/version.h`
-
-rootVcVersion="${vcVersion%%-*}-root"
-sed -i "s/${vcVersion}.*\"/$rootVcVersion\"/" $rootVcDir/inc/Vc/version.h
-
-# TODO: generate $rootVcDir/Module.mk
-cat > $rootVcDir/Module.mk <<EOF
-# Module.mk for Vc module
-# Generated on `date` by Vc/${scriptName}
-
-MODNAME      := vc
-VCVERS       := vc-${rootVcVersion}
-
-MODDIR       := \$(ROOT_SRCDIR)/misc/\$(MODNAME)
-MODDIRS      := \$(MODDIR)/src
-MODDIRI      := \$(MODDIR)/inc
-VCBUILDDIR   := build/misc/\$(MODNAME)
-
-
-ifeq (\$(PLATFORM),win32)
-#VCLIBVCA     := \$(call stripsrc,\$(MODDIRS)/win32/libVc-${vcVersion}.lib)
-VCLIBVC      := \$(LPATH)/libVc.lib
-else
-VCLIBVC      := \$(LPATH)/libVc.a
-endif
-
-VCH          := \$(wildcard \$(MODDIRI)/Vc/*.h \$(MODDIRI)/Vc/*/*.h)
-
-ALLHDRS      += \$(patsubst \$(MODDIRI)/%.h,include/%.h,\$(VCH))
-ALLLIBS      += \$(VCLIBVC)
-
-##### local rules #####
-.PHONY:         all-\$(MODNAME) clean-\$(MODNAME) distclean-\$(MODNAME)
-
-VCFLAGS      := -DVC_COMPILE_LIB \$(OPT) \$(CXXFLAGS) -Iinclude/Vc
-VCLIBVCOBJ   := \$(patsubst \$(MODDIRS)/%.cpp,\$(VCBUILDDIR)/%.cpp.o,\$(wildcard \$(MODDIRS)/*.cpp))
-ifndef AVXFLAGS
-VCLIBVCOBJ   := \$(filter-out \$(MODDIRS)/avx-%.cpp,\$(VCLIBVCOBJ))
-endif
-
-\$(VCLIBVC): \$(VCLIBVCOBJ)
-	\$(MAKEDIR)
-	@echo "Create static library \$@"
-	@ar r \$@ \$?
-	@ranlib \$@
-
-\$(VCBUILDDIR)/avx-%.cpp.o: \$(MODDIRS)/avx-%.cpp
-	\$(MAKEDIR)
-	@echo "Compiling (AVX) \$<"
-	@\$(CXX) \$(VCFLAGS) \$(AVXFLAGS) -Iinclude/Vc/avx -c \$(CXXOUT)\$@ \$<
-
-\$(VCBUILDDIR)/%.cpp.o: \$(MODDIRS)/%.cpp
-	\$(MAKEDIR)
-	@echo "Compiling \$<"
-	@\$(CXX) \$(VCFLAGS) -c \$(CXXOUT)\$@ \$<
-
-include/%.h: \$(MODDIRI)/%.h
-	\$(MAKEDIR)
-	cp \$< \$@
-
-all-\$(MODNAME): \$(VCLIBVC)
-
-clean-\$(MODNAME):
-	@rm -f \$(VCLIBVC) \$(VCLIBVCOBJ)
-
-clean:: clean-\$(MODNAME)
-
-distclean-\$(MODNAME): clean-\$(MODNAME)
-	@rm -rf include/Vc
-
-distclean:: distclean-\$(MODNAME)
-
-EOF
-
-# vim: sw=2 noet ft=zsh
diff -Nru vc-0.7.4/mic/casts.h vc-1.3.0/mic/casts.h
--- vc-0.7.4/mic/casts.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/casts.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,134 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_CASTS_H_
+#define VC_MIC_CASTS_H_
+
+#include "intrinsics.h"
+#include "types.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+// mic_cast {{{1
+template <typename T> static Vc_INTRINSIC_L Vc_CONST_L T mic_cast(__m512  v) Vc_INTRINSIC_R Vc_CONST_R;
+template <typename T> static Vc_INTRINSIC_L Vc_CONST_L T mic_cast(__m512i v) Vc_INTRINSIC_R Vc_CONST_R;
+template <typename T> static Vc_INTRINSIC_L Vc_CONST_L T mic_cast(__m512d v) Vc_INTRINSIC_R Vc_CONST_R;
+
+template <> Vc_INTRINSIC Vc_CONST __m512  mic_cast(__m512  v) { return v; }
+template <> Vc_INTRINSIC Vc_CONST __m512  mic_cast(__m512i v) { return _mm512_castsi512_ps(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512  mic_cast(__m512d v) { return _mm512_castpd_ps(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512i mic_cast(__m512  v) { return _mm512_castps_si512(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512i mic_cast(__m512i v) { return v; }
+template <> Vc_INTRINSIC Vc_CONST __m512i mic_cast(__m512d v) { return _mm512_castpd_si512(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512d mic_cast(__m512  v) { return _mm512_castps_pd(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512d mic_cast(__m512i v) { return _mm512_castsi512_pd(v); }
+template <> Vc_INTRINSIC Vc_CONST __m512d mic_cast(__m512d v) { return v; }
+
+// convert {{{1
+template <typename From, typename To> struct ConvertTag
+{
+};
+template <typename From, typename To>
+Vc_INTRINSIC typename VectorTypeHelper<To>::Type convert(
+    typename VectorTypeHelper<From>::Type v)
+{
+    return convert(v, ConvertTag<From, To>());
+}
+
+Vc_INTRINSIC __m512d convert(__m512  v, ConvertTag<float , double>) { return _mm512_cvtpslo_pd(v); }
+Vc_INTRINSIC __m512i convert(__m512  v, ConvertTag<float , int   >) { return _mm512_cvtfxpnt_round_adjustps_epi32(v, _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512i convert(__m512  v, ConvertTag<float , uint  >) {
+    // cvtfxpntps2udq converts any negative input to 0
+    // but static_cast<uint>(-1.f) == static_cast<uint>(-1)
+    // => for negative input use cvtfxpntps2dq instead
+    const auto negative = _mm512_cmplt_ps_mask(v, _mm512_setzero_ps());
+    return _mm512_mask_cvtfxpnt_round_adjustps_epi32(
+        _mm512_cvtfxpnt_round_adjustps_epu32(v, _MM_ROUND_MODE_TOWARD_ZERO,
+                                             _MM_EXPADJ_NONE),
+        negative, v, _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE);
+}
+Vc_INTRINSIC __m512i convert(__m512  v, ConvertTag<float , short >) { return _mm512_cvtfxpnt_round_adjustps_epi32(v, _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512i convert(__m512  v, ConvertTag<float , ushort>) {
+    // use conversion to epi32 on purpose here! Conversion to epu32 drops negative inputs.
+    // And since we convert to 32bit ints the positive values are all covered.
+    return _mm512_cvtfxpnt_round_adjustps_epi32(v, _MM_ROUND_MODE_TOWARD_ZERO,
+                                                _MM_EXPADJ_NONE);
+}
+
+Vc_INTRINSIC __m512  convert(__m512d v, ConvertTag<double, float >) { return _mm512_cvtpd_pslo(v); }
+Vc_INTRINSIC __m512i convert(__m512d v, ConvertTag<double, int   >) { return _mm512_cvtfxpnt_roundpd_epi32lo(v, _MM_ROUND_MODE_TOWARD_ZERO); }
+Vc_INTRINSIC __m512i convert(__m512d v, ConvertTag<double, uint  >) {
+    // conversion of negative inputs needs to use _mm512_cvtfxpnt_roundpd_epi32lo
+    const auto negative = _mm512_cmplt_pd_mask(v, _mm512_setzero_pd());
+    return _mm512_mask_cvtfxpnt_roundpd_epi32lo(
+        _mm512_cvtfxpnt_roundpd_epu32lo(v, _MM_ROUND_MODE_TOWARD_ZERO), negative, v,
+        _MM_ROUND_MODE_TOWARD_ZERO);
+}
+Vc_INTRINSIC __m512i convert(__m512d v, ConvertTag<double, short >) { return _mm512_cvtfxpnt_roundpd_epi32lo(v, _MM_ROUND_MODE_TOWARD_ZERO); }
+Vc_INTRINSIC __m512i convert(__m512d v, ConvertTag<double, ushort>) {
+    // use conversion to epi32 on purpose here! Conversion to epu32 drops negative inputs.
+    // And since we convert to 32bit ints the positive values are all covered.
+    return _mm512_cvtfxpnt_roundpd_epi32lo(v, _MM_ROUND_MODE_TOWARD_ZERO);
+}
+
+Vc_INTRINSIC __m512  convert(__m512i v, ConvertTag<int   , float >) { return _mm512_cvtfxpnt_round_adjustepi32_ps(v, _MM_FROUND_CUR_DIRECTION, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512d convert(__m512i v, ConvertTag<int   , double>) { return _mm512_cvtepi32lo_pd(v); }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<int   , uint  >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<int   , short >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<int   , ushort>) { return v; }
+
+Vc_INTRINSIC __m512  convert(__m512i v, ConvertTag<uint  , float >) { return _mm512_cvtfxpnt_round_adjustepu32_ps(v, _MM_FROUND_CUR_DIRECTION, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512d convert(__m512i v, ConvertTag<uint  , double>) { return _mm512_cvtepu32lo_pd(v); }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<uint  , int   >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<uint  , short >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<uint  , ushort>) { return v; }
+
+Vc_INTRINSIC __m512  convert(__m512i v, ConvertTag<short , float >) { return _mm512_cvtfxpnt_round_adjustepi32_ps(v, _MM_FROUND_CUR_DIRECTION, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512d convert(__m512i v, ConvertTag<short , double>) { return _mm512_cvtepi32lo_pd(v); }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<short , int   >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<short , uint  >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<short , ushort>) { return v; }
+
+Vc_INTRINSIC __m512  convert(__m512i v, ConvertTag<ushort, float >) { return _mm512_cvtfxpnt_round_adjustepu32_ps(v, _MM_FROUND_CUR_DIRECTION, _MM_EXPADJ_NONE); }
+Vc_INTRINSIC __m512d convert(__m512i v, ConvertTag<ushort, double>) { return _mm512_cvtepu32lo_pd(v); }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<ushort, int   >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<ushort, uint  >) { return v; }
+Vc_INTRINSIC __m512i convert(__m512i v, ConvertTag<ushort, short >) {
+    const auto negative = _mm512_cmpgt_epu32_mask(v, _mm512_set1_epi32(0x7fff));
+    return _mm512_mask_or_epi32(v, negative, v, _mm512_set1_epi32(0xffff0000u));
+}
+
+//}}}1
+}  // namespace MIC
+}  // namespace Vc
+
+#endif // VC_MIC_CASTS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/const_data.h vc-1.3.0/mic/const_data.h
--- vc-0.7.4/mic/const_data.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/const_data.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,59 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_CONST_DATA_H_
+#define VC_MIC_CONST_DATA_H_
+
+#include "../common/data.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+alignas(16) extern const char  _IndexesFromZero8[16];
+
+struct alignas(64) c_general
+{
+    static const float oneFloat;
+    static const unsigned int absMaskFloat[2];
+    static const unsigned int signMaskFloat[2];
+    static const unsigned int highMaskFloat;
+    static const unsigned short minShort[2];
+    static const unsigned short one16[2];
+    static const float _2power31;
+    static const double oneDouble;
+    static const unsigned long long frexpMask;
+    static const unsigned long long highMaskDouble;
+    static const unsigned char frexpAndMask[16];
+};
+
+}  // namespace MIC
+}  // namespace Vc
+
+#endif // VC_MIC_CONST_DATA_H_
diff -Nru vc-0.7.4/mic/debug.h vc-1.3.0/mic/debug.h
--- vc-0.7.4/mic/debug.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/debug.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,96 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_DEBUG_H_
+#define VC_MIC_DEBUG_H_
+
+#ifndef NDEBUG
+#include "vector.h"
+#include <iostream>
+#include <iomanip>
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+#ifdef NDEBUG
+class DebugStream
+{
+    public:
+        DebugStream(const char *, const char *, int) {}
+        template<typename T> inline DebugStream &operator<<(const T &) { return *this; }
+};
+#else
+class DebugStream
+{
+    private:
+        template<typename T, typename V> static void printVector(V _x)
+        {
+            enum { Size = sizeof(V) / sizeof(T) };
+            union { V v; T m[Size]; } x = { _x };
+            std::cerr << '[' << std::setprecision(24) << x.m[0];
+            for (int i = 1; i < Size; ++i) {
+                std::cerr << ", " << std::setprecision(24) << x.m[i];
+            }
+            std::cerr << ']';
+        }
+    public:
+        DebugStream(const char *func, const char *file, int line)
+        {
+            std::cerr << "\033[1;40;33mDEBUG: " << file << ':' << line << ' ' << func << ' ';
+        }
+
+        template<typename T> DebugStream &operator<<(const T &x) { std::cerr << x; return *this; }
+
+        DebugStream &operator<<(__m512 x) {
+            printVector<float, __m512>(x);
+            return *this;
+        }
+        DebugStream &operator<<(__m512d x) {
+            printVector<double, __m512d>(x);
+            return *this;
+        }
+        DebugStream &operator<<(__m512i x) {
+            printVector<unsigned int, __m512i>(x);
+            return *this;
+        }
+
+        ~DebugStream()
+        {
+            std::cerr << "\033[0m" << std::endl;
+        }
+};
+#endif
+
+#define Vc_DEBUG Vc::MIC::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)
+
+}  // namespace MIC
+}  // namespace Vc
+
+#endif // VC_MIC_DEBUG_H_
diff -Nru vc-0.7.4/mic/deinterleave.tcc vc-1.3.0/mic/deinterleave.tcc
--- vc-0.7.4/mic/deinterleave.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/deinterleave.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,40 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+template <typename V, typename M, typename A>
+inline void deinterleave(V &a, V &b, const M *m, A)
+{
+    const auto i = MIC::int_v::IndexesFromZero() << 1;
+    a.data() = MicIntrinsics::gather(i.data(), m, MIC::UpDownConversion<typename V::VectorEntryType, M>());
+    b.data() = MicIntrinsics::gather(i.data(), m + 1, MIC::UpDownConversion<typename V::VectorEntryType, M>());
+}
+}  // namespace Detail
+}  // namespace Vc
diff -Nru vc-0.7.4/mic/detail.h vc-1.3.0/mic/detail.h
--- vc-0.7.4/mic/detail.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/detail.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,177 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_DETAIL_H_
+#define VC_MIC_DETAIL_H_
+
+#include "casts.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+// zero {{{1
+template <typename T> inline T zero();
+template <> Vc_INTRINSIC Vc_CONST __m512  zero<__m512 >() { return _mm512_setzero_ps(); }
+template <> Vc_INTRINSIC Vc_CONST __m512d zero<__m512d>() { return _mm512_setzero_pd(); }
+template <> Vc_INTRINSIC Vc_CONST __m512i zero<__m512i>() { return _mm512_setzero_epi32(); }
+
+// one {{{1
+Vc_INTRINSIC Vc_CONST __m512  one( float) { return _mm512_set1_ps(1.f); }
+Vc_INTRINSIC Vc_CONST __m512d one(double) { return _mm512_set1_pd(1.); }
+Vc_INTRINSIC Vc_CONST __m512i one(   int) { return _mm512_set1_epi32(1); }
+Vc_INTRINSIC Vc_CONST __m512i one(  uint) { return _mm512_set1_epi32(1); }
+Vc_INTRINSIC Vc_CONST __m512i one( short) { return _mm512_set1_epi32(1); }
+Vc_INTRINSIC Vc_CONST __m512i one(ushort) { return _mm512_set1_epi32(1); }
+Vc_INTRINSIC Vc_CONST __m512i one( schar) { return _mm512_set1_epi32(1); }
+Vc_INTRINSIC Vc_CONST __m512i one( uchar) { return _mm512_set1_epi32(1); }
+
+// xor_ {{{1
+Vc_INTRINSIC __m512  xor_(__m512  a, __m512  b) { return MIC::_xor(a, b); }
+Vc_INTRINSIC __m512d xor_(__m512d a, __m512d b) { return MIC::_xor(a, b); }
+Vc_INTRINSIC __m512i xor_(__m512i a, __m512i b) { return _mm512_xor_si512(a, b); }
+
+// and_ {{{1
+Vc_INTRINSIC __m512  and_(__m512  a, __m512  b) { return MIC::_and(a, b); }
+Vc_INTRINSIC __m512d and_(__m512d a, __m512d b) { return MIC::_and(a, b); }
+Vc_INTRINSIC __m512i and_(__m512i a, __m512i b) { return _mm512_and_si512(a, b); }
+
+// or_ {{{1
+Vc_INTRINSIC __m512  or_(__m512  a, __m512  b) { return MIC::_or(a, b); }
+Vc_INTRINSIC __m512d or_(__m512d a, __m512d b) { return MIC::_or(a, b); }
+Vc_INTRINSIC __m512i or_(__m512i a, __m512i b) { return _mm512_or_si512(a, b); }
+
+// add {{{1
+Vc_INTRINSIC __m512  add(__m512  a, __m512  b, float ) { return _mm512_add_ps(a, b); }
+Vc_INTRINSIC __m512d add(__m512d a, __m512d b, double) { return _mm512_add_pd(a, b); }
+Vc_INTRINSIC __m512i add(__m512i a, __m512i b, int   ) { return _mm512_add_epi32(a, b); }
+Vc_INTRINSIC __m512i add(__m512i a, __m512i b, uint  ) { return _mm512_add_epi32(a, b); }
+Vc_INTRINSIC __m512i add(__m512i a, __m512i b, short ) { return _mm512_add_epi32(a, b); }
+Vc_INTRINSIC __m512i add(__m512i a, __m512i b, ushort) { return _mm512_add_epi32(a, b); }
+
+// sub {{{1
+Vc_INTRINSIC __m512  sub(__m512  a, __m512  b, float ) { return _mm512_sub_ps(a, b); }
+Vc_INTRINSIC __m512d sub(__m512d a, __m512d b, double) { return _mm512_sub_pd(a, b); }
+Vc_INTRINSIC __m512i sub(__m512i a, __m512i b, int   ) { return _mm512_sub_epi32(a, b); }
+Vc_INTRINSIC __m512i sub(__m512i a, __m512i b, uint  ) { return _mm512_sub_epi32(a, b); }
+Vc_INTRINSIC __m512i sub(__m512i a, __m512i b, short ) { return _mm512_sub_epi32(a, b); }
+Vc_INTRINSIC __m512i sub(__m512i a, __m512i b, ushort) { return _mm512_sub_epi32(a, b); }
+
+// mul {{{1
+Vc_INTRINSIC __m512  mul(__m512  a, __m512  b, float ) { return _mm512_mul_ps(a, b); }
+Vc_INTRINSIC __m512d mul(__m512d a, __m512d b, double) { return _mm512_mul_pd(a, b); }
+Vc_INTRINSIC __m512i mul(__m512i a, __m512i b, int   ) { return _mm512_mullo_epi32(a, b); }
+Vc_INTRINSIC __m512i mul(__m512i a, __m512i b, uint  ) { return _mm512_mullo_epi32(a, b); }
+Vc_INTRINSIC __m512i mul(__m512i a, __m512i b, short ) { return _mm512_mullo_epi32(a, b); }
+Vc_INTRINSIC __m512i mul(__m512i a, __m512i b, ushort) { return _mm512_mullo_epi32(a, b); }
+
+// div {{{1
+Vc_INTRINSIC __m512  div(__m512  a, __m512  b, float ) { return _mm512_div_ps(a, b); }
+Vc_INTRINSIC __m512d div(__m512d a, __m512d b, double) { return _mm512_div_pd(a, b); }
+Vc_INTRINSIC __m512i div(__m512i a, __m512i b, int   ) { return _mm512_div_epi32(a, b); }
+Vc_INTRINSIC __m512i div(__m512i a, __m512i b, uint  ) { return _mm512_div_epu32(a, b); }
+Vc_INTRINSIC __m512i div(__m512i a, __m512i b, short ) { return _mm512_div_epi32(a, b); }
+Vc_INTRINSIC __m512i div(__m512i a, __m512i b, ushort) {
+    // this specialization is required because overflow is well defined (mod 2^16) for
+    // unsigned short, but a / b is not independent of the high bits (in contrast to mul,
+    // add, and sub)
+    return div(and_(a, MIC::_set1(0xffff)), and_(b, MIC::_set1(0xffff)), uint());
+}
+
+// rem {{{1
+Vc_INTRINSIC __m512i rem(__m512i a, __m512i b, int   ) { return _mm512_rem_epi32(a, b); }
+Vc_INTRINSIC __m512i rem(__m512i a, __m512i b, uint  ) { return _mm512_rem_epu32(a, b); }
+Vc_INTRINSIC __m512i rem(__m512i a, __m512i b, short ) { return _mm512_rem_epi32(a, b); }
+Vc_INTRINSIC __m512i rem(__m512i a, __m512i b, ushort) { return _mm512_rem_epu32(and_(a, MIC::_set1(0xffff)), and_(b, MIC::_set1(0xffff))); }
+
+// horizontal add{{{1
+Vc_INTRINSIC  float add(__m512  a,  float) { return _mm512_reduce_add_ps(a); }
+Vc_INTRINSIC double add(__m512d a, double) { return _mm512_reduce_add_pd(a); }
+Vc_INTRINSIC    int add(__m512i a,    int) { return _mm512_reduce_add_epi32(a); }
+Vc_INTRINSIC   uint add(__m512i a,   uint) { return _mm512_reduce_add_epi32(a); }
+Vc_INTRINSIC  short add(__m512i a,  short) { return _mm512_reduce_add_epi32(a); }
+Vc_INTRINSIC ushort add(__m512i a, ushort) { return _mm512_reduce_add_epi32(a); }
+
+// horizontal mul{{{1
+Vc_INTRINSIC  float mul(__m512  a,  float) { return _mm512_reduce_mul_ps(a); }
+Vc_INTRINSIC double mul(__m512d a, double) { return _mm512_reduce_mul_pd(a); }
+Vc_INTRINSIC    int mul(__m512i a,    int) { return _mm512_reduce_mul_epi32(a); }
+Vc_INTRINSIC   uint mul(__m512i a,   uint) { return _mm512_reduce_mul_epi32(a); }
+Vc_INTRINSIC  short mul(__m512i a,  short) { return _mm512_reduce_mul_epi32(a); }
+Vc_INTRINSIC ushort mul(__m512i a, ushort) { return _mm512_reduce_mul_epi32(a); }
+
+// horizontal min{{{1
+Vc_INTRINSIC  float min(__m512  a,  float) { return _mm512_reduce_min_ps(a); }
+Vc_INTRINSIC double min(__m512d a, double) { return _mm512_reduce_min_pd(a); }
+Vc_INTRINSIC    int min(__m512i a,    int) { return _mm512_reduce_min_epi32(a); }
+Vc_INTRINSIC   uint min(__m512i a,   uint) { return _mm512_reduce_min_epi32(a); }
+Vc_INTRINSIC  short min(__m512i a,  short) { return _mm512_reduce_min_epi32(a); }
+Vc_INTRINSIC ushort min(__m512i a, ushort) { return _mm512_reduce_min_epi32(a); }
+
+// horizontal max{{{1
+Vc_INTRINSIC  float max(__m512  a,  float) { return _mm512_reduce_max_ps(a); }
+Vc_INTRINSIC double max(__m512d a, double) { return _mm512_reduce_max_pd(a); }
+Vc_INTRINSIC    int max(__m512i a,    int) { return _mm512_reduce_max_epi32(a); }
+Vc_INTRINSIC   uint max(__m512i a,   uint) { return _mm512_reduce_max_epi32(a); }
+Vc_INTRINSIC  short max(__m512i a,  short) { return _mm512_reduce_max_epi32(a); }
+Vc_INTRINSIC ushort max(__m512i a, ushort) { return _mm512_reduce_max_epi32(a); }
+
+// abs{{{1
+Vc_INTRINSIC __m512d abs(__m512d a, double)
+{
+    const __m512i absMask =
+        _mm512_set_4to16_epi32(0xffffffff, 0x7fffffff, 0xffffffff, 0x7fffffff);
+    return MIC::mic_cast<__m512d>(_mm512_and_epi32(MIC::mic_cast<__m512i>(a), absMask));
+}
+Vc_INTRINSIC __m512 abs(__m512 a, float)
+{
+    const __m512i absMask = _mm512_set_1to16_epi32(0x7fffffff);
+    return MIC::mic_cast<__m512>(_mm512_and_epi32(MIC::mic_cast<__m512i>(a), absMask));
+}
+Vc_INTRINSIC __m512i abs(__m512i a, int)
+{
+    const __m512i minusOne = _mm512_set_1to16_epi32(-1);
+    return _mm512_mask_mullo_epi32(a, _mm512_cmplt_epi32_mask(a, zero<__m512i>()), a,
+                                   minusOne);
+}
+Vc_INTRINSIC __m512i abs(__m512i a, short)
+{
+    const __m512i minusOne = _mm512_set_1to16_epi32(-1);
+    return _mm512_mask_mullo_epi32(a, _mm512_cmplt_epi32_mask(a, zero<__m512i>()), a,
+                                   minusOne);
+}
+
+//InterleaveImpl{{{1
+template <typename V, int Wt, size_t Sizeof> struct InterleaveImpl;
+
+//}}}1
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_MIC_DETAIL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/helperimpl.h vc-1.3.0/mic/helperimpl.h
--- vc-0.7.4/mic/helperimpl.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/helperimpl.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,35 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_HELPERIMPL_H_
+#define VC_MIC_HELPERIMPL_H_
+
+#include "macros.h"
+#include "deinterleave.tcc"
+#include "prefetches.tcc"
+
+#endif // VC_MIC_HELPERIMPL_H_
diff -Nru vc-0.7.4/mic/interleaveimpl.h vc-1.3.0/mic/interleaveimpl.h
--- vc-0.7.4/mic/interleaveimpl.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/interleaveimpl.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,98 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_INTERLEAVEIMPL_H_
+#define VC_MIC_INTERLEAVEIMPL_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+template <typename T, int Wt, size_t Sizeof>
+struct InterleaveImpl<Vector<T, VectorAbi::Mic>, Wt, Sizeof> {
+    using V = Vector<T, VectorAbi::Mic>;
+    using IT = typename V::IndexType;
+    using VT = typename V::VectorEntryType;
+    using UpDownC = MIC::UpDownConversion<VT, T>;
+    // fixup functions{{{1
+    static Vc_INTRINSIC __m512i fixup(__m512i i)
+    {
+        return i;
+    }
+    static Vc_INTRINSIC __m512i fixup(const SimdArray<int, 16> &i)
+    {
+        return internal_data(i).data();
+    }
+    static Vc_INTRINSIC __m512i fixup(const SimdArray<int, 8> &i)
+    {
+        return _mm512_mask_loadunpacklo_epi32(_mm512_setzero_epi32(), 0x00ff, &i);
+    }
+    template <size_t StructSize>
+    static Vc_INTRINSIC __m512i fixup(const Common::SuccessiveEntries<StructSize> &i)
+    {
+        using namespace Detail;
+        return (MIC::int_v::IndexesFromZero() * MIC::int_v(StructSize) +
+                MIC::int_v(i.data()))
+            .data();
+    }
+    template <size_t... IndexSeq, typename... Vs>  // interleave pack expansion{{{1
+    static Vc_INTRINSIC void interleave(index_sequence<IndexSeq...>, T *const data,
+                                        const MIC::int_v indexes, Vs &&... vs)
+    {
+        const auto &&tmp = {(vs.scatter(data + IndexSeq, indexes), 0)...};
+    }
+    template <typename I, typename... Vs>  // interleave interface{{{1
+    static inline void interleave(T *const data, I &&indexes, Vs &&... vs)
+    {
+        interleave(make_index_sequence<sizeof...(Vs)>(), data,
+                   fixup(std::forward<I>(indexes)), std::forward<Vs>(vs)...);
+    }
+    template <size_t... IndexSeq, typename... Vs>  // deinterleave pack expansion{{{1
+    static Vc_INTRINSIC void deinterleave(index_sequence<IndexSeq...>,
+                                          const T *const data, const MIC::int_v indexes,
+                                          Vs &&... vs)
+    {
+        using Vc::MicIntrinsics::gather;
+        const auto &&tmp = {
+            (vs = gather(indexes.data(), data + IndexSeq, UpDownC()), 0)...};
+    }
+    template <typename I, typename... Vs>  // deinterleave interface{{{1
+    static inline void deinterleave(const T *const data, I &&indexes, Vs &&... vs)
+    {
+        deinterleave(make_index_sequence<sizeof...(Vs)>(), data,
+                     fixup(std::forward<I>(indexes)), std::forward<Vs>(vs)...);
+    }
+    //}}}2
+};
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_MIC_INTERLEAVEIMPL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/intrinsics.h vc-1.3.0/mic/intrinsics.h
--- vc-0.7.4/mic/intrinsics.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/intrinsics.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,580 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_INTRINSICS_H_
+#define VC_MIC_INTRINSICS_H_
+
+#include <immintrin.h>
+
+#include "const_data.h"
+#include "../common/loadstoreflags.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MicIntrinsics
+{
+    using MIC::c_general;
+
+    static Vc_INTRINSIC Vc_CONST __m512  _mm512_setallone_ps()    { return _mm512_castsi512_ps(_mm512_set_1to16_pi(~0)); }
+    static Vc_INTRINSIC Vc_CONST __m512d _mm512_setallone_pd()    { return _mm512_castsi512_pd(_mm512_set_1to16_pi(~0)); }
+    static Vc_INTRINSIC Vc_CONST __m512i _mm512_setallone_si512() { return _mm512_set_1to16_pi(~0); }
+
+    template<typename T> T allone();
+    template<> __m512i allone<__m512i>() { return _mm512_setallone_si512(); }
+    template<> __m512d allone<__m512d>() { return _mm512_setallone_pd(); }
+    template<> __m512  allone<__m512 >() { return _mm512_setallone_ps(); }
+
+    static Vc_INTRINSIC Vc_CONST __m512d _mm512_setabsmask_pd() { return _mm512_set1_pd(reinterpret_cast<const double &>(c_general::absMaskFloat[0])); }
+    static Vc_INTRINSIC Vc_CONST __m512  _mm512_setabsmask_ps() { return _mm512_set1_ps(reinterpret_cast<const float &>(c_general::absMaskFloat[1])); }
+    static Vc_INTRINSIC Vc_CONST __m512d _mm512_setsignmask_pd(){ return _mm512_set1_pd(reinterpret_cast<const double &>(c_general::signMaskFloat[0])); }
+    static Vc_INTRINSIC Vc_CONST __m512  _mm512_setsignmask_ps(){ return _mm512_set1_ps(reinterpret_cast<const float &>(c_general::signMaskFloat[1])); }
+
+    static Vc_INTRINSIC __m512d mm512_loadu_pd(const void *mt,
+            _MM_UPCONV_PD_ENUM upconv = _MM_UPCONV_PD_NONE, int memHint = _MM_HINT_NONE)
+    {
+        __m512d r;
+#pragma warning(disable: 592)
+        r = _mm512_extloadunpacklo_pd(r, mt, upconv, memHint);
+#pragma warning(default: 592)
+        r = _mm512_extloadunpackhi_pd(r, static_cast<const char *>(mt) + 8 * sizeof(double), upconv, memHint);
+        return r;
+    }
+
+    static Vc_INTRINSIC __m512  mm512_loadu_ps(const void *mt,
+            _MM_UPCONV_PS_ENUM upconv = _MM_UPCONV_PS_NONE, int memHint = _MM_HINT_NONE)
+    {
+        __m512 r = _mm512_setzero_ps();
+#pragma warning(disable: 592)
+        r = _mm512_extloadunpacklo_ps(r, mt, upconv, memHint);
+#pragma warning(default: 592)
+        r = _mm512_extloadunpackhi_ps(r, static_cast<const char *>(mt) + 16 * sizeof(float), upconv, memHint);
+        return r;
+    }
+
+    static Vc_INTRINSIC __m512i mm512_loadu_epi32(const void *mt,
+            _MM_UPCONV_EPI32_ENUM upconv = _MM_UPCONV_EPI32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        __m512i r;
+#pragma warning(disable: 592)
+        r = _mm512_extloadunpacklo_epi32(r, mt, upconv, memHint);
+#pragma warning(default: 592)
+        r = _mm512_extloadunpackhi_epi32(r, static_cast<const char *>(mt) + 16 * sizeof(int), upconv, memHint);
+        return r;
+    }
+
+    static Vc_INTRINSIC __m512i _mm512_loadu_epu32(const void *mt,
+            _MM_UPCONV_EPI32_ENUM upconv = _MM_UPCONV_EPI32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        __m512i r;
+#pragma warning(disable: 592)
+        r = _mm512_extloadunpacklo_epi32(r, mt, upconv, memHint);
+#pragma warning(default: 592)
+        r = _mm512_extloadunpackhi_epi32(r, static_cast<const char *>(mt) + 16 * sizeof(int), upconv, memHint);
+        return r;
+    }
+
+    static Vc_INTRINSIC __m512 _load(const float *m, _MM_UPCONV_PS_ENUM upconv = _MM_UPCONV_PS_NONE,
+            _MM_BROADCAST32_ENUM broadcast = _MM_BROADCAST32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_extload_ps(m, upconv, broadcast, memHint);
+    }
+    static Vc_INTRINSIC __m512 _load(__m512 v, __mmask16 k, const float *m, _MM_UPCONV_PS_ENUM upconv = _MM_UPCONV_PS_NONE,
+            _MM_BROADCAST32_ENUM broadcast = _MM_BROADCAST32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_mask_extload_ps(v, k, m, upconv, broadcast, memHint);
+    }
+    static Vc_INTRINSIC __m512d _load(const double *m, _MM_UPCONV_PD_ENUM upconv = _MM_UPCONV_PD_NONE,
+            _MM_BROADCAST64_ENUM broadcast = _MM_BROADCAST64_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_extload_pd(m, upconv, broadcast, memHint);
+    }
+    static Vc_INTRINSIC __m512d _load(__m512d v, __mmask8 k, const double *m, _MM_UPCONV_PD_ENUM upconv = _MM_UPCONV_PD_NONE,
+            _MM_BROADCAST64_ENUM broadcast = _MM_BROADCAST64_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_mask_extload_pd(v, k, m, upconv, broadcast, memHint);
+    }
+    template<typename T>
+    static Vc_INTRINSIC __m512i _load(const T *m, _MM_UPCONV_EPI32_ENUM upconv = _MM_UPCONV_EPI32_NONE,
+            _MM_BROADCAST32_ENUM broadcast = _MM_BROADCAST32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_extload_epi32(m, upconv, broadcast, memHint);
+    }
+    template<typename T>
+    static Vc_INTRINSIC __m512i _load(__m512i v, __mmask16 k, const T *m,
+            _MM_UPCONV_EPI32_ENUM upconv = _MM_UPCONV_EPI32_NONE,
+            _MM_BROADCAST32_ENUM broadcast = _MM_BROADCAST32_NONE, int memHint = _MM_HINT_NONE)
+    {
+        return _mm512_mask_extload_epi32(v, k, m, upconv, broadcast, memHint);
+    }
+
+static Vc_INTRINSIC void store_unaligned(void *m, __m512 v, _MM_DOWNCONV_PS_ENUM downconv, int memHint)
+{
+    _mm512_extpackstorelo_ps(m, v, downconv, memHint);
+    _mm512_extpackstorehi_ps(static_cast<char *>(m) + 64, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_unaligned(void *m, __m512d v, _MM_DOWNCONV_PD_ENUM downconv, int memHint)
+{
+    _mm512_extpackstorelo_pd(m, v, downconv, memHint);
+    _mm512_extpackstorehi_pd(static_cast<char *>(m) + 64, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_unaligned(void *m, __m512i v, _MM_DOWNCONV_EPI32_ENUM downconv, int memHint)
+{
+    _mm512_extpackstorelo_epi32(m, v, downconv, memHint);
+    _mm512_extpackstorehi_epi32(static_cast<char *>(m) + 64, v, downconv, memHint);
+}
+
+/*
+void store_unaligned(__mmask16 mask, void *m, __m512 v, _MM_DOWNCONV_PS_ENUM downconv, int memHint)
+and friends are not that easy. MIC only provides packstore for unaligned stores. But packstore packs
+the masked values consecutively, which is not what we want.
+The maskstore is thus better implemented in the Vector class - where more type information is still
+available.
+*/
+
+static Vc_INTRINSIC void store_aligned(void *m, __m512 v, _MM_DOWNCONV_PS_ENUM downconv, int memHint)
+{
+    _mm512_extstore_ps(m, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_aligned(void *m, __m512d v, _MM_DOWNCONV_PD_ENUM downconv, int memHint)
+{
+    _mm512_extstore_pd(m, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_aligned(void *m, __m512i v, _MM_DOWNCONV_EPI32_ENUM downconv, int memHint)
+{
+    _mm512_extstore_epi32(m, v, downconv, memHint);
+}
+
+static Vc_INTRINSIC void store_aligned(__mmask16 mask, void *m, __m512 v, _MM_DOWNCONV_PS_ENUM downconv, int memHint)
+{
+    _mm512_mask_extstore_ps(m, mask, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_aligned(__mmask8 mask, void *m, __m512d v, _MM_DOWNCONV_PD_ENUM downconv, int memHint)
+{
+    _mm512_mask_extstore_pd(m, mask, v, downconv, memHint);
+}
+static Vc_INTRINSIC void store_aligned(__mmask16 mask, void *m, __m512i v, _MM_DOWNCONV_EPI32_ENUM downconv, int memHint)
+{
+    _mm512_mask_extstore_epi32(m, mask, v, downconv, memHint);
+}
+
+template<typename Flags, typename V, typename DownConv> static Vc_INTRINSIC void store(void *m, V v, DownConv downconv, typename Flags::EnableIfAligned               = nullptr) { store_aligned(m, v, downconv, _MM_HINT_NONE); }
+template<typename Flags, typename V, typename DownConv> static Vc_INTRINSIC void store(void *m, V v, DownConv downconv, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { store_unaligned(m, v, downconv, _MM_HINT_NONE); }
+template<typename Flags, typename V, typename DownConv> static Vc_INTRINSIC void store(void *m, V v, DownConv downconv, typename Flags::EnableIfStreaming             = nullptr) { store_aligned(m, v, downconv, _MM_HINT_NT); }
+template<typename Flags, typename V, typename DownConv> static Vc_INTRINSIC void store(void *m, V v, DownConv downconv, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { store_unaligned(m, v, downconv, _MM_HINT_NT); }
+
+template<typename Flags, typename M, typename V, typename DownConv> static Vc_INTRINSIC void store(M mask, void *m, V v, DownConv downconv, typename Flags::EnableIfAligned               = nullptr) { store_aligned(mask, m, v, downconv, _MM_HINT_NONE); }
+template<typename Flags, typename M, typename V, typename DownConv> static Vc_INTRINSIC void store(M mask, void *m, V v, DownConv downconv, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { store_unaligned(mask, m, v, downconv, _MM_HINT_NONE); }
+template<typename Flags, typename M, typename V, typename DownConv> static Vc_INTRINSIC void store(M mask, void *m, V v, DownConv downconv, typename Flags::EnableIfStreaming             = nullptr) { store_aligned(mask, m, v, downconv, _MM_HINT_NT); }
+template<typename Flags, typename M, typename V, typename DownConv> static Vc_INTRINSIC void store(M mask, void *m, V v, DownConv downconv, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { store_unaligned(mask, m, v, downconv, _MM_HINT_NT); }
+
+//__m512  _mm512_i32extgather_ps(__m512i, void const*, _MM_UPCONV_PS_ENUM, int, int /* mem hint */);
+//__m512  _mm512_mask_i32extgather_ps(__m512, __mmask16, __m512i, void const*, _MM_UPCONV_PS_ENUM, int, int /* mem hint */);
+template<typename MemT> static Vc_INTRINSIC __m512  gather(__m512i i, MemT const *mem, _MM_UPCONV_PS_ENUM    conv, int scale = sizeof(MemT)) { return _mm512_i32extgather_ps   (i, mem, conv, scale, _MM_HINT_NONE); }
+template<typename MemT> static Vc_INTRINSIC __m512d gather(__m512i i, MemT const *mem, _MM_UPCONV_PD_ENUM    conv, int scale = sizeof(MemT)) { return _mm512_i32loextgather_pd (i, mem, conv, scale, _MM_HINT_NONE); }
+template<typename MemT> static Vc_INTRINSIC __m512i gather(__m512i i, MemT const *mem, _MM_UPCONV_EPI32_ENUM conv, int scale = sizeof(MemT)) { return _mm512_i32extgather_epi32(i, mem, conv, scale, _MM_HINT_NONE); }
+
+template<typename MemT> static Vc_INTRINSIC __m512  gather(__m512  old, __mmask16 mask, __m512i i, MemT const *mem, _MM_UPCONV_PS_ENUM    conv, int scale = sizeof(MemT)) { return _mm512_mask_i32extgather_ps   (old, mask, i, mem, conv, scale, _MM_HINT_NONE); }
+template<typename MemT> static Vc_INTRINSIC __m512d gather(__m512d old, __mmask8  mask, __m512i i, MemT const *mem, _MM_UPCONV_PD_ENUM    conv, int scale = sizeof(MemT)) { return _mm512_mask_i32loextgather_pd (old, mask, i, mem, conv, scale, _MM_HINT_NONE); }
+template<typename MemT> static Vc_INTRINSIC __m512i gather(__m512i old, __mmask16 mask, __m512i i, MemT const *mem, _MM_UPCONV_EPI32_ENUM conv, int scale = sizeof(MemT)) { return _mm512_mask_i32extgather_epi32(old, mask, i, mem, conv, scale, _MM_HINT_NONE); }
+
+template<typename DownConv> static Vc_INTRINSIC
+    void scatter(void *m, __m512i i, __m512  v, DownConv downconv, int scale)
+{
+    _mm512_i32extscatter_ps(m, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+template<typename DownConv> static Vc_INTRINSIC
+    void scatter(void *m, __m512i i, __m512d v, DownConv downconv, int scale)
+{
+    _mm512_i32loextscatter_pd(m, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+template<typename DownConv> static Vc_INTRINSIC
+    void scatter(void *m, __m512i i, __m512i v, DownConv downconv, int scale)
+{
+    _mm512_i32extscatter_epi32(m, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+
+template<typename M, typename DownConv, typename MemT> static Vc_INTRINSIC
+    void scatter(M mask, MemT *m, __m512i i, __m512  v, DownConv downconv, int scale = sizeof(MemT))
+{
+    _mm512_mask_i32extscatter_ps(m, mask, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+template<typename M, typename DownConv, typename MemT> static Vc_INTRINSIC
+    void scatter(M mask, MemT *m, __m512i i, __m512d v, DownConv downconv, int scale = sizeof(MemT))
+{
+    _mm512_mask_i32loextscatter_pd(m, mask, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+template<typename M, typename DownConv, typename MemT> static Vc_INTRINSIC
+    void scatter(M mask, MemT *m, __m512i i, __m512i v, DownConv downconv, int scale = sizeof(MemT))
+{
+    _mm512_mask_i32extscatter_epi32(m, mask, i, v, downconv.down(), scale, _MM_HINT_NONE);
+}
+
+static Vc_INTRINSIC __m512  swizzle(__m512  v, _MM_SWIZZLE_ENUM swiz) { return _mm512_swizzle_ps(v, swiz); }
+static Vc_INTRINSIC __m512d swizzle(__m512d v, _MM_SWIZZLE_ENUM swiz) { return _mm512_swizzle_pd(v, swiz); }
+static Vc_INTRINSIC __m512i swizzle(__m512i v, _MM_SWIZZLE_ENUM swiz) { return _mm512_swizzle_epi32(v, swiz); }
+
+static Vc_INTRINSIC __m512  shuffle(__m512  v, _MM_PERM_ENUM perm) { return _mm512_castsi512_ps(_mm512_shuffle_epi32(_mm512_castps_si512(v), perm)); }
+static Vc_INTRINSIC __m512i shuffle(__m512i v, _MM_PERM_ENUM perm) { return _mm512_shuffle_epi32(v, perm); }
+
+static Vc_INTRINSIC __m512 permute128(__m512 v, _MM_PERM_ENUM perm)
+{
+    return _mm512_permute4f128_ps(v, perm);
+}
+static Vc_INTRINSIC __m512i permute128(__m512i v, _MM_PERM_ENUM perm)
+{
+    return _mm512_permute4f128_epi32(v, perm);
+}
+static Vc_INTRINSIC __m512d permute128(__m512d v, _MM_PERM_ENUM perm)
+{
+    return _mm512_castps_pd(_mm512_permute4f128_ps(_mm512_castpd_ps(v), perm));
+}
+
+#define _mm512_rsqrt_pd _mm512_invsqrt_pd
+#define _mm512_mask_rsqrt_pd _mm512_mask_invsqrt_pd
+#define _mm512_rsqrt_ps _mm512_invsqrt_ps
+#define _mm512_mask_rsqrt_ps _mm512_mask_invsqrt_ps
+#define _mm512_reduce_max_pi _mm512_reduce_max_epi32
+#define _mm512_reduce_min_pi _mm512_reduce_min_epi32
+#define _mm512_reduce_mul_pi _mm512_reduce_mul_epi32
+#define _mm512_reduce_add_pi _mm512_reduce_add_epi32
+
+#define Vc_INTEGER_FUN2(fun) \
+    static Vc_INTRINSIC __m512  fun(__m512  a, __m512  b) { \
+        return _mm512_castsi512_ps(_mm512##fun##_epi32(_mm512_castps_si512(a), _mm512_castps_si512(b))); \
+    } \
+    static Vc_INTRINSIC __m512d fun(__m512d a, __m512d b) { \
+        return _mm512_castsi512_pd(_mm512##fun##_epi64(_mm512_castpd_si512(a), _mm512_castpd_si512(b))); \
+    } \
+    static Vc_INTRINSIC __m512i fun(__m512i a, __m512i b) { \
+        return _mm512##fun##_epi32(a, b); \
+    } \
+    static Vc_INTRINSIC __m512  fun(__m512  r, __mmask16 k, __m512  a, __m512  b) { \
+        return _mm512_castsi512_ps(_mm512_mask##fun##_epi32(_mm512_castps_si512(r), k, _mm512_castps_si512(a), _mm512_castps_si512(b))); \
+    } \
+    static Vc_INTRINSIC __m512d fun(__m512d r, __mmask8  k, __m512d a, __m512d b) { \
+        return _mm512_castsi512_pd(_mm512_mask##fun##_epi64(_mm512_castpd_si512(r), k, _mm512_castpd_si512(a), _mm512_castpd_si512(b))); \
+    } \
+    static Vc_INTRINSIC __m512i fun(__m512i r, __mmask16 k, __m512i a, __m512i b) { \
+        return _mm512_mask##fun##_epi32(r, k, a, b); \
+    }
+    Vc_INTEGER_FUN2(_and)
+    Vc_INTEGER_FUN2(_or)
+    Vc_INTEGER_FUN2(_xor)
+    Vc_INTEGER_FUN2(_andnot)
+#undef Vc_INTEGER_FUN2
+
+    Vc_INTRINSIC __m512i _mm512_add_epu32(__m512i a, __m512i b) { return _mm512_add_epi32(a, b); }
+    Vc_INTRINSIC __m512i _mm512_sub_epu32(__m512i a, __m512i b) { return _mm512_sub_epi32(a, b); }
+    Vc_INTRINSIC __m512i _mm512_mask_add_epu32(__m512i r, __mmask16 k, __m512i a, __m512i b) { return _mm512_mask_add_epi32(r, k, a, b); }
+    Vc_INTRINSIC __m512i _mm512_mask_sub_epu32(__m512i r, __mmask16 k, __m512i a, __m512i b) { return _mm512_mask_sub_epi32(r, k, a, b); }
+#define Vc_FUN2(fun) \
+    template<typename> Vc_INTRINSIC __m512  fun(__m512  a, __m512  b) { \
+        return _mm512##fun##_ps(a, b); \
+    } \
+    template<typename> Vc_INTRINSIC __m512d fun(__m512d a, __m512d b) { \
+        return _mm512##fun##_pd(a, b); \
+    } \
+    template<typename> Vc_INTRINSIC __m512i fun(__m512i a, __m512i b) { \
+        return _mm512##fun##_epi32(a, b); \
+    } \
+    template<> Vc_INTRINSIC __m512i fun<unsigned int>(__m512i a, __m512i b) { \
+        return _mm512##fun##_epu32(a, b); \
+    } \
+    template<typename> Vc_INTRINSIC __m512  fun(__m512  r, __mmask16 k, __m512  a, __m512  b) { \
+        return _mm512_mask##fun##_ps(r, k, a, b); \
+    } \
+    template<typename> Vc_INTRINSIC __m512d fun(__m512d r, __mmask8  k, __m512d a, __m512d b) { \
+        return _mm512_mask##fun##_pd(r, k, a, b); \
+    } \
+    template<typename> Vc_INTRINSIC __m512i fun(__m512i r, __mmask16 k, __m512i a, __m512i b) { \
+        return _mm512_mask##fun##_epi32(r, k, a, b); \
+    } \
+    template<> Vc_INTRINSIC __m512i fun<unsigned int>(__m512i r, __mmask16 k, __m512i a, __m512i b) { \
+        return _mm512_mask##fun##_epu32(r, k, a, b); \
+    }
+    Vc_FUN2(_min)
+    Vc_FUN2(_max)
+    Vc_FUN2(_add)
+    Vc_FUN2(_sub)
+    Vc_FUN2(_div)
+#undef Vc_FUN2
+
+Vc_INTRINSIC __m512  _set1(             float a) { return _mm512_set1_ps(a); }
+Vc_INTRINSIC __m512d _set1(            double a) { return _mm512_set1_pd(a); }
+Vc_INTRINSIC __m512i _set1(         long long a) { return _mm512_set1_epi64(a); }
+Vc_INTRINSIC __m512i _set1(unsigned long long a) { return _mm512_set1_epi64(a); }
+Vc_INTRINSIC __m512i _set1(               int a) { return _mm512_set1_epi32(a); }
+Vc_INTRINSIC __m512i _set1(      unsigned int a) { return _mm512_set1_epi32(a); }
+Vc_INTRINSIC __m512i _set1(             short a) { return _mm512_set1_epi32(a); }
+Vc_INTRINSIC __m512i _set1(    unsigned short a) { return _mm512_set1_epi32(a); }
+Vc_INTRINSIC __m512i _set1(       signed char a) { return _mm512_set1_epi32(a); }
+Vc_INTRINSIC __m512i _set1(     unsigned char a) { return _mm512_set1_epi32(a); }
+
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_signed<T>::value, __m512i> mod_(__m512i a, __m512i b)
+{ return _mm512_rem_epi32(a, b); }
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_same<T, uint>::value, __m512i> mod_(__m512i a, __m512i b)
+{ return _mm512_rem_epu32(a, b); }
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_same<T, ushort>::value, __m512i> mod_(__m512i a, __m512i b)
+{
+    return _mm512_rem_epu32(_and(a, _set1(0xffff)), _and(b, _set1(0xffff)));
+}
+
+    template<typename> Vc_INTRINSIC __m512  _mul(__m512  a, __m512  b) { return _mm512_mul_ps(a, b); }
+    template<typename> Vc_INTRINSIC __m512d _mul(__m512d a, __m512d b) { return _mm512_mul_pd(a, b); }
+    template<typename> Vc_INTRINSIC __m512i _mul(__m512i a, __m512i b) { return _mm512_mullo_epi32(a, b); }
+    template<typename> Vc_INTRINSIC __m512  _mul(__m512  r, __mmask16 k, __m512  a, __m512  b) { return _mm512_mask_mul_ps(r, k, a, b); }
+    template<typename> Vc_INTRINSIC __m512d _mul(__m512d r, __mmask8  k, __m512d a, __m512d b) { return _mm512_mask_mul_pd(r, k, a, b); }
+    template<typename> Vc_INTRINSIC __m512i _mul(__m512i r, __mmask16 k, __m512i a, __m512i b) { return _mm512_mask_mullo_epi32(r, k, a, b); }
+
+    static Vc_INTRINSIC __m512  mask_mov(__m512  r, __mmask16 k, __m512  a) { return _mm512_mask_mov_ps(r, k, a); }
+    static Vc_INTRINSIC __m512d mask_mov(__m512d r, __mmask8  k, __m512d a) { return _mm512_mask_mov_pd(r, k, a); }
+    static Vc_INTRINSIC __m512i mask_mov(__m512i r, __mmask16 k, __m512i a) { return _mm512_mask_mov_epi32(r, k, a); }
+
+}
+}
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+using namespace MicIntrinsics;
+
+template<typename T> struct DetermineVectorEntryType { typedef T Type; };
+// MIC does not support epi8/epu8 operations, thus we change the EntryType to int/uint
+template<> struct DetermineVectorEntryType<char> { typedef int Type; };
+template<> struct DetermineVectorEntryType<signed char> { typedef int Type; };
+template<> struct DetermineVectorEntryType<unsigned char> { typedef unsigned int Type; };
+// MIC does not support epi16/epu16 operations, thus we change the EntryType to int/uint
+template<> struct DetermineVectorEntryType<short> { typedef int Type; };
+template<> struct DetermineVectorEntryType<unsigned short> { typedef unsigned int Type; };
+// MIC does not support epi64/epu64 operations, thus we change the EntryType to int/uint
+template<> struct DetermineVectorEntryType<long> { typedef int Type; };
+template<> struct DetermineVectorEntryType<unsigned long> { typedef unsigned int Type; };
+// MIC does not support epi64/epu64 operations, thus we change the EntryType to int/uint
+template<> struct DetermineVectorEntryType<long long> { typedef int Type; };
+template<> struct DetermineVectorEntryType<unsigned long long> { typedef unsigned int Type; };
+
+template <typename T> struct SwizzledVector;
+template <typename T> class VectorMultiplication;
+
+alignas(16) extern const char _IndexesFromZero[16];
+
+template <typename T> struct VectorTypeHelper;
+template <> struct VectorTypeHelper<char> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<signed char> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<unsigned char> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<short> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<unsigned short> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<int> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<unsigned int> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<long> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<unsigned long> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<long long> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<unsigned long long> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<float> { typedef __m512 Type; };
+template <> struct VectorTypeHelper<double> { typedef __m512d Type; };
+template <> struct VectorTypeHelper<__m512i> { typedef __m512i Type; };
+template <> struct VectorTypeHelper<__m512> { typedef __m512 Type; };
+template <> struct VectorTypeHelper<__m512d> { typedef __m512d Type; };
+
+template <typename T> struct MaskTypeHelper { typedef __mmask16 Type; };
+template <> struct MaskTypeHelper<__m512d> { typedef __mmask8 Type; };
+template <> struct MaskTypeHelper<double> { typedef __mmask8 Type; };
+
+template <typename T> struct ReturnTypeHelper { typedef char Type; };
+template <> struct ReturnTypeHelper<unsigned int> { typedef unsigned char Type; };
+template <> struct ReturnTypeHelper<int> { typedef signed char Type; };
+template <typename T> const typename ReturnTypeHelper<T>::Type *IndexesFromZeroHelper()
+{
+    return reinterpret_cast<const typename ReturnTypeHelper<T>::Type *>(&_IndexesFromZero[0]);
+}
+
+template <size_t Size> struct IndexScaleHelper;
+template <> struct IndexScaleHelper<8> { static inline _MM_INDEX_SCALE_ENUM value() { return _MM_SCALE_4; } };
+template <> struct IndexScaleHelper<4> { static inline _MM_INDEX_SCALE_ENUM value() { return _MM_SCALE_4; } };
+template <> struct IndexScaleHelper<2> { static inline _MM_INDEX_SCALE_ENUM value() { return _MM_SCALE_2; } };
+template <> struct IndexScaleHelper<1> { static inline _MM_INDEX_SCALE_ENUM value() { return _MM_SCALE_1; } };
+template <typename T> struct IndexScale
+{
+    static inline _MM_INDEX_SCALE_ENUM value() { return IndexScaleHelper<sizeof(T)>::value(); }
+};
+
+template <typename EntryType, typename MemType> struct UpDownConversion;
+template <> struct UpDownConversion<double, double>
+{
+    constexpr _MM_DOWNCONV_PD_ENUM down() const { return _MM_DOWNCONV_PD_NONE; }
+    constexpr _MM_UPCONV_PD_ENUM up() const { return _MM_UPCONV_PD_NONE; }
+    constexpr operator _MM_DOWNCONV_PD_ENUM() const { return _MM_DOWNCONV_PD_NONE; }
+    constexpr operator _MM_UPCONV_PD_ENUM() const { return _MM_UPCONV_PD_NONE; }
+};
+template <> struct UpDownConversion<float, float>
+{
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_NONE; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_NONE; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_NONE; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_NONE; }
+};
+/*template<> struct UpDownConversion<float, half_float> {
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_FLOAT16; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_FLOAT16; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_FLOAT16; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_FLOAT16; }
+};*/
+template <> struct UpDownConversion<float, unsigned char>
+{
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_UINT8; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_UINT8; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_UINT8; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_UINT8; }
+};
+template <> struct UpDownConversion<float, signed char>
+{
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_SINT8; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_SINT8; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_SINT8; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_SINT8; }
+};
+template <> struct UpDownConversion<float, unsigned short>
+{
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_UINT16; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_UINT16; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_UINT16; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_UINT16; }
+};
+template <> struct UpDownConversion<float, signed short>
+{
+    constexpr _MM_DOWNCONV_PS_ENUM down() const { return _MM_DOWNCONV_PS_SINT16; }
+    constexpr _MM_UPCONV_PS_ENUM up() const { return _MM_UPCONV_PS_SINT16; }
+    constexpr operator _MM_DOWNCONV_PS_ENUM() const { return _MM_DOWNCONV_PS_SINT16; }
+    constexpr operator _MM_UPCONV_PS_ENUM() const { return _MM_UPCONV_PS_SINT16; }
+};
+template <> struct UpDownConversion<unsigned int, char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT8; }
+};
+template <> struct UpDownConversion<unsigned int, signed char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT8; }
+};
+template <> struct UpDownConversion<unsigned int, unsigned char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_UINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_UINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_UINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_UINT8; }
+};
+template <> struct UpDownConversion<unsigned int, short>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT16; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT16; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT16; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT16; }
+};
+template <> struct UpDownConversion<unsigned int, unsigned short>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_UINT16; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_UINT16; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_UINT16; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_UINT16; }
+};
+template <> struct UpDownConversion<unsigned int, int>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_NONE; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_NONE; }
+};
+template <> struct UpDownConversion<unsigned int, unsigned int>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_NONE; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_NONE; }
+};
+template <> struct UpDownConversion<int, char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT8; }
+};
+template <> struct UpDownConversion<int, signed char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT8; }
+};
+template <> struct UpDownConversion<int, unsigned char>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_UINT8; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_UINT8; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_UINT8; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_UINT8; }
+};
+template <> struct UpDownConversion<int, short>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_SINT16; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_SINT16; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_SINT16; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_SINT16; }
+};
+template <> struct UpDownConversion<int, unsigned short>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_UINT16; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_UINT16; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_UINT16; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_UINT16; }
+};
+template <> struct UpDownConversion<int, int>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_NONE; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_NONE; }
+};
+template <> struct UpDownConversion<int, unsigned int>
+{
+    constexpr _MM_DOWNCONV_EPI32_ENUM down() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr _MM_UPCONV_EPI32_ENUM up() const { return _MM_UPCONV_EPI32_NONE; }
+    constexpr operator _MM_DOWNCONV_EPI32_ENUM() const { return _MM_DOWNCONV_EPI32_NONE; }
+    constexpr operator _MM_UPCONV_EPI32_ENUM() const { return _MM_UPCONV_EPI32_NONE; }
+};
+}  // namespace MIC
+}  // namespace Vc
+
+#endif  // VC_MIC_INTRINSICS_H_
diff -Nru vc-0.7.4/mic/limits.h vc-1.3.0/mic/limits.h
--- vc-0.7.4/mic/limits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/limits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,42 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_LIMITS_H_
+#define VC_MIC_LIMITS_H_
+#ifdef CAN_OFFLOAD
+#pragma offload_attribute(push, target(mic))
+#endif
+
+namespace std
+{
+// no need for specializations as <Vc/limits> uses broadcasts and they work very efficently on MIC
+} // namespace std
+
+#ifdef CAN_OFFLOAD
+#pragma offload_attribute(pop)
+#endif
+#endif // VC_MIC_LIMITS_H_
diff -Nru vc-0.7.4/mic/macros.h vc-1.3.0/mic/macros.h
--- vc-0.7.4/mic/macros.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/macros.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,33 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "../common/macros.h"
+
+#ifndef VC_MIC_MACROS_H_
+#define VC_MIC_MACROS_H_
+
+#endif // VC_MIC_MACROS_H_
diff -Nru vc-0.7.4/mic/mask.h vc-1.3.0/mic/mask.h
--- vc-0.7.4/mic/mask.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/mask.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,267 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_MASK_H_
+#define VC_MIC_MASK_H_
+
+#include "../common/maskbool.h"
+#include "detail.h"
+#include "macros.h"
+
+#ifdef CAN_OFFLOAD
+#pragma offload_attribute(push, target(mic))
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+template<unsigned int VectorSize> struct MaskHelper;
+template<> struct MaskHelper<8> {
+    typedef __mmask8  Type;
+    static inline bool isFull (Type k) {
+        // I can't find a way around ICC creating an unnecessary kmov to GPR. Every method involves
+        // a cast to __mmask16 and thus induces the “problem”.
+        //__mmask16 kk; asm("kmerge2l1l %[in],%[out]" : [out]"=k"(kk) : [in]"k"((__mmask16)k));
+        __mmask16 kk = _mm512_kmovlhb(k, k);
+        return _mm512_kortestc(kk, kk);
+    }
+    static inline bool isEmpty(Type k) { return _mm512_kortestz(k, k); }
+    static inline bool isNotEmpty(Type k) { return !isEmpty(k); }
+    static inline bool isMix  (Type k) { return !isFull(k) && !isEmpty(k); }
+    static inline bool cmpeq  (Type k1, Type k2) { return isEmpty(_mm512_kxor(k1, k2)); }
+    static inline bool cmpneq (Type k1, Type k2) { return isNotEmpty(_mm512_kxor(k1, k2)); }
+    static Vc_INTRINSIC Vc_CONST Type cast(Type k) { return k; }
+    static Vc_INTRINSIC Vc_CONST Type cast(__mmask16 k) { return _mm512_kand(k, 0xff); }
+};
+template<> struct MaskHelper<16> {
+    typedef __mmask16 Type;
+    static inline bool isFull (Type k) { return _mm512_kortestc(k, k); }
+    static inline bool isEmpty(Type k) { return _mm512_kortestz(k, k); }
+    static inline bool isNotEmpty(Type k) { return !isEmpty(k); }
+    static inline bool isMix  (Type k) { return !isFull(k) && !isEmpty(k); }
+    static inline bool cmpeq  (Type k1, Type k2) { return isEmpty(_mm512_kxor(k1, k2)); }
+    static inline bool cmpneq (Type k1, Type k2) { return isNotEmpty(_mm512_kxor(k1, k2)); }
+    static Vc_INTRINSIC Vc_CONST Type cast(Type k) { return k; }
+    static Vc_INTRINSIC Vc_CONST Type cast(__mmask8 k) { return _mm512_kand(k, 0xff); }
+};
+
+template <typename T> class Mask<T, VectorAbi::Mic>
+{
+public:
+    using abi = VectorAbi::Mic;
+
+private:
+    friend class Mask<  double, abi>;
+    friend class Mask<   float, abi>;
+    friend class Mask< int32_t, abi>;
+    friend class Mask<uint32_t, abi>;
+    friend class Mask< int16_t, abi>;
+    friend class Mask<uint16_t, abi>;
+
+public:
+    /**
+     * The \c EntryType of masks is always bool, independent of \c T.
+     */
+    typedef bool EntryType;
+    using value_type = EntryType;
+
+    using MaskBool = Common::MaskBool<sizeof(T)>;
+    /**
+     * The \c VectorEntryType, in contrast to \c EntryType, reveals information about the
+     * SIMD implementation. This type is useful for the \c sizeof operator in generic
+     * functions.
+     */
+    using VectorEntryType = MaskBool;
+
+    using EntryReference = Vc::Detail::ElementReference<Mask>;
+    using reference = EntryReference;
+
+    /**
+     * The \c VectorType reveals the implementation-specific internal type used for the
+     * SIMD type.
+     */
+    typedef typename MIC::VectorTypeHelper<T>::Type VectorType;
+
+    /**
+     * The associated Vector<T> type.
+     */
+    using Vector = MIC::Vector<T>;
+
+    /** \internal
+     * The intrinsic type of the register/memory representation of the mask data.
+     */
+    typedef typename MIC::MaskTypeHelper<T>::Type MaskType;
+
+    static constexpr size_t Size = sizeof(MaskType) * 8;
+    static constexpr size_t MemoryAlignment = Size;
+    static constexpr std::size_t size() { return Size; }
+    typedef Mask<T> AsArg; // for now only ICC can compile this code and it is not broken :)
+
+    Vc_INTRINSIC Mask() : k() {}
+    Vc_INTRINSIC Mask(MaskType _k) : k(_k) {}
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero) : k(0) {}
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne) : k(Size == 16 ? 0xffff : 0xff) {}
+    Vc_INTRINSIC explicit Mask(bool b) : k(b ? (Size == 16 ? 0xffff : 0xff) : 0) {}
+    Vc_INTRINSIC static Mask Zero() { return Mask{Vc::Zero}; }
+    Vc_INTRINSIC static Mask One() { return Mask{Vc::One}; }
+
+    // implicit cast
+    template <typename U>
+    Vc_INTRINSIC Mask(U &&rhs, Common::enable_if_mask_converts_implicitly<T, U> = nullarg)
+        : k(MaskHelper<Size>::cast(rhs.data())) {}
+
+#if Vc_IS_VERSION_1
+    // explicit cast, implemented via simd_cast (in mic/simd_cast_caller.h)
+    template <typename U>
+    Vc_DEPRECATED(
+        "use simd_cast instead of explicit type casting to convert between mask types")
+        Vc_INTRINSIC_L
+        explicit Mask(U &&rhs, Common::enable_if_mask_converts_explicitly<T, U> = nullarg)
+            Vc_INTRINSIC_R;
+#endif
+
+    inline explicit Mask(const bool *mem) { load(mem, Aligned); }
+    template<typename Flags>
+    inline explicit Mask(const bool *mem, Flags f) { load(mem, f); }
+
+    inline void load(const bool *mem) { load(mem, Aligned); }
+    template<typename Flags>
+    inline void load(const bool *mem, Flags) {
+        const __m512i ones = MIC::mm512_loadu_epi32(
+            mem, MIC::UpDownConversion<unsigned int, unsigned char>());
+            //_mm512_extload_epi32(mem, UpDownConversion<unsigned int, unsigned char>(), _MM_BROADCAST32_NONE, _MM_HINT_NONE);
+        k = _mm512_cmpneq_epi32_mask(ones, _mm512_setzero_epi32());
+    }
+
+    inline void store(bool *mem) const { store(mem, Aligned); }
+    template<typename Flags>
+    inline void store(bool *mem, Flags) const {
+        const __m512i zero = _mm512_setzero_epi32();
+        const __m512i one = Detail::one(int());
+        const __m512i tmp = MIC::_and(zero, k, one, one);
+        MicIntrinsics::store<decltype(Unaligned)>(mem, tmp, MIC::UpDownConversion<unsigned int, unsigned char>());
+    }
+
+    inline bool operator==(const Mask &rhs) const { return MaskHelper<Size>::cmpeq (k, rhs.k); }
+    inline bool operator!=(const Mask &rhs) const { return MaskHelper<Size>::cmpneq(k, rhs.k); }
+
+    inline Mask operator&&(const Mask &rhs) const { return _mm512_kand(k, rhs.k); }
+    inline Mask operator& (const Mask &rhs) const { return _mm512_kand(k, rhs.k); }
+    inline Mask operator||(const Mask &rhs) const { return _mm512_kor (k, rhs.k); }
+    inline Mask operator| (const Mask &rhs) const { return _mm512_kor (k, rhs.k); }
+    inline Mask operator^ (const Mask &rhs) const { return _mm512_kxor(k, rhs.k); }
+    inline Mask operator!() const { return ~k; }
+
+    inline Mask &operator&=(const Mask &rhs) { k = _mm512_kand(k, rhs.k); return *this; }
+    inline Mask &operator|=(const Mask &rhs) { k = _mm512_kor (k, rhs.k); return *this; }
+    inline Mask &operator^=(const Mask &rhs) { k = _mm512_kxor(k, rhs.k); return *this; }
+
+    inline bool isFull () const { return MaskHelper<Size>::isFull (k); }
+    inline bool isEmpty() const { return MaskHelper<Size>::isEmpty(k); }
+    inline bool isMix  () const { return MaskHelper<Size>::isMix  (k); }
+    inline bool isNotEmpty() const { return MaskHelper<Size>::isNotEmpty(k); }
+
+    inline MaskType data () const { return k; }
+    inline MaskType dataI() const { return k; }
+    inline MaskType dataD() const { return k; }
+
+private:
+    friend reference;
+    Vc_INTRINSIC static value_type get(const Mask &m, int i) noexcept
+    {
+        return static_cast<bool>(m.k & (1u << i));
+    }
+    template <typename U>
+    Vc_INTRINSIC static void set(Mask &m, int i, U &&v) noexcept(
+        noexcept(static_cast<bool>(std::declval<U>())))
+    {
+        const auto bitmask = 1u << i;
+        if (std::forward<U>(v)) {
+            m.k |= bitmask;
+        } else {
+            m.k &= ~bitmask;
+        }
+    }
+
+public:
+    Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+    {
+        return {*this, int(index)};
+    }
+    Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept
+    {
+        return static_cast<bool>(k & (1 << index));
+    }
+
+    Vc_ALWAYS_INLINE Vc_PURE int count() const {
+        if (Size == 16) {
+            return _mm_countbits_32(k);
+        } else {
+            return _mm_countbits_32(k & 0xffu);
+        }
+    }
+
+    /**
+     * Returns the index of the first one in the mask.
+     *
+     * The return value is undefined if the mask is empty.
+     */
+    int firstOne() const { return _mm_tzcnt_32(k); }
+
+    int toInt() const { return k; }
+
+    template <typename G> static Vc_INTRINSIC Mask generate(G &&gen)
+    {
+        unsigned int bits = 0;
+        Common::unrolled_loop<std::size_t, 0, Size>([&](std::size_t i) {
+            bits |= gen(i) << i;
+        });
+        return static_cast<MaskType>(bits);
+    }
+    Vc_INTRINSIC Vc_PURE Mask shifted(int amount) const
+    {
+        if (amount > 0) {
+            if (amount < Size) {
+                return static_cast<MaskType>(k >> amount);
+            }
+        } else if (amount > -int(Size)) {
+            return static_cast<MaskType>(k << -amount);
+        }
+        return Zero();
+    }
+
+private:
+    MaskType k;
+};
+template <typename T> constexpr size_t Mask<T, VectorAbi::Mic>::Size;
+template <typename T> constexpr size_t Mask<T, VectorAbi::Mic>::MemoryAlignment;
+
+}  // namespace Vc
+
+#include "mask.tcc"
+
+#endif // VC_MIC_MASK_H_
diff -Nru vc-0.7.4/mic/mask.tcc vc-1.3.0/mic/mask.tcc
--- vc-0.7.4/mic/mask.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/mask.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,58 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_MASK_TCC_
+#define VC_MIC_MASK_TCC_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+template <>
+template <typename Flags>
+inline void MIC::double_m::load(const bool *mem, Flags)
+{
+    __m512i ones = _mm512_setzero_epi32();
+    ones = _mm512_mask_extloadunpacklo_epi32(ones, 0xff, mem, MIC::UpDownConversion<unsigned int, unsigned char>().up(), _MM_HINT_NONE);
+    ones = _mm512_mask_extloadunpackhi_epi32(ones, 0xff, mem + 64, MIC::UpDownConversion<unsigned int, unsigned char>().up(), _MM_HINT_NONE);
+    //const __m512i ones = _mm512_mask_extload_epi32(_mm512_setzero_epi32(), 0xff, mem, , _MM_BROADCAST32_NONE, _MM_HINT_NONE);
+    k = _mm512_cmpneq_epi32_mask(ones, _mm512_setzero_epi32());
+}
+
+template <>
+template <typename Flags>
+inline void MIC::double_m::store(bool *mem, Flags) const
+{
+    const __m512i zero = _mm512_setzero_epi32();
+    const __m512i one = _mm512_set1_epi32(1);
+    const __m512i tmp = MIC::_and(zero, static_cast<__mmask16>(k), one, one);
+    _mm512_mask_extpackstorelo_epi32(mem, 0xff, tmp, MIC::UpDownConversion<unsigned int, unsigned char>().down(), _MM_HINT_NONE);
+    _mm512_mask_extpackstorehi_epi32(mem + 64, 0xff, tmp, MIC::UpDownConversion<unsigned int, unsigned char>().down(), _MM_HINT_NONE);
+}
+}  // namespace Vc
+
+#endif // VC_MIC_MASK_TCC_
diff -Nru vc-0.7.4/mic/math.h vc-1.3.0/mic/math.h
--- vc-0.7.4/mic/math.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/math.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,169 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_MATH_H_
+#define VC_MIC_MATH_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+// copysign {{{1
+Vc_INTRINSIC Vc_CONST MIC::float_v copysign(MIC::float_v mag, MIC::float_v sign)
+{
+    return MIC::_or(MIC::_and(sign.data(), MIC::_mm512_setsignmask_ps()),
+                    MIC::_and(mag.data(), MIC::_mm512_setabsmask_ps()));
+}
+Vc_INTRINSIC Vc_CONST MIC::double_v copysign(MIC::double_v mag, MIC::double_v sign)
+{
+    return MIC::_or(MIC::_and(sign.data(), MIC::_mm512_setsignmask_pd()),
+                    MIC::_and(mag.data(), MIC::_mm512_setabsmask_pd()));
+}
+
+// trunc {{{1
+template <typename V> Vc_ALWAYS_INLINE V trunc(V v) { return _mm512_trunc_ps(v.data()); }
+Vc_ALWAYS_INLINE MIC::double_v trunc(MIC::double_v v)
+{
+    return _mm512_trunc_pd(v.data());
+}
+// isfinite {{{1
+template <typename T>
+static Vc_ALWAYS_INLINE Mask<T> isfinite(Vector<T, VectorAbi::Mic> x)
+{
+    return _mm512_cmpord_ps_mask(x.data(),
+                                 (x * Vector<T, VectorAbi::Mic>::Zero()).data());
+}
+static Vc_ALWAYS_INLINE MIC::double_m isfinite(MIC::double_v x)
+{
+    return _mm512_cmpord_pd_mask(x.data(), (x * MIC::double_v::Zero()).data());
+}
+// isnotfinite {{{1
+// i.e. !isfinite(x), this is not equivalent to isinfinite because NaN also is not finite
+template <typename T>
+static Vc_ALWAYS_INLINE Mask<T> isnotfinite(Vector<T, VectorAbi::Mic> x)
+{
+    return _mm512_cmpunord_ps_mask(x.data(),
+                                   (x * Vector<T, VectorAbi::Mic>::Zero()).data());
+}
+static Vc_ALWAYS_INLINE MIC::double_m isnotfinite(MIC::double_v x)
+{
+    return _mm512_cmpunord_pd_mask(x.data(), (x * MIC::double_v::Zero()).data());
+}
+// isinf {{{1
+Vc_ALWAYS_INLINE MIC::float_m isinf(MIC::float_v x)
+{
+    return _mm512_cmpeq_epi32_mask(_mm512_castps_si512(abs(x).data()),
+                                   _mm512_set1_epi32(0x7f800000));
+}
+Vc_ALWAYS_INLINE MIC::double_m isinf(MIC::double_v x)
+{
+    auto mask = _mm512_cmpeq_epi32_mask(_mm512_castpd_si512(abs(x).data()),
+                                        _mm512_set1_epi64(0x7ff0000000000000ull));
+    // FIXME this is not efficient:
+    return ((mask & 0x01) | ((mask >> 2) & 0x06) | ((mask >> 4) & 0x18) |
+            ((mask >> 6) & 0x60) | ((mask >> 8) & 0x80)) &
+           (((mask >> 1) & 0x03) | ((mask >> 3) & 0x0c) | ((mask >> 5) & 0x30) |
+            ((mask >> 7) & 0xc0));
+}
+// isnan {{{1
+template <typename T> static Vc_ALWAYS_INLINE Mask<T> isnan(Vector<T, VectorAbi::Mic> x)
+{
+    return _mm512_cmpunord_ps_mask(x.data(), x.data());
+}
+static Vc_ALWAYS_INLINE MIC::double_m isnan(MIC::double_v x)
+{
+    return _mm512_cmpunord_pd_mask(x.data(), x.data());
+}
+// fma {{{1
+Vc_ALWAYS_INLINE Vector<double, VectorAbi::Mic> fma(Vector<double, VectorAbi::Mic> a,
+                                                    Vector<double, VectorAbi::Mic> b,
+                                                    Vector<double, VectorAbi::Mic> c)
+{
+    return _mm512_fmadd_pd(a.data(), b.data(), c.data());
+}
+Vc_ALWAYS_INLINE Vector<float, VectorAbi::Mic> fma(Vector<float, VectorAbi::Mic> a,
+                                                   Vector<float, VectorAbi::Mic> b,
+                                                   Vector<float, VectorAbi::Mic> c)
+{
+    return _mm512_fmadd_ps(a.data(), b.data(), c.data());
+}
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> fma(Vector<T, VectorAbi::Mic> a,
+                                               Vector<T, VectorAbi::Mic> b,
+                                               Vector<T, VectorAbi::Mic> c)
+{
+    return _mm512_fmadd_epi32(a.data(), b.data(), c.data());
+}
+
+// frexp {{{1
+inline MIC::double_v frexp(MIC::double_v::AsArg v, MIC::double_v::IndexType *e)
+{
+    using namespace MIC;
+    const __m512d mantissa =
+        _mm512_getmant_pd(v.data(), _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src);
+    int_v exponent = int_v::Zero();
+    exponent(static_cast<int_m>(v != v.Zero())) =
+        int_v(convert<double, int>(_mm512_getexp_pd(v.data()))) + 1;
+    *e = simd_cast<double_v::IndexType>(exponent);
+    return double_v(mantissa) * 0.5;
+}
+inline MIC::float_v frexp(MIC::float_v::AsArg v, MIC::float_v::IndexType *e)
+{
+    using namespace MIC;
+    const __m512 mantissa =
+        _mm512_getmant_ps(v.data(), _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src);
+    int_v exponent = int_v::Zero();
+    exponent(static_cast<int_m>(v != v.Zero())) =
+        int_v(convert<float, int>(_mm512_getexp_ps(v.data()))) + 1;
+    internal_data(*e) = exponent;
+    return float_v(mantissa) * 0.5f;
+}
+// ldexp {{{1
+Vc_ALWAYS_INLINE MIC::double_v ldexp(MIC::double_v::AsArg v, MIC::double_v::IndexType _e)
+{
+    using namespace MIC;
+    static_assert(sizeof(_e) >= 32, "");
+    static_assert(std::is_same<double_v::IndexType::EntryType, int>::value, "");
+    const auto e_ = _mm512_extload_epi32(&_e, _MM_UPCONV_EPI32_SINT16,
+                                         _MM_BROADCAST32_NONE, _MM_HINT_NONE);
+    __m512i e = _mm512_mask_xor_epi64(e_, (v == double_v::Zero()).data(), e_, e_);
+    const __m512i exponentBits = _mm512_mask_slli_epi32(
+        _mm512_setzero_epi32(), 0xaaaa, _mm512_swizzle_epi32(e, _MM_SWIZ_REG_CDAB), 20);
+    return mic_cast<__m512d>(_mm512_add_epi32(mic_cast<__m512i>(v.data()), exponentBits));
+}
+Vc_ALWAYS_INLINE MIC::float_v ldexp(MIC::float_v::AsArg v, MIC::float_v::IndexType _e)
+{
+    MIC::int_v e = internal_data(_e);
+    e.setZero(static_cast<MIC::int_m>(v == MIC::float_v::Zero()));
+    return (v.reinterpretCast<MIC::int_v>() + (e << 23)).reinterpretCast<MIC::float_v>();
+}
+//}}}1
+}  // namespace Vc
+
+#endif  // VC_MIC_MATH_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/prefetches.tcc vc-1.3.0/mic/prefetches.tcc
--- vc-0.7.4/mic/prefetches.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/prefetches.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,58 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_PREFETCHES_TCC_
+#define VC_MIC_PREFETCHES_TCC_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+Vc_ALWAYS_INLINE void prefetchForOneRead(const void *addr, VectorAbi::Mic)
+{
+    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_NTA);
+}
+Vc_ALWAYS_INLINE void prefetchClose(const void *addr, VectorAbi::Mic)
+{
+    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
+}
+Vc_ALWAYS_INLINE void prefetchMid(const void *addr, VectorAbi::Mic)
+{
+    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T1);
+}
+Vc_ALWAYS_INLINE void prefetchFar(const void *addr, VectorAbi::Mic)
+{
+    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T2);
+}
+Vc_ALWAYS_INLINE void prefetchForModify(const void *addr, VectorAbi::Mic)
+{
+    _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_ET0);
+}
+}  // namespace Detail
+}  // namespace Vc
+
+#endif // VC_MIC_PREFETCHES_TCC_
diff -Nru vc-0.7.4/mic/simd_cast_caller.tcc vc-1.3.0/mic/simd_cast_caller.tcc
--- vc-0.7.4/mic/simd_cast_caller.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/simd_cast_caller.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,48 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef Vc_MIC_SIMD_CAST_CALLER_TCC_
+#define Vc_MIC_SIMD_CAST_CALLER_TCC_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#if Vc_IS_VERSION_1
+template <typename T>
+template <typename U>
+Vc_INTRINSIC Mask<T, VectorAbi::Mic>::Mask(
+    U &&rhs, Common::enable_if_mask_converts_explicitly<T, U>)
+    : Mask(simd_cast<Mask>(std::forward<U>(rhs)))
+{
+}
+#endif
+}  // namespace Vc
+
+#endif  // Vc_MIC_SIMD_CAST_CALLER_TCC_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/simd_cast.h vc-1.3.0/mic/simd_cast.h
--- vc-0.7.4/mic/simd_cast.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/simd_cast.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,597 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_SIMD_CAST_H_
+#define VC_MIC_SIMD_CAST_H_
+
+#ifndef VC_MIC_VECTOR_H_
+#error "Vc/mic/vector.h needs to be included before Vc/mic/simd_cast.h"
+#endif
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+// MIC <-> MIC Vector casts {{{1
+// 1 MIC::Vector to 1 MIC::Vector {{{2
+#define Vc_CAST_(To_)                                                                    \
+    template <typename Return>                                                           \
+    Vc_INTRINSIC Vc_CONST enable_if<std::is_same<Return, To_>::value, Return>
+// to int_v {{{3
+Vc_CAST_(   int_v) simd_cast( short_v x) { return x.data(); }
+Vc_CAST_(   int_v) simd_cast(ushort_v x) { return _mm512_and_epi32(x.data(), _mm512_set1_epi32(0xffff)); }
+Vc_CAST_(   int_v) simd_cast(  uint_v x) { return x.data(); }
+Vc_CAST_(   int_v) simd_cast(double_v x) { return _mm512_cvtfxpnt_roundpd_epi32lo(x.data(), _MM_ROUND_MODE_TOWARD_ZERO); }
+Vc_CAST_(   int_v) simd_cast( float_v x) { return _mm512_cvtfxpnt_round_adjustps_epi32(x.data(), _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE); }
+
+// to uint_v {{{3
+Vc_CAST_(  uint_v) simd_cast( short_v x) { return x.data(); }
+Vc_CAST_(  uint_v) simd_cast(ushort_v x)
+{ return _mm512_and_epi32(x.data(), _mm512_set1_epi32(0xffff)); }
+Vc_CAST_(  uint_v) simd_cast(   int_v x) { return x.data(); }
+Vc_CAST_(  uint_v) simd_cast(double_v x) {
+    const auto negative = _mm512_cmplt_pd_mask(x.data(), _mm512_setzero_pd());
+    return _mm512_mask_cvtfxpnt_roundpd_epi32lo(
+        _mm512_cvtfxpnt_roundpd_epu32lo(x.data(), _MM_ROUND_MODE_TOWARD_ZERO), negative,
+        x.data(), _MM_ROUND_MODE_TOWARD_ZERO);
+}
+Vc_CAST_(  uint_v) simd_cast( float_v x) {
+    const auto negative = _mm512_cmplt_ps_mask(x.data(), _mm512_setzero_ps());
+    return _mm512_mask_cvtfxpnt_round_adjustps_epi32(
+        _mm512_cvtfxpnt_round_adjustps_epu32(x.data(), _MM_ROUND_MODE_TOWARD_ZERO,
+                                             _MM_EXPADJ_NONE),
+        negative, x.data(), _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE);
+}
+
+// to short_v {{{3
+Vc_CAST_( short_v) simd_cast(ushort_v x) { return _mm512_srai_epi32(_mm512_slli_epi32(x.data(), 16), 16); }
+Vc_CAST_( short_v) simd_cast(   int_v x) { return _mm512_srai_epi32(_mm512_slli_epi32(x.data(), 16), 16); }
+Vc_CAST_( short_v) simd_cast(  uint_v x) { return _mm512_srai_epi32(_mm512_slli_epi32(x.data(), 16), 16); }
+Vc_CAST_( short_v) simd_cast(double_v x) { return _mm512_cvtfxpnt_roundpd_epi32lo(x.data(), _MM_ROUND_MODE_TOWARD_ZERO); }
+Vc_CAST_( short_v) simd_cast( float_v x) { return _mm512_cvtfxpnt_round_adjustps_epi32(x.data(), _MM_ROUND_MODE_TOWARD_ZERO, _MM_EXPADJ_NONE); }
+
+// to ushort_v {{{3
+Vc_CAST_(ushort_v) simd_cast( short_v x) { return x.data(); }
+Vc_CAST_(ushort_v) simd_cast(   int_v x) { return x.data(); }
+Vc_CAST_(ushort_v) simd_cast(  uint_v x) { return x.data(); }
+Vc_CAST_(ushort_v) simd_cast(double_v x) {
+    // use conversion to epi32 on purpose here! Conversion to epu32 drops negative inputs.
+    // And since we convert to 32bit ints the positive values are all covered.
+    return _mm512_cvtfxpnt_roundpd_epi32lo(x.data(), _MM_ROUND_MODE_TOWARD_ZERO);
+}
+Vc_CAST_(ushort_v) simd_cast( float_v x) {
+    // use conversion to epi32 on purpose here! Conversion to epu32 drops negative inputs.
+    // And since we convert to 32bit ints the positive values are all covered.
+    return _mm512_cvtfxpnt_round_adjustps_epi32(x.data(), _MM_ROUND_MODE_TOWARD_ZERO,
+                                                _MM_EXPADJ_NONE);
+}
+// to float_v {{{3
+Vc_CAST_( float_v) simd_cast(   int_v x) {
+    return _mm512_cvtfxpnt_round_adjustepi32_ps(x.data(), _MM_FROUND_CUR_DIRECTION,
+                                                _MM_EXPADJ_NONE);
+}
+Vc_CAST_( float_v) simd_cast(  uint_v x) {
+    return _mm512_cvtfxpnt_round_adjustepu32_ps(x.data(), _MM_FROUND_CUR_DIRECTION,
+                                                _MM_EXPADJ_NONE);
+}
+Vc_CAST_( float_v) simd_cast( short_v x) { return simd_cast<float_v>(simd_cast< int_v>(x)); }
+Vc_CAST_( float_v) simd_cast(ushort_v x) { return simd_cast<float_v>(simd_cast<uint_v>(x)); }
+Vc_CAST_( float_v) simd_cast(double_v x) { return _mm512_cvtpd_pslo(x.data()); }
+// to double_v {{{3
+Vc_CAST_(double_v) simd_cast( float_v x) { return _mm512_cvtpslo_pd(x.data()); }
+Vc_CAST_(double_v) simd_cast(   int_v x) { return _mm512_cvtepi32lo_pd(x.data()); }
+Vc_CAST_(double_v) simd_cast(  uint_v x) { return _mm512_cvtepu32lo_pd(x.data()); }
+Vc_CAST_(double_v) simd_cast( short_v x) { return simd_cast<double_v>(simd_cast< int_v>(x)); }
+Vc_CAST_(double_v) simd_cast(ushort_v x) { return simd_cast<double_v>(simd_cast<uint_v>(x)); }
+// 2 MIC::Vector to 1 MIC::Vector {{{2
+Vc_CAST_(ushort_v) simd_cast(double_v a, double_v b)
+{
+    return _mm512_mask_permute4f128_epi32(
+        _mm512_cvtfxpnt_roundpd_epi32lo(a.data(), _MM_ROUND_MODE_TOWARD_ZERO), 0xff00,
+        _mm512_cvtfxpnt_roundpd_epi32lo(b.data(), _MM_ROUND_MODE_TOWARD_ZERO),
+        _MM_PERM_BABA);
+}
+Vc_CAST_( short_v) simd_cast(double_v a, double_v b)
+{
+    return _mm512_mask_permute4f128_epi32(
+        _mm512_cvtfxpnt_roundpd_epi32lo(a.data(), _MM_ROUND_MODE_TOWARD_ZERO), 0xff00,
+        _mm512_cvtfxpnt_roundpd_epi32lo(b.data(), _MM_ROUND_MODE_TOWARD_ZERO),
+        _MM_PERM_BABA);
+}
+Vc_CAST_(  uint_v) simd_cast(double_v a, double_v b)
+{
+    return _mm512_mask_permute4f128_epi32(
+        _mm512_cvtfxpnt_roundpd_epu32lo(a.data(), _MM_ROUND_MODE_TOWARD_ZERO), 0xff00,
+        _mm512_cvtfxpnt_roundpd_epu32lo(b.data(), _MM_ROUND_MODE_TOWARD_ZERO),
+        _MM_PERM_BABA);
+}
+Vc_CAST_(   int_v) simd_cast(double_v a, double_v b)
+{
+    return _mm512_mask_permute4f128_epi32(
+        _mm512_cvtfxpnt_roundpd_epi32lo(a.data(), _MM_ROUND_MODE_TOWARD_ZERO), 0xff00,
+        _mm512_cvtfxpnt_roundpd_epi32lo(b.data(), _MM_ROUND_MODE_TOWARD_ZERO),
+        _MM_PERM_BABA);
+}
+Vc_CAST_( float_v) simd_cast(double_v a, double_v b)
+{
+    return _mm512_mask_permute4f128_ps(_mm512_cvtpd_pslo(a.data()), 0xff00,
+                                       _mm512_cvtpd_pslo(b.data()), _MM_PERM_BABA);
+}
+#undef Vc_CAST_
+// 1 MIC::Vector to 2 MIC::Vector {{{2
+#define Vc_CAST_(To_, Offset_)                                                           \
+    template <typename Return, int offset>                                               \
+    Vc_INTRINSIC Vc_CONST                                                                \
+        enable_if<std::is_same<Return, To_>::value && offset == Offset_, Return>
+Vc_CAST_(double_v, 1) simd_cast(ushort_v x) { return simd_cast<double_v>(ushort_v(_mm512_permute4f128_epi32(x.data(), _MM_PERM_DCDC))); }
+Vc_CAST_(double_v, 1) simd_cast( short_v x) { return simd_cast<double_v>( short_v(_mm512_permute4f128_epi32(x.data(), _MM_PERM_DCDC))); }
+Vc_CAST_(double_v, 1) simd_cast(  uint_v x) { return simd_cast<double_v>(  uint_v(_mm512_permute4f128_epi32(x.data(), _MM_PERM_DCDC))); }
+Vc_CAST_(double_v, 1) simd_cast(   int_v x) { return simd_cast<double_v>(   int_v(_mm512_permute4f128_epi32(x.data(), _MM_PERM_DCDC))); }
+Vc_CAST_(double_v, 1) simd_cast( float_v x) { return simd_cast<double_v>( float_v(_mm512_permute4f128_ps(x.data(), _MM_PERM_DCDC))); }
+#undef Vc_CAST_
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(is_vector<Return>::value && offset == 0), Return>
+    simd_cast(Vector<T> x)
+{ return simd_cast<Return>(x); }
+// MIC <-> Scalar Vector casts {{{1
+// 1 MIC::Vector to 1 Scalar::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(Scalar::is_vector<Return>::value), Return> simd_cast(
+    MIC::Vector<T> x)
+{
+    return {static_cast<typename Return::value_type>(x[0])};
+}
+// 1 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x[0]);
+    return r;
+}
+// 2 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    return r;
+}
+// 3 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    r[2] = static_cast<typename Return::value_type>(x2[0]);
+    return r;
+}
+// 4 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+    Scalar::Vector<T> x3)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    r[2] = static_cast<typename Return::value_type>(x2[0]);
+    r[3] = static_cast<typename Return::value_type>(x3[0]);
+    return r;
+}
+// 5 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+    Scalar::Vector<T> x3, Scalar::Vector<T> x4)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    r[2] = static_cast<typename Return::value_type>(x2[0]);
+    r[3] = static_cast<typename Return::value_type>(x3[0]);
+    r[4] = static_cast<typename Return::value_type>(x4[0]);
+    return r;
+}
+// 6 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+    Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    r[2] = static_cast<typename Return::value_type>(x2[0]);
+    r[3] = static_cast<typename Return::value_type>(x3[0]);
+    r[4] = static_cast<typename Return::value_type>(x4[0]);
+    r[5] = static_cast<typename Return::value_type>(x5[0]);
+    return r;
+}
+// 7 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+    Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+    Scalar::Vector<T> x6)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::value_type>(x0[0]);
+    r[1] = static_cast<typename Return::value_type>(x1[0]);
+    r[2] = static_cast<typename Return::value_type>(x2[0]);
+    r[3] = static_cast<typename Return::value_type>(x3[0]);
+    r[4] = static_cast<typename Return::value_type>(x4[0]);
+    r[5] = static_cast<typename Return::value_type>(x5[0]);
+    r[6] = static_cast<typename Return::value_type>(x6[0]);
+    return r;
+}
+// 8 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(MIC::is_vector<Return>::value), Return> simd_cast(
+    Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+    Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+    Scalar::Vector<T> x6, Scalar::Vector<T> x7)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[0] = static_cast<typename Return::value_type>(x0[0]);
+    m[1] = static_cast<typename Return::value_type>(x1[0]);
+    m[2] = static_cast<typename Return::value_type>(x2[0]);
+    m[3] = static_cast<typename Return::value_type>(x3[0]);
+    m[4] = static_cast<typename Return::value_type>(x4[0]);
+    m[5] = static_cast<typename Return::value_type>(x5[0]);
+    m[6] = static_cast<typename Return::value_type>(x6[0]);
+    m[7] = static_cast<typename Return::value_type>(x7[0]);
+    return m.firstVector();
+}
+// 9 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    return m.firstVector();
+}
+// 10 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    return m.firstVector();
+}
+// 11 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    return m.firstVector();
+}
+// 12 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    m[11] = static_cast<typename Return::value_type>(x11[0]);
+    return m.firstVector();
+}
+// 13 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+              Scalar::Vector<T> x12)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    m[11] = static_cast<typename Return::value_type>(x11[0]);
+    m[12] = static_cast<typename Return::value_type>(x12[0]);
+    return m.firstVector();
+}
+// 14 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+              Scalar::Vector<T> x12, Scalar::Vector<T> x13)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    m[11] = static_cast<typename Return::value_type>(x11[0]);
+    m[12] = static_cast<typename Return::value_type>(x12[0]);
+    m[13] = static_cast<typename Return::value_type>(x13[0]);
+    return m.firstVector();
+}
+// 15 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+              Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    m[11] = static_cast<typename Return::value_type>(x11[0]);
+    m[12] = static_cast<typename Return::value_type>(x12[0]);
+    m[13] = static_cast<typename Return::value_type>(x13[0]);
+    m[14] = static_cast<typename Return::value_type>(x14[0]);
+    return m.firstVector();
+}
+// 16 Scalar::Vector to 1 MIC::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(MIC::is_vector<Return>::value && Return::Size == 16), Return>
+    simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6, Scalar::Vector<T> x7, Scalar::Vector<T> x8,
+              Scalar::Vector<T> x9, Scalar::Vector<T> x10, Scalar::Vector<T> x11,
+              Scalar::Vector<T> x12, Scalar::Vector<T> x13, Scalar::Vector<T> x14,
+              Scalar::Vector<T> x15)
+{
+    Memory<Return, Return::Size> m;
+    m.setZero();
+    m[ 0] = static_cast<typename Return::value_type>(x0[0]);
+    m[ 1] = static_cast<typename Return::value_type>(x1[0]);
+    m[ 2] = static_cast<typename Return::value_type>(x2[0]);
+    m[ 3] = static_cast<typename Return::value_type>(x3[0]);
+    m[ 4] = static_cast<typename Return::value_type>(x4[0]);
+    m[ 5] = static_cast<typename Return::value_type>(x5[0]);
+    m[ 6] = static_cast<typename Return::value_type>(x6[0]);
+    m[ 7] = static_cast<typename Return::value_type>(x7[0]);
+    m[ 8] = static_cast<typename Return::value_type>(x8[0]);
+    m[ 9] = static_cast<typename Return::value_type>(x9[0]);
+    m[10] = static_cast<typename Return::value_type>(x10[0]);
+    m[11] = static_cast<typename Return::value_type>(x11[0]);
+    m[12] = static_cast<typename Return::value_type>(x12[0]);
+    m[13] = static_cast<typename Return::value_type>(x13[0]);
+    m[14] = static_cast<typename Return::value_type>(x14[0]);
+    m[15] = static_cast<typename Return::value_type>(x15[0]);
+    return m.firstVector();
+}
+// MIC <-> MIC Mask casts {{{1
+// 1 MIC::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename M>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(is_mask<Return>::value&& is_mask<M>::value &&
+               !std::is_same<Return, M>::value && Return::Size == M::Size),
+              Return>
+        simd_cast(M k)
+{
+    return {k.data()};
+}
+template <typename Return, typename M>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (is_mask<Return>::value && is_mask<M>::value && Return::Size != M::Size), Return>
+    simd_cast(M k)
+{
+    return {static_cast<typename Return::MaskType>(_mm512_kand(k.data(), 0xff))};
+}
+// 2 MIC::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename M>
+Vc_INTRINSIC Vc_CONST enable_if<
+    (is_mask<Return>::value&& is_mask<M>::value&& Return::Size == 2 * M::Size), Return>
+    simd_cast(M k0, M k1)
+{
+    return {_mm512_kmovlhb(k0.data(), k1.data())};
+}
+// 1 MIC::Mask to 2 MIC::Mask {{{2
+template <typename Return, int offset, typename M>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(is_mask<Return>::value&& is_mask<M>::value&& offset == 0), Return>
+        simd_cast(M k)
+{
+    return simd_cast<Return>(k);
+}
+template <typename Return, int offset, typename M>
+Vc_INTRINSIC Vc_CONST
+    enable_if<(is_mask<Return>::value&& is_mask<M>::value&& Return::Size * 2 ==
+               M::Size&& offset == 1),
+              Return>
+        simd_cast(M k)
+{
+    return {static_cast<typename Return::MaskType>(_mm512_kswapb(k.data(), 0))};
+}
+// MIC <-> Scalar Mask casts {{{1
+// 1 MIC::Mask to 1 Scalar::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC enable_if<Scalar::is_mask<Return>::value, Return> simd_cast(MIC::Mask<T> k)
+{
+    return Return(static_cast<bool>(k[0]));
+}
+// 1 Scalar::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC enable_if<MIC::is_mask<Return>::value, Return> simd_cast(Scalar::Mask<T> k)
+{
+    Return r{};
+    r[0] = k[0];
+    return r;
+}
+// 2 Scalar::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC enable_if<MIC::is_mask<Return>::value, Return> simd_cast(Scalar::Mask<T> k0,
+                                                                      Scalar::Mask<T> k1)
+{
+    Return r{};
+    r[0] = k0[0];
+    r[1] = k1[0];
+    return r;
+}
+// 4 Scalar::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC enable_if<MIC::is_mask<Return>::value, Return> simd_cast(Scalar::Mask<T> k0,
+                                                                      Scalar::Mask<T> k1,
+                                                                      Scalar::Mask<T> k2,
+                                                                      Scalar::Mask<T> k3)
+{
+    Return r{};
+    r[0] = k0[0];
+    r[1] = k1[0];
+    r[2] = k2[0];
+    r[3] = k3[0];
+    return r;
+}
+// 8 Scalar::Mask to 1 MIC::Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC enable_if<MIC::is_mask<Return>::value, Return> simd_cast(Scalar::Mask<T> k0,
+                                                                      Scalar::Mask<T> k1,
+                                                                      Scalar::Mask<T> k2,
+                                                                      Scalar::Mask<T> k3,
+                                                                      Scalar::Mask<T> k4,
+                                                                      Scalar::Mask<T> k5,
+                                                                      Scalar::Mask<T> k6,
+                                                                      Scalar::Mask<T> k7)
+{
+    Return r{};
+    r[0] = k0[0];
+    r[1] = k1[0];
+    r[2] = k2[0];
+    r[3] = k3[0];
+    r[4] = k4[0];
+    r[5] = k5[0];
+    r[6] = k6[0];
+    r[7] = k7[0];
+    return r;
+}
+//}}}1
+
+}  // namespace MIC
+using MIC::simd_cast;
+}  // namespace Vc
+
+#endif  // VC_MIC_SIMD_CAST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/sorthelper.h vc-1.3.0/mic/sorthelper.h
--- vc-0.7.4/mic/sorthelper.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/sorthelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_SORTHELPER_H_
+#define VC_MIC_SORTHELPER_H_
+
+#include <tuple>
+#include "types.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+template<typename T> struct SortHelper
+{
+    typedef typename VectorTypeHelper<T>::Type VectorType;
+    static VectorType sort(VectorType);
+    template <typename... Vs> static std::tuple<Vs...> sort(std::tuple<Vs...>);
+};
+
+}  // namespace MIC
+}  // namespace Vc
+
+#endif // VC_MIC_SORTHELPER_H_
diff -Nru vc-0.7.4/mic/storemixin.h vc-1.3.0/mic/storemixin.h
--- vc-0.7.4/mic/storemixin.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/storemixin.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,84 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_STOREMIXIN_H_
+#define VC_MIC_STOREMIXIN_H_
+
+#include <type_traits>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+template<typename Parent, typename T> class StoreMixin
+{
+private:
+    typedef typename VectorTypeHelper<T>::Type VectorType;
+    using EntryType = T;
+    typedef typename DetermineVectorEntryType<T>::Type VectorEntryType;
+    typedef MIC::Mask<T> Mask;
+
+    template<typename MemType> using UpDownC = UpDownConversion<VectorEntryType, typename std::decay<MemType>::type>;
+
+    VectorType  data() const { return static_cast<const Parent *>(this)->data(); }
+    VectorType &data()       { return static_cast<      Parent *>(this)->data(); }
+
+public:
+    template <typename U,
+              typename Flags = DefaultStoreTag,
+              typename std::enable_if<std::is_arithmetic<U>::value, int>::type = 0>
+    Vc_INTRINSIC_L void store(U *mem, Flags = Flags()) const Vc_INTRINSIC_R;
+    template <typename U,
+              typename Flags = DefaultStoreTag,
+              typename std::enable_if<std::is_arithmetic<U>::value, int>::type = 0>
+    Vc_INTRINSIC_L void store(U *mem, Mask mask, Flags = Flags()) const Vc_INTRINSIC_R;
+    // the following store overloads are here to support classes that have a cast operator to EntryType.
+    // Without this overload GCC complains about not finding a matching store function.
+    Vc_INTRINSIC void store(EntryType *mem) const
+    {
+        store<EntryType, DefaultStoreTag>(mem);
+    }
+    template <typename Flags> Vc_INTRINSIC void store(EntryType *mem, Flags flags) const
+    {
+        store<EntryType, Flags>(mem, flags);
+    }
+    Vc_INTRINSIC void store(EntryType *mem, Mask mask) const
+    {
+        store<EntryType, DefaultStoreTag>(mem, mask);
+    }
+    template <typename Flags> Vc_INTRINSIC void store(EntryType *mem, Mask mask, Flags flags) const
+    {
+        store<EntryType, Flags>(mem, mask, flags);
+    }
+
+    inline void store(VectorEntryType *mem, decltype(Streaming)) const;
+};
+
+}  // namespace MIC
+}  // namespace Vc
+#endif // VC_MIC_STOREMIXIN_H_
diff -Nru vc-0.7.4/mic/types.h vc-1.3.0/mic/types.h
--- vc-0.7.4/mic/types.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/types.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,79 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "../scalar/types.h"
+
+#ifndef VC_MIC_TYPES_H_
+#define VC_MIC_TYPES_H_
+
+#ifdef Vc_DEFAULT_IMPL_MIC
+#define Vc_DOUBLE_V_SIZE 8
+#define Vc_FLOAT_V_SIZE 16
+#define Vc_INT_V_SIZE 16
+#define Vc_UINT_V_SIZE 16
+#define Vc_SHORT_V_SIZE 16
+#define Vc_USHORT_V_SIZE 16
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+template <typename T> using Vector = Vc::Vector<T, VectorAbi::Mic>;
+typedef Vector<double>         double_v;
+typedef Vector<float>           float_v;
+typedef Vector<int>               int_v;
+typedef Vector<unsigned int>     uint_v;
+typedef Vector<short>           short_v;
+typedef Vector<unsigned short> ushort_v;
+typedef Vector<schar>           schar_v;
+typedef Vector<uchar>           uchar_v;
+
+template <typename T> using Mask = Vc::Mask<T, VectorAbi::Mic>;
+typedef Mask<double>         double_m;
+typedef Mask<float>           float_m;
+typedef Mask<int>               int_m;
+typedef Mask<unsigned int>     uint_m;
+typedef Mask<short>           short_m;
+typedef Mask<unsigned short> ushort_m;
+typedef Mask<schar>           schar_m;
+typedef Mask<uchar>           uchar_m;
+
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace MIC
+
+namespace Traits
+{
+template <typename T> struct is_simd_mask_internal<MIC::Mask<T>> : public std::true_type {};
+template <typename T> struct is_simd_vector_internal<MIC::Vector<T>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace Vc
+
+#endif // VC_MIC_TYPES_H_
diff -Nru vc-0.7.4/mic/type_traits.h vc-1.3.0/mic/type_traits.h
--- vc-0.7.4/mic/type_traits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/type_traits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_TYPE_TRAITS_H_
+#define VC_MIC_TYPE_TRAITS_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+namespace Traits
+{
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace MIC
+}  // namespace Vc
+
+#endif  // VC_MIC_TYPE_TRAITS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/vector.h vc-1.3.0/mic/vector.h
--- vc-0.7.4/mic/vector.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,484 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_VECTOR_H_
+#define VC_MIC_VECTOR_H_
+
+#ifdef CAN_OFFLOAD
+#pragma offload_attribute(push, target(mic))
+#endif
+
+#include "types.h"
+#include "intrinsics.h"
+#include "casts.h"
+#include "../common/storage.h"
+#include "mask.h"
+#include "storemixin.h"
+//#include "vectormultiplication.h"
+#include "writemaskedvector.h"
+#include "sorthelper.h"
+#include "../common/where.h"
+#include "macros.h"
+
+#ifdef isfinite
+#undef isfinite
+#endif
+#ifdef isnan
+#undef isnan
+#endif
+
+#define Vc_HAVE_FMA
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#define Vc_CURRENT_CLASS_NAME Vector
+template <typename T>
+class Vector<T, VectorAbi::Mic> : public MIC::StoreMixin<MIC::Vector<T>, T>
+{
+    static_assert(std::is_arithmetic<T>::value,
+                  "Vector<T> only accepts arithmetic builtin types as template parameter T.");
+
+public:
+    using abi = VectorAbi::Mic;
+
+private:
+    //friend class VectorMultiplication<T>;
+    friend class MIC::WriteMaskedVector<T>;
+    //friend Vector<T> operator+<>(const Vector<T> &x, const VectorMultiplication<T> &y);
+    //friend Vector<T> operator-<>(const Vector<T> &x, const VectorMultiplication<T> &y);
+    friend class Vector<float, abi>;
+    friend class Vector<double, abi>;
+    friend class Vector<int, abi>;
+    friend class Vector<unsigned int, abi>;
+    friend class MIC::StoreMixin<Vector, T>;
+
+public:
+    Vc_FREE_STORE_OPERATORS_ALIGNED(64);
+    typedef typename MIC::VectorTypeHelper<T>::Type VectorType;
+    using vector_type = VectorType;
+    Vc_ALIGNED_TYPEDEF(sizeof(T), T, EntryType);
+    using value_type = EntryType;
+    typedef typename MIC::DetermineVectorEntryType<T>::Type VectorEntryType;
+    static constexpr size_t Size = sizeof(VectorType) / sizeof(VectorEntryType);
+    static constexpr size_t MemoryAlignment = sizeof(EntryType) * Size;
+    enum Constants {
+        HasVectorDivision = true
+    };
+    typedef MIC::Mask<T> Mask;
+    using MaskType = Mask;
+    using mask_type = Mask;
+    typedef typename Mask::AsArg MaskArgument;
+    typedef Vector<T> AsArg; // for now only ICC can compile this code and it is not broken :)
+    typedef VectorType VectorTypeArg;
+    using reference = Detail::ElementReference<Vector>;
+
+    inline const VectorType &data() const { return d.v(); }
+    inline VectorType &data() { return d.v(); }
+
+protected:
+    typedef Common::VectorMemoryUnion<VectorType, VectorEntryType> StorageType;
+    StorageType d;
+    Vc_DEPRECATED("renamed to data()") inline const VectorType vdata() const { return d.v(); }
+
+    template <typename V> static Vc_INTRINSIC VectorType _cast(V x)
+    {
+        return MIC::mic_cast<VectorType>(x);
+    }
+
+public:
+    template <typename MemType>
+    using UpDownC =
+        MIC::UpDownConversion<VectorEntryType, typename std::decay<MemType>::type>;
+
+    /**
+     * Reinterpret some array of T as a vector of T. You may only do this if the pointer is
+     * aligned correctly and the content of the memory isn't changed from somewhere else because
+     * the load operation will happen implicitly at some later point(s).
+     */
+    static inline Vector fromMemory(T *mem) {
+        assert(0 == (mem & (VectorAlignment - 1)));
+        return reinterpret_cast<Vector<T> >(mem);
+    }
+
+#include "../common/generalinterface.h"
+    using IndexType = SimdArray<int, Size>;
+
+    static Vector Random();
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // internal: required to enable returning objects of VectorType
+    Vc_INTRINSIC Vector(VectorType x) : d(x) {}
+
+    // implict conversion from compatible Vector<U>
+    template <typename U>
+    Vc_INTRINSIC Vector(
+        Vector<U> x,
+        typename std::enable_if<Traits::is_implicit_cast_allowed<U, T>::value,
+                                void *>::type = nullptr)
+        : d(MIC::convert<U, T>(x.data()))
+    {
+    }
+
+#if Vc_IS_VERSION_1
+    // static_cast from the remaining Vector<U>
+    template <typename U>
+    Vc_DEPRECATED("use simd_cast instead of explicit type casting to "
+                  "convert between vector types") Vc_INTRINSIC
+        explicit Vector(
+            Vector<U> x,
+            typename std::enable_if<!Traits::is_implicit_cast_allowed<U, T>::value,
+                                    void *>::type = nullptr)
+        : d(MIC::convert<U, T>(x.data()))
+    {
+    }
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // broadcast
+    Vc_INTRINSIC Vector(EntryType a) : d(MIC::_set1(a)) {}
+    template <typename U>
+    Vc_INTRINSIC Vector(
+        U a,
+        typename std::enable_if<std::is_same<U, int>::value && !std::is_same<U, EntryType>::value,
+                                void *>::type = nullptr)
+        : Vector(static_cast<EntryType>(a))
+        {
+        }
+
+#include "../common/loadinterface.h"
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // zeroing
+    inline void setZero();
+    inline void setZero(MaskArgument k);
+    inline void setZeroInverted(MaskArgument k);
+
+    inline void setQnan();
+    inline void setQnan(MaskArgument k);
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // stores in StoreMixin
+
+#include "../common/gatherinterface.h"
+#include "../common/scatterinterface.h"
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    //prefix
+    Vc_ALWAYS_INLINE Vector &operator++()
+    {
+        d.v() = MIC::_add<VectorEntryType>(d.v(), Detail::one(EntryType()));
+        return *this;
+    }
+    //postfix
+    Vc_ALWAYS_INLINE Vector operator++(int)
+    {
+        const Vector<T> r = *this;
+        d.v() = MIC::_add<VectorEntryType>(d.v(), Detail::one(EntryType()));
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // aliasing scalar access
+private:
+    friend reference;
+    Vc_INTRINSIC static value_type get(const Vector &o, int i) noexcept
+    {
+        return o.d.m(i);
+    }
+    template <typename U>
+    Vc_INTRINSIC static void set(Vector &o, int i, U &&v) noexcept(
+        noexcept(std::declval<value_type &>() = v))
+    {
+        return o.d.set(i, v);
+    }
+
+public:
+    Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+    {
+        static_assert(noexcept(reference{std::declval<Vector &>(), int()}), "");
+        return {*this, int(index)};
+    }
+    Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept
+    {
+        return d.m(index);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // unary operators
+    Vc_INTRINSIC Vc_PURE Mask operator!() const
+    {
+        return *this == Zero();
+    }
+    Vc_PURE Vc_ALWAYS_INLINE Vc_FLATTEN Vector operator~() const
+    {
+#ifndef Vc_ENABLE_FLOAT_BIT_OPERATORS
+        static_assert(std::is_integral<T>::value,
+                      "bit-complement can only be used with Vectors of integral type");
+#endif
+        return MIC::_andnot(d.v(), MIC::allone<VectorType>());
+    }
+    Vc_PURE_L Vc_ALWAYS_INLINE_L Vector operator-() const Vc_PURE_R Vc_ALWAYS_INLINE_R;
+    Vc_PURE Vc_ALWAYS_INLINE Vc_FLATTEN Vector operator+() const { return *this; }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // binary operators
+    Vc_ALWAYS_INLINE_L Vector &operator<<=(AsArg x) Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector &operator>>=(AsArg x) Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector  operator<< (AsArg x) const Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector  operator>> (AsArg x) const Vc_ALWAYS_INLINE_R;
+
+    Vc_ALWAYS_INLINE_L Vector &operator<<=(unsigned int x) Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector &operator>>=(unsigned int x) Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector  operator<< (unsigned int x) const Vc_ALWAYS_INLINE_R;
+    Vc_ALWAYS_INLINE_L Vector  operator>> (unsigned int x) const Vc_ALWAYS_INLINE_R;
+
+    Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC Vc_PURE Mask
+        isNegative() const
+    {
+        return Vc::isnegative(*this);
+    }
+
+    Vc_INTRINSIC_L void assign(Vector<T> v, Mask mask) Vc_INTRINSIC_R;
+
+    template <typename V2>
+    Vc_DEPRECATED("Use simd_cast instead of Vector::staticCast") Vc_INTRINSIC V2
+        staticCast() const
+    {
+        return V2(*this);
+    }
+    template <typename V2>
+    Vc_DEPRECATED("use reinterpret_components_cast instead") Vc_INTRINSIC V2
+        reinterpretCast() const
+    {
+        return MIC::mic_cast<typename V2::VectorType>(d.v());
+    }
+
+    Vc_ALWAYS_INLINE MIC::WriteMaskedVector<T> operator()(MaskArgument k)
+    {
+        return MIC::WriteMaskedVector<T>(*this, k);
+    }
+
+    Vc_ALWAYS_INLINE EntryType min() const { return Detail::min(d.v(), EntryType()); }
+    Vc_ALWAYS_INLINE EntryType max() const { return Detail::max(d.v(), EntryType()); }
+    Vc_ALWAYS_INLINE EntryType product() const { return Detail::mul(d.v(), EntryType()); }
+    Vc_ALWAYS_INLINE EntryType sum() const { return Detail::add(d.v(), EntryType()); }
+    Vc_ALWAYS_INLINE_L Vector partialSum() const Vc_ALWAYS_INLINE_R;
+    inline EntryType min(MaskArgument m) const;
+    inline EntryType max(MaskArgument m) const;
+    inline EntryType product(MaskArgument m) const;
+    inline EntryType sum(MaskArgument m) const;
+
+    Vc_INTRINSIC_L Vector shifted(int amount, Vector shiftIn) const Vc_INTRINSIC_R;
+    Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R;
+    Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R;
+    Vc_INTRINSIC_L Vc_PURE_L Vector reversed() const Vc_INTRINSIC_R Vc_PURE_R;
+    Vc_INTRINSIC Vector sorted() const { return MIC::SortHelper<T>::sort(d.v()); }
+
+    template<typename F> void callWithValuesSorted(F &f) {
+        EntryType value = d.m(0);
+        f(value);
+        for (int i = 1; i < Size; ++i) {
+            if (EntryType(d.m(i)) != value) {
+                value = d.m(i);
+                f(value);
+            }
+        }
+    }
+
+    template<typename F> Vc_INTRINSIC void call(F &&f) const {
+        Common::for_all_vector_entries<Size>([&](size_t i) { f(EntryType(d.m(i))); });
+    }
+
+    template<typename F> Vc_INTRINSIC void call(F &&f, const Mask &mask) const {
+        for (size_t i : where(mask)) {
+            f(EntryType(d.m(i)));
+        }
+    }
+
+    template<typename F> Vc_INTRINSIC Vector<T> apply(F &&f) const {
+        Vector<T> r;
+        Common::for_all_vector_entries<Size>(
+            [&](size_t i) { r.d.set(i, f(EntryType(d.m(i)))); });
+        return r;
+    }
+
+    template<typename F> Vc_INTRINSIC Vector<T> apply(F &&f, const Mask &mask) const {
+        Vector<T> r(*this);
+        for (size_t i : where(mask)) {
+            r.d.set(i, f(EntryType(r.d.m(i))));
+        }
+        return r;
+    }
+
+    template<typename IndexT> Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {
+        Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f(i)); });
+    }
+    Vc_INTRINSIC void fill(EntryType (&f)()) {
+        Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f()); });
+    }
+
+    template <typename G> static Vc_INTRINSIC Vector generate(G gen)
+    {
+        Vector r;
+        Common::unrolled_loop<std::size_t, 0, Size>([&](std::size_t i) {
+            r.d.set(i, gen(i));
+        });
+        return r;
+    }
+
+    Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC Vector
+        copySign(AsArg reference) const
+    {
+        return Vc::copysign(*this, reference);
+    }
+    Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC Vector exponent() const
+    {
+        return Vc::exponent(*this);
+    }
+
+    Vc_INTRINSIC_L Vector interleaveLow(Vector x) const Vc_INTRINSIC_R;
+    Vc_INTRINSIC_L Vector interleaveHigh(Vector x) const Vc_INTRINSIC_R;
+};
+#undef Vc_CURRENT_CLASS_NAME
+template <typename T> constexpr size_t Vector<T, VectorAbi::Mic>::Size;
+template <typename T> constexpr size_t Vector<T, VectorAbi::Mic>::MemoryAlignment;
+
+Vc_INTRINSIC MIC::int_v    min(const MIC::int_v    &x, const MIC::int_v    &y) { return _mm512_min_epi32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::uint_v   min(const MIC::uint_v   &x, const MIC::uint_v   &y) { return _mm512_min_epu32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::short_v  min(const MIC::short_v  &x, const MIC::short_v  &y) { return _mm512_min_epi32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::ushort_v min(const MIC::ushort_v &x, const MIC::ushort_v &y) { return _mm512_min_epu32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::float_v  min(const MIC::float_v  &x, const MIC::float_v  &y) { return _mm512_min_ps   (x.data(), y.data()); }
+Vc_INTRINSIC MIC::double_v min(const MIC::double_v &x, const MIC::double_v &y) { return _mm512_min_pd   (x.data(), y.data()); }
+Vc_INTRINSIC MIC::int_v    max(const MIC::int_v    &x, const MIC::int_v    &y) { return _mm512_max_epi32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::uint_v   max(const MIC::uint_v   &x, const MIC::uint_v   &y) { return _mm512_max_epu32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::short_v  max(const MIC::short_v  &x, const MIC::short_v  &y) { return _mm512_max_epi32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::ushort_v max(const MIC::ushort_v &x, const MIC::ushort_v &y) { return _mm512_max_epu32(x.data(), y.data()); }
+Vc_INTRINSIC MIC::float_v  max(const MIC::float_v  &x, const MIC::float_v  &y) { return _mm512_max_ps   (x.data(), y.data()); }
+Vc_INTRINSIC MIC::double_v max(const MIC::double_v &x, const MIC::double_v &y) { return _mm512_max_pd   (x.data(), y.data()); }
+
+Vc_ALWAYS_INLINE MIC::double_v atan2(MIC::double_v x, MIC::double_v y)
+{
+    return _mm512_atan2_pd(x.data(), y.data());
+}
+Vc_ALWAYS_INLINE MIC::float_v atan2(MIC::float_v x, MIC::float_v y)
+{
+    return _mm512_atan2_ps(x.data(), y.data());
+}
+
+template <typename T>
+Vc_ALWAYS_INLINE Vc_CONST enable_if<std::is_signed<T>::value, MIC::Vector<T>> abs(
+    MIC::Vector<T> x)
+{
+    return Detail::abs(x.data(), T());
+}
+
+#define Vc_MATH_OP1(name_, call_)                                                        \
+    Vc_ALWAYS_INLINE MIC::double_v name_(MIC::double_v x)                                \
+    {                                                                                    \
+        return _mm512_##call_##_pd(x.data());                                            \
+    }                                                                                    \
+    Vc_ALWAYS_INLINE MIC::float_v name_(MIC::float_v x)                                  \
+    {                                                                                    \
+        return _mm512_##call_##_ps(x.data());                                            \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+    Vc_MATH_OP1(sqrt, sqrt);
+    Vc_MATH_OP1(rsqrt, rsqrt);
+    Vc_MATH_OP1(sin, sin);
+    Vc_MATH_OP1(cos, cos);
+    Vc_MATH_OP1(log, log);
+    Vc_MATH_OP1(log2, log2);
+    Vc_MATH_OP1(log10, log10);
+    Vc_MATH_OP1(atan, atan);
+    Vc_MATH_OP1(reciprocal, recip);
+    Vc_MATH_OP1(asin, asin);
+    Vc_MATH_OP1(floor, floor);
+    Vc_MATH_OP1(ceil, ceil);
+    Vc_MATH_OP1(exp, exp);
+#undef Vc_MATH_OP1
+    Vc_ALWAYS_INLINE MIC::double_v round(MIC::double_v x)
+    {
+        return _mm512_roundfxpnt_adjust_pd(x.data(), _MM_FROUND_TO_NEAREST_INT,
+                                           _MM_EXPADJ_NONE);
+    }
+    Vc_ALWAYS_INLINE MIC::float_v round(MIC::float_v x)
+    {
+        return _mm512_round_ps(x.data(), _MM_FROUND_TO_NEAREST_INT, _MM_EXPADJ_NONE);
+    }
+    template <typename T> Vc_ALWAYS_INLINE MIC::Vector<T> round(MIC::Vector<T> x)
+    {
+        return x;
+    }
+
+    template<typename T> static inline void sincos(const Vector<T> &x, Vector<T> *s, Vector<T> *c) {
+        *s = sin(x);
+        *c = cos(x);
+    }
+
+#define Vc_CONDITIONAL_ASSIGN(name_, op_)                                                \
+    template <Operator O, typename T, typename M, typename U>                            \
+    Vc_INTRINSIC enable_if<O == Operator::name_, void> conditional_assign(               \
+        Vector<T> &lhs, M &&mask, U &&rhs)                                               \
+    {                                                                                    \
+        lhs(mask) op_ rhs;                                                               \
+    }
+Vc_CONDITIONAL_ASSIGN(          Assign,  =)
+Vc_CONDITIONAL_ASSIGN(      PlusAssign, +=)
+Vc_CONDITIONAL_ASSIGN(     MinusAssign, -=)
+Vc_CONDITIONAL_ASSIGN(  MultiplyAssign, *=)
+Vc_CONDITIONAL_ASSIGN(    DivideAssign, /=)
+Vc_CONDITIONAL_ASSIGN( RemainderAssign, %=)
+Vc_CONDITIONAL_ASSIGN(       XorAssign, ^=)
+Vc_CONDITIONAL_ASSIGN(       AndAssign, &=)
+Vc_CONDITIONAL_ASSIGN(        OrAssign, |=)
+Vc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=)
+Vc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=)
+#undef Vc_CONDITIONAL_ASSIGN
+
+#define Vc_CONDITIONAL_ASSIGN(name_, expr_)                                              \
+    template <Operator O, typename T, typename M>                                        \
+    Vc_INTRINSIC enable_if<O == Operator::name_, Vector<T>> conditional_assign(          \
+        Vector<T> &lhs, M &&mask)                                                        \
+    {                                                                                    \
+        return expr_;                                                                    \
+    }
+Vc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++)
+Vc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask))
+Vc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--)
+Vc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask))
+#undef Vc_CONDITIONAL_ASSIGN
+
+} // namespace Vc
+
+#include "vector.tcc"
+#include "simd_cast.h"
+
+#ifdef CAN_OFFLOAD
+#pragma offload_attribute(pop)
+#endif
+
+#endif // VC_MIC_VECTOR_H_
diff -Nru vc-0.7.4/mic/vector.tcc vc-1.3.0/mic/vector.tcc
--- vc-0.7.4/mic/vector.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/vector.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,949 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <type_traits>
+#include "../common/x86_prefetches.h"
+#include "interleaveimpl.h"
+#include "debug.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+// bitwise operators {{{1
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator^(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return xor_(a.data(), b.data());
+}
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator&(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return and_(a.data(), b.data());
+}
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator|(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return or_(a.data(), b.data());
+}
+
+// compare operators {{{1
+Vc_INTRINSIC MIC::double_m operator==(MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_EQ_OQ); }
+Vc_INTRINSIC MIC:: float_m operator==(MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_EQ_OQ); }
+Vc_INTRINSIC MIC::   int_m operator==(MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_EQ); }
+Vc_INTRINSIC MIC::  uint_m operator==(MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_EQ); }
+Vc_INTRINSIC MIC:: short_m operator==(MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_EQ); }
+
+Vc_INTRINSIC MIC::double_m operator!=(MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_NEQ_UQ); }
+Vc_INTRINSIC MIC:: float_m operator!=(MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_NEQ_UQ); }
+Vc_INTRINSIC MIC::   int_m operator!=(MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NE); }
+Vc_INTRINSIC MIC::  uint_m operator!=(MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_NE); }
+Vc_INTRINSIC MIC:: short_m operator!=(MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NE); }
+
+Vc_INTRINSIC MIC::double_m operator>=(MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_NLT_US); }
+Vc_INTRINSIC MIC:: float_m operator>=(MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_NLT_US); }
+Vc_INTRINSIC MIC::   int_m operator>=(MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NLT); }
+Vc_INTRINSIC MIC::  uint_m operator>=(MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_NLT); }
+Vc_INTRINSIC MIC:: short_m operator>=(MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NLT); }
+
+Vc_INTRINSIC MIC::double_m operator<=(MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_LE_OS); }
+Vc_INTRINSIC MIC:: float_m operator<=(MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_LE_OS); }
+Vc_INTRINSIC MIC::   int_m operator<=(MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_LE); }
+Vc_INTRINSIC MIC::  uint_m operator<=(MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_LE); }
+Vc_INTRINSIC MIC:: short_m operator<=(MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_LE); }
+
+Vc_INTRINSIC MIC::double_m operator> (MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_NLE_US); }
+Vc_INTRINSIC MIC:: float_m operator> (MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_NLE_US); }
+Vc_INTRINSIC MIC::   int_m operator> (MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NLE); }
+Vc_INTRINSIC MIC::  uint_m operator> (MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_NLE); }
+Vc_INTRINSIC MIC:: short_m operator> (MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_NLE); }
+
+Vc_INTRINSIC MIC::double_m operator< (MIC::double_v a, MIC::double_v b) { return _mm512_cmp_pd_mask(a.data(), b.data(), _CMP_LT_OS); }
+Vc_INTRINSIC MIC:: float_m operator< (MIC:: float_v a, MIC:: float_v b) { return _mm512_cmp_ps_mask(a.data(), b.data(), _CMP_LT_OS); }
+Vc_INTRINSIC MIC::   int_m operator< (MIC::   int_v a, MIC::   int_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_LT); }
+Vc_INTRINSIC MIC::  uint_m operator< (MIC::  uint_v a, MIC::  uint_v b) { return _mm512_cmp_epu32_mask(a.data(), b.data(), _MM_CMPINT_LT); }
+Vc_INTRINSIC MIC:: short_m operator< (MIC:: short_v a, MIC:: short_v b) { return _mm512_cmp_epi32_mask(a.data(), b.data(), _MM_CMPINT_LT); }
+
+// only unsigned integers have well-defined behavior on over-/underflow
+Vc_INTRINSIC MIC::ushort_m operator==(MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmpeq_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+Vc_INTRINSIC MIC::ushort_m operator!=(MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmpneq_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+Vc_INTRINSIC MIC::ushort_m operator>=(MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmpge_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+Vc_INTRINSIC MIC::ushort_m operator<=(MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmple_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+Vc_INTRINSIC MIC::ushort_m operator> (MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmpgt_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+Vc_INTRINSIC MIC::ushort_m operator< (MIC::ushort_v a, MIC::ushort_v b) { return _mm512_cmplt_epu32_mask(and_(a.data(), MIC::_set1(0xffff)), and_(b.data(), MIC::_set1(0xffff))); }
+
+// only unsigned integers have well-defined behavior on over-/underflow
+Vc_INTRINSIC MIC::uchar_m operator==(MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmpeq_epu32_mask (and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+Vc_INTRINSIC MIC::uchar_m operator!=(MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmpneq_epu32_mask(and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+Vc_INTRINSIC MIC::uchar_m operator>=(MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmpge_epu32_mask (and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+Vc_INTRINSIC MIC::uchar_m operator> (MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmpgt_epu32_mask (and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+Vc_INTRINSIC MIC::uchar_m operator<=(MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmple_epu32_mask (and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+Vc_INTRINSIC MIC::uchar_m operator< (MIC::uchar_v a, MIC::uchar_v b) { return _mm512_cmplt_epu32_mask (and_(a.data(), MIC::_set1(0xff)), and_(b.data(), MIC::_set1(0xff))); }
+
+// arithmetic operators {{{1
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator+(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return add(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator-(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return sub(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator*(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return mul(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC MIC::Vector<T> operator/(MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return div(a.data(), b.data(), T());
+}
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_integral<T>::value, MIC::Vector<T>> operator%(
+    MIC::Vector<T> a, MIC::Vector<T> b)
+{
+    return rem(a.data(), b.data(), T());
+    //return a - a / b * b;
+}
+// }}}1
+}  // namespace Detail
+
+// LoadHelper {{{1
+namespace
+{
+
+template<typename V, typename T> struct LoadHelper2;
+
+template<typename V> struct LoadHelper/*{{{*/
+{
+    typedef typename V::VectorType VectorType;
+
+    static Vc_INTRINSIC VectorType _load(const void *m, _MM_UPCONV_PS_ENUM upconv, int memHint) {
+        return _mm512_extload_ps(m, upconv, _MM_BROADCAST32_NONE, memHint);
+    }
+    static Vc_INTRINSIC VectorType _load(const void *m, _MM_UPCONV_PD_ENUM upconv, int memHint) {
+        return _mm512_extload_pd(m, upconv, _MM_BROADCAST64_NONE, memHint);
+    }
+    static Vc_INTRINSIC VectorType _load(const void *m, _MM_UPCONV_EPI32_ENUM upconv, int memHint) {
+        return _mm512_extload_epi32(m, upconv, _MM_BROADCAST32_NONE, memHint);
+    }
+
+    static Vc_INTRINSIC VectorType _loadu(const void *m, _MM_UPCONV_PS_ENUM upconv, int memHint) {
+        return MIC::mm512_loadu_ps(m, upconv, memHint);
+    }
+    static Vc_INTRINSIC VectorType _loadu(const void *m, _MM_UPCONV_PD_ENUM upconv, int memHint) {
+        return MIC::mm512_loadu_pd(m, upconv, memHint);
+    }
+    static Vc_INTRINSIC VectorType _loadu(const void *m, _MM_UPCONV_EPI32_ENUM upconv, int memHint) {
+        return MIC::mm512_loadu_epi32(m, upconv, memHint);
+    }
+
+    template<typename T, typename Flags> static Vc_INTRINSIC VectorType load(const T *mem, Flags)
+    {
+        return LoadHelper2<V, T>::template load<Flags>(mem);
+    }
+};/*}}}*/
+
+template<typename V, typename T = typename V::VectorEntryType> struct LoadHelper2
+{
+    typedef typename V::VectorType VectorType;
+
+    template<typename Flags> static Vc_INTRINSIC VectorType genericLoad(const T *mem, typename Flags::EnableIfAligned = nullptr) {
+        return LoadHelper<V>::_load(mem, MIC::UpDownConversion<typename V::VectorEntryType, T>(), _MM_HINT_NONE);
+    }
+    template<typename Flags> static Vc_INTRINSIC VectorType genericLoad(const T *mem, typename Flags::EnableIfUnalignedNotStreaming = nullptr) {
+        return LoadHelper<V>::_loadu(mem, MIC::UpDownConversion<typename V::VectorEntryType, T>(), _MM_HINT_NONE);
+    }
+    template<typename Flags> static Vc_INTRINSIC VectorType genericLoad(const T *mem, typename Flags::EnableIfStreaming = nullptr) {
+        return LoadHelper<V>::_load(mem, MIC::UpDownConversion<typename V::VectorEntryType, T>(), _MM_HINT_NT);
+    }
+    template<typename Flags> static Vc_INTRINSIC VectorType genericLoad(const T *mem, typename Flags::EnableIfUnalignedAndStreaming = nullptr) {
+        return LoadHelper<V>::_loadu(mem, MIC::UpDownConversion<typename V::VectorEntryType, T>(), _MM_HINT_NT);
+    }
+
+    template<typename Flags> static Vc_INTRINSIC VectorType load(const T *mem) {
+        return genericLoad<Flags>(mem);
+    }
+};
+
+template<> template<typename Flags> Vc_INTRINSIC __m512 LoadHelper2<MIC::float_v, double>::load(const double *mem)
+{
+    return MIC::mic_cast<__m512>(_mm512_mask_permute4f128_epi32(MIC::mic_cast<__m512i>(
+                    _mm512_cvt_roundpd_pslo(LoadHelper<MIC::double_v>::load(&mem[0], Flags()), _MM_FROUND_CUR_DIRECTION)),
+                0xff00, MIC::mic_cast<__m512i>(
+                    _mm512_cvt_roundpd_pslo(LoadHelper<MIC::double_v>::load(&mem[MIC::double_v::Size], Flags()), _MM_FROUND_CUR_DIRECTION)),
+                _MM_PERM_BABA));
+}
+template<> template<typename Flags> Vc_INTRINSIC __m512 LoadHelper2<MIC::float_v, int>::load(const int *mem)
+{
+    return MIC::convert<int, float>(LoadHelper<MIC::int_v>::load(mem, Flags()));
+}
+template<> template<typename Flags> Vc_INTRINSIC __m512 LoadHelper2<MIC::float_v, unsigned int>::load(const unsigned int *mem)
+{
+    return MIC::convert<unsigned int, float>(LoadHelper<MIC::uint_v>::load(mem, Flags()));
+}
+
+} // anonymous namespace
+
+// constants {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic>::Vector(VectorSpecialInitializerZero)
+    : d(Detail::zero<VectorType>())
+{
+}
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic>::Vector(VectorSpecialInitializerOne)
+    : d(Detail::one(EntryType()))
+{
+}
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic>::Vector(
+    VectorSpecialInitializerIndexesFromZero)
+    : d(LoadHelper<Vector<T, VectorAbi::Mic>>::load(MIC::IndexesFromZeroHelper<T>(),
+                                                    Aligned))
+{
+}
+
+template <>
+Vc_ALWAYS_INLINE MIC::float_v::Vector(VectorSpecialInitializerIndexesFromZero)
+    : d(_mm512_extload_ps(&MIC::_IndexesFromZero, _MM_UPCONV_PS_SINT8,
+                          _MM_BROADCAST32_NONE, _MM_HINT_NONE))
+{
+}
+
+template <>
+Vc_ALWAYS_INLINE MIC::double_v::Vector(VectorSpecialInitializerIndexesFromZero)
+    : d(MIC::convert<int, double>(MIC::int_v::IndexesFromZero().data()))
+{
+}
+
+// loads {{{1
+template <typename T>
+template <typename U, typename Flags>
+Vc_INTRINSIC typename Vector<T, VectorAbi::Mic>::template load_concept<U, Flags>::type
+Vector<T, VectorAbi::Mic>::load(const U *x, Flags flags)
+{
+    Common::handleLoadPrefetches(x, flags);
+    d.v() = LoadHelper<Vector<T, VectorAbi::Mic>>::load(x, flags);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// zeroing {{{1
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::setZero()
+{
+    data() = Detail::zero<VectorType>();
+}
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::setZero(MaskArgument k)
+{
+    data() = MIC::_xor(data(), k.data(), data(), data());
+}
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::setZeroInverted(MaskArgument k)
+{
+    data() = MIC::_xor(data(), (!k).data(), data(), data());
+}
+
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::setQnan()
+{
+    data() = MIC::allone<VectorType>();
+}
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::setQnan(MaskArgument k)
+{
+    data() = MIC::mask_mov(data(), k.data(), MIC::allone<VectorType>());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// assign {{{1
+template<> Vc_INTRINSIC void MIC::double_v::assign(MIC::double_v v, MIC::double_m m)
+{
+    d.v() = _mm512_mask_mov_pd(d.v(), m.data(), v.d.v());
+}
+template<> Vc_INTRINSIC void MIC::float_v::assign(MIC::float_v v, MIC::float_m m)
+{
+    d.v() = _mm512_mask_mov_ps(d.v(), m.data(), v.d.v());
+}
+template<> Vc_INTRINSIC void MIC::int_v::assign(MIC::int_v v, MIC::int_m m)
+{
+    d.v() = _mm512_mask_mov_epi32(d.v(), m.data(), v.d.v());
+}
+template<> Vc_INTRINSIC void MIC::uint_v::assign(MIC::uint_v v, MIC::uint_m m)
+{
+    d.v() = _mm512_mask_mov_epi32(d.v(), m.data(), v.d.v());
+}
+template<> Vc_INTRINSIC void MIC::short_v::assign(MIC::short_v v, MIC::short_m m)
+{
+    d.v() = _mm512_mask_mov_epi32(d.v(), m.data(), v.d.v());
+}
+template<> Vc_INTRINSIC void MIC::ushort_v::assign(MIC::ushort_v v, MIC::ushort_m m)
+{
+    d.v() = _mm512_mask_mov_epi32(d.v(), m.data(), v.d.v());
+}
+// stores {{{1
+template <typename V> Vc_INTRINSIC V foldAfterOverflow(V vector)
+{
+    return vector;
+}
+Vc_INTRINSIC MIC::ushort_v foldAfterOverflow(MIC::ushort_v vector)
+{
+    using Detail::operator&;
+    return vector & MIC::ushort_v(0xffffu);
+}
+
+namespace MIC
+{
+template <typename Parent, typename T>
+template <typename U,
+          typename Flags,
+          typename std::enable_if<std::is_arithmetic<U>::value, int>::type>
+Vc_INTRINSIC void StoreMixin<Parent, T>::store(U *mem, Flags flags) const
+{
+    Common::handleStorePrefetches(mem, flags);
+    MicIntrinsics::store<Flags>(mem, foldAfterOverflow(*static_cast<const Parent *>(this)).data(), UpDownC<U>());
+}
+}  // namespace MIC
+
+constexpr int alignrCount(int rotationStride, int offset)
+{
+    return 16 - (rotationStride * offset > 16 ? 16 : rotationStride * offset);
+}
+
+template<int rotationStride>
+inline __m512i rotationHelper(__m512i v, int offset, std::integral_constant<int, rotationStride>)
+{
+    switch (offset) {
+    case  1: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  1));
+    case  2: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  2));
+    case  3: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  3));
+    case  4: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  4));
+    case  5: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  5));
+    case  6: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  6));
+    case  7: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  7));
+    case  8: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  8));
+    case  9: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride,  9));
+    case 10: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 10));
+    case 11: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 11));
+    case 12: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 12));
+    case 13: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 13));
+    case 14: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 14));
+    case 15: return _mm512_alignr_epi32(v, v, alignrCount(rotationStride, 15));
+    default: return v;
+    }
+}
+
+template <typename V,
+          typename Mem,
+          typename Mask,
+          typename Flags,
+          typename Flags::EnableIfUnaligned = nullptr>
+inline void storeDispatch(V vector, Mem *address, Mask mask, Flags flags)
+{
+    constexpr std::ptrdiff_t alignment = sizeof(Mem) * V::Size;
+    constexpr std::ptrdiff_t alignmentMask = ~(alignment - 1);
+
+    const auto loAddress = reinterpret_cast<Mem *>((reinterpret_cast<char *>(address) - static_cast<const char*>(0)) & alignmentMask);
+
+    const auto offset = address - loAddress;
+    if (offset == 0) {
+        MicIntrinsics::store<Flags::UnalignedRemoved>(mask.data(), address, vector.data(), V::template UpDownC<Mem>());
+        return;
+    }
+
+    constexpr int rotationStride = sizeof(typename V::VectorEntryType) / 4; // palignr shifts by 4 Bytes per "count"
+    auto v = rotationHelper(MIC::mic_cast<__m512i>(vector.data()), offset, std::integral_constant<int, rotationStride>());
+    auto rotated = MIC::mic_cast<typename V::VectorType>(v);
+
+    MicIntrinsics::store<Flags::UnalignedRemoved>(mask.data() << offset, loAddress, rotated, V::template UpDownC<Mem>());
+    MicIntrinsics::store<Flags::UnalignedRemoved>(mask.data() >> (V::Size - offset), loAddress + V::Size, rotated, V::template UpDownC<Mem>());
+}
+
+template <typename V,
+          typename Mem,
+          typename Mask,
+          typename Flags,
+          typename Flags::EnableIfNotUnaligned = nullptr>
+Vc_INTRINSIC void storeDispatch(V vector, Mem *address, Mask mask, Flags flags)
+{
+    MicIntrinsics::store<Flags>(mask.data(), address, vector.data(), V::template UpDownC<Mem>());
+}
+
+namespace MIC
+{
+template <typename Parent, typename T>
+template <typename U,
+          typename Flags,
+          typename std::enable_if<std::is_arithmetic<U>::value, int>::type>
+Vc_INTRINSIC void StoreMixin<Parent, T>::store(U *mem, Mask mask, Flags flags) const
+{
+    Common::handleStorePrefetches(mem, flags);
+    // MicIntrinsics::store does not exist for Flags containing Vc::Unaligned
+    storeDispatch(foldAfterOverflow(*static_cast<const Parent *>(this)), mem, mask, flags);
+}
+
+template<typename Parent, typename T> Vc_INTRINSIC void StoreMixin<Parent, T>::store(VectorEntryType *mem, decltype(Vc::Streaming)) const
+{
+    // NR = No-Read hint, NGO = Non-Globally Ordered hint
+    // It is not clear whether we will get issues with nrngo if users only expected nr
+    //_mm512_storenr_ps(mem, MIC::mic_cast<__m512>(data()));
+    _mm512_storenrngo_ps(mem, MIC::mic_cast<__m512>(data()));
+
+    // the ICC auto-vectorizer adds clevict after storenrngo, but testing shows this to be slower...
+    //_mm_clevict(mem, _MM_HINT_T1);
+}
+}  // namespace MIC
+
+// negation {{{1
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::operator-() const
+{
+    return Zero() - *this;
+}
+template<> Vc_ALWAYS_INLINE Vc_PURE MIC::double_v MIC::double_v::operator-() const
+{
+    return MIC::_xor(d.v(), MIC::mic_cast<VectorType>(MIC::_set1(0x8000000000000000ull)));
+}
+template<> Vc_ALWAYS_INLINE Vc_PURE MIC::float_v MIC::float_v::operator-() const
+{
+    return MIC::_xor(d.v(), MIC::mic_cast<VectorType>(MIC::_set1(0x80000000u)));
+}
+// horizontal ops {{{1
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::partialSum() const
+{
+    //   a    b    c    d    e    f    g    h
+    // +      a    b    c    d    e    f    g    -> a ab bc  cd   de    ef     fg      gh
+    // +           a    ab   bc   cd   de   ef   -> a ab abc abcd bcde  cdef   defg    efgh
+    // +                     a    ab   abc  abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh
+    Vector<T, VectorAbi::Mic> tmp = *this;
+    if (Size >  1) tmp += tmp.shifted(-1);
+    if (Size >  2) tmp += tmp.shifted(-2);
+    if (Size >  4) tmp += tmp.shifted(-4);
+    if (Size >  8) tmp += tmp.shifted(-8);
+    if (Size > 16) tmp += tmp.shifted(-16);
+    return tmp;
+}
+template<typename T> inline typename Vector<T, VectorAbi::Mic>::EntryType Vector<T, VectorAbi::Mic>::min(MaskArgument m) const
+{
+    return _mm512_mask_reduce_min_epi32(m.data(), data());
+}
+template<> inline float Vector<float>::min(MaskArgument m) const
+{
+    return _mm512_mask_reduce_min_ps(m.data(), data());
+}
+template<> inline double Vector<double>::min(MaskArgument m) const
+{
+    return _mm512_mask_reduce_min_pd(m.data(), data());
+}
+template<typename T> inline typename Vector<T, VectorAbi::Mic>::EntryType Vector<T, VectorAbi::Mic>::max(MaskArgument m) const
+{
+    return _mm512_mask_reduce_max_epi32(m.data(), data());
+}
+template<> inline float Vector<float>::max(MaskArgument m) const
+{
+    return _mm512_mask_reduce_max_ps(m.data(), data());
+}
+template<> inline double Vector<double>::max(MaskArgument m) const
+{
+    return _mm512_mask_reduce_max_pd(m.data(), data());
+}
+template<typename T> inline typename Vector<T, VectorAbi::Mic>::EntryType Vector<T, VectorAbi::Mic>::product(MaskArgument m) const
+{
+    return _mm512_mask_reduce_mul_epi32(m.data(), data());
+}
+template<> inline float Vector<float>::product(MaskArgument m) const
+{
+    return _mm512_mask_reduce_mul_ps(m.data(), data());
+}
+template<> inline double Vector<double>::product(MaskArgument m) const
+{
+    return _mm512_mask_reduce_mul_pd(m.data(), data());
+}
+template<typename T> inline typename Vector<T, VectorAbi::Mic>::EntryType Vector<T, VectorAbi::Mic>::sum(MaskArgument m) const
+{
+    return _mm512_mask_reduce_add_epi32(m.data(), data());
+}
+template<> inline float Vector<float>::sum(MaskArgument m) const
+{
+    return _mm512_mask_reduce_add_ps(m.data(), data());
+}
+template<> inline double Vector<double>::sum(MaskArgument m) const
+{
+    return _mm512_mask_reduce_add_pd(m.data(), data());
+}
+
+// integer ops {{{1
+template<> Vc_ALWAYS_INLINE    MIC::int_v    MIC::int_v::operator<<(   MIC::int_v::AsArg x) const { return _mm512_sllv_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE   MIC::uint_v   MIC::uint_v::operator<<(  MIC::uint_v::AsArg x) const { return _mm512_sllv_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE  MIC::short_v  MIC::short_v::operator<<( MIC::short_v::AsArg x) const { return _mm512_sllv_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE MIC::ushort_v MIC::ushort_v::operator<<(MIC::ushort_v::AsArg x) const { return _mm512_sllv_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE    MIC::int_v    MIC::int_v::operator>>(   MIC::int_v::AsArg x) const { return _mm512_srav_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE   MIC::uint_v   MIC::uint_v::operator>>(  MIC::uint_v::AsArg x) const { return _mm512_srlv_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE  MIC::short_v  MIC::short_v::operator>>( MIC::short_v::AsArg x) const { return _mm512_srav_epi32(d.v(), x.d.v()); }
+template<> Vc_ALWAYS_INLINE MIC::ushort_v MIC::ushort_v::operator>>(MIC::ushort_v::AsArg x) const { return _mm512_srlv_epi32(d.v(), x.d.v()); }
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> &Vector<T, VectorAbi::Mic>::operator<<=(AsArg x) { return *this = *this << x; }
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> &Vector<T, VectorAbi::Mic>::operator>>=(AsArg x) { return *this = *this >> x; }
+
+template<> Vc_ALWAYS_INLINE    MIC::int_v    MIC::int_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE   MIC::uint_v   MIC::uint_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::short_v  MIC::short_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE MIC::ushort_v MIC::ushort_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::schar_v  MIC::schar_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::uchar_v  MIC::uchar_v::operator<<(unsigned int x) const { return _mm512_slli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE    MIC::int_v    MIC::int_v::operator>>(unsigned int x) const { return _mm512_srai_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE   MIC::uint_v   MIC::uint_v::operator>>(unsigned int x) const { return _mm512_srli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::short_v  MIC::short_v::operator>>(unsigned int x) const { return _mm512_srai_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE MIC::ushort_v MIC::ushort_v::operator>>(unsigned int x) const { return _mm512_srli_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::schar_v  MIC::schar_v::operator>>(unsigned int x) const { return _mm512_srai_epi32(d.v(), x); }
+template<> Vc_ALWAYS_INLINE  MIC::uchar_v  MIC::uchar_v::operator>>(unsigned int x) const { return _mm512_srli_epi32(d.v(), x); }
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> &Vector<T, VectorAbi::Mic>::operator<<=(unsigned int x) { return *this = *this << x; }
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> &Vector<T, VectorAbi::Mic>::operator>>=(unsigned int x) { return *this = *this >> x; }
+
+// isnegative {{{1
+Vc_INTRINSIC Vc_CONST MIC::float_m isnegative(MIC::float_v x)
+{
+    return _mm512_cmpge_epu32_mask(MIC::mic_cast<__m512i>(x.data()),
+                                   MIC::_set1(MIC::c_general::signMaskFloat[1]));
+}
+Vc_INTRINSIC Vc_CONST MIC::double_m isnegative(MIC::double_v x)
+{
+    return _mm512_cmpge_epu32_mask(MIC::mic_cast<__m512i>(_mm512_cvtpd_pslo(x.data())),
+                                   MIC::_set1(MIC::c_general::signMaskFloat[1]));
+}
+
+// ensureVector helper {{{1
+namespace
+{
+template <typename IT>
+Vc_ALWAYS_INLINE enable_if<MIC::is_vector<IT>::value, __m512i> ensureVector(IT indexes)
+{ return indexes.data(); }
+
+template <typename IT>
+Vc_ALWAYS_INLINE enable_if<Traits::isAtomicSimdArray<IT>::value, __m512i> ensureVector(
+    IT indexes)
+{ return internal_data(indexes).data(); }
+
+template <typename IT>
+Vc_ALWAYS_INLINE
+    enable_if<(!MIC::is_vector<IT>::value && !Traits::isAtomicSimdArray<IT>::value &&
+               Traits::has_subscript_operator<IT>::value &&
+               Traits::has_contiguous_storage<IT>::value),
+              __m512i>
+    ensureVector(IT indexes)
+{
+    return MIC::int_v(std::addressof(indexes[0]), Vc::Unaligned).data();
+}
+
+Vc_ALWAYS_INLINE __m512i ensureVector(const SimdArray<int, 8> &indexes)
+{
+    return _mm512_mask_loadunpacklo_epi32(_mm512_setzero_epi32(), 0x00ff, &indexes);
+}
+
+template <typename IT>
+Vc_ALWAYS_INLINE
+    enable_if<(!MIC::is_vector<IT>::value && !Traits::isAtomicSimdArray<IT>::value &&
+               !(Traits::has_subscript_operator<IT>::value &&
+                 Traits::has_contiguous_storage<IT>::value)),
+              __m512i> ensureVector(IT) = delete;
+} // anonymous namespace
+
+// gathers {{{1
+template <typename T>
+template <typename MT, typename IT>
+Vc_INTRINSIC Vc_PURE void Vector<T, VectorAbi::Mic>::gatherImplementation(const MT *mem, IT &&indexes)
+{
+    d.v() = MicIntrinsics::gather(ensureVector(std::forward<IT>(indexes)), mem,
+                                  UpDownC<MT>());
+}
+
+template <typename T>
+template <typename MT, typename IT>
+Vc_INTRINSIC Vc_PURE void Vector<T, VectorAbi::Mic>::gatherImplementation(const MT *mem, IT &&indexes,
+                                                          MaskArgument mask)
+{
+    d.v() = MicIntrinsics::gather(
+        d.v(), mask.data(), ensureVector(std::forward<IT>(indexes)), mem, UpDownC<MT>());
+}
+
+// scatters {{{1
+template <typename T>
+template <typename MT, typename IT>
+Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::scatterImplementation(MT *mem, IT &&indexes) const
+{
+    using namespace Detail;
+    const auto v =
+        std::is_same<T, ushort>::value ? (*this & Vector(0xffff)).data() : d.v();
+    MicIntrinsics::scatter(mem, ensureVector(std::forward<IT>(indexes)), v, UpDownC<MT>(),
+                           sizeof(MT));
+}
+template <typename T>
+template <typename MT, typename IT>
+Vc_INTRINSIC void Vector<T, VectorAbi::Mic>::scatterImplementation(MT *mem, IT &&indexes,
+                                                   MaskArgument mask) const
+{
+    using namespace Detail;
+    const auto v =
+        std::is_same<T, ushort>::value ? (*this & Vector(0xffff)).data() : d.v();
+    MicIntrinsics::scatter(mask.data(), mem, ensureVector(std::forward<IT>(indexes)),
+                           d.v(), UpDownC<MT>(), sizeof(MT));
+}
+
+// exponent {{{1
+Vc_INTRINSIC Vc_CONST MIC::float_v exponent(MIC::float_v x)
+{
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return _mm512_getexp_ps(x.data());
+}
+Vc_INTRINSIC Vc_CONST MIC::double_v exponent(MIC::double_v x)
+{
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return _mm512_getexp_pd(x.data());
+}
+
+// Random {{{1
+static Vc_ALWAYS_INLINE void _doRandomStep(Vector<unsigned int> &state0,
+        Vector<unsigned int> &state1)
+{
+    using MIC::uint_v;
+    using namespace Detail;
+    state0.load(&Common::RandomState[0]);
+    state1.load(&Common::RandomState[uint_v::Size]);
+    (state1 * uint_v(0xdeece66du) + uint_v(11)).store(&Common::RandomState[uint_v::Size]);
+    uint_v(xor_((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),
+                _mm512_srli_epi32(state1.data(), 16))).store(&Common::RandomState[0]);
+}
+
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::Random()
+{
+    Vector<unsigned int> state0, state1;
+    _doRandomStep(state0, state1);
+    if (std::is_same<T, short>::value) {
+        // short and ushort vectors would hold values that are outside of their range
+        // for ushort this doesn't matter because overflow behavior is defined in the compare
+        // operators
+        return state0.reinterpretCast<Vector<T, VectorAbi::Mic>>() >> 16;
+    }
+    return state0.reinterpretCast<Vector<T, VectorAbi::Mic> >();
+}
+
+template<> Vc_ALWAYS_INLINE Vector<float> Vector<float>::Random()
+{
+    Vector<unsigned int> state0, state1;
+    _doRandomStep(state0, state1);
+    using namespace Detail;
+    return (reinterpret_components_cast<Vector<float>>(state0 >> 2) | One()) - One();
+}
+
+// _mm512_srli_epi64 is neither documented nor defined in any header, here's what it does:
+//Vc_INTRINSIC __m512i _mm512_srli_epi64(__m512i v, int n) {
+//    return _mm512_mask_mov_epi32(
+//            _mm512_srli_epi32(v, n),
+//            0x5555,
+//            _mm512_swizzle_epi32(_mm512_slli_epi32(v, 32 - n), _MM_SWIZ_REG_CDAB)
+//            );
+//}
+
+template<> Vc_ALWAYS_INLINE Vector<double> Vector<double>::Random()
+{
+    using MicIntrinsics::swizzle;
+    const auto state = LoadHelper<MIC::uint_v>::load(&Common::RandomState[0], Vc::Aligned);
+    const auto factor = MIC::_set1(0x5deece66dull);
+    _mm512_store_epi32(&Common::RandomState[0],
+            _mm512_add_epi64(
+                // the following is not _mm512_mullo_epi64, but something close...
+                _mm512_add_epi32(_mm512_mullo_epi32(state, factor), swizzle(_mm512_mulhi_epu32(state, factor), _MM_SWIZ_REG_CDAB)),
+                MIC::_set1(11ull)));
+
+    using Detail::operator|;
+    using Detail::operator-;
+    return (Vector<double>(_cast(_mm512_srli_epi64(MIC::mic_cast<__m512i>(state), 12))) | One()) - One();
+}
+// }}}1
+// shifted / rotated {{{1
+namespace
+{
+template<size_t SIMDWidth, size_t Size> struct VectorShift;
+template<> struct VectorShift<64, 8>/*{{{*/
+{
+    typedef __m512i VectorType;
+    static Vc_INTRINSIC VectorType shifted(VectorType v, int amount,
+                                           VectorType z = _mm512_setzero_epi32())
+    {
+        switch (amount) {
+        case 15: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 14);
+        case 14: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 12);
+        case 13: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 10);
+        case 12: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  8);
+        case 11: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  6);
+        case 10: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  4);
+        case  9: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  2);
+        case  8: return z;
+        case  7: return _mm512_alignr_epi32(z, v, 14);
+        case  6: return _mm512_alignr_epi32(z, v, 12);
+        case  5: return _mm512_alignr_epi32(z, v, 10);
+        case  4: return _mm512_alignr_epi32(z, v,  8);
+        case  3: return _mm512_alignr_epi32(z, v,  6);
+        case  2: return _mm512_alignr_epi32(z, v,  4);
+        case  1: return _mm512_alignr_epi32(z, v,  2);
+        case  0: return v;
+        case -1: return _mm512_alignr_epi32(v, z, 14);
+        case -2: return _mm512_alignr_epi32(v, z, 12);
+        case -3: return _mm512_alignr_epi32(v, z, 10);
+        case -4: return _mm512_alignr_epi32(v, z,  8);
+        case -5: return _mm512_alignr_epi32(v, z,  6);
+        case -6: return _mm512_alignr_epi32(v, z,  4);
+        case -7: return _mm512_alignr_epi32(v, z,  2);
+        case -8: return z;
+        case -9: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 14);
+        case-10: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 12);
+        case-11: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 10);
+        case-12: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  8);
+        case-13: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  6);
+        case-14: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  4);
+        case-15: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  2);
+        }
+        return z;
+    }
+};/*}}}*/
+template<> struct VectorShift<64, 16>/*{{{*/
+{
+    typedef __m512i VectorType;
+    static Vc_INTRINSIC VectorType shifted(VectorType v, int amount,
+                                           VectorType z = _mm512_setzero_epi32())
+    {
+        switch (amount) {
+        case 31: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 15);
+        case 30: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 14);
+        case 29: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 13);
+        case 28: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 12);
+        case 27: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 11);
+        case 26: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z, 10);
+        case 25: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  9);
+        case 24: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  8);
+        case 23: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  7);
+        case 22: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  6);
+        case 21: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  5);
+        case 20: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  4);
+        case 19: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  3);
+        case 18: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  2);
+        case 17: return _mm512_alignr_epi32(_mm512_setzero_epi32(), z,  1);
+        case 16: return z;
+        case 15: return _mm512_alignr_epi32(z, v, 15);
+        case 14: return _mm512_alignr_epi32(z, v, 14);
+        case 13: return _mm512_alignr_epi32(z, v, 13);
+        case 12: return _mm512_alignr_epi32(z, v, 12);
+        case 11: return _mm512_alignr_epi32(z, v, 11);
+        case 10: return _mm512_alignr_epi32(z, v, 10);
+        case  9: return _mm512_alignr_epi32(z, v,  9);
+        case  8: return _mm512_alignr_epi32(z, v,  8);
+        case  7: return _mm512_alignr_epi32(z, v,  7);
+        case  6: return _mm512_alignr_epi32(z, v,  6);
+        case  5: return _mm512_alignr_epi32(z, v,  5);
+        case  4: return _mm512_alignr_epi32(z, v,  4);
+        case  3: return _mm512_alignr_epi32(z, v,  3);
+        case  2: return _mm512_alignr_epi32(z, v,  2);
+        case  1: return _mm512_alignr_epi32(z, v,  1);
+        case  0: return v;
+        case -1: return _mm512_alignr_epi32(v, z, 15);
+        case -2: return _mm512_alignr_epi32(v, z, 14);
+        case -3: return _mm512_alignr_epi32(v, z, 13);
+        case -4: return _mm512_alignr_epi32(v, z, 12);
+        case -5: return _mm512_alignr_epi32(v, z, 11);
+        case -6: return _mm512_alignr_epi32(v, z, 10);
+        case -7: return _mm512_alignr_epi32(v, z,  9);
+        case -8: return _mm512_alignr_epi32(v, z,  8);
+        case -9: return _mm512_alignr_epi32(v, z,  7);
+        case-10: return _mm512_alignr_epi32(v, z,  6);
+        case-11: return _mm512_alignr_epi32(v, z,  5);
+        case-12: return _mm512_alignr_epi32(v, z,  4);
+        case-13: return _mm512_alignr_epi32(v, z,  3);
+        case-14: return _mm512_alignr_epi32(v, z,  2);
+        case-15: return _mm512_alignr_epi32(v, z,  1);
+        case-16: return z;
+        case-17: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 15);
+        case-18: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 14);
+        case-19: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 13);
+        case-20: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 12);
+        case-21: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 11);
+        case-22: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(), 10);
+        case-23: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  9);
+        case-24: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  8);
+        case-25: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  7);
+        case-26: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  6);
+        case-27: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  5);
+        case-28: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  4);
+        case-29: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  3);
+        case-30: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  2);
+        case-31: return _mm512_alignr_epi32(z, _mm512_setzero_epi32(),  1);
+        }
+        return z;
+    }
+};/*}}}*/
+} // anonymous namespace
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::shifted(int amount) const
+{
+    typedef VectorShift<sizeof(VectorType), Size> VS;
+    return _cast(VS::shifted(MIC::mic_cast<typename VS::VectorType>(d.v()), amount));
+}
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::shifted(int amount, Vector shiftIn) const
+{
+    typedef VectorShift<sizeof(VectorType), Size> VS;
+    return _cast(VS::shifted(MIC::mic_cast<typename VS::VectorType>(d.v()), amount,
+                MIC::mic_cast<typename VS::VectorType>(shiftIn.d.v())));
+}
+
+namespace
+{
+template<size_t SIMDWidth, size_t Size> struct VectorRotate;
+template<> struct VectorRotate<64, 8>/*{{{*/
+{
+    typedef __m512i VectorType;
+    static Vc_INTRINSIC VectorType rotated(VectorType v, int amount)
+    {
+        switch (static_cast<unsigned int>(amount) % 8) {
+        case  0: return v;
+        case  1: return _mm512_alignr_epi32(v, v,  2);
+        case  2: return _mm512_alignr_epi32(v, v,  4);
+        case  3: return _mm512_alignr_epi32(v, v,  6);
+        case  4: return _mm512_alignr_epi32(v, v,  8);
+        case  5: return _mm512_alignr_epi32(v, v, 10);
+        case  6: return _mm512_alignr_epi32(v, v, 12);
+        case  7: return _mm512_alignr_epi32(v, v, 14);
+        }
+        return _mm512_setzero_epi32();
+    }
+};/*}}}*/
+template<> struct VectorRotate<64, 16>/*{{{*/
+{
+    typedef __m512i VectorType;
+    static Vc_INTRINSIC VectorType rotated(VectorType v, int amount)
+    {
+        switch (static_cast<unsigned int>(amount) % 16) {
+        case 15: return _mm512_alignr_epi32(v, v, 15);
+        case 14: return _mm512_alignr_epi32(v, v, 14);
+        case 13: return _mm512_alignr_epi32(v, v, 13);
+        case 12: return _mm512_alignr_epi32(v, v, 12);
+        case 11: return _mm512_alignr_epi32(v, v, 11);
+        case 10: return _mm512_alignr_epi32(v, v, 10);
+        case  9: return _mm512_alignr_epi32(v, v,  9);
+        case  8: return _mm512_alignr_epi32(v, v,  8);
+        case  7: return _mm512_alignr_epi32(v, v,  7);
+        case  6: return _mm512_alignr_epi32(v, v,  6);
+        case  5: return _mm512_alignr_epi32(v, v,  5);
+        case  4: return _mm512_alignr_epi32(v, v,  4);
+        case  3: return _mm512_alignr_epi32(v, v,  3);
+        case  2: return _mm512_alignr_epi32(v, v,  2);
+        case  1: return _mm512_alignr_epi32(v, v,  1);
+        case  0: return v;
+        }
+        return _mm512_setzero_epi32();
+    }
+};/*}}}*/
+} // anonymous namespace
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::rotated(int amount) const
+{
+    typedef VectorRotate<sizeof(VectorType), Size> VR;
+    return _cast(VR::rotated(MIC::mic_cast<typename VR::VectorType>(d.v()), amount));
+}
+// interleaveLow/-High {{{1
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::interleaveLow(
+    Vector<T, VectorAbi::Mic> x) const
+{
+    using namespace MIC;
+    __m512i lo = mic_cast<__m512i>(d.v());
+    __m512i hi = mic_cast<__m512i>(x.d.v());
+    lo = _mm512_permute4f128_epi32(lo, _MM_PERM_BBAA);
+    lo = _mm512_mask_swizzle_epi32(lo, 0xf0f0, lo, _MM_SWIZ_REG_BADC);
+    lo = _mm512_shuffle_epi32(lo, _MM_PERM_BBAA);
+    hi = _mm512_permute4f128_epi32(hi, _MM_PERM_BBAA);
+    hi = _mm512_mask_swizzle_epi32(hi, 0xf0f0, hi, _MM_SWIZ_REG_BADC);
+    return mic_cast<VectorType>(_mm512_mask_shuffle_epi32(lo, 0xaaaa, hi, _MM_PERM_BBAA));
+}
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::interleaveHigh(
+    Vector<T, VectorAbi::Mic> x) const
+{
+    using namespace MIC;
+    __m512i lo = mic_cast<__m512i>(d.v());
+    __m512i hi = mic_cast<__m512i>(x.d.v());
+    lo = _mm512_permute4f128_epi32(lo, _MM_PERM_DDCC);
+    lo = _mm512_mask_swizzle_epi32(lo, 0xf0f0, lo, _MM_SWIZ_REG_BADC);
+    lo = _mm512_shuffle_epi32(lo, _MM_PERM_BBAA);
+    hi = _mm512_permute4f128_epi32(hi, _MM_PERM_DDCC);
+    hi = _mm512_mask_swizzle_epi32(hi, 0xf0f0, hi, _MM_SWIZ_REG_BADC);
+    return mic_cast<VectorType>(_mm512_mask_shuffle_epi32(lo, 0xaaaa, hi, _MM_PERM_BBAA));
+}
+template <>
+Vc_INTRINSIC Vector<double, VectorAbi::Mic> Vector<double, VectorAbi::Mic>::interleaveLow(
+    Vector<double, VectorAbi::Mic> x) const
+{
+    using namespace MIC;
+    __m512i lo = mic_cast<__m512i>(d.v());
+    __m512i hi = mic_cast<__m512i>(x.d.v());
+    lo = _mm512_permute4f128_epi32(lo, _MM_PERM_BBAA);
+    lo = _mm512_mask_swizzle_epi32(lo, 0xf0f0, lo, _MM_SWIZ_REG_BADC);
+    lo = _mm512_shuffle_epi32(lo, _MM_PERM_BABA);
+    hi = _mm512_permute4f128_epi32(hi, _MM_PERM_BBAA);
+    hi = _mm512_mask_swizzle_epi32(hi, 0xf0f0, hi, _MM_SWIZ_REG_BADC);
+    return mic_cast<VectorType>(_mm512_mask_shuffle_epi32(lo, 0xcccc, hi, _MM_PERM_BABA));
+}
+template <>
+Vc_INTRINSIC Vector<double, VectorAbi::Mic>
+Vector<double, VectorAbi::Mic>::interleaveHigh(Vector<double, VectorAbi::Mic> x) const
+{
+    using namespace MIC;
+    __m512i lo = mic_cast<__m512i>(d.v());
+    __m512i hi = mic_cast<__m512i>(x.d.v());
+    lo = _mm512_permute4f128_epi32(lo, _MM_PERM_DDCC);
+    lo = _mm512_mask_swizzle_epi32(lo, 0xf0f0, lo, _MM_SWIZ_REG_BADC);
+    lo = _mm512_shuffle_epi32(lo, _MM_PERM_BABA);
+    hi = _mm512_permute4f128_epi32(hi, _MM_PERM_DDCC);
+    hi = _mm512_mask_swizzle_epi32(hi, 0xf0f0, hi, _MM_SWIZ_REG_BADC);
+    return mic_cast<VectorType>(_mm512_mask_shuffle_epi32(lo, 0xcccc, hi, _MM_PERM_BABA));
+}
+
+// reversed {{{1
+template <typename T>
+Vc_INTRINSIC Vc_PURE Vector<T, VectorAbi::Mic> Vector<T, VectorAbi::Mic>::reversed() const
+{
+    return MIC::mic_cast<VectorType>(MIC::permute128(
+        _mm512_shuffle_epi32(MIC::mic_cast<__m512i>(data()), _MM_PERM_ABCD),
+        _MM_PERM_ABCD));
+}
+template <> Vc_INTRINSIC Vc_PURE MIC::double_v MIC::double_v::reversed() const
+{
+    return _mm512_castps_pd(MIC::permute128(
+        _mm512_swizzle_ps(_mm512_castpd_ps(d.v()), _MM_SWIZ_REG_BADC), _MM_PERM_ABCD));
+}
+
+// }}}1
+
+}  // namespace Vc
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/mic/writemaskedvector.h vc-1.3.0/mic/writemaskedvector.h
--- vc-0.7.4/mic/writemaskedvector.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/mic/writemaskedvector.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,110 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_MIC_WRITEMASKEDVECTOR_H_
+#define VC_MIC_WRITEMASKEDVECTOR_H_
+
+#include <utility>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+template<typename T> class WriteMaskedVector
+{
+    friend class Vc::Vector<T, VectorAbi::Mic>;
+    typedef typename VectorTypeHelper<T>::Type VectorType;
+    using EntryType = T;
+    typedef typename DetermineVectorEntryType<T>::Type VectorEntryType;
+    typedef MIC::Mask<T> Mask;
+public:
+    //prefix
+    Vc_ALWAYS_INLINE Vector<T> &operator++() {
+        vec.d = _add<VectorEntryType>(vec.d.v(), mask, vec.d.v(), _set1(VectorEntryType(1)));
+        return vec;
+    }
+    Vc_ALWAYS_INLINE Vector<T> &operator--() {
+        vec.d = _sub<VectorEntryType>(vec.d.v(), mask, vec.d.v(), _set1(VectorEntryType(1)));
+        return vec;
+    }
+    //postfix
+    Vc_ALWAYS_INLINE Vector<T> operator++(int) {
+        Vector<T> ret(vec);
+        vec.d = _add<VectorEntryType>(vec.d.v(), mask, vec.d.v(), _set1(VectorEntryType(1)));
+        return ret;
+    }
+    Vc_ALWAYS_INLINE Vector<T> operator--(int) {
+        Vector<T> ret(vec);
+        vec.d = _sub<VectorEntryType>(vec.d.v(), mask, vec.d.v(), _set1(VectorEntryType(1)));
+        return ret;
+    }
+
+    Vc_ALWAYS_INLINE Vector<T> &operator+=(Vector<T> x) {
+        vec.d = _add<VectorEntryType>(vec.d.v(), mask, vec.d.v(), x.d.v());
+        return vec;
+    }
+    Vc_ALWAYS_INLINE Vector<T> &operator-=(Vector<T> x) {
+        vec.d = _sub<VectorEntryType>(vec.d.v(), mask, vec.d.v(), x.d.v());
+        return vec;
+    }
+    Vc_ALWAYS_INLINE Vector<T> &operator*=(Vector<T> x) {
+        vec.d = _mul<VectorEntryType>(vec.d.v(), mask, vec.d.v(), x.d.v());
+        return vec;
+    }
+    Vc_ALWAYS_INLINE Vector<T> &operator/=(Vector<T> x) {
+        vec.d = _div<VectorEntryType>(vec.d.v(), mask, vec.d.v(), x.d.v());
+        return vec;
+    }
+
+    Vc_ALWAYS_INLINE Vector<T> &operator+=(EntryType x) { return operator+=(Vector<T>(x)); }
+    Vc_ALWAYS_INLINE Vector<T> &operator-=(EntryType x) { return operator-=(Vector<T>(x)); }
+    Vc_ALWAYS_INLINE Vector<T> &operator*=(EntryType x) { return operator*=(Vector<T>(x)); }
+    Vc_ALWAYS_INLINE Vector<T> &operator/=(EntryType x) { return operator/=(Vector<T>(x)); }
+
+    Vc_ALWAYS_INLINE Vector<T> &operator=(Vector<T> x) {
+        vec.assign(x, mask);
+        return vec;
+    }
+    Vc_ALWAYS_INLINE Vector<T> &operator=(EntryType x) { return operator=(Vector<T>(x)); }
+
+    template<typename F> Vc_INTRINSIC void call(F &&f) const {
+        return vec.call(std::forward<F>(f), mask);
+    }
+    template<typename F> Vc_INTRINSIC Vector<T> apply(F &&f) const {
+        return vec.apply(std::forward<F>(f), mask);
+    }
+private:
+    constexpr WriteMaskedVector(Vector<T> &v, const Mask &k) : vec(v), mask(k.data()) {}
+    Vector<T> &vec;
+    const typename MaskTypeHelper<EntryType>::Type mask;
+};
+
+}  // namespace MIC
+}  // namespace Vc
+
+#endif // VC_MIC_WRITEMASKEDVECTOR_H_
diff -Nru vc-0.7.4/print_target_architecture.cmake vc-1.3.0/print_target_architecture.cmake
--- vc-0.7.4/print_target_architecture.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/print_target_architecture.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -5,7 +5,7 @@
    set(CMAKE_SYSTEM_NAME "Linux")
 elseif(arch STREQUAL "darwin")
    set(CMAKE_SYSTEM_NAME "Darwin")
-elseif(arch MATCHES "mingw" OR arch MATCHES "[Ww]indows" OR arch MATCHES "win7")
+elseif(arch MATCHES "mingw" OR arch MATCHES "[Ww]indows" OR arch MATCHES "win7" OR arch MATCHES "msys")
    set(CMAKE_SYSTEM_NAME "Windows")
 else()
    message(FATAL_ERROR "unhandled system")
diff -Nru vc-0.7.4/README.md vc-1.3.0/README.md
--- vc-0.7.4/README.md	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/README.md	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,116 @@
+# Vc: portable, zero-overhead C++ types for explicitly data-parallel programming
+
+Recent generations of CPUs, and GPUs in particular, require data-parallel codes
+for full efficiency. Data parallelism requires that the same sequence of
+operations is applied to different input data. CPUs and GPUs can thus reduce
+the necessary hardware for instruction decoding and scheduling in favor of more
+arithmetic and logic units, which execute the same instructions synchronously.
+On CPU architectures this is implemented via SIMD registers and instructions.
+A single SIMD register can store N values and a single SIMD instruction can
+execute N operations on those values. On GPU architectures N threads run in
+perfect sync, fed by a single instruction decoder/scheduler. Each thread has
+local memory and a given index to calculate the offsets in memory for loads and
+stores.
+
+Current C++ compilers can do automatic transformation of scalar codes to SIMD
+instructions (auto-vectorization). However, the compiler must reconstruct an
+intrinsic property of the algorithm that was lost when the developer wrote a
+purely scalar implementation in C++. Consequently, C++ compilers cannot
+vectorize any given code to its most efficient data-parallel variant.
+Especially larger data-parallel loops, spanning over multiple functions or even
+translation units, will often not be transformed into efficient SIMD code.
+
+The Vc library provides the missing link. Its types enable explicitly stating
+data-parallel operations on multiple values. The parallelism is therefore added
+via the type system. Competing approaches state the parallelism via new control
+structures and consequently new semantics inside the body of these control
+structures.
+
+Vc is a free software library to ease explicit vectorization of C++ code. It
+has an intuitive API and provides portability between different compilers and
+compiler versions as well as portability between different vector instruction
+sets. Thus an application written with Vc can be compiled for:
+
+* AVX and AVX2
+* SSE2 up to SSE4.2 or SSE4a
+* Scalar
+* MIC
+* AVX-512 (in development)
+* NEON (in development)
+* NVIDIA GPUs / CUDA (in development)
+
+
+## Build Requirements
+
+cmake >= 3.0
+
+C++11 Compiler:
+
+* GCC >= 4.8.1
+* clang >= 3.4
+* ICC >= 15.0.3
+* Visual Studio 2015 (64-bit target)
+
+
+## Building and Installing Vc
+
+* Create a build directory:
+
+```sh
+$ mkdir build
+$ cd build
+```
+
+* Call cmake with the relevant options:
+
+```sh
+$ cmake -DCMAKE_INSTALL_PREFIX=/opt/Vc -DBUILD_TESTING=OFF <srcdir>
+```
+
+* Build and install:
+
+```sh
+$ make -j16
+$ make install
+```
+
+## Documentation
+
+The documentation is generated via [doxygen](http://doxygen.org). You can build
+the documentation by running `doxygen` in the `doc` subdirectory.
+Alternatively, you can find nightly builds of the documentation at:
+
+* [master branch](https://web-docs.gsi.de/~mkretz/Vc-master/)
+* [1.3.0 release](https://web-docs.gsi.de/~mkretz/Vc-1.3.0/)
+* [1.2.0 release](https://web-docs.gsi.de/~mkretz/Vc-1.2.0/)
+* [1.1.0 release](https://web-docs.gsi.de/~mkretz/Vc-1.1.0/)
+* [0.7 branch](https://web-docs.gsi.de/~mkretz/Vc-0.7/)
+
+## Publications
+
+* [M. Kretz, "Extending C++ for Explicit Data-Parallel Programming via SIMD
+  Vector Types", Goethe University Frankfurt, Dissertation,
+  2015.](http://publikationen.ub.uni-frankfurt.de/frontdoor/index/index/docId/38415)
+* [M. Kretz and V. Lindenstruth, "Vc: A C++ library for explicit
+  vectorization", Software: Practice and Experience,
+  2011.](http://dx.doi.org/10.1002/spe.1149)
+* [M. Kretz, "Efficient Use of Multi- and Many-Core Systems with Vectorization
+  and Multithreading", University of Heidelberg,
+  2009.](http://code.compeng.uni-frankfurt.de/attachments/13/Diplomarbeit.pdf)
+
+[Work on integrating the functionality of Vc in the C++ standard library.](
+https://github.com/VcDevel/Vc/wiki/ISO-Standardization-of-the-Vector-classes)
+
+## Communication
+
+A channel on the freenode IRC network is reserved for discussions on Vc:
+[##vc on freenode](irc://chat.freenode.net:6667/##vc)
+([via SSL](ircs://chat.freenode.net:6697/##vc))
+
+Feel free to use the GitHub issue tracker for questions.
+Alternatively, there's a [mailinglist for users of
+Vc](https://compeng.uni-frankfurt.de/mailman/listinfo/vc)
+
+## License
+
+Vc is released under the terms of the [3-clause BSD license](http://opensource.org/licenses/BSD-3-Clause).
diff -Nru vc-0.7.4/scalar/detail.h vc-1.3.0/scalar/detail.h
--- vc-0.7.4/scalar/detail.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/scalar/detail.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,165 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SCALAR_DETAIL_H_
+#define VC_SCALAR_DETAIL_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+//InterleaveImpl{{{1
+template<typename V, int Size, size_t VSize> struct InterleaveImpl;
+template<typename V, size_t VSize> struct InterleaveImpl<V, 1, VSize> {
+    template <typename I>  // interleave 2 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        data[i[0] + 0] = v0.data();
+        data[i[0] + 1] = v1.data();
+    }
+    template <typename I>  // interleave 3 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2)
+    {
+        data[i[0] + 0] = v0.data();
+        data[i[0] + 1] = v1.data();
+        data[i[0] + 2] = v2.data();
+    }
+    template <typename I>  // interleave 4 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        data[i[0] + 0] = v0.data();
+        data[i[0] + 1] = v1.data();
+        data[i[0] + 2] = v2.data();
+        data[i[0] + 3] = v3.data();
+    }
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        data[i[0] + 4] = v4.data();
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template <typename I>  // deinterleave 2 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1)
+    {
+        v0.data() = data[i[0] + 0];
+        v1.data() = data[i[0] + 1];
+    }
+    template <typename I>  // deinterleave 3 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2)
+    {
+        v0.data() = data[i[0] + 0];
+        v1.data() = data[i[0] + 1];
+        v2.data() = data[i[0] + 2];
+    }
+    template <typename I>  // deinterleave 4 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2, V &v3)
+    {
+        v0.data() = data[i[0] + 0];
+        v1.data() = data[i[0] + 1];
+        v2.data() = data[i[0] + 2];
+        v3.data() = data[i[0] + 3];
+    }
+    template <typename I>  // deinterleave 5 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        v4.data() = data[i[0] + 4];
+    }
+    template <typename I>  // deinterleave 6 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // deinterleave 7 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // deinterleave 8 args{{{2
+    static inline void deinterleave(typename V::EntryType const *const data, const I &i,
+                                    V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6,
+                                    V &v7)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6, v7);
+    }
+};
+//}}}1
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_SCALAR_DETAIL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/helperimpl.h vc-1.3.0/scalar/helperimpl.h
--- vc-0.7.4/scalar/helperimpl.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/helperimpl.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,58 +1,53 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_DEINTERLEAVE_H
-#define VC_SCALAR_DEINTERLEAVE_H
+#ifndef VC_SCALAR_DEINTERLEAVE_H_
+#define VC_SCALAR_DEINTERLEAVE_H_
 
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Internal
+namespace Detail
 {
-
-template<> struct HelperImpl<Vc::ScalarImpl>
+template <typename T, typename M, typename A>
+Vc_ALWAYS_INLINE void deinterleave(Scalar::Vector<T> &a, Scalar::Vector<T> &b,
+                                   const M *mem, A)
 {
-    template<typename V, typename M, typename A>
-    static Vc_ALWAYS_INLINE void deinterleave(V &a, V &b, const M *mem, A)
-    {
-        a = mem[0];
-        b = mem[1];
-    }
-
-    static Vc_ALWAYS_INLINE void prefetchForOneRead(const void *) {}
-    static Vc_ALWAYS_INLINE void prefetchForModify(const void *) {}
-    static Vc_ALWAYS_INLINE void prefetchClose(const void *) {}
-    static Vc_ALWAYS_INLINE void prefetchMid(const void *) {}
-    static Vc_ALWAYS_INLINE void prefetchFar(const void *) {}
-
-    template<Vc::MallocAlignment A>
-    static Vc_ALWAYS_INLINE_L void *malloc(size_t n) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void free(void *p) Vc_ALWAYS_INLINE_R;
-};
-
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "helperimpl.tcc"
-#include "undomacros.h"
+    a = mem[0];
+    b = mem[1];
+}
+
+Vc_ALWAYS_INLINE void prefetchForOneRead(const void *, VectorAbi::Scalar) {}
+Vc_ALWAYS_INLINE void prefetchForModify(const void *, VectorAbi::Scalar) {}
+Vc_ALWAYS_INLINE void prefetchClose(const void *, VectorAbi::Scalar) {}
+Vc_ALWAYS_INLINE void prefetchMid(const void *, VectorAbi::Scalar) {}
+Vc_ALWAYS_INLINE void prefetchFar(const void *, VectorAbi::Scalar) {}
+}  // namespace Detail
+}  // namespace Vc
 
-#endif // VC_SCALAR_DEINTERLEAVE_H
+#endif // VC_SCALAR_DEINTERLEAVE_H_
diff -Nru vc-0.7.4/scalar/helperimpl.tcc vc-1.3.0/scalar/helperimpl.tcc
--- vc-0.7.4/scalar/helperimpl.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/helperimpl.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,86 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_HELPERIMPL_TCC
-#define VC_SCALAR_HELPERIMPL_TCC
-
-#include <cstdlib>
-#if defined _WIN32 || defined _WIN64
-#include <malloc.h>
-#endif
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Internal
-{
-
-template<size_t X>
-static _VC_CONSTEXPR size_t nextMultipleOf(size_t value)
-{
-    return (value % X) > 0 ? value + X - (value % X) : value;
-}
-
-template<Vc::MallocAlignment A>
-Vc_ALWAYS_INLINE void *HelperImpl<ScalarImpl>::malloc(size_t n)
-{
-    void *ptr = 0;
-    switch (A) {
-        case Vc::AlignOnVector:
-            return std::malloc(n);
-        case Vc::AlignOnCacheline:
-            // TODO: hardcoding 64 is not such a great idea
-#ifdef _WIN32
-#ifdef __GNUC__
-#define _VC_ALIGNED_MALLOC __mingw_aligned_malloc
-#else
-#define _VC_ALIGNED_MALLOC _aligned_malloc
-#endif
-            ptr = _VC_ALIGNED_MALLOC(nextMultipleOf<64>(n), 64);
-#else
-            if (0 == posix_memalign(&ptr, 64, nextMultipleOf<64>(n))) {
-                return ptr;
-            }
-#endif
-            break;
-        case Vc::AlignOnPage:
-            // TODO: hardcoding 4096 is not such a great idea
-#ifdef _WIN32
-            ptr = _VC_ALIGNED_MALLOC(nextMultipleOf<4096>(n), 4096);
-#undef _VC_ALIGNED_MALLOC
-#else
-            if (0 == posix_memalign(&ptr, 4096, nextMultipleOf<4096>(n))) {
-                return ptr;
-            }
-#endif
-            break;
-    }
-    return ptr;
-}
-
-Vc_ALWAYS_INLINE void HelperImpl<ScalarImpl>::free(void *p)
-{
-    std::free(p);
-}
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_SCALAR_HELPERIMPL_TCC
diff -Nru vc-0.7.4/scalar/interleavedmemory.tcc vc-1.3.0/scalar/interleavedmemory.tcc
--- vc-0.7.4/scalar/interleavedmemory.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/interleavedmemory.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,160 +0,0 @@
-/*  This file is part of the Vc library. {{{
-
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-}}}*/
-
-#ifndef VC_SCALAR_INTERLEAVEDMEMORY_TCC
-#define VC_SCALAR_INTERLEAVEDMEMORY_TCC
-
-#include "macros.h"
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Common
-{
-
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-    m_data[m_indexes.data() + 3] = v3.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-    m_data[m_indexes.data() + 3] = v3.data();
-    m_data[m_indexes.data() + 4] = v4.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-    m_data[m_indexes.data() + 3] = v3.data();
-    m_data[m_indexes.data() + 4] = v4.data();
-    m_data[m_indexes.data() + 5] = v5.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-    m_data[m_indexes.data() + 3] = v3.data();
-    m_data[m_indexes.data() + 4] = v4.data();
-    m_data[m_indexes.data() + 5] = v5.data();
-    m_data[m_indexes.data() + 6] = v6.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6, const typename V::AsArg v7)
-{
-    m_data[m_indexes.data() + 0] = v0.data();
-    m_data[m_indexes.data() + 1] = v1.data();
-    m_data[m_indexes.data() + 2] = v2.data();
-    m_data[m_indexes.data() + 3] = v3.data();
-    m_data[m_indexes.data() + 4] = v4.data();
-    m_data[m_indexes.data() + 5] = v5.data();
-    m_data[m_indexes.data() + 6] = v6.data();
-    m_data[m_indexes.data() + 7] = v7.data();
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-    v3.data() = m_data[m_indexes.data() + 3];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-    v3.data() = m_data[m_indexes.data() + 3];
-    v4.data() = m_data[m_indexes.data() + 4];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-    v3.data() = m_data[m_indexes.data() + 3];
-    v4.data() = m_data[m_indexes.data() + 4];
-    v5.data() = m_data[m_indexes.data() + 5];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-    v3.data() = m_data[m_indexes.data() + 3];
-    v4.data() = m_data[m_indexes.data() + 4];
-    v5.data() = m_data[m_indexes.data() + 5];
-    v6.data() = m_data[m_indexes.data() + 6];
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7) const/*{{{*/
-{
-    v0.data() = m_data[m_indexes.data() + 0];
-    v1.data() = m_data[m_indexes.data() + 1];
-    v2.data() = m_data[m_indexes.data() + 2];
-    v3.data() = m_data[m_indexes.data() + 3];
-    v4.data() = m_data[m_indexes.data() + 4];
-    v5.data() = m_data[m_indexes.data() + 5];
-    v6.data() = m_data[m_indexes.data() + 6];
-    v7.data() = m_data[m_indexes.data() + 7];
-}/*}}}*/
-
-} // namespace Common
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#include "undomacros.h"
-
-#endif // VC_SCALAR_INTERLEAVEDMEMORY_TCC
-
-// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/limits.h vc-1.3.0/scalar/limits.h
--- vc-0.7.4/scalar/limits.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/limits.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,24 +1,32 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_SCALAR_LIMITS_H_
+#define VC_SCALAR_LIMITS_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
 
-*/
-
-#ifndef VC_SCALAR_LIMITS_H
-#define VC_SCALAR_LIMITS_H
-
-
-#endif // VC_SCALAR_LIMITS_H
+#endif // VC_SCALAR_LIMITS_H_
diff -Nru vc-0.7.4/scalar/macros.h vc-1.3.0/scalar/macros.h
--- vc-0.7.4/scalar/macros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/macros.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,25 +1,33 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "../common/macros.h"
 
-#ifndef VC_SCALAR_MACROS_H
-#define VC_SCALAR_MACROS_H
+#ifndef VC_SCALAR_MACROS_H_
+#define VC_SCALAR_MACROS_H_
 
-#endif // VC_SCALAR_MACROS_H
+#endif // VC_SCALAR_MACROS_H_
diff -Nru vc-0.7.4/scalar/mask.h vc-1.3.0/scalar/mask.h
--- vc-0.7.4/scalar/mask.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/mask.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,48 +1,112 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_MASK_H
-#define VC_SCALAR_MASK_H
+#ifndef VC_SCALAR_MASK_H_
+#define VC_SCALAR_MASK_H_
 
 #include "types.h"
+#include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Scalar
+namespace Vc_VERSIONED_NAMESPACE
 {
-template<unsigned int VectorSize = 1> class Mask
+template <typename T> class Mask<T, VectorAbi::Scalar>
 {
-    public:
-        Vc_ALWAYS_INLINE Mask() {}
-        Vc_ALWAYS_INLINE explicit Mask(bool b) : m(b) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerZero::ZEnum) : m(false) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerOne::OEnum) : m(true) {}
-        Vc_ALWAYS_INLINE Mask(const Mask<VectorSize> *a) : m(a[0].m) {}
+    friend class Mask<  double, VectorAbi::Scalar>;
+    friend class Mask<   float, VectorAbi::Scalar>;
+    friend class Mask< int32_t, VectorAbi::Scalar>;
+    friend class Mask<uint32_t, VectorAbi::Scalar>;
+    friend class Mask< int16_t, VectorAbi::Scalar>;
+    friend class Mask<uint16_t, VectorAbi::Scalar>;
+
+public:
+    using abi = VectorAbi::Scalar;
+
+    static constexpr size_t Size = 1;
+    static constexpr size_t MemoryAlignment = 1;
+    static constexpr std::size_t size() { return 1; }
+
+    /**
+     * The \c EntryType of masks is always bool, independent of \c T.
+     */
+    typedef bool EntryType;
+    using value_type = EntryType;
+
+    using EntryReference = Vc::Detail::ElementReference<Mask>;
+    using reference = EntryReference;
+
+    /**
+     * The \c VectorEntryType, in contrast to \c EntryType, reveals information about the SIMD
+     * implementation. This type is useful for the \c sizeof operator in generic functions.
+     */
+    typedef bool VectorEntryType;
+
+    /**
+     * The \c VectorType reveals the implementation-specific internal type used for the SIMD type.
+     */
+    using VectorType = bool;
+
+    /**
+     * The associated Vector<T> type.
+     */
+    using Vector = Scalar::Vector<T>;
+
+    Vc_INTRINSIC Mask() = default;
+    Vc_INTRINSIC explicit Mask(bool b) : m(b) {}
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero) : m(false) {}
+    Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne) : m(true) {}
+    Vc_INTRINSIC static Mask Zero() { return Mask(false); }
+    Vc_INTRINSIC static Mask One() { return Mask(true); }
+
+    // implicit cast
+    template <typename U>
+    Vc_INTRINSIC Mask(U &&rhs, Common::enable_if_mask_converts_implicitly<T, U> = nullarg)
+        : m(rhs.m) {}
+
+#if Vc_IS_VERSION_1
+    // explicit cast, implemented via simd_cast (in scalar/simd_cast_caller.h)
+    template <typename U>
+    Vc_DEPRECATED(
+        "use simd_cast instead of explicit type casting to convert between mask types")
+        Vc_INTRINSIC_L
+        explicit Mask(U &&rhs, Common::enable_if_mask_converts_explicitly<T, U> = nullarg)
+            Vc_INTRINSIC_R;
+#endif
+
+        Vc_ALWAYS_INLINE explicit Mask(const bool *mem) : m(mem[0]) {}
+        template<typename Flags> Vc_ALWAYS_INLINE explicit Mask(const bool *mem, Flags) : m(mem[0]) {}
 
-        Vc_ALWAYS_INLINE Mask &operator=(const Mask &rhs) { m = rhs.m; return *this; }
-        Vc_ALWAYS_INLINE Mask &operator=(bool rhs) { m = rhs; return *this; }
+        Vc_ALWAYS_INLINE void load(const bool *mem) { m = mem[0]; }
+        template<typename Flags> Vc_ALWAYS_INLINE void load(const bool *mem, Flags) { m = mem[0]; }
 
-        Vc_ALWAYS_INLINE void expand(Mask *x) { x[0].m = m; }
+        Vc_ALWAYS_INLINE void store(bool *mem) const { *mem = m; }
+        template<typename Flags> Vc_ALWAYS_INLINE void store(bool *mem, Flags) const { *mem = m; }
 
-        Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return Mask(m == rhs.m); }
-        Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return Mask(m != rhs.m); }
+        Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return m == rhs.m; }
+        Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return m != rhs.m; }
 
         Vc_ALWAYS_INLINE Mask operator&&(const Mask &rhs) const { return Mask(m && rhs.m); }
         Vc_ALWAYS_INLINE Mask operator& (const Mask &rhs) const { return Mask(m && rhs.m); }
@@ -56,6 +120,7 @@
         Vc_ALWAYS_INLINE Mask &operator^=(const Mask &rhs) { m ^= rhs.m; return *this; }
 
         Vc_ALWAYS_INLINE bool isFull () const { return  m; }
+        Vc_ALWAYS_INLINE bool isNotEmpty() const { return m; }
         Vc_ALWAYS_INLINE bool isEmpty() const { return !m; }
         Vc_ALWAYS_INLINE bool isMix  () const { return false; }
 
@@ -63,14 +128,27 @@
         Vc_ALWAYS_INLINE bool dataI() const { return m; }
         Vc_ALWAYS_INLINE bool dataD() const { return m; }
 
-#ifndef VC_NO_AUTOMATIC_BOOL_FROM_MASK
-        Vc_ALWAYS_INLINE operator bool() const { return isFull(); }
-#endif
-
-        template<unsigned int OtherSize>
-            Vc_ALWAYS_INLINE Mask cast() const { return *this; }
-
-        Vc_ALWAYS_INLINE bool operator[](int) const { return m; }
+private:
+    friend reference;
+    static Vc_INTRINSIC bool get(const Mask &o, int) noexcept { return o.m; }
+    template <typename U>
+    static Vc_INTRINSIC void set(Mask &o, int, U &&v) noexcept(
+        noexcept(std::declval<bool &>() = std::declval<U>()))
+    {
+        o.m = std::forward<U>(v);
+    }
+
+public:
+    Vc_ALWAYS_INLINE reference operator[](size_t i) noexcept
+    {
+        Vc_ASSERT(i == 0); if (i) {}
+        return {*this, 0};
+    }
+    Vc_ALWAYS_INLINE value_type operator[](size_t i) const noexcept
+    {
+        Vc_ASSERT(i == 0); if (i) {}
+        return m;
+    }
 
         Vc_ALWAYS_INLINE int count() const { return m ? 1 : 0; }
 
@@ -80,24 +158,28 @@
          * The return value is undefined if the mask is empty.
          */
         Vc_ALWAYS_INLINE int firstOne() const { return 0; }
+        Vc_ALWAYS_INLINE int toInt() const { return m ? 1 : 0; }
+
+        template <typename G> static Vc_INTRINSIC Mask generate(G &&gen)
+        {
+            return Mask(gen(0));
+        }
+
+        Vc_INTRINSIC Vc_PURE Mask shifted(int amount) const
+        {
+            if (amount == 0) {
+                return *this;
+            } else {
+                return Zero();
+            }
+        }
 
     private:
         bool m;
 };
+template <typename T> constexpr size_t Mask<T, VectorAbi::Scalar>::Size;
+template <typename T> constexpr size_t Mask<T, VectorAbi::Scalar>::MemoryAlignment;
 
-struct ForeachHelper
-{
-    bool continu;
-    Vc_ALWAYS_INLINE ForeachHelper(bool mask) : continu(mask) {}
-    Vc_ALWAYS_INLINE void next() { continu = false; }
-};
-
-#define Vc_foreach_bit(_it_, _mask_) \
-    for (Vc::Scalar::ForeachHelper Vc__make_unique(foreach_bit_obj)(_mask_); Vc__make_unique(foreach_bit_obj).continu; Vc__make_unique(foreach_bit_obj).next()) \
-        for (_it_ = 0; Vc__make_unique(foreach_bit_obj).continu; Vc__make_unique(foreach_bit_obj).next())
-
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Vc
 
-#endif // VC_SCALAR_MASK_H
+#endif // VC_SCALAR_MASK_H_
diff -Nru vc-0.7.4/scalar/math.h vc-1.3.0/scalar/math.h
--- vc-0.7.4/scalar/math.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/math.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,161 +1,181 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_MATH_H
-#define VC_SCALAR_MATH_H
+#ifndef VC_SCALAR_MATH_H_
+#define VC_SCALAR_MATH_H_
 
+#include <cstdlib>
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Scalar
+// copysign {{{1
+Vc_INTRINSIC Scalar::float_v copysign(Scalar::float_v mag, Scalar::float_v sign)
 {
+    union {
+        float f;
+        unsigned int i;
+    } value, s;
+    value.f = mag.data();
+    s.f = sign.data();
+    value.i = (s.i & 0x80000000u) | (value.i & 0x7fffffffu);
+    return Scalar::float_v{value.f};
+}
+Vc_INTRINSIC Vc_CONST Scalar::double_v copysign(Scalar::double_v mag,
+                                                Scalar::double_v sign)
+{
+    union {
+        double f;
+        unsigned long long i;
+    } value, s;
+    value.f = mag.data();
+    s.f = sign.data();
+    value.i = (s.i & 0x8000000000000000ull) | (value.i & 0x7fffffffffffffffull);
+    return Scalar::double_v{value.f};
+}
+
+// }}}1
+
+#define Vc_MINMAX(V)                                                                     \
+    static Vc_ALWAYS_INLINE Scalar::V min(const Scalar::V &x, const Scalar::V &y)        \
+    {                                                                                    \
+        return Scalar::V(std::min(x.data(), y.data()));                                  \
+    }                                                                                    \
+    static Vc_ALWAYS_INLINE Scalar::V max(const Scalar::V &x, const Scalar::V &y)        \
+    {                                                                                    \
+        return Scalar::V(std::max(x.data(), y.data()));                                  \
+    }
+Vc_ALL_VECTOR_TYPES(Vc_MINMAX);
+#undef Vc_MINMAX
 
-#define VC_MINMAX(V) \
-static Vc_ALWAYS_INLINE V min(const V &x, const V &y) { return V(std::min(x.data(), y.data())); } \
-static Vc_ALWAYS_INLINE V max(const V &x, const V &y) { return V(std::max(x.data(), y.data())); }
-VC_ALL_VECTOR_TYPES(VC_MINMAX)
-#undef VC_MINMAX
-
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> sqrt (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> sqrt (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::sqrt(x.data()));
+    return Scalar::Vector<T>(std::sqrt(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> rsqrt(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> rsqrt(const Scalar::Vector<T> &x)
 {
-    const typename Vector<T>::EntryType one = 1; return Vector<T>(one / std::sqrt(x.data()));
+    const typename Vector<T, VectorAbi::Scalar>::EntryType one = 1; return Scalar::Vector<T>(one / std::sqrt(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> abs  (const Vector<T> &x)
+template <typename T,
+          typename = enable_if<std::is_same<T, double>::value || std::is_same<T, float>::value ||
+                               std::is_same<T, short>::value ||
+                               std::is_same<T, int>::value>>
+Vc_ALWAYS_INLINE Vc_PURE Scalar::Vector<T> abs(Scalar::Vector<T> x)
 {
-    return Vector<T>(std::abs(x.data()));
+    return std::abs(x.data());
 }
 
-template<> Vc_ALWAYS_INLINE int_v abs(const int_v &x) { return x < 0 ? -x : x; }
-template<> Vc_ALWAYS_INLINE uint_v abs(const uint_v &x) { return x; }
-template<> Vc_ALWAYS_INLINE short_v abs(const short_v &x) { return x < 0 ? -x : x; }
-template<> Vc_ALWAYS_INLINE ushort_v abs(const ushort_v &x) { return x; }
-
-template<typename T> static Vc_ALWAYS_INLINE void sincos(const Vector<T> &x, Vector<T> *sin, Vector<T> *cos)
+template<typename T> static Vc_ALWAYS_INLINE void sincos(const Scalar::Vector<T> &x, Scalar::Vector<T> *sin, Scalar::Vector<T> *cos)
 {
-#if (defined(VC_CLANG) && VC_HAS_BUILTIN(__builtin_sincosf)) || (!defined(VC_CLANG) && defined(__GNUC__) && !defined(_WIN32))
-    __builtin_sincosf(x.data(), &sin->data(), &cos->data());
-#elif defined(_GNU_SOURCE)
-    sincosf(x.data(), &sin->data(), &cos->data());
-#else
+#if defined(_WIN32) || defined(__APPLE__)
     sin->data() = std::sin(x.data());
     cos->data() = std::cos(x.data());
+#elif Vc_HAS_BUILTIN(__builtin_sincosf) || defined Vc_GCC
+    __builtin_sincosf(x.data(), &sin->data(), &cos->data());
+#else
+    sincosf(x.data(), &sin->data(), &cos->data());
 #endif
 }
 
-template<> Vc_ALWAYS_INLINE void sincos(const Vector<double> &x, Vector<double> *sin, Vector<double> *cos)
+template<> Vc_ALWAYS_INLINE void sincos(const Scalar::Vector<double> &x, Scalar::Vector<double> *sin, Scalar::Vector<double> *cos)
 {
-#if (defined(VC_CLANG) && VC_HAS_BUILTIN(__builtin_sincos)) || (!defined(VC_CLANG) && defined(__GNUC__) && !defined(_WIN32))
-    __builtin_sincos(x.data(), &sin->data(), &cos->data());
-#elif defined(_GNU_SOURCE)
-    ::sincos(x.data(), &sin->data(), &cos->data());
-#else
+#if defined(_WIN32) || defined(__APPLE__)
     sin->data() = std::sin(x.data());
     cos->data() = std::cos(x.data());
+#elif Vc_HAS_BUILTIN(__builtin_sincos) || defined Vc_GCC
+    __builtin_sincos(x.data(), &sin->data(), &cos->data());
+#else
+    ::sincos(x.data(), &sin->data(), &cos->data());
 #endif
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> sin  (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> sin  (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::sin(x.data()));
+    return Scalar::Vector<T>(std::sin(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> asin (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> asin (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::asin(x.data()));
+    return Scalar::Vector<T>(std::asin(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> cos  (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> cos  (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::cos(x.data()));
+    return Scalar::Vector<T>(std::cos(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> log  (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> log  (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::log(x.data()));
+    return Scalar::Vector<T>(std::log(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> log10(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> log10(const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::log10(x.data()));
+    return Scalar::Vector<T>(std::log10(x.data()));
 }
 
-#if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600) || defined(_ISOC99_SOURCE) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L)
-static Vc_ALWAYS_INLINE double_v log2(double_v::AsArg x) { return double_v(::log2 (x.data())); }
-static Vc_ALWAYS_INLINE sfloat_v log2(sfloat_v::AsArg x) { return sfloat_v(::log2f(x.data())); }
-static Vc_ALWAYS_INLINE  float_v log2( float_v::AsArg x) { return  float_v(::log2f(x.data())); }
-#else
-namespace {
-template<typename T> static _VC_CONSTEXPR T c_ln2() { return Vc_buildFloat(1, 0x317218, -1); } // .693147182464599609375
-template<> _VC_CONSTEXPR double c_ln2() { return Vc_buildDouble(1, 0x62E42FEFA39EFull, -1); } // .69314718055994528622676398299518041312694549560546875
-}
-#define VC_LOG2(V) \
-static Vc_ALWAYS_INLINE V log2(const V &x) \
-{ \
-    return V(std::log(x.data()) / c_ln2<V::EntryType>()); \
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> log2(const Scalar::Vector<T> &x)
+{
+    return Scalar::Vector<T>(std::log2(x.data()));
 }
-VC_ALL_FLOAT_VECTOR_TYPES(VC_LOG2)
-#undef VC_LOG2
-#endif
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> exp (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> exp (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::exp(x.data()));
+    return Scalar::Vector<T>(std::exp(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> atan (const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> atan (const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::atan( x.data() ));
+    return Scalar::Vector<T>(std::atan( x.data() ));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> atan2(const Vector<T> &x, const Vector<T> &y)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> atan2(const Scalar::Vector<T> &x, const Scalar::Vector<T> &y)
 {
-    return Vector<T>(std::atan2( x.data(), y.data() ));
+    return Scalar::Vector<T>(std::atan2( x.data(), y.data() ));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> trunc(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> trunc(const Scalar::Vector<T> &x)
 {
-#if __cplusplus >= 201103 /*C++11*/
     return std::trunc(x.data());
-#else
-    return x.data() > 0 ? std::floor(x.data()) : std::ceil(x.data());
-#endif
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> floor(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> floor(const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::floor(x.data()));
+    return Scalar::Vector<T>(std::floor(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> ceil(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> ceil(const Scalar::Vector<T> &x)
 {
-    return Vector<T>(std::ceil(x.data()));
+    return Scalar::Vector<T>(std::ceil(x.data()));
 }
 
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> round(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> round(const Scalar::Vector<T> &x)
 {
     return x;
 }
@@ -169,24 +189,19 @@
         return (x - f) == half;
     }
 } // namespace
-template<> Vc_ALWAYS_INLINE Vector<float>  round(const Vector<float>  &x)
+template<> Vc_ALWAYS_INLINE Scalar::Vector<float>  round(const Scalar::Vector<float>  &x)
 {
-    return float_v(std::floor(x.data() + 0.5f) - (_realIsEvenHalf(x.data()) ? 1.f : 0.f));
+    return Scalar::float_v(std::floor(x.data() + 0.5f) - (_realIsEvenHalf(x.data()) ? 1.f : 0.f));
 }
 
-template<> Vc_ALWAYS_INLINE Vector<sfloat> round(const Vector<sfloat> &x)
+template<> Vc_ALWAYS_INLINE Scalar::Vector<double> round(const Scalar::Vector<double> &x)
 {
-    return sfloat_v(std::floor(x.data() + 0.5f) - (_realIsEvenHalf(x.data()) ? 1.f : 0.f));
+    return Scalar::double_v(std::floor(x.data() + 0.5 ) - (_realIsEvenHalf(x.data()) ? 1.  : 0. ));
 }
 
-template<> Vc_ALWAYS_INLINE Vector<double> round(const Vector<double> &x)
+template<typename T> static Vc_ALWAYS_INLINE Scalar::Vector<T> reciprocal(const Scalar::Vector<T> &x)
 {
-    return double_v(std::floor(x.data() + 0.5 ) - (_realIsEvenHalf(x.data()) ? 1.  : 0. ));
-}
-
-template<typename T> static Vc_ALWAYS_INLINE Vector<T> reciprocal(const Vector<T> &x)
-{
-    const typename Vector<T>::EntryType one = 1; return Vector<T>(one / x.data());
+    const typename Vector<T, VectorAbi::Scalar>::EntryType one = 1; return Scalar::Vector<T>(one / x.data());
 }
 
 #ifdef isfinite
@@ -195,12 +210,12 @@
 #ifdef isnan
 #undef isnan
 #endif
-template<typename T> static Vc_ALWAYS_INLINE typename Vector<T>::Mask isfinite(const Vector<T> &x)
+template<typename T> static Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Scalar>::Mask isfinite(const Scalar::Vector<T> &x)
 {
-    return typename Vector<T>::Mask(
+    return typename Vector<T, VectorAbi::Scalar>::Mask(
 #ifdef _MSC_VER
             !!_finite(x.data())
-#elif defined(__INTEL_COMPILER)
+#elif defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1500
             ::isfinite(x.data())
 #else
             std::isfinite(x.data())
@@ -208,12 +223,17 @@
             );
 }
 
-template<typename T> static Vc_ALWAYS_INLINE typename Vector<T>::Mask isnan(const Vector<T> &x)
+template<typename T> Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Scalar>::Mask isinf(const Scalar::Vector<T> &x)
+{
+    return typename Vector<T, VectorAbi::Scalar>::Mask(std::isinf(x.data()));
+}
+
+template<typename T> static Vc_ALWAYS_INLINE typename Vector<T, VectorAbi::Scalar>::Mask isnan(const Scalar::Vector<T> &x)
 {
-    return typename Vector<T>::Mask(
+    return typename Vector<T, VectorAbi::Scalar>::Mask(
 #ifdef _MSC_VER
             !!_isnan(x.data())
-#elif defined(__INTEL_COMPILER)
+#elif defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1500
             ::isnan(x.data())
 #else
             std::isnan(x.data())
@@ -221,33 +241,36 @@
             );
 }
 
-Vc_ALWAYS_INLINE Vector<float> frexp(Vector<float> x, Vector<int> *e) {
-    return float_v(::frexpf(x.data(), &e->data()));
+Vc_ALWAYS_INLINE Scalar::Vector<float> frexp(Scalar::Vector<float> x, SimdArray<int, 1, Scalar::Vector<int>, 1> *e) {
+    return Scalar::float_v(std::frexp(x.data(), &internal_data(*e).data()));
 }
-Vc_ALWAYS_INLINE Vector<double> frexp(Vector<double> x, Vector<int> *e) {
-    return double_v(::frexp(x.data(), &e->data()));
-}
-Vc_ALWAYS_INLINE sfloat_v frexp(sfloat_v x, short_v *e) {
-    int ee;
-    const float r = ::frexpf(x.data(), &ee);
-    e->data() = ee;
-    return sfloat_v(r);
+Vc_ALWAYS_INLINE Scalar::Vector<double> frexp(Scalar::Vector<double> x, SimdArray<int, 1, Scalar::Vector<int>, 1> *e) {
+    return Scalar::double_v(std::frexp(x.data(), &internal_data(*e).data()));
 }
 
-Vc_ALWAYS_INLINE Vector<float> ldexp(Vector<float> x, Vector<int> e) {
-    return float_v(::ldexpf(x.data(), e.data()));
+Vc_ALWAYS_INLINE Scalar::Vector<float> ldexp(Scalar::Vector<float> x, const SimdArray<int, 1, Scalar::Vector<int>, 1> &e) {
+    return Scalar::float_v(std::ldexp(x.data(), internal_data(e).data()));
 }
-Vc_ALWAYS_INLINE Vector<double> ldexp(Vector<double> x, Vector<int> e) {
-    return double_v(::ldexp(x.data(), e.data()));
+Vc_ALWAYS_INLINE Scalar::Vector<double> ldexp(Scalar::Vector<double> x, const SimdArray<int, 1, Scalar::Vector<int>, 1> &e) {
+    return Scalar::double_v(std::ldexp(x.data(), internal_data(e).data()));
 }
-Vc_ALWAYS_INLINE sfloat_v ldexp(sfloat_v x, short_v e) {
-    return sfloat_v(::ldexpf(x.data(), e.data()));
+
+// fma {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Scalar> fma(Vector<T, VectorAbi::Scalar> a,
+                                                  Vector<T, VectorAbi::Scalar> b,
+                                                  Vector<T, VectorAbi::Scalar> c)
+{
+    if (std::is_integral<T>::value) {
+        return a * b + c;
+    } else {
+        return std::fma(a.data(), b.data(), c.data());
+    }
 }
 
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+// }}}1
+}  // namespace Vc
 
-#include "undomacros.h"
+#endif // VC_SCALAR_MATH_H_
 
-#endif // VC_SCALAR_MATH_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/operators.h vc-1.3.0/scalar/operators.h
--- vc-0.7.4/scalar/operators.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/scalar/operators.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,102 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SCALAR_OPERATORS_H_
+#define VC_SCALAR_OPERATORS_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+// compare operators {{{1
+#define Vc_OP(op_)                                                                       \
+    template <typename T>                                                                \
+    Vc_INTRINSIC Scalar::Mask<T> operator op_(Scalar::Vector<T> a, Scalar::Vector<T> b)  \
+    {                                                                                    \
+        return Scalar::Mask<T>(a.data() op_ b.data());                                   \
+    }
+Vc_ALL_COMPARES(Vc_OP);
+#undef Vc_OP
+
+// bitwise operators {{{1
+#define Vc_OP(symbol)                                                                    \
+    template <typename T>                                                                \
+    Vc_INTRINSIC enable_if<std::is_integral<T>::value, Scalar::Vector<T>>                \
+    operator symbol(Scalar::Vector<T> a, Scalar::Vector<T> b)                            \
+    {                                                                                    \
+        return a.data() symbol b.data();                                                 \
+    }                                                                                    \
+    template <typename T>                                                                \
+    Vc_INTRINSIC enable_if<std::is_floating_point<T>::value, Scalar::Vector<T>>          \
+    operator symbol(Scalar::Vector<T> &lhs, Scalar::Vector<T> rhs)                       \
+    {                                                                                    \
+        using uinta =                                                                    \
+            MayAlias<typename std::conditional<sizeof(T) == sizeof(int), unsigned int,   \
+                                               unsigned long long>::type>;               \
+        uinta *left = reinterpret_cast<uinta *>(&lhs.data());                            \
+        const uinta *right = reinterpret_cast<const uinta *>(&rhs.data());               \
+        *left symbol## = *right;                                                         \
+        return lhs;                                                                      \
+    }
+Vc_ALL_BINARY(Vc_OP);
+#undef Vc_OP
+
+// arithmetic operators {{{1
+template <typename T>
+Vc_INTRINSIC Scalar::Vector<T> operator+(Scalar::Vector<T> a, Scalar::Vector<T> b)
+{
+    return a.data() + b.data();
+}
+template <typename T>
+Vc_INTRINSIC Scalar::Vector<T> operator-(Scalar::Vector<T> a, Scalar::Vector<T> b)
+{
+    return a.data() - b.data();
+}
+template <typename T>
+Vc_INTRINSIC Scalar::Vector<T> operator*(Scalar::Vector<T> a, Scalar::Vector<T> b)
+{
+    return a.data() * b.data();
+}
+template <typename T>
+Vc_INTRINSIC Scalar::Vector<T> operator/(Scalar::Vector<T> a, Scalar::Vector<T> b)
+{
+    return a.data() / b.data();
+}
+template <typename T>
+Vc_INTRINSIC Scalar::Vector<T> operator%(Scalar::Vector<T> a, Scalar::Vector<T> b)
+{
+    return a.data() % b.data();
+}
+// }}}1
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_SCALAR_OPERATORS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/simd_cast_caller.tcc vc-1.3.0/scalar/simd_cast_caller.tcc
--- vc-0.7.4/scalar/simd_cast_caller.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/scalar/simd_cast_caller.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,48 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef Vc_SCALAR_SIMD_CAST_CALLER_TCC_
+#define Vc_SCALAR_SIMD_CAST_CALLER_TCC_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#if Vc_IS_VERSION_1
+template <typename T>
+template <typename U>
+Vc_INTRINSIC Mask<T, VectorAbi::Scalar>::Mask(
+    U &&rhs, Common::enable_if_mask_converts_explicitly<T, U>)
+    : Mask(simd_cast<Mask>(std::forward<U>(rhs)))
+{
+}
+#endif
+}  // namespace Vc
+
+#endif  // Vc_SCALAR_SIMD_CAST_CALLER_TCC_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/simd_cast.h vc-1.3.0/scalar/simd_cast.h
--- vc-0.7.4/scalar/simd_cast.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/scalar/simd_cast.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,99 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SCALAR_SIMD_CAST_H_
+#define VC_SCALAR_SIMD_CAST_H_
+
+#include "../common/simd_cast.h"
+#include "type_traits.h"
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+// Scalar::Vector to Scalar::Vector
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+    simd_cast(Scalar::Vector<From> x, enable_if<Scalar::is_vector<To>::value> = nullarg)
+{
+    return static_cast<To>(x.data());
+}
+
+// Scalar::Mask to Scalar::Mask
+template <typename To, typename From>
+Vc_INTRINSIC Vc_CONST To
+    simd_cast(Scalar::Mask<From> x, enable_if<Scalar::is_mask<To>::value> = nullarg)
+{
+    return static_cast<To>(x.data());
+}
+
+// Any vector (Vector<T> or SimdArray) to multiple Scalar::Vector<T>
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    T &&x,
+    enable_if<Traits::is_simd_vector<T>::value && Scalar::is_vector<Return>::value> = nullarg)
+{
+    return Return(x[offset]);
+}
+
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<offset == 0 && Traits::is_simd_vector<Return>::value &&
+                                    !Scalar::is_vector<Return>::value,
+                                Return>
+    simd_cast(Scalar::Vector<T> x)
+{
+    Return r{};
+    r[0] = static_cast<typename Return::EntryType>(x.data());
+    return r;
+}
+
+
+// Any mask (Mask<T> or SimdMaskArray) to multiple Scalar::Mask<T>
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    T &&x,
+    enable_if<Traits::is_simd_mask<T>::value && Scalar::is_mask<Return>::value> = nullarg)
+{
+    return Return(bool(x[offset]));
+}
+
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<
+    offset == 0 && Traits::is_simd_mask<Return>::value && !Scalar::is_mask<Return>::value,
+    Return>
+    simd_cast(Scalar::Mask<T> x)
+{
+    Return r(false);
+    r[0] = x[0];
+    return r;
+}
+
+}  // namespace Vc
+
+#endif  // VC_SCALAR_SIMD_CAST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/types.h vc-1.3.0/scalar/types.h
--- vc-0.7.4/scalar/types.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/types.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,44 +1,75 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_TYPES_H
-#define VC_SCALAR_TYPES_H
-
-#define VC_DOUBLE_V_SIZE 1
-#define VC_FLOAT_V_SIZE 1
-#define VC_SFLOAT_V_SIZE 1
-#define VC_INT_V_SIZE 1
-#define VC_UINT_V_SIZE 1
-#define VC_SHORT_V_SIZE 1
-#define VC_USHORT_V_SIZE 1
+}}}*/
 
 #include "../common/types.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#ifndef VC_SCALAR_TYPES_H_
+#define VC_SCALAR_TYPES_H_
+
+#ifdef Vc_DEFAULT_IMPL_Scalar
+#define Vc_DOUBLE_V_SIZE 1
+#define Vc_FLOAT_V_SIZE 1
+#define Vc_INT_V_SIZE 1
+#define Vc_UINT_V_SIZE 1
+#define Vc_SHORT_V_SIZE 1
+#define Vc_USHORT_V_SIZE 1
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Scalar
+{
+template <typename T> using Vector = Vc::Vector<T, VectorAbi::Scalar>;
+typedef Vector<double>         double_v;
+typedef Vector<float>           float_v;
+typedef Vector<int>               int_v;
+typedef Vector<unsigned int>     uint_v;
+typedef Vector<short>           short_v;
+typedef Vector<unsigned short> ushort_v;
+
+template <typename T> using Mask = Vc::Mask<T, VectorAbi::Scalar>;
+typedef Mask<double>         double_m;
+typedef Mask<float>           float_m;
+typedef Mask<int>               int_m;
+typedef Mask<unsigned int>     uint_m;
+typedef Mask<short>           short_m;
+typedef Mask<unsigned short> ushort_m;
+
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace Scalar
+
+namespace Traits
 {
-    namespace Scalar
-    {
-        template<typename V = float> class VectorAlignedBaseT {};
-        template<typename T> class Vector;
-    } // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+template <typename T> struct is_simd_mask_internal<Scalar::Mask<T>> : public std::true_type {};
+template <typename T> struct is_simd_vector_internal<Scalar::Vector<T>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace Vc
 
-#endif // VC_SCALAR_TYPES_H
+#endif // VC_SCALAR_TYPES_H_
diff -Nru vc-0.7.4/scalar/type_traits.h vc-1.3.0/scalar/type_traits.h
--- vc-0.7.4/scalar/type_traits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/scalar/type_traits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SCALAR_TYPE_TRAITS_H_
+#define VC_SCALAR_TYPE_TRAITS_H_
+
+#include "types.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Scalar
+{
+namespace Traits
+{
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace Traits
+}
+}
+
+#endif  // VC_SCALAR_TYPE_TRAITS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/undomacros.h vc-1.3.0/scalar/undomacros.h
--- vc-0.7.4/scalar/undomacros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/undomacros.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,25 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_UNDOMACROS_H
-#define VC_SCALAR_UNDOMACROS_H
-
-#endif // VC_SCALAR_UNDOMACROS_H
-
-#include "../common/undomacros.h"
diff -Nru vc-0.7.4/scalar/vector.h vc-1.3.0/scalar/vector.h
--- vc-0.7.4/scalar/vector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,24 +1,32 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SCALAR_VECTOR_H
-#define SCALAR_VECTOR_H
+#ifndef VC_SCALAR_VECTOR_H_
+#define VC_SCALAR_VECTOR_H_
 
 #include <assert.h>
 #include <algorithm>
@@ -28,165 +36,100 @@
 #include <float.h>
 #endif
 
-#include "../common/memoryfwd.h"
-#include "macros.h"
 #include "types.h"
+#include "detail.h"
 #include "mask.h"
-#include "writemaskedvector.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Scalar
+#define Vc_CURRENT_CLASS_NAME Vector
+template <typename T> class Vector<T, VectorAbi::Scalar>
 {
-    enum VectorAlignmentEnum { VectorAlignment = 4 };
+    static_assert(std::is_arithmetic<T>::value,
+                  "Vector<T> only accepts arithmetic builtin types as template parameter T.");
 
-template<typename T>
-class Vector
-{
-    friend class WriteMaskedVector<T>;
-    public:
-        typedef typename DetermineEntryType<T>::Type EntryType;
-    protected:
-        EntryType m_data;
     public:
-        typedef Vc::Memory<Vector<T>, 1> Memory;
-        typedef Vector<unsigned int> IndexType;
-        typedef Scalar::Mask<1u> Mask;
-        typedef Vector<T> AsArg;
+        using abi = VectorAbi::Scalar;
+    Vc_ALIGNED_TYPEDEF(sizeof(T), T, EntryType);
+        using VectorEntryType = EntryType;
+        using value_type = EntryType;
+        using VectorType = EntryType;
+        using vector_type = VectorType;
+        using reference = Detail::ElementReference<Vector>;
 
-        Vc_ALWAYS_INLINE EntryType &data() { return m_data; }
-        Vc_ALWAYS_INLINE EntryType data() const { return m_data; }
+    protected:
+        VectorType m_data = VectorType();
+        template <typename U> using V = Vector<U, abi>;
 
-        enum Constants { Size = 1 };
+    public:
+        typedef Scalar::Mask<T> Mask;
+        using MaskType = Mask;
+        using mask_type = Mask;
+        typedef Mask MaskArgument;
+        typedef Vector AsArg;
+
+        Vc_ALWAYS_INLINE VectorType &data() { return m_data; }
+        Vc_ALWAYS_INLINE const VectorType &data() const { return m_data; }
+
+        static constexpr size_t Size = 1;
+        static constexpr size_t MemoryAlignment = alignof(VectorType);
+        typedef SimdArray<int, Size, Scalar::int_v, 1> IndexType;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // uninitialized
-        Vc_ALWAYS_INLINE Vector() {}
+#include "../common/generalinterface.h"
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // constants
-        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerZero::ZEnum) : m_data(0) {}
-        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerOne::OEnum) : m_data(1) {}
-        Vc_ALWAYS_INLINE Vector(VectorSpecialInitializerIndexesFromZero::IEnum) : m_data(0) {}
-        static Vc_ALWAYS_INLINE Vector Zero() { Vector r; r.m_data = 0; return r; }
-        static Vc_ALWAYS_INLINE Vector One() { Vector r; r.m_data = 1; return r; }
-        static Vc_ALWAYS_INLINE Vector IndexesFromZero() { return Zero(); }
         static Vc_INTRINSIC_L Vector Random() Vc_INTRINSIC_R;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // static_cast / copy ctor
-        template<typename OtherT> explicit Vc_ALWAYS_INLINE Vector(const Vector<OtherT> &x) : m_data(static_cast<EntryType>(x.data())) {}
-
-        // implicit cast
-        template<typename OtherT> Vc_ALWAYS_INLINE_L Vector &operator=(const Vector<OtherT> &x) Vc_ALWAYS_INLINE_R;
-
-        // copy assignment
-        Vc_ALWAYS_INLINE Vector &operator=(Vector v) { m_data = v.data(); return *this; }
+        // implict conversion from compatible Vector<U, abi>
+        template <typename U>
+        Vc_INTRINSIC Vector(
+            V<U> x, typename std::enable_if<Traits::is_implicit_cast_allowed<U, T>::value,
+                                            void *>::type = nullptr)
+            : m_data(static_cast<EntryType>(x.data()))
+        {
+        }
+
+#if Vc_IS_VERSION_1
+        // static_cast from the remaining Vector<U, abi>
+        template <typename U>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "vector types") Vc_INTRINSIC
+            explicit Vector(
+                V<U> x,
+                typename std::enable_if<!Traits::is_implicit_cast_allowed<U, T>::value,
+                                        void *>::type = nullptr)
+            : m_data(static_cast<EntryType>(x.data()))
+        {
+        }
+#endif
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // broadcast
-        explicit Vc_ALWAYS_INLINE Vector(EntryType x) : m_data(x) {}
-        template<typename TT> Vc_ALWAYS_INLINE Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *) = 0) : m_data(x) {}
-        Vc_ALWAYS_INLINE Vector &operator=(EntryType a) { m_data = a; return *this; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load ctors
-        explicit Vc_ALWAYS_INLINE Vector(const EntryType *x) : m_data(x[0]) {}
-        template<typename A> Vc_ALWAYS_INLINE Vector(const EntryType *x, A) : m_data(x[0]) {}
-        template<typename Other> explicit Vc_ALWAYS_INLINE Vector(const Other *x) : m_data(x[0]) {}
-        template<typename Other, typename A> Vc_ALWAYS_INLINE Vector(const Other *x, A) : m_data(x[0]) {}
+        Vc_INTRINSIC Vector(EntryType a) : m_data(a) {}
+        template <typename U>
+        Vc_INTRINSIC Vector(U a,
+                            typename std::enable_if<std::is_same<U, int>::value &&
+                                                        !std::is_same<U, EntryType>::value,
+                                                    void *>::type = nullptr)
+            : Vector(static_cast<EntryType>(a))
+        {
+        }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // expand 1 float_v to 2 double_v                 XXX rationale? remove it for release? XXX
-        template<typename OtherT> Vc_ALWAYS_INLINE void expand(Vector<OtherT> *x) const { x->data() = static_cast<OtherT>(m_data); }
-        template<typename OtherT> explicit Vc_ALWAYS_INLINE Vector(const Vector<OtherT> *a) : m_data(static_cast<EntryType>(a->data())) {}
+#include "../common/loadinterface.h"
+#include "../common/storeinterface.h"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // zeroing
         Vc_ALWAYS_INLINE void setZero() { m_data = 0; }
-        Vc_ALWAYS_INLINE void setZero(Mask k) { if (k) m_data = 0; }
+        Vc_ALWAYS_INLINE void setZero(Mask k) { if (k.data()) m_data = 0; }
+        Vc_ALWAYS_INLINE void setZeroInverted(Mask k) { if (!k.data()) m_data = 0; }
 
         Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;
         Vc_INTRINSIC_L void setQnan(Mask m) Vc_INTRINSIC_R;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load member functions
-        template<typename Other> Vc_ALWAYS_INLINE void load(const Other *mem) { m_data = mem[0]; }
-        template<typename Other, typename A> Vc_ALWAYS_INLINE void load(const Other *mem, A) { m_data = mem[0]; }
-        template<typename Other> Vc_ALWAYS_INLINE void load(const Other *mem, Mask m) { if (m.data()) m_data = mem[0]; }
-
-        Vc_ALWAYS_INLINE void load(const EntryType *mem) { m_data = mem[0]; }
-        template<typename A> Vc_ALWAYS_INLINE void load(const EntryType *mem, A) { m_data = mem[0]; }
-        Vc_ALWAYS_INLINE void load(const EntryType *mem, Mask m) { if (m.data()) m_data = mem[0]; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // stores
-        Vc_ALWAYS_INLINE void store(EntryType *mem) const { mem[0] = m_data; }
-        Vc_ALWAYS_INLINE void store(EntryType *mem, Mask m) const { if (m.data()) mem[0] = m_data; }
-        template<typename A> Vc_ALWAYS_INLINE void store(EntryType *mem, A) const { store(mem); }
-        template<typename A> Vc_ALWAYS_INLINE void store(EntryType *mem, Mask m, A) const { store(mem, m); }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // swizzles
-        Vc_INTRINSIC const Vector<T> &abcd() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  cdab() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  badc() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  aaaa() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  bbbb() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  cccc() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  dddd() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  bcad() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  bcda() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  dabc() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  acbd() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  dbca() const { return *this; }
-        Vc_INTRINSIC const Vector<T>  dcba() const { return *this; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // gathers
-        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, const IndexT *indexes) : m_data(array[indexes[0]]) {}
-        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, Vector<IndexT> indexes) : m_data(array[indexes[0]]) {}
-        template<typename IndexT> Vc_ALWAYS_INLINE Vector(const EntryType *array, IndexT indexes, Mask m) : m_data(m.data() ? array[indexes[0]] : 0) {}
-        template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector(const S1 *array, const EntryType S1::* member1, IT indexes, Mask mask = Mask(true))
-            : m_data(mask.data() ? (&array[indexes[0]])->*(member1) : 0) {}
-        template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector(const S1 *array, const S2 S1::* member1,
-                const EntryType S2::* member2, IT indexes, Mask mask = Mask(true))
-            : m_data(mask.data() ? array[indexes[0]].*(member1).*(member2) : 0) {}
-        template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector(const S1 *array, const EntryType *const S1::* ptrMember1,
-                IT1 outerIndex, IT2 innerIndex, Mask mask = Mask(true))
-            : m_data(mask.data() ? (array[outerIndex[0]].*(ptrMember1))[innerIndex[0]] : 0) {}
-
-        template<typename IT> Vc_ALWAYS_INLINE void gather(const EntryType *array, IT indexes, Mask mask = Mask(true))
-            { if (mask.data()) m_data = array[indexes[0]]; }
-        template<typename S1, typename IT> Vc_ALWAYS_INLINE void gather(const S1 *array, const EntryType S1::* member1, IT indexes, Mask mask = Mask(true))
-            { if (mask.data()) m_data = (&array[indexes[0]])->*(member1); }
-        template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void gather(const S1 *array, const S2 S1::* member1,
-                const EntryType S2::* member2, IT indexes, Mask mask = Mask(true))
-            { if (mask.data()) m_data = array[indexes[0]].*(member1).*(member2); }
-        template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void gather(const S1 *array, const EntryType *const S1::* ptrMember1,
-                IT1 outerIndex, IT2 innerIndex, Mask mask = Mask(true))
-            { if (mask.data()) m_data = (array[outerIndex[0]].*(ptrMember1))[innerIndex[0]]; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // scatters
-        Vc_ALWAYS_INLINE void scatter(EntryType *array, const Vector<unsigned int> &indexes, Mask m = Mask(true)) const { if (m.data()) array[indexes[0]] = m_data; }
-        template<typename S1> Vc_ALWAYS_INLINE void scatter(S1 *array, EntryType S1::* member, const Vector<unsigned int> &indexes, Mask m = Mask(true)) const {
-            if (m.data()) array[indexes[0]].*(member) = m_data;
-        }
-        template<typename S1, typename S2> Vc_ALWAYS_INLINE void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2,
-                const Vector<unsigned int> &indexes, Mask m = Mask(true)) const {
-            if (m.data()) array[indexes[0]].*(member1).*(member2) = m_data;
-        }
-
-        Vc_ALWAYS_INLINE void scatter(EntryType *array, const Vector<unsigned short> &indexes, Mask m = Mask(true)) const { if (m.data()) array[indexes[0]] = m_data; }
-        template<typename S1> Vc_ALWAYS_INLINE void scatter(S1 *array, EntryType S1::* member, const Vector<unsigned short> &indexes, Mask m = Mask(true)) const {
-            if (m.data()) array[indexes[0]].*(member) = m_data;
-        }
-        template<typename S1, typename S2> Vc_ALWAYS_INLINE void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2,
-                const Vector<unsigned short> &indexes, Mask m = Mask(true)) const {
-            if (m.data()) array[indexes[0]].*(member1).*(member2) = m_data;
-        }
+#include "../common/gatherinterface.h"
+#include "../common/scatterinterface.h"
 
         //prefix
         Vc_ALWAYS_INLINE Vector &operator++() { ++m_data; return *this; }
@@ -195,121 +138,127 @@
         Vc_ALWAYS_INLINE Vector operator++(int) { return m_data++; }
         Vc_ALWAYS_INLINE Vector operator--(int) { return m_data--; }
 
-        Vc_ALWAYS_INLINE EntryType &operator[](size_t index) {
-            assert(index == 0); if(index) {}
-            return m_data;
+    private:
+        friend reference;
+        Vc_INTRINSIC static value_type get(const Vector &o, int i) noexcept
+        {
+            Vc_ASSERT(i == 0); if (i) {}
+            return o.m_data;
+        }
+        template <typename U>
+        Vc_INTRINSIC static void set(Vector &o, int i, U &&v) noexcept(
+            noexcept(std::declval<value_type &>() = v))
+        {
+            Vc_ASSERT(i == 0); if (i) {}
+            o.m_data = v;
         }
 
-        Vc_ALWAYS_INLINE EntryType operator[](size_t index) const {
-            assert(index == 0); if(index) {}
+    public:
+        Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+        {
+            static_assert(noexcept(reference{std::declval<Vector &>(), int()}), "");
+            return {*this, int(index)};
+        }
+        Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept
+        {
+            Vc_ASSERT(index == 0); if (index) {}
             return m_data;
         }
 
-        Vc_ALWAYS_INLINE Vector operator~() const { return Vector(~m_data); }
-        Vc_ALWAYS_INLINE Vector<typename NegateTypeHelper<T>::Type> operator-() const { return Vector<typename NegateTypeHelper<T>::Type>(-m_data); }
-        Vc_INTRINSIC Vector Vc_PURE operator+() const { return *this; }
+        Vc_ALWAYS_INLINE Mask operator!() const
+        {
+            return Mask(!m_data);
+        }
+        Vc_ALWAYS_INLINE Vector operator~() const
+        {
+#ifndef Vc_ENABLE_FLOAT_BIT_OPERATORS
+            static_assert(std::is_integral<T>::value, "bit-complement can only be used with Vectors of integral type");
+#endif
+            return Vector(~m_data);
+        }
 
-#define OPshift(symbol) \
-        Vc_ALWAYS_INLINE Vector &operator symbol##=(const Vector<T> &x) { m_data symbol##= x.m_data; return *this; } \
-        Vc_ALWAYS_INLINE Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector(x)); } \
-        Vc_ALWAYS_INLINE Vector operator symbol(const Vector<T> &x) const { return Vector<T>(m_data symbol x.m_data); }
-#define OPshift_int(symbol) \
-        Vc_ALWAYS_INLINE Vector operator symbol(int x) const { return Vector(m_data symbol x); }
-#define OP(symbol) \
-        OPshift(symbol) \
-        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Vector) operator symbol(TT x) const { return operator symbol(Vector(x)); }
-#define OPcmp(symbol) \
-        Vc_ALWAYS_INLINE Mask operator symbol(const Vector<T> &x) const { return Mask(m_data symbol x.m_data); } \
-        template<typename TT> Vc_ALWAYS_INLINE VC_EXACT_TYPE(TT, EntryType, Mask) operator symbol(TT x) const { return Mask(m_data symbol x); }
-
-        VC_ALL_ARITHMETICS(OP)
-        VC_ALL_BINARY(OP)
-        VC_ALL_SHIFTS(OPshift)
-        VC_ALL_SHIFTS(OPshift_int)
-        VC_ALL_COMPARES(OPcmp)
-#undef OP
-#undef OPcmp
-#undef OPshift
-#undef OPshift_int
-        Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R;
+        Vc_ALWAYS_INLINE Vector operator-() const
+        {
+            return -m_data;
+        }
+        Vc_INTRINSIC Vector Vc_PURE operator+() const { return *this; }
 
-        Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector<T> &factor, const Vector<T> &summand) {
-            m_data = m_data * factor.data() + summand.data();
+#define Vc_OP(symbol) \
+        Vc_ALWAYS_INLINE Vc_PURE Vector operator symbol(const Vector &x) const { return Vector(m_data symbol x.m_data); }
+        Vc_ALL_SHIFTS(Vc_OP);
+#undef Vc_OP
+
+        Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC Vc_PURE Mask
+            isNegative() const
+        {
+            return Vc::isnegative(*this);
         }
 
-        Vc_ALWAYS_INLINE void assign(const Vector<T> &v, const Mask &m) {
+        Vc_ALWAYS_INLINE void assign(const Vector &v, const Mask &m) {
           if (m.data()) m_data = v.m_data;
         }
 
-        template<typename V2> Vc_ALWAYS_INLINE V2 staticCast() const { return V2(static_cast<typename V2::EntryType>(m_data)); }
-        template<typename V2> Vc_ALWAYS_INLINE V2 reinterpretCast() const {
+        template <typename V2>
+        Vc_DEPRECATED("Use simd_cast instead of Vector::staticCast") Vc_ALWAYS_INLINE V2
+            staticCast() const
+        {
+            return V2(static_cast<typename V2::EntryType>(m_data));
+        }
+        template <typename V2>
+        Vc_DEPRECATED("use reinterpret_components_cast instead") Vc_ALWAYS_INLINE V2
+            reinterpretCast() const
+        {
             typedef typename V2::EntryType AliasT2 Vc_MAY_ALIAS;
             return V2(*reinterpret_cast<const AliasT2 *>(&m_data));
         }
 
-        Vc_ALWAYS_INLINE WriteMaskedVector<T> operator()(Mask m) { return WriteMaskedVector<T>(this, m); }
-
-        Vc_ALWAYS_INLINE bool pack(Mask &m1, Vector<T> &v2, Mask &m2) {
-            if (!m1.data() && m2.data()) {
-                m_data = v2.m_data;
-                m1 = true;
-                m2 = false;
-                return true;
-            }
-            return m1;
+        Vc_ALWAYS_INLINE Common::WriteMaskedVector<Vector, Mask> operator()(Mask m)
+        {
+            return {*this, m};
         }
 
         Vc_ALWAYS_INLINE EntryType min() const { return m_data; }
         Vc_ALWAYS_INLINE EntryType max() const { return m_data; }
         Vc_ALWAYS_INLINE EntryType product() const { return m_data; }
         Vc_ALWAYS_INLINE EntryType sum() const { return m_data; }
+        Vc_ALWAYS_INLINE Vector partialSum() const { return *this; }
         Vc_ALWAYS_INLINE EntryType min(Mask) const { return m_data; }
         Vc_ALWAYS_INLINE EntryType max(Mask) const { return m_data; }
-        Vc_ALWAYS_INLINE EntryType product(Mask) const { return m_data; }
-        Vc_ALWAYS_INLINE EntryType sum(Mask m) const { if (m) return m_data; return static_cast<EntryType>(0); }
+        Vc_ALWAYS_INLINE EntryType product(Mask m) const
+        {
+            if (m.data()) {
+                return m_data;
+            } else {
+                return EntryType(1);
+            }
+        }
+        Vc_ALWAYS_INLINE EntryType sum(Mask m) const { if (m.data()) return m_data; return static_cast<EntryType>(0); }
 
+        Vc_INTRINSIC Vector Vc_VDECL shifted(int amount, Vector shiftIn) const {
+            Vc_ASSERT(amount >= -1 && amount <= 1);
+            return amount == 0 ? *this : shiftIn;
+        }
         Vc_INTRINSIC Vector shifted(int amount) const { return amount == 0 ? *this : Zero(); }
         Vc_INTRINSIC Vector rotated(int) const { return *this; }
-        Vector sorted() const { return *this; }
+        Vc_INTRINSIC Vector reversed() const { return *this; }
+        Vc_INTRINSIC Vector sorted() const { return *this; }
 
-        template<typename F> void callWithValuesSorted(F &f) {
-            f(m_data);
-        }
+        template <typename F> void callWithValuesSorted(F &&f) { f(m_data); }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f) const {
-            f(m_data);
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f) const {
-            f(m_data);
-        }
+        template <typename F> Vc_INTRINSIC void call(F &&f) const { f(m_data); }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f, Mask mask) const {
-            if (mask) {
-                f(m_data);
-            }
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f, Mask mask) const {
-            if (mask) {
+        template <typename F> Vc_INTRINSIC void call(F &&f, Mask mask) const
+        {
+            if (mask.data()) {
                 f(m_data);
             }
         }
 
-        template<typename F> Vc_INTRINSIC Vector apply(const F &f) const {
-            return Vector(f(m_data));
-        }
-        template<typename F> Vc_INTRINSIC Vector apply(F &f) const {
-            return Vector(f(m_data));
-        }
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f) const { return Vector(f(m_data)); }
 
-        template<typename F> Vc_INTRINSIC Vector apply(const F &f, Mask mask) const {
-            if (mask) {
-                return Vector(f(m_data));
-            } else {
-                return *this;
-            }
-        }
-        template<typename F> Vc_INTRINSIC Vector apply(F &f, Mask mask) const {
-            if (mask) {
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f, Mask mask) const
+        {
+            if (mask.data()) {
                 return Vector(f(m_data));
             } else {
                 return *this;
@@ -323,158 +272,82 @@
             m_data = f();
         }
 
-        Vc_INTRINSIC_L Vector copySign(Vector reference) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R;
-};
+        template <typename G> static Vc_INTRINSIC Vector generate(G gen)
+        {
+            return gen(0);
+        }
+
+        Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC Vector Vc_VDECL
+            copySign(Vector reference) const
+        {
+            return Vc::copysign(*this, reference);
+        }
 
-typedef Vector<double>         double_v;
-typedef Vector<float>          float_v;
-typedef Vector<sfloat>         sfloat_v;
-typedef Vector<int>            int_v;
-typedef Vector<unsigned int>   uint_v;
-typedef Vector<short>          short_v;
-typedef Vector<unsigned short> ushort_v;
-typedef double_v::Mask double_m;
-typedef float_v::Mask float_m;
-typedef sfloat_v::Mask sfloat_m;
-typedef int_v::Mask int_m;
-typedef uint_v::Mask uint_m;
-typedef short_v::Mask short_m;
-typedef ushort_v::Mask ushort_m;
+        Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC Vector exponent() const
+        {
+            return Vc::exponent(*this);
+        }
 
-template<typename T> class SwizzledVector : public Vector<T> {};
+        Vc_INTRINSIC Vector Vc_VDECL interleaveLow(Vector) const { return *this; }
+        Vc_INTRINSIC Vector Vc_VDECL interleaveHigh(Vector x) const { return x; }
+};
+#undef Vc_CURRENT_CLASS_NAME
+template <typename T> constexpr size_t Vector<T, VectorAbi::Scalar>::Size;
+template <typename T> constexpr size_t Vector<T, VectorAbi::Scalar>::MemoryAlignment;
+
+#define Vc_OP(symbol)                                                                    \
+    template <typename T, typename U,                                                    \
+              typename = decltype(std::declval<T &>() symbol## = std::declval<T>())>     \
+    Vc_INTRINSIC enable_if<std::is_convertible<U, Vector<T, VectorAbi::Scalar>>::value,  \
+                           Vector<T, VectorAbi::Scalar>>                                 \
+        &operator symbol##=(Vector<T, VectorAbi::Scalar> &lhs, U &&rhs)                  \
+    {                                                                                    \
+        lhs.data() symbol## = Vector<T, VectorAbi::Scalar>(std::forward<U>(rhs)).data(); \
+        return lhs;                                                                      \
+    }
+Vc_ALL_SHIFTS(Vc_OP);
+#undef Vc_OP
+
+#define Vc_CONDITIONAL_ASSIGN(name_, op_)                                                \
+    template <Operator O, typename T, typename M, typename U>                            \
+    Vc_INTRINSIC enable_if<O == Operator::name_, void> conditional_assign(               \
+        Vector<T, VectorAbi::Scalar> &lhs, M &&mask, U &&rhs)                            \
+    {                                                                                    \
+        if (mask.isFull()) {                                                             \
+            lhs op_ std::forward<U>(rhs);                                                \
+        }                                                                                \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(          Assign,  =);
+Vc_CONDITIONAL_ASSIGN(      PlusAssign, +=);
+Vc_CONDITIONAL_ASSIGN(     MinusAssign, -=);
+Vc_CONDITIONAL_ASSIGN(  MultiplyAssign, *=);
+Vc_CONDITIONAL_ASSIGN(    DivideAssign, /=);
+Vc_CONDITIONAL_ASSIGN( RemainderAssign, %=);
+Vc_CONDITIONAL_ASSIGN(       XorAssign, ^=);
+Vc_CONDITIONAL_ASSIGN(       AndAssign, &=);
+Vc_CONDITIONAL_ASSIGN(        OrAssign, |=);
+Vc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);
+Vc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);
+#undef Vc_CONDITIONAL_ASSIGN
+
+#define Vc_CONDITIONAL_ASSIGN(name_, expr_)                                              \
+    template <Operator O, typename T, typename M>                                        \
+    Vc_INTRINSIC enable_if<O == Operator::name_, Vector<T, VectorAbi::Scalar>>           \
+    conditional_assign(Vector<T, VectorAbi::Scalar> &lhs, M &&mask)                      \
+    {                                                                                    \
+        return mask.isFull() ? (expr_) : lhs;                                            \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(PostIncrement, lhs++);
+Vc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs);
+Vc_CONDITIONAL_ASSIGN(PostDecrement, lhs--);
+Vc_CONDITIONAL_ASSIGN( PreDecrement, --lhs);
+#undef Vc_CONDITIONAL_ASSIGN
 
-#ifdef _MSC_VER
-  template<typename T> static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T> &) {
-  }
-#else
-  template<typename T> static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T> &x01) {
-      __asm__ __volatile__(""::"r"(x01.data()));
-  }
-  template<> Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float> &x01) {
-      __asm__ __volatile__(""::"x"(x01.data()));
-  }
-  template<> Vc_ALWAYS_INLINE void forceToRegisters(const Vector<double> &x01) {
-      __asm__ __volatile__(""::"x"(x01.data()));
-  }
-#endif
-  template<typename T1, typename T2> static Vc_ALWAYS_INLINE void forceToRegisters(
-      const Vector<T1> &x01, const Vector<T2> &x02) {
-      forceToRegisters(x01);
-      forceToRegisters(x02);
-  }
-  template<typename T1, typename T2, typename T3> static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &, const Vector<T3>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4> static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &,
-        const Vector<T5>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &,
-        const Vector<T5>  &,  const Vector<T6>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &,
-        const Vector<T5>  &,  const Vector<T6>  &,
-        const Vector<T7>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &,
-        const Vector<T5>  &,  const Vector<T6>  &,
-        const Vector<T7>  &,  const Vector<T8>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &,  const Vector<T2>  &,
-        const Vector<T3>  &,  const Vector<T4>  &,
-        const Vector<T5>  &,  const Vector<T6>  &,
-        const Vector<T7>  &,  const Vector<T8>  &,
-        const Vector<T9>  &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &, const Vector<T12> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-    static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &, const Vector<T12> &,
-        const Vector<T13> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
-    typename T14> static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &, const Vector<T12> &,
-        const Vector<T13> &, const Vector<T14> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
-    typename T14, typename T15> static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &, const Vector<T12> &,
-        const Vector<T13> &, const Vector<T14> &,
-        const Vector<T15> &) {}
-  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-    typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
-    typename T14, typename T15, typename T16> static Vc_ALWAYS_INLINE void forceToRegisters(
-        const Vector<T1>  &, const Vector<T2>  &,
-        const Vector<T3>  &, const Vector<T4>  &,
-        const Vector<T5>  &, const Vector<T6>  &,
-        const Vector<T7>  &, const Vector<T8>  &,
-        const Vector<T9>  &, const Vector<T10> &,
-        const Vector<T11> &, const Vector<T12> &,
-        const Vector<T13> &, const Vector<T14> &,
-        const Vector<T15> &, const Vector<T16> &) {}
-
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Vc
 
 #include "vector.tcc"
-#include "math.h"
-#include "undomacros.h"
+#include "simd_cast.h"
 
-#endif // SCALAR_VECTOR_H
+#endif // VC_SCALAR_VECTOR_H_
diff -Nru vc-0.7.4/scalar/vector.tcc vc-1.3.0/scalar/vector.tcc
--- vc-0.7.4/scalar/vector.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/vector.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,244 +1,232 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-ALIGN(64) extern unsigned int RandomState[16];
-
-namespace Scalar
-{
-
-// conversion/casts {{{1
-template<> template<> Vc_INTRINSIC short_v &Vector<short>::operator=(const ushort_v &x) {
-    data() = static_cast<short>(x.data()); return *this;
-}
-template<> template<> Vc_INTRINSIC ushort_v &Vector<unsigned short>::operator=(const short_v &x) {
-    data() = static_cast<unsigned short>(x.data()); return *this;
-}
-template<> template<> Vc_INTRINSIC int_v &Vector<int>::operator=(const uint_v &x) {
-    data() = static_cast<int>(x.data()); return *this;
-}
-template<> template<> Vc_INTRINSIC uint_v &Vector<unsigned int>::operator=(const int_v &x) {
-    data() = static_cast<unsigned int>(x.data()); return *this;
-}
-
-// copySign ///////////////////////////////////////////////////////////////////////// {{{1
-template<> Vc_INTRINSIC Vector<float> Vector<float>::copySign(Vector<float> reference) const
-{
-    union {
-        float f;
-        unsigned int i;
-    } value, sign;
-    value.f = data();
-    sign.f = reference.data();
-    value.i = (sign.i & 0x80000000u) | (value.i & 0x7fffffffu);
-    return float_v(value.f);
-}
-template<> Vc_INTRINSIC sfloat_v Vector<sfloat>::copySign(sfloat_v reference) const
-{
-    return sfloat_v(float_v(m_data).copySign(float_v(reference.data())).data());
-}
-template<> Vc_INTRINSIC Vector<double> Vector<double>::copySign(Vector<double> reference) const
-{
-    union {
-        double f;
-        unsigned long long i;
-    } value, sign;
-    value.f = data();
-    sign.f = reference.data();
-    value.i = (sign.i & 0x8000000000000000ull) | (value.i & 0x7fffffffffffffffull);
-    return double_v(value.f);
-} // }}}1
-// bitwise operators {{{1
-#define VC_CAST_OPERATOR_FORWARD(op, IntT, VecT) \
-template<> Vc_ALWAYS_INLINE VecT &VecT::operator op##=(const VecT &x) { \
-    typedef IntT uinta Vc_MAY_ALIAS; \
-    uinta *left = reinterpret_cast<uinta *>(&m_data); \
-    const uinta *right = reinterpret_cast<const uinta *>(&x.m_data); \
-    *left op##= *right; \
-    return *this; \
-} \
-template<> Vc_ALWAYS_INLINE Vc_PURE VecT VecT::operator op(const VecT &x) const { \
-    VecT ret = *this; \
-    return VecT(ret op##= x); \
-}
-#define VC_CAST_OPERATOR_FORWARD_FLOAT(op)  VC_CAST_OPERATOR_FORWARD(op, unsigned int, Vector<float>)
-#define VC_CAST_OPERATOR_FORWARD_SFLOAT(op) VC_CAST_OPERATOR_FORWARD(op, unsigned int, Vector<sfloat>)
-#define VC_CAST_OPERATOR_FORWARD_DOUBLE(op) VC_CAST_OPERATOR_FORWARD(op, unsigned long long, Vector<double>)
-VC_ALL_BINARY(VC_CAST_OPERATOR_FORWARD_FLOAT)
-VC_ALL_BINARY(VC_CAST_OPERATOR_FORWARD_SFLOAT)
-VC_ALL_BINARY(VC_CAST_OPERATOR_FORWARD_DOUBLE)
-#undef VC_CAST_OPERATOR_FORWARD
-#undef VC_CAST_OPERATOR_FORWARD_FLOAT
-#undef VC_CAST_OPERATOR_FORWARD_SFLOAT
-#undef VC_CAST_OPERATOR_FORWARD_DOUBLE
-// }}}1
-// operators {{{1
-#include "../common/operators.h"
-// }}}1
-// exponent {{{1
-template<> Vc_INTRINSIC Vector<float> Vector<float>::exponent() const
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <cmath>
+#include "../common/data.h"
+#include "../common/where.h"
+#include "../common/transpose.h"
+#include "operators.h"
+#include "macros.h"
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+// special value constructors{{{1
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Scalar>::Vector(VectorSpecialInitializerZero)
+    : m_data(0)
 {
-    VC_ASSERT(m_data >= 0.f);
-    union { float f; int i; } value;
-    value.f = m_data;
-    return float_v(static_cast<float>((value.i >> 23) - 0x7f));
 }
-template<> Vc_INTRINSIC sfloat_v Vector<sfloat>::exponent() const
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Scalar>::Vector(VectorSpecialInitializerOne)
+    : m_data(1)
 {
-    return sfloat_v(float_v(m_data).exponent().data());
 }
-template<> Vc_INTRINSIC Vector<double> Vector<double>::exponent() const
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Scalar>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : m_data(0)
 {
-    VC_ASSERT(m_data >= 0.);
-    union { double f; long long i; } value;
-    value.f = m_data;
-    return double_v(static_cast<double>((value.i >> 52) - 0x3ff));
 }
-// }}}1
-// FMA {{{1
-static Vc_ALWAYS_INLINE float highBits(float x)
+
+// load member functions{{{1
+template <typename T>
+template <typename U, typename Flags>
+Vc_INTRINSIC typename Vector<T, VectorAbi::Scalar>::
+#ifndef Vc_MSVC
+template
+#endif
+load_concept<U, Flags>::type Vector<T, VectorAbi::Scalar>::load(const U *mem, Flags)
+{
+    m_data = mem[0];
+}
+
+// store member functions{{{1
+template <typename T>
+template <typename U, typename Flags, typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Scalar>::store(U *mem, Flags) const
+{
+    mem[0] = m_data;
+}
+template <typename T>
+template <typename U, typename Flags, typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Scalar>::store(U *mem, Mask mask, Flags) const
+{
+    if (mask.data())
+        mem[0] = m_data;
+}
+
+// gather {{{1
+template <typename T>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void Vector<T, VectorAbi::Scalar>::gatherImplementation(const MT *mem,
+                                                                         IT &&indexes)
 {
-    union {
-        float f;
-        unsigned int i;
-    } y;
-    y.f = x;
-    y.i &= 0xfffff000u;
-    return y.f;
-}
-static Vc_ALWAYS_INLINE double highBits(double x)
-{
-    union {
-        double f;
-        unsigned long long i;
-    } y;
-    y.f = x;
-    y.i &= 0xfffffffff8000000ull;
-    return y.f;
-}
-template<typename T> Vc_ALWAYS_INLINE T _fusedMultiplyAdd(T a, T b, T c)
-{
-    const T h1 = highBits(a);
-    const T l1 = a - h1;
-    const T h2 = highBits(b);
-    const T l2 = b - h2;
-    const T ll = l1 * l2;
-    const T lh = l1 * h2 + h1 * l2;
-    const T hh = h1 * h2;
-    if (std::abs(c) < std::abs(lh)) {
-        return (ll + c) + (lh + hh);
-    } else {
-        return (ll + lh) + (c + hh);
+    m_data = mem[indexes[0]];
+}
+
+template <typename T>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void Vector<T, VectorAbi::Scalar>::gatherImplementation(
+    const MT *mem, IT &&indexes, MaskArgument mask)
+{
+    if (mask.data()) {
+        m_data = mem[indexes[0]];
     }
 }
-template<> Vc_ALWAYS_INLINE void float_v::fusedMultiplyAdd(const float_v &f, const float_v &s)
+// scatter {{{1
+template <typename T>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void Vector<T, VectorAbi::Scalar>::scatterImplementation(MT *mem,
+                                                                          IT &&indexes)
+    const
+{
+    mem[indexes[0]] = m_data;
+}
+
+template <typename T>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void Vector<T, VectorAbi::Scalar>::scatterImplementation(
+    MT *mem, IT &&indexes, MaskArgument mask) const
 {
-    data() = _fusedMultiplyAdd(data(), f.data(), s.data());
+    if (mask.data()) {
+        mem[indexes[0]] = m_data;
+    }
 }
-template<> Vc_ALWAYS_INLINE void sfloat_v::fusedMultiplyAdd(const sfloat_v &f, const sfloat_v &s)
+
+// exponent {{{1
+Vc_INTRINSIC Vc_CONST Scalar::float_v exponent(Scalar::float_v x)
 {
-    data() = _fusedMultiplyAdd(data(), f.data(), s.data());
+    Vc_ASSERT(x.data() >= 0.f);
+    union { float f; int i; } value;
+    value.f = x.data();
+    return Scalar::float_v(static_cast<float>((value.i >> 23) - 0x7f));
 }
-template<> Vc_ALWAYS_INLINE void double_v::fusedMultiplyAdd(const double_v &f, const double_v &s)
+Vc_INTRINSIC Vc_CONST Scalar::double_v Vc_VDECL exponent(Scalar::double_v x)
 {
-    data() = _fusedMultiplyAdd(data(), f.data(), s.data());
+    Vc_ASSERT(x.data() >= 0.);
+    union { double f; long long i; } value;
+    value.f = x.data();
+    return Scalar::double_v(static_cast<double>((value.i >> 52) - 0x3ff));
 }
+
 // Random {{{1
-static Vc_ALWAYS_INLINE void _doRandomStep(Vector<unsigned int> &state0,
-        Vector<unsigned int> &state1)
+static Vc_ALWAYS_INLINE void _doRandomStep(Scalar::uint_v &state0, Scalar::uint_v &state1)
 {
-    state0.load(&Vc::RandomState[0]);
-    state1.load(&Vc::RandomState[uint_v::Size]);
-    (state1 * 0xdeece66du + 11).store(&Vc::RandomState[uint_v::Size]);
-    uint_v((state0 * 0xdeece66du + 11).data() ^ (state1.data() >> 16)).store(&Vc::RandomState[0]);
+    using Scalar::uint_v;
+    state0.load(&Common::RandomState[0]);
+    state1.load(&Common::RandomState[uint_v::Size]);
+    Detail::operator+(Detail::operator*(state1, uint_v(0xdeece66du)),
+                      uint_v(11))
+        .store(&Common::RandomState[uint_v::Size]);
+    uint_v(Detail::operator+(Detail::operator*(state0, uint_v(0xdeece66du)), uint_v(11))
+               .data() ^
+           (state1.data() >> 16))
+        .store(&Common::RandomState[0]);
 }
 
-template<typename T> Vc_INTRINSIC Vector<T> Vector<T>::Random()
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Scalar> Vector<T, VectorAbi::Scalar>::Random()
 {
-    Vector<unsigned int> state0, state1;
+    Scalar::uint_v state0, state1;
     _doRandomStep(state0, state1);
-    return Vector<T>(static_cast<EntryType>(state0.data()));
+    return Vector<T, VectorAbi::Scalar>(static_cast<EntryType>(state0.data()));
 }
-template<> Vc_INTRINSIC Vector<float> Vector<float>::Random()
+template<> Vc_INTRINSIC Scalar::float_v Scalar::float_v::Random()
 {
-    Vector<unsigned int> state0, state1;
+    Scalar::uint_v state0, state1;
     _doRandomStep(state0, state1);
     union { unsigned int i; float f; } x;
     x.i = (state0.data() & 0x0fffffffu) | 0x3f800000u;
-    return float_v(x.f - 1.f);
+    return Scalar::float_v(x.f - 1.f);
 }
-template<> Vc_INTRINSIC sfloat_v Vector<sfloat>::Random()
-{
-    return sfloat_v(Vector<float>::Random().data());
-}
-template<> Vc_INTRINSIC Vector<double> Vector<double>::Random()
+template<> Vc_INTRINSIC Scalar::double_v Scalar::double_v::Random()
 {
     typedef unsigned long long uint64 Vc_MAY_ALIAS;
-    uint64 state0 = *reinterpret_cast<const uint64 *>(&Vc::RandomState[8]);
+    uint64 state0 = *reinterpret_cast<const uint64 *>(&Common::RandomState[8]);
     state0 = (state0 * 0x5deece66dull + 11) & 0x000fffffffffffffull;
-    *reinterpret_cast<uint64 *>(&Vc::RandomState[8]) = state0;
+    *reinterpret_cast<uint64 *>(&Common::RandomState[8]) = state0;
     union { unsigned long long i; double f; } x;
     x.i = state0 | 0x3ff0000000000000ull;
-    return double_v(x.f - 1.);
+    return Scalar::double_v(x.f - 1.);
 }
-// isNegative {{{1
-template<typename T> Vc_INTRINSIC Vc_PURE typename Vector<T>::Mask Vector<T>::isNegative() const
+// isnegative {{{1
+Vc_INTRINSIC Vc_CONST Scalar::float_m isnegative(Scalar::float_v x)
 {
+    static_assert(sizeof(float) == sizeof(unsigned int),
+                  "This code assumes float and unsigned int have the same number of "
+                  "Bytes. Please file a bug report if this is a problem.");
     union { float f; unsigned int i; } u;
-    u.f = m_data;
-    return Mask(0u != (u.i & 0x80000000u));
+    u.f = x.data();
+    return Scalar::float_m(0u != (u.i & 0x80000000u));
 }
-template<> Vc_INTRINSIC Vc_PURE double_m double_v::isNegative() const
+Vc_INTRINSIC Vc_CONST Scalar::double_m Vc_VDECL isnegative(Scalar::double_v x)
 {
+    static_assert(sizeof(double) == sizeof(unsigned long long),
+                  "This code assumes double and unsigned long long have the same number "
+                  "of Bytes. Please file a bug report if this is a problem.");
     union { double d; unsigned long long l; } u;
-    u.d = m_data;
-    return double_m(0ull != (u.l & 0x8000000000000000ull));
+    u.d = x.data();
+    return Scalar::double_m(0ull != (u.l & 0x8000000000000000ull));
 }
+
 // setQnan {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::setQnan()
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Scalar>::setQnan()
 {
     union { float f; unsigned int i; } u;
     u.i = 0xffffffffu;
     m_data = u.f;
 }
-template<> Vc_INTRINSIC void double_v::setQnan()
+template<> Vc_INTRINSIC void Scalar::double_v::setQnan()
 {
     union { double d; unsigned long long l; } u;
     u.l = 0xffffffffffffffffull;
     m_data = u.d;
 }
-template<typename T> Vc_INTRINSIC void Vector<T>::setQnan(Mask m)
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Scalar>::setQnan(Mask m)
 {
-    if (m) {
+    if (m.data()) {
         setQnan();
     }
 }
-template<> Vc_INTRINSIC void double_v::setQnan(Mask m)
+template<> Vc_INTRINSIC void Scalar::double_v::setQnan(Scalar::double_v::Mask m)
 {
-    if (m) {
+    if (m.data()) {
         setQnan();
     }
 }
 // }}}1
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+
+namespace Common
+{
+// transpose_impl {{{1
+Vc_ALWAYS_INLINE void transpose_impl(TransposeTag<1, 1>, Scalar::float_v *Vc_RESTRICT r[],
+                                     const TransposeProxy<Scalar::float_v> &proxy)
+{
+    *r[0] = std::get<0>(proxy.in).data();
+}
+// }}}1
+}  // namespace Common
+}
 // vim: foldmethod=marker
diff -Nru vc-0.7.4/scalar/writemaskedvector.h vc-1.3.0/scalar/writemaskedvector.h
--- vc-0.7.4/scalar/writemaskedvector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/scalar/writemaskedvector.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,91 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SCALAR_WRITEMASKEDVECTOR_H
-#define VC_SCALAR_WRITEMASKEDVECTOR_H
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Scalar
-{
-
-template<typename T> class WriteMaskedVector
-{
-    friend class Vector<T>;
-    typedef typename Vector<T>::Mask Mask;
-    typedef typename Vector<T>::EntryType EntryType;
-    public:
-        //prefix
-        Vc_ALWAYS_INLINE Vector<T> &operator++() { if (mask) ++vec->m_data; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator--() { if (mask) --vec->m_data; return *vec; }
-        //postfix
-        Vc_ALWAYS_INLINE Vector<T> operator++(int) { if (mask) vec->m_data++; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> operator--(int) { if (mask) vec->m_data--; return *vec; }
-
-        Vc_ALWAYS_INLINE Vector<T> &operator+=(Vector<T> x) { if (mask) vec->m_data += x.m_data; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator-=(Vector<T> x) { if (mask) vec->m_data -= x.m_data; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator*=(Vector<T> x) { if (mask) vec->m_data *= x.m_data; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator/=(Vector<T> x) { if (mask) vec->m_data /= x.m_data; return *vec; }
-
-        Vc_ALWAYS_INLINE Vector<T> &operator=(Vector<T> x) {
-            vec->assign(x, mask);
-            return *vec;
-        }
-
-        Vc_ALWAYS_INLINE Vector<T> &operator+=(EntryType x) { if (mask) vec->m_data += x; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator-=(EntryType x) { if (mask) vec->m_data -= x; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator*=(EntryType x) { if (mask) vec->m_data *= x; return *vec; }
-        Vc_ALWAYS_INLINE Vector<T> &operator/=(EntryType x) { if (mask) vec->m_data /= x; return *vec; }
-
-        Vc_ALWAYS_INLINE Vector<T> &operator=(EntryType x) {
-            vec->assign(Vector<T>(x), mask);
-            return *vec;
-        }
-
-        template<typename F> Vc_ALWAYS_INLINE void call(const F &f) const {
-            vec->call(f, mask);
-        }
-        template<typename F> Vc_ALWAYS_INLINE void call(F &f) const {
-            vec->call(f, mask);
-        }
-        template<typename F> Vc_ALWAYS_INLINE Vector<T> apply(const F &f) const {
-            if (mask) {
-                return Vector<T>(f(vec->m_data));
-            } else {
-                return *vec;
-            }
-        }
-        template<typename F> Vc_ALWAYS_INLINE Vector<T> apply(F &f) const {
-            if (mask) {
-                return Vector<T>(f(vec->m_data));
-            } else {
-                return *vec;
-            }
-        }
-    private:
-        Vc_ALWAYS_INLINE WriteMaskedVector(Vector<T> *v, Mask k) : vec(v), mask(k) {}
-        Vector<T> *const vec;
-        Mask mask;
-};
-
-} // namespace Scalar
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#endif // VC_SCALAR_WRITEMASKEDVECTOR_H
diff -Nru vc-0.7.4/src/avx_sorthelper.cpp vc-1.3.0/src/avx_sorthelper.cpp
--- vc-0.7.4/src/avx_sorthelper.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/src/avx_sorthelper.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,118 +1,233 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include <avx/intrinsics.h>
-#include <avx/casts.h>
-#include <avx/sorthelper.h>
+#include <avx/vector.h>
+#include <avx/debug.h>
 #include <avx/macros.h>
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace AVX
+namespace Detail
 {
-
-template<> m128i SortHelper<short>::sort(VTArg _x)
+#ifdef Vc_IMPL_AVX2
+template <>
+Vc_CONST AVX2::short_v sorted<CurrentImplementation::current()>(AVX2::short_v x_)
 {
-    m128i lo, hi, y, x = _x;
-    // sort pairs
-    y = _mm_shufflelo_epi16(_mm_shufflehi_epi16(x, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-    x = _mm_blend_epi16(lo, hi, 0xaa);
-
-    // merge left and right quads
-    y = _mm_shufflelo_epi16(_mm_shufflehi_epi16(x, _MM_SHUFFLE(0, 1, 2, 3)), _MM_SHUFFLE(0, 1, 2, 3));
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-    x = _mm_blend_epi16(lo, hi, 0xcc);
-    y = _mm_srli_si128(x, 2);
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-    x = _mm_blend_epi16(lo, _mm_slli_si128(hi, 2), 0xaa);
-
-    // merge quads into octs
-    y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
-    y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = _mm_min_epi16(x, y);
-    hi = _mm_max_epi16(x, y);
-
-    return _mm_unpacklo_epi16(lo, hi);
+    // ab cd ef gh ij kl mn op
+    // ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑
+    // ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮
+    // ⎮ ╳ ⎮ ⎮ ╳ ⎮ ⎮ ╳ ⎮ ⎮ ╳ ⎮
+    // ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮
+    // <> <> <> <> <> <> <> <>
+    // ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑
+    // ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮
+    // ⎮ o ⎮ ⎮ o ⎮ ⎮ o ⎮ ⎮ o ⎮
+    // ⎮↓ ↑⎮ ⎮↓ ↑⎮ ⎮↓ ↑⎮ ⎮↓ ↑⎮
+    // 01 23 01 23 01 23 01 23
+    // ⎮⎮ ⎮⎮   ╳   ⎮⎮ ⎮⎮   ╳
+    // 01 23 32 10 01 23 32 10
+    // ⎮⎝ ⎮⎝ ⎠⎮ ⎠⎮ ⎮⎝ ⎮⎝ ⎠⎮ ⎠⎮
+    // ⎮ ╲⎮ ╳ ⎮╱ ⎮ ⎮ ╲⎮ ╳ ⎮╱ ⎮
+    // ⎮  ╲╱ ╲╱  ⎮ ⎮  ╲╱ ╲╱  ⎮
+    // ⎮  ╱╲ ╱╲  ⎮ ⎮  ╱╲ ╱╲  ⎮
+    // ⎮ ╱⎮ ╳ ⎮╲ ⎮ ⎮ ╱⎮ ╳ ⎮╲ ⎮
+    // ⎮⎛ ⎮⎛ ⎞⎮ ⎞⎮ ⎮⎛ ⎮⎛ ⎞⎮ ⎞⎮
+    // <> <> <> <> <> <> <> <>
+    // ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑
+    // ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮
+    // ⎮ ╳ ⎮ ⎮ ╳ ⎮ ⎮ ╳ ⎮ ⎮ ╳ ⎮
+    // ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮ ⎮⎛ ⎞⎮
+    // <> <> <> <> <> <> <> <>
+    // ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑ ↓↑
+    // ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮ ⎮⎝ ⎠⎮
+    // ⎮ o ⎮ ⎮ o ⎮ ⎮ o ⎮ ⎮ o ⎮
+    // ⎮↓ ↑⎮ ⎮↓ ↑⎮ ⎮↓ ↑⎮ ⎮↓ ↑⎮
+    // 01 23 01 23 01 23 01 23
+
+    // sort pairs (one min/max)
+    auto x = AVX::lo128(x_.data());
+    auto y = AVX::hi128(x_.data());
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    auto l = _mm_min_epi16(x, y);
+    auto h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+
+    // merge left & right quads (two min/max)
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(h, l);
+    Vc_DEBUG << "8x2 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteLo<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h));
+    y = Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+
+    // merge quads into octs (three min/max)
+    x = _mm_unpacklo_epi16(h, l);
+    y = _mm_unpackhi_epi16(l, h);
+    Vc_DEBUG << "4x4 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteLo<X2, X3, X0, X1>(Mem::blend<X0, X1, Y2, Y3, X4, X5, Y6, Y7>(h, l));
+    y = Mem::permuteHi<X6, X7, X4, X5>(Mem::blend<X0, X1, Y2, Y3, X4, X5, Y6, Y7>(l, h));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h));
+    y = Mem::permuteLo<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h) << " done?";
+
+    // merge octs into hexa (four min/max)
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(h, l);
+    Vc_DEBUG << "2x8 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_unpacklo_epi64(l, h);
+    y = _mm_unpackhi_epi64(l, h);
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_castps_si128(Mem::permute<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3>(_mm_castsi128_ps(h), _mm_castsi128_ps(l))));
+    y = _mm_castps_si128(Mem::blend<X0, Y1, X2, Y3>(_mm_castsi128_ps(l), _mm_castsi128_ps(h)));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h);
+    y = Mem::permuteLo<X1, X0, X3, X2>(
+        Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l)));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epi16(x, y);
+    h = _mm_max_epi16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(l, h);
+    return AVX::concat(x, y);
 }
-template<> m128i SortHelper<unsigned short>::sort(VTArg _x)
-{
-    m128i lo, hi, y, x = _x;
-    // sort pairs
-    y = _mm_shufflelo_epi16(_mm_shufflehi_epi16(x, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
-    x = _mm_blend_epi16(lo, hi, 0xaa);
-
-    // merge left and right quads
-    y = _mm_shufflelo_epi16(_mm_shufflehi_epi16(x, _MM_SHUFFLE(0, 1, 2, 3)), _MM_SHUFFLE(0, 1, 2, 3));
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
-    x = _mm_blend_epi16(lo, hi, 0xcc);
-    y = _mm_srli_si128(x, 2);
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
-    x = _mm_blend_epi16(lo, _mm_slli_si128(hi, 2), 0xaa);
-
-    // merge quads into octs
-    y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
-    y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = _mm_min_epu16(x, y);
-    hi = _mm_max_epu16(x, y);
 
-    return _mm_unpacklo_epi16(lo, hi);
+template <>
+Vc_CONST AVX2::ushort_v sorted<CurrentImplementation::current()>(AVX2::ushort_v x_)
+{
+    // sort pairs (one min/max)
+    auto x = AVX::lo128(x_.data());
+    auto y = AVX::hi128(x_.data());
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    auto l = _mm_min_epu16(x, y);
+    auto h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+
+    // merge left & right quads (two min/max)
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(h, l);
+    Vc_DEBUG << "8x2 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteLo<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h));
+    y = Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+
+    // merge quads into octs (three min/max)
+    x = _mm_unpacklo_epi16(h, l);
+    y = _mm_unpackhi_epi16(l, h);
+    Vc_DEBUG << "4x4 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteLo<X2, X3, X0, X1>(Mem::blend<X0, X1, Y2, Y3, X4, X5, Y6, Y7>(h, l));
+    y = Mem::permuteHi<X6, X7, X4, X5>(Mem::blend<X0, X1, Y2, Y3, X4, X5, Y6, Y7>(l, h));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h));
+    y = Mem::permuteLo<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h) << " done?";
+
+    // merge octs into hexa (four min/max)
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(h, l);
+    Vc_DEBUG << "2x8 sorted xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_unpacklo_epi64(l, h);
+    y = _mm_unpackhi_epi64(l, h);
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_castps_si128(Mem::permute<X1, X0, X3, X2>(Mem::blend<X0, Y1, X2, Y3>(_mm_castsi128_ps(h), _mm_castsi128_ps(l))));
+    y = _mm_castps_si128(Mem::blend<X0, Y1, X2, Y3>(_mm_castsi128_ps(l), _mm_castsi128_ps(h)));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(l, h);
+    y = Mem::permuteLo<X1, X0, X3, X2>(
+        Mem::permuteHi<X5, X4, X7, X6>(Mem::blend<X0, Y1, X2, Y3, X4, Y5, X6, Y7>(h, l)));
+    Vc_DEBUG << "xy: " << AVX::addType<short>(x) << AVX::addType<short>(y);
+    l = _mm_min_epu16(x, y);
+    h = _mm_max_epu16(x, y);
+    Vc_DEBUG << "lh: " << AVX::addType<short>(l) << AVX::addType<short>(h);
+    x = _mm_unpacklo_epi16(l, h);
+    y = _mm_unpackhi_epi16(l, h);
+    return AVX::concat(x, y);
 }
 
-template<> m256i SortHelper<int>::sort(VTArg _hgfedcba)
+template <> Vc_CONST AVX2::int_v sorted<CurrentImplementation::current()>(AVX2::int_v x_)
 {
-    VectorType hgfedcba = _hgfedcba;
-    const m128i hgfe = hi128(hgfedcba);
-    const m128i dcba = lo128(hgfedcba);
-    m128i l = _mm_min_epi32(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
-    m128i h = _mm_max_epi32(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
+    using namespace AVX;
+    const __m256i hgfedcba = x_.data();
+    const __m128i hgfe = hi128(hgfedcba);
+    const __m128i dcba = lo128(hgfedcba);
+    __m128i l = _mm_min_epi32(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
+    __m128i h = _mm_max_epi32(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
 
-    m128i x = _mm_unpacklo_epi32(l, h); // ↑fb ↓fb ↑ea ↓ea
-    m128i y = _mm_unpackhi_epi32(l, h); // ↑hd ↓hd ↑gc ↓gc
+    __m128i x = _mm_unpacklo_epi32(l, h); // ↑fb ↓fb ↑ea ↓ea
+    __m128i y = _mm_unpackhi_epi32(l, h); // ↑hd ↓hd ↑gc ↓gc
 
     l = _mm_min_epi32(x, y); // ↓(↑fb,↑hd) ↓hfdb ↓(↑ea,↑gc) ↓geca
     h = _mm_max_epi32(x, y); // ↑hfdb ↑(↓fb,↓hd) ↑geca ↑(↓ea,↓gc)
@@ -120,14 +235,13 @@
     x = _mm_min_epi32(l, Reg::permute<X2, X2, X0, X0>(h)); // 2(hfdb) 1(hfdb) 2(geca) 1(geca)
     y = _mm_max_epi32(h, Reg::permute<X3, X3, X1, X1>(l)); // 4(hfdb) 3(hfdb) 4(geca) 3(geca)
 
-    m128i b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
-    m128i a = _mm_unpackhi_epi64(x, y);           // a3 >= a2 >= a1 >= a0
+    __m128i b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
+    __m128i a = _mm_unpackhi_epi64(x, y);           // a3 >= a2 >= a1 >= a0
 
-    // _mm_extract_epi32 from clang < 3.4 returns an unsigned int - the static_cast is free for
-    // conforming compilers, but fixes broken ones
-    if (VC_IS_UNLIKELY(static_cast<int>(_mm_extract_epi32(x, 2)) >= static_cast<int>(_mm_extract_epi32(y, 1)))) {
+    // _mm_extract_epi32 may return an unsigned int, breaking these comparisons.
+    if (Vc_IS_UNLIKELY(static_cast<int>(_mm_extract_epi32(x, 2)) >= static_cast<int>(_mm_extract_epi32(y, 1)))) {
         return concat(Reg::permute<X0, X1, X2, X3>(b), a);
-    } else if (VC_IS_UNLIKELY(static_cast<int>(_mm_extract_epi32(x, 0)) >= static_cast<int>(_mm_extract_epi32(y, 3)))) {
+    } else if (Vc_IS_UNLIKELY(static_cast<int>(_mm_extract_epi32(x, 0)) >= static_cast<int>(_mm_extract_epi32(y, 3)))) {
         return concat(a, Reg::permute<X0, X1, X2, X3>(b));
     }
 
@@ -148,16 +262,18 @@
     return concat(_mm_unpacklo_epi32(l, h), _mm_unpackhi_epi32(l, h));
 }
 
-template<> m256i SortHelper<unsigned int>::sort(VTArg _hgfedcba)
+template <>
+Vc_CONST AVX2::uint_v sorted<CurrentImplementation::current()>(AVX2::uint_v x_)
 {
-    VectorType hgfedcba = _hgfedcba;
-    const m128i hgfe = hi128(hgfedcba);
-    const m128i dcba = lo128(hgfedcba);
-    m128i l = _mm_min_epu32(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
-    m128i h = _mm_max_epu32(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
+    using namespace AVX;
+    const __m256i hgfedcba = x_.data();
+    const __m128i hgfe = hi128(hgfedcba);
+    const __m128i dcba = lo128(hgfedcba);
+    __m128i l = _mm_min_epu32(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
+    __m128i h = _mm_max_epu32(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
 
-    m128i x = _mm_unpacklo_epi32(l, h); // ↑fb ↓fb ↑ea ↓ea
-    m128i y = _mm_unpackhi_epi32(l, h); // ↑hd ↓hd ↑gc ↓gc
+    __m128i x = _mm_unpacklo_epi32(l, h); // ↑fb ↓fb ↑ea ↓ea
+    __m128i y = _mm_unpackhi_epi32(l, h); // ↑hd ↓hd ↑gc ↓gc
 
     l = _mm_min_epu32(x, y); // ↓(↑fb,↑hd) ↓hfdb ↓(↑ea,↑gc) ↓geca
     h = _mm_max_epu32(x, y); // ↑hfdb ↑(↓fb,↓hd) ↑geca ↑(↓ea,↓gc)
@@ -165,12 +281,12 @@
     x = _mm_min_epu32(l, Reg::permute<X2, X2, X0, X0>(h)); // 2(hfdb) 1(hfdb) 2(geca) 1(geca)
     y = _mm_max_epu32(h, Reg::permute<X3, X3, X1, X1>(l)); // 4(hfdb) 3(hfdb) 4(geca) 3(geca)
 
-    m128i b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
-    m128i a = _mm_unpackhi_epi64(x, y);           // a3 >= a2 >= a1 >= a0
+    __m128i b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
+    __m128i a = _mm_unpackhi_epi64(x, y);           // a3 >= a2 >= a1 >= a0
 
-    if (VC_IS_UNLIKELY(_mm_extract_epu32(x, 2) >= _mm_extract_epu32(y, 1))) {
+    if (Vc_IS_UNLIKELY(extract_epu32<2>(x) >= extract_epu32<1>(y))) {
         return concat(Reg::permute<X0, X1, X2, X3>(b), a);
-    } else if (VC_IS_UNLIKELY(_mm_extract_epu32(x, 0) >= _mm_extract_epu32(y, 3))) {
+    } else if (Vc_IS_UNLIKELY(extract_epu32<0>(x) >= extract_epu32<3>(y))) {
         return concat(a, Reg::permute<X0, X1, X2, X3>(b));
     }
 
@@ -190,17 +306,19 @@
 
     return concat(_mm_unpacklo_epi32(l, h), _mm_unpackhi_epi32(l, h));
 }
+#endif  // AVX2
 
-template<> m256 SortHelper<float>::sort(VTArg _hgfedcba)
+template <>
+Vc_CONST AVX2::float_v sorted<CurrentImplementation::current()>(AVX2::float_v x_)
 {
-    VectorType hgfedcba = _hgfedcba;
-    const m128 hgfe = hi128(hgfedcba);
-    const m128 dcba = lo128(hgfedcba);
-    m128 l = _mm_min_ps(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
-    m128 h = _mm_max_ps(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
+    __m256 hgfedcba = x_.data();
+    const __m128 hgfe = AVX::hi128(hgfedcba);
+    const __m128 dcba = AVX::lo128(hgfedcba);
+    __m128 l = _mm_min_ps(hgfe, dcba); // ↓hd ↓gc ↓fb ↓ea
+    __m128 h = _mm_max_ps(hgfe, dcba); // ↑hd ↑gc ↑fb ↑ea
 
-    m128 x = _mm_unpacklo_ps(l, h); // ↑fb ↓fb ↑ea ↓ea
-    m128 y = _mm_unpackhi_ps(l, h); // ↑hd ↓hd ↑gc ↓gc
+    __m128 x = _mm_unpacklo_ps(l, h); // ↑fb ↓fb ↑ea ↓ea
+    __m128 y = _mm_unpackhi_ps(l, h); // ↑hd ↓hd ↑gc ↓gc
 
     l = _mm_min_ps(x, y); // ↓(↑fb,↑hd) ↓hfdb ↓(↑ea,↑gc) ↓geca
     h = _mm_max_ps(x, y); // ↑hfdb ↑(↓fb,↓hd) ↑geca ↑(↓ea,↓gc)
@@ -208,8 +326,8 @@
     x = _mm_min_ps(l, Reg::permute<X2, X2, X0, X0>(h)); // 2(hfdb) 1(hfdb) 2(geca) 1(geca)
     y = _mm_max_ps(h, Reg::permute<X3, X3, X1, X1>(l)); // 4(hfdb) 3(hfdb) 4(geca) 3(geca)
 
-    m128 a = _mm_castpd_ps(_mm_unpackhi_pd(_mm_castps_pd(x), _mm_castps_pd(y))); // a3 >= a2 >= a1 >= a0
-    m128 b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
+    __m128 a = _mm_castpd_ps(_mm_unpackhi_pd(_mm_castps_pd(x), _mm_castps_pd(y))); // a3 >= a2 >= a1 >= a0
+    __m128 b = Reg::shuffle<Y0, Y1, X0, X1>(y, x); // b3 <= b2 <= b1 <= b0
 
     // merge
     l = _mm_min_ps(a, b); // ↓a3b3 ↓a2b2 ↓a1b1 ↓a0b0
@@ -222,21 +340,17 @@
 
     a = _mm_unpacklo_ps(l, h); // ↑a2b0 ↓(↑a0b0,↑a2b2) ↑(↓a0b0,↓a2b2) ↓a0b2
     b = _mm_unpackhi_ps(l, h); // ↑a3b1 ↓(↑a1b1,↑a3b3) ↑(↓a1b1,↓a3b3) ↓a1b3
-    l = _mm_min_ps(a, b); // ↓(↑a2b0,↑a3b1) ↓(↑a0b0,↑a2b2,↑a1b1,↑a3b3) ↓(↑(↓a0b0,↓a2b2) ↑(↓a1b1,↓a3b3)) ↓a0b3
-    h = _mm_max_ps(a, b); // ↑a3b0 ↑(↓(↑a0b0,↑a2b2) ↓(↑a1b1,↑a3b3)) ↑(↓a0b0,↓a2b2,↓a1b1,↓a3b3) ↑(↓a0b2,↓a1b3)
-
-    return concat(_mm_unpacklo_ps(l, h), _mm_unpackhi_ps(l, h));
-}
+    l = _mm_min_ps(a, b); // ↓(↑a2b0,↑a3b1) ↓(↑a0b0,↑a2b2,↑a1b1,↑a3b3) ↓(↑(↓a0b0,↓a2b2),↑(↓a1b1,↓a3b3)) ↓a0b3
+    h = _mm_max_ps(a, b); // ↑a3b0 ↑(↓(↑a0b0,↑a2b2),↓(↑a1b1,↑a3b3)) ↑(↓a0b0,↓a2b2,↓a1b1,↓a3b3) ↑(↓a0b2,↓a1b3)
 
-template<> m256 SortHelper<sfloat>::sort(VTArg hgfedcba)
-{
-    return SortHelper<float>::sort(hgfedcba);
+    return AVX::concat(_mm_unpacklo_ps(l, h), _mm_unpackhi_ps(l, h));
 }
 
-template<> void SortHelper<double>::sort(m256d &VC_RESTRICT x, m256d &VC_RESTRICT y)
+#if 0
+template<> void SortHelper<double>::sort(__m256d &Vc_RESTRICT x, __m256d &Vc_RESTRICT y)
 {
-    m256d l = _mm256_min_pd(x, y); // ↓x3y3 ↓x2y2 ↓x1y1 ↓x0y0
-    m256d h = _mm256_max_pd(x, y); // ↑x3y3 ↑x2y2 ↑x1y1 ↑x0y0
+    __m256d l = _mm256_min_pd(x, y); // ↓x3y3 ↓x2y2 ↓x1y1 ↓x0y0
+    __m256d h = _mm256_max_pd(x, y); // ↑x3y3 ↑x2y2 ↑x1y1 ↑x0y0
     x = _mm256_unpacklo_pd(l, h); // ↑x2y2 ↓x2y2 ↑x0y0 ↓x0y0
     y = _mm256_unpackhi_pd(l, h); // ↑x3y3 ↓x3y3 ↑x1y1 ↓x1y1
     l = _mm256_min_pd(x, y); // ↓(↑x2y2,↑x3y3) ↓x3x2y3y2 ↓(↑x0y0,↑x1y1) ↓x1x0y1y0
@@ -245,8 +359,8 @@
     y = _mm256_unpackhi_pd(h, l); // ↓(↑x2y2,↑x3y3) ↑x3x2y3y2 ↓(↑x0y0,↑x1y1) ↑x1x0y1y0
     l = _mm256_min_pd(x, y); // ↓(↑(↓x2y2,↓x3y3) ↓(↑x2y2,↑x3y3)) ↓x3x2y3y2 ↓(↑(↓x0y0,↓x1y1) ↓(↑x0y0,↑x1y1)) ↓x1x0y1y0
     h = _mm256_max_pd(x, y); // ↑(↑(↓x2y2,↓x3y3) ↓(↑x2y2,↑x3y3)) ↑x3x2y3y2 ↑(↑(↓x0y0,↓x1y1) ↓(↑x0y0,↑x1y1)) ↑x1x0y1y0
-    m256d a = Reg::permute<X2, X3, X1, X0>(Reg::permute128<X0, X1>(h, h)); // h0 h1 h3 h2
-    m256d b = Reg::permute<X2, X3, X1, X0>(l);                             // l2 l3 l1 l0
+    __m256d a = Reg::permute<X2, X3, X1, X0>(Reg::permute128<X0, X1>(h, h)); // h0 h1 h3 h2
+    __m256d b = Reg::permute<X2, X3, X1, X0>(l);                             // l2 l3 l1 l0
 
     // a3 >= a2 >= b1 >= b0
     // b3 <= b2 <= a1 <= a0
@@ -268,26 +382,28 @@
     x = _mm256_unpacklo_pd(l, h); // h2 l2 h0 l0
     y = _mm256_unpackhi_pd(l, h); // h3 l3 h1 l1
 }
-template<> m256d SortHelper<double>::sort(VTArg _dcba)
+#endif
+template <>
+Vc_CONST AVX2::double_v sorted<CurrentImplementation::current()>(AVX2::double_v x_)
 {
-    VectorType dcba = _dcba;
+    __m256d dcba = x_.data();
     /*
      * to find the second largest number find
      * max(min(max(ab),max(cd)), min(max(ad),max(bc)))
      *  or
      * max(max(min(ab),min(cd)), min(max(ab),max(cd)))
      *
-    const m256d adcb = avx_cast<m256d>(concat(_mm_alignr_epi8(avx_cast<m128i>(dc), avx_cast<m128i>(ba), 8), _mm_alignr_epi8(avx_cast<m128i>(ba), avx_cast<m128i>(dc), 8)));
-    const m256d l = _mm256_min_pd(dcba, adcb); // min(ad cd bc ab)
-    const m256d h = _mm256_max_pd(dcba, adcb); // max(ad cd bc ab)
+    const __m256d adcb = avx_cast<__m256d>(AVX::concat(_mm_alignr_epi8(avx_cast<__m128i>(dc), avx_cast<__m128i>(ba), 8), _mm_alignr_epi8(avx_cast<__m128i>(ba), avx_cast<__m128i>(dc), 8)));
+    const __m256d l = _mm256_min_pd(dcba, adcb); // min(ad cd bc ab)
+    const __m256d h = _mm256_max_pd(dcba, adcb); // max(ad cd bc ab)
     // max(h3, h1)
     // max(min(h0,h2), min(h3,h1))
     // min(max(l0,l2), max(l3,l1))
     // min(l3, l1)
 
-    const m256d ll = _mm256_min_pd(h, Reg::permute128<X0, X1>(h, h)); // min(h3h1 h2h0 h1h3 h0h2)
-    //const m256d hh = _mm256_max_pd(h3 ll1_3 l1 l0, h1 ll0_2 l3 l2);
-    const m256d hh = _mm256_max_pd(
+    const __m256d ll = _mm256_min_pd(h, Reg::permute128<X0, X1>(h, h)); // min(h3h1 h2h0 h1h3 h0h2)
+    //const __m256d hh = _mm256_max_pd(h3 ll1_3 l1 l0, h1 ll0_2 l3 l2);
+    const __m256d hh = _mm256_max_pd(
             Reg::permute128<X1, Y0>(_mm256_unpackhi_pd(ll, h), l),
             Reg::permute128<X0, Y1>(_mm256_blend_pd(h ll, 0x1), l));
     _mm256_min_pd(hh0, hh1
@@ -298,13 +414,13 @@
     // max(max(min(ac),min(bd)), min(max(ac),max(bd)))
     // min(max(min(ac),min(bd)), min(max(ac),max(bd)))
     // min(min(ac), min(bd))
-    m128d l = _mm_min_pd(lo128(dcba), hi128(dcba)); // min(bd) min(ac)
-    m128d h = _mm_max_pd(lo128(dcba), hi128(dcba)); // max(bd) max(ac)
-    m128d h0_l0 = _mm_unpacklo_pd(l, h);
-    m128d h1_l1 = _mm_unpackhi_pd(l, h);
+    __m128d l = _mm_min_pd(AVX::lo128(dcba), AVX::hi128(dcba)); // min(bd) min(ac)
+    __m128d h = _mm_max_pd(AVX::lo128(dcba), AVX::hi128(dcba)); // max(bd) max(ac)
+    __m128d h0_l0 = _mm_unpacklo_pd(l, h);
+    __m128d h1_l1 = _mm_unpackhi_pd(l, h);
     l = _mm_min_pd(h0_l0, h1_l1);
     h = _mm_max_pd(h0_l0, h1_l1);
-    return concat(
+    return AVX::concat(
         _mm_min_pd(l, Reg::permute<X0, X0>(h)),
         _mm_max_pd(h, Reg::permute<X1, X1>(l))
             );
@@ -319,11 +435,11 @@
     // total:   17 cycles
 
     /*
-    m256d cdab = Reg::permute<X2, X3, X0, X1>(dcba);
-    m256d l = _mm256_min_pd(dcba, cdab);
-    m256d h = _mm256_max_pd(dcba, cdab);
-    m256d maxmin_ba = Reg::permute128<X0, Y0>(l, h);
-    m256d maxmin_dc = Reg::permute128<X1, Y1>(l, h);
+    __m256d cdab = Reg::permute<X2, X3, X0, X1>(dcba);
+    __m256d l = _mm256_min_pd(dcba, cdab);
+    __m256d h = _mm256_max_pd(dcba, cdab);
+    __m256d maxmin_ba = Reg::permute128<X0, Y0>(l, h);
+    __m256d maxmin_dc = Reg::permute128<X1, Y1>(l, h);
 
     l = _mm256_min_pd(maxmin_ba, maxmin_dc);
     h = _mm256_max_pd(maxmin_ba, maxmin_dc);
@@ -335,8 +451,8 @@
     // a b c d
     // b a d c
     // sort pairs
-    m256d y, l, h;
-    m128d l2, h2;
+    __m256d y, l, h;
+    __m128d l2, h2;
     y = shuffle<X1, Y0, X3, Y2>(x, x);
     l = _mm256_min_pd(x, y); // min[ab ab cd cd]
     h = _mm256_max_pd(x, y); // max[ab ab cd cd]
@@ -348,18 +464,18 @@
 
     // don't be fooled by unpack here. It works differently for AVX pd than for SSE ps
     x = _mm256_unpacklo_pd(l, h); // l_ab h_ab l_cd h_cd
-    l2 = _mm_min_pd(lo128(x), hi128(x)); // l_abcd l(h_ab hcd)
-    h2 = _mm_max_pd(lo128(x), hi128(x)); // h(l_ab l_cd) h_abcd
+    l2 = _mm_min_pd(AVX::lo128(x), AVX::hi128(x)); // l_abcd l(h_ab hcd)
+    h2 = _mm_max_pd(AVX::lo128(x), AVX::hi128(x)); // h(l_ab l_cd) h_abcd
 
     // either it is:
-    return concat(l2, h2);
+    return AVX::concat(l2, h2);
     // or:
-    // concat(_mm_unpacklo_pd(l2, h2), _mm_unpackhi_pd(l2, h2));
+    // AVX::concat(_mm_unpacklo_pd(l2, h2), _mm_unpackhi_pd(l2, h2));
 
     // I'd like to have four useful compares
-    const m128d dc = hi128(dcba);
-    const m128d ba = lo128(dcba);
-    const m256d adcb = avx_cast<m256d>(concat(_mm_alignr_epi8(avx_cast<m128i>(dc), avx_cast<m128i>(ba), 8), _mm_alignr_epi8(avx_cast<m128i>(ba), avx_cast<m128i>(dc), 8)));
+    const __m128d dc = AVX::hi128(dcba);
+    const __m128d ba = AVX::lo128(dcba);
+    const __m256d adcb = avx_cast<__m256d>(AVX::concat(_mm_alignr_epi8(avx_cast<__m128i>(dc), avx_cast<__m128i>(ba), 8), _mm_alignr_epi8(avx_cast<__m128i>(ba), avx_cast<__m128i>(dc), 8)));
 
     const int extraCmp = _mm_movemask_pd(_mm_cmpgt_pd(dc, ba));
     // 0x0: d <= b && c <= a
@@ -422,6 +538,7 @@
     */
 }
 
-} // namespace AVX
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Detail
+}  // namespace Vc
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/src/const.cpp vc-1.3.0/src/const.cpp
--- vc-0.7.4/src/const.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/src/const.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,29 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef V_ALIGN
-# ifdef __GNUC__
-#  define V_ALIGN(n) __attribute__((aligned(n)))
-# else
-#  define V_ALIGN(n) __declspec(align(n))
-# endif
-#endif
+}}}*/
 
 #include "avx/const_data.h"
 #include "sse/const_data.h"
@@ -33,156 +33,161 @@
 #include <cstdlib>
 #include <cstring>
 
+#include "common/const.h"
 #include "common/macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace AVX
 {
+    using Detail::doubleConstant;
+    using Detail::floatConstant;
+
     // cacheline 1
-    V_ALIGN(64) extern const unsigned int   _IndexesFromZero32[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-    V_ALIGN(16) extern const unsigned short _IndexesFromZero16[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-    V_ALIGN(16) extern const unsigned char  _IndexesFromZero8 [16]= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    alignas(64) extern const unsigned int   _IndexesFromZero32[ 8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+    alignas(16) extern const unsigned short _IndexesFromZero16[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    alignas(16) extern const unsigned char  _IndexesFromZero8 [32] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
 
-    template<> const double c_trig<double>::data[] = {
+    template <>
+    alignas(64) const double c_trig<double>::data[] = {
     // cacheline 4
-        Vc_buildDouble(1, 0x921fb54442d18ull, -1), // π/4
-        Vc_buildDouble(1, 0x921fb40000000ull, -1), // π/4 - 30bits precision
-        Vc_buildDouble(1, 0x4442d00000000ull, -25), // π/4 remainder1 - 32bits precision
-        Vc_buildDouble(1, 0x8469898cc5170ull, -49), // π/4 remainder2
+        doubleConstant<1, 0x921fb54442d18ull, -1>(), // π/4
+        doubleConstant<1, 0x921fb40000000ull, -1>(), // π/4 - 30bits precision
+        doubleConstant<1, 0x4442d00000000ull, -25>(), // π/4 remainder1 - 32bits precision
+        doubleConstant<1, 0x8469898cc5170ull, -49>(), // π/4 remainder2
         0.0625,
         16.,
         0., // padding
         0., // padding
     // cacheline 5
-        Vc_buildDouble( 1, 0x555555555554bull,  -5), // ~ 1/4!
-        Vc_buildDouble(-1, 0x6c16c16c14f91ull, -10), // ~-1/6!
-        Vc_buildDouble( 1, 0xa01a019c844f5ull, -16), // ~ 1/8!
-        Vc_buildDouble(-1, 0x27e4f7eac4bc6ull, -22), // ~-1/10!
-        Vc_buildDouble( 1, 0x1ee9d7b4e3f05ull, -29), // ~ 1/12!
-        Vc_buildDouble(-1, 0x8fa49a0861a9bull, -37), // ~-1/14!
-        Vc_buildDouble(-1, 0x5555555555548ull,  -3), // ~-1/3!
-        Vc_buildDouble( 1, 0x111111110f7d0ull,  -7), // ~ 1/5!
+        doubleConstant< 1, 0x555555555554bull,  -5>(), // ~ 1/4!
+        doubleConstant<-1, 0x6c16c16c14f91ull, -10>(), // ~-1/6!
+        doubleConstant< 1, 0xa01a019c844f5ull, -16>(), // ~ 1/8!
+        doubleConstant<-1, 0x27e4f7eac4bc6ull, -22>(), // ~-1/10!
+        doubleConstant< 1, 0x1ee9d7b4e3f05ull, -29>(), // ~ 1/12!
+        doubleConstant<-1, 0x8fa49a0861a9bull, -37>(), // ~-1/14!
+        doubleConstant<-1, 0x5555555555548ull,  -3>(), // ~-1/3!
+        doubleConstant< 1, 0x111111110f7d0ull,  -7>(), // ~ 1/5!
     // cacheline 8
-        Vc_buildDouble(-1, 0xa01a019bfdf03ull, -13), // ~-1/7!
-        Vc_buildDouble( 1, 0x71de3567d48a1ull, -19), // ~ 1/9!
-        Vc_buildDouble(-1, 0xae5e5a9291f5dull, -26), // ~-1/11!
-        Vc_buildDouble( 1, 0x5d8fd1fd19ccdull, -33), // ~ 1/13!
+        doubleConstant<-1, 0xa01a019bfdf03ull, -13>(), // ~-1/7!
+        doubleConstant< 1, 0x71de3567d48a1ull, -19>(), // ~ 1/9!
+        doubleConstant<-1, 0xae5e5a9291f5dull, -26>(), // ~-1/11!
+        doubleConstant< 1, 0x5d8fd1fd19ccdull, -33>(), // ~ 1/13!
         0., // padding (for alignment with float)
-        Vc_buildDouble(1, 0x8BE60DB939105ull,  0), // 4/π
-        Vc_buildDouble(1, 0x921fb54442d18ull,  0), // π/2
-        Vc_buildDouble(1, 0x921fb54442d18ull,  1), // π
+        doubleConstant<1, 0x8BE60DB939105ull,  0>(), // 4/π
+        doubleConstant<1, 0x921fb54442d18ull,  0>(), // π/2
+        doubleConstant<1, 0x921fb54442d18ull,  1>(), // π
     // cacheline 10
-        Vc_buildDouble(-1, 0xc007fa1f72594ull, -1), // atan P coefficients
-        Vc_buildDouble(-1, 0x028545b6b807aull,  4), // atan P coefficients
-        Vc_buildDouble(-1, 0x2c08c36880273ull,  6), // atan P coefficients
-        Vc_buildDouble(-1, 0xeb8bf2d05ba25ull,  6), // atan P coefficients
-        Vc_buildDouble(-1, 0x03669fd28ec8eull,  6), // atan P coefficients
-        Vc_buildDouble( 1, 0x8dbc45b14603cull,  4), // atan Q coefficients
-        Vc_buildDouble( 1, 0x4a0dd43b8fa25ull,  7), // atan Q coefficients
-        Vc_buildDouble( 1, 0xb0e18d2e2be3bull,  8), // atan Q coefficients
+        doubleConstant<-1, 0xc007fa1f72594ull, -1>(), // atan P coefficients
+        doubleConstant<-1, 0x028545b6b807aull,  4>(), // atan P coefficients
+        doubleConstant<-1, 0x2c08c36880273ull,  6>(), // atan P coefficients
+        doubleConstant<-1, 0xeb8bf2d05ba25ull,  6>(), // atan P coefficients
+        doubleConstant<-1, 0x03669fd28ec8eull,  6>(), // atan P coefficients
+        doubleConstant< 1, 0x8dbc45b14603cull,  4>(), // atan Q coefficients
+        doubleConstant< 1, 0x4a0dd43b8fa25ull,  7>(), // atan Q coefficients
+        doubleConstant< 1, 0xb0e18d2e2be3bull,  8>(), // atan Q coefficients
     // cacheline 12
-        Vc_buildDouble( 1, 0xe563f13b049eaull,  8), // atan Q coefficients
-        Vc_buildDouble( 1, 0x8519efbbd62ecull,  7), // atan Q coefficients
-        Vc_buildDouble( 1, 0x3504f333f9de6ull,  1), // tan( 3/8 π )
+        doubleConstant< 1, 0xe563f13b049eaull,  8>(), // atan Q coefficients
+        doubleConstant< 1, 0x8519efbbd62ecull,  7>(), // atan Q coefficients
+        doubleConstant< 1, 0x3504f333f9de6ull,  1>(), // tan( 3/8 π )
         0.66,                                    // lower threshold for special casing in atan
-        Vc_buildDouble(1, 0x1A62633145C07ull, -54), // remainder of pi/2
+        doubleConstant<1, 0x1A62633145C07ull, -54>(), // remainder of pi/2
         1.e-8, // small asin input threshold
         0.625, // large asin input threshold
         0., // padding
     // cacheline 14
-        Vc_buildDouble( 1, 0x84fc3988e9f08ull, -9), // asinCoeff0
-        Vc_buildDouble(-1, 0x2079259f9290full, -1), // asinCoeff0
-        Vc_buildDouble( 1, 0xbdff5baf33e6aull,  2), // asinCoeff0
-        Vc_buildDouble(-1, 0x991aaac01ab68ull,  4), // asinCoeff0
-        Vc_buildDouble( 1, 0xc896240f3081dull,  4), // asinCoeff0
-        Vc_buildDouble(-1, 0x5f2a2b6bf5d8cull,  4), // asinCoeff1
-        Vc_buildDouble( 1, 0x26219af6a7f42ull,  7), // asinCoeff1
-        Vc_buildDouble(-1, 0x7fe08959063eeull,  8), // asinCoeff1
+        doubleConstant< 1, 0x84fc3988e9f08ull, -9>(), // asinCoeff0
+        doubleConstant<-1, 0x2079259f9290full, -1>(), // asinCoeff0
+        doubleConstant< 1, 0xbdff5baf33e6aull,  2>(), // asinCoeff0
+        doubleConstant<-1, 0x991aaac01ab68ull,  4>(), // asinCoeff0
+        doubleConstant< 1, 0xc896240f3081dull,  4>(), // asinCoeff0
+        doubleConstant<-1, 0x5f2a2b6bf5d8cull,  4>(), // asinCoeff1
+        doubleConstant< 1, 0x26219af6a7f42ull,  7>(), // asinCoeff1
+        doubleConstant<-1, 0x7fe08959063eeull,  8>(), // asinCoeff1
     // cacheline 16
-        Vc_buildDouble( 1, 0x56709b0b644beull,  8), // asinCoeff1
-        Vc_buildDouble( 1, 0x16b9b0bd48ad3ull, -8), // asinCoeff2
-        Vc_buildDouble(-1, 0x34341333e5c16ull, -1), // asinCoeff2
-        Vc_buildDouble( 1, 0x5c74b178a2dd9ull,  2), // asinCoeff2
-        Vc_buildDouble(-1, 0x04331de27907bull,  4), // asinCoeff2
-        Vc_buildDouble( 1, 0x39007da779259ull,  4), // asinCoeff2
-        Vc_buildDouble(-1, 0x0656c06ceafd5ull,  3), // asinCoeff2
-        Vc_buildDouble(-1, 0xd7b590b5e0eabull,  3), // asinCoeff3
+        doubleConstant< 1, 0x56709b0b644beull,  8>(), // asinCoeff1
+        doubleConstant< 1, 0x16b9b0bd48ad3ull, -8>(), // asinCoeff2
+        doubleConstant<-1, 0x34341333e5c16ull, -1>(), // asinCoeff2
+        doubleConstant< 1, 0x5c74b178a2dd9ull,  2>(), // asinCoeff2
+        doubleConstant<-1, 0x04331de27907bull,  4>(), // asinCoeff2
+        doubleConstant< 1, 0x39007da779259ull,  4>(), // asinCoeff2
+        doubleConstant<-1, 0x0656c06ceafd5ull,  3>(), // asinCoeff2
+        doubleConstant<-1, 0xd7b590b5e0eabull,  3>(), // asinCoeff3
     // cacheline 18
-        Vc_buildDouble( 1, 0x19fc025fe9054ull,  6), // asinCoeff3
-        Vc_buildDouble(-1, 0x265bb6d3576d7ull,  7), // asinCoeff3
-        Vc_buildDouble( 1, 0x1705684ffbf9dull,  7), // asinCoeff3
-        Vc_buildDouble(-1, 0x898220a3607acull,  5), // asinCoeff3
+        doubleConstant< 1, 0x19fc025fe9054ull,  6>(), // asinCoeff3
+        doubleConstant<-1, 0x265bb6d3576d7ull,  7>(), // asinCoeff3
+        doubleConstant< 1, 0x1705684ffbf9dull,  7>(), // asinCoeff3
+        doubleConstant<-1, 0x898220a3607acull,  5>(), // asinCoeff3
     };
-#define _4(x) x
-    template<> const float c_trig<float>::data[] = {
-    // cacheline
-        _4(Vc_buildFloat( 1, 0x490FDB,  -1)), // π/4
-        _4(Vc_buildFloat( 1, 0x491000,  -1)), // π/4 - 12 bits precision
-        _4(Vc_buildFloat(-1, 0x157000, -19)), // π/4 remainder1 - 12 bits precision
-        _4(Vc_buildFloat(-1, 0x6F4B9F, -32)), // π/4 remainder2
-        _4(0.0625f),
-        _4(16.f),
-        _4(0.f), // padding
-        _4(0.f), // padding
-        _4(4.166664568298827e-2f),  // ~ 1/4!
-        _4(-1.388731625493765e-3f), // ~-1/6!
-        _4(2.443315711809948e-5f),  // ~ 1/8!
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(-1.6666654611e-1f), // ~-1/3!
-        _4(8.3321608736e-3f),  // ~ 1/5!
-    // cacheline
-        _4(-1.9515295891e-4f), // ~-1/7!
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(8192.f), // loss threshold
-        _4(Vc_buildFloat(1, 0x22F983, 0)), // 1.27323949337005615234375 = 4/π
-        _4(Vc_buildFloat(1, 0x490FDB, 0)), // π/2
-        _4(Vc_buildFloat(1, 0x490FDB, 1)), // π
-        _4(8.05374449538e-2f), // atan P coefficients
-        _4(1.38776856032e-1f), // atan P coefficients
-        _4(1.99777106478e-1f), // atan P coefficients
-        _4(3.33329491539e-1f), // atan P coefficients
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(2.414213562373095f), // tan( 3/8 π )
-        _4(0.414213562373095f), // tan( 1/8 π ) lower threshold for special casing in atan
-        _4(Vc_buildFloat(-1, 0x3BBD2E, -25)), // remainder of pi/2
-        _4(1.e-4f), // small asin input threshold
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(4.2163199048e-2f), // asinCoeff0
-        _4(2.4181311049e-2f), // asinCoeff0
-        _4(4.5470025998e-2f), // asinCoeff0
-        _4(7.4953002686e-2f), // asinCoeff0
-        _4(1.6666752422e-1f), // asinCoeff0
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
+#define Vc_4(x) x
+    template <>
+    alignas(64) const float c_trig<float>::data[] = {
+    // cacheline
+        Vc_4((floatConstant< 1, 0x490FDB,  -1>())), // π/4
+        Vc_4((floatConstant< 1, 0x491000,  -1>())), // π/4 - 12 bits precision
+        Vc_4((floatConstant<-1, 0x157000, -19>())), // π/4 remainder1 - 12 bits precision
+        Vc_4((floatConstant<-1, 0x6F4B9F, -32>())), // π/4 remainder2
+        Vc_4(0.0625f),
+        Vc_4(16.f),
+        Vc_4(0.f), // padding
+        Vc_4(0.f), // padding
+        Vc_4(4.166664568298827e-2f),  // ~ 1/4!
+        Vc_4(-1.388731625493765e-3f), // ~-1/6!
+        Vc_4(2.443315711809948e-5f),  // ~ 1/8!
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(-1.6666654611e-1f), // ~-1/3!
+        Vc_4(8.3321608736e-3f),  // ~ 1/5!
+    // cacheline
+        Vc_4(-1.9515295891e-4f), // ~-1/7!
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(8192.f), // loss threshold
+        Vc_4((floatConstant<1, 0x22F983, 0>())), // 1.27323949337005615234375 = 4/π
+        Vc_4((floatConstant<1, 0x490FDB, 0>())), // π/2
+        Vc_4((floatConstant<1, 0x490FDB, 1>())), // π
+        Vc_4(8.05374449538e-2f), // atan P coefficients
+        Vc_4(1.38776856032e-1f), // atan P coefficients
+        Vc_4(1.99777106478e-1f), // atan P coefficients
+        Vc_4(3.33329491539e-1f), // atan P coefficients
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(2.414213562373095f), // tan( 3/8 π )
+        Vc_4(0.414213562373095f), // tan( 1/8 π ) lower threshold for special casing in atan
+        Vc_4((floatConstant<-1, 0x3BBD2E, -25>())), // remainder of pi/2
+        Vc_4(1.e-4f), // small asin input threshold
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(4.2163199048e-2f), // asinCoeff0
+        Vc_4(2.4181311049e-2f), // asinCoeff0
+        Vc_4(4.5470025998e-2f), // asinCoeff0
+        Vc_4(7.4953002686e-2f), // asinCoeff0
+        Vc_4(1.6666752422e-1f), // asinCoeff0
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
     };
-#undef _4
+#undef Vc_4
 
     const unsigned       int c_general::absMaskFloat[2] = { 0xffffffffu, 0x7fffffffu };
     const unsigned       int c_general::signMaskFloat[2] = { 0x0u, 0x80000000u };
@@ -197,7 +202,7 @@
     const             double c_general::oneDouble = 1.;
     const unsigned long long c_general::frexpMask = 0xbfefffffffffffffull;
 
-    const unsigned long long c_log<double>::data[21] = {
+    alignas(64) const unsigned long long c_log<double>::data[21] = {
         0x000003ff000003ffull // bias TODO: remove
       , 0x7ff0000000000000ull // exponentMask (+inf)
 
@@ -224,7 +229,8 @@
       , 0x3ff71547652b82feull // log2(e)
     };
 
-    template<> const unsigned int c_log<float>::data[21] = {
+    template <>
+    alignas(64) const unsigned int c_log<float>::data[21] = {
         0x0000007fu // bias TODO: remove
       , 0x7f800000u // exponentMask (+inf)
 
@@ -249,193 +255,231 @@
       , 0x3ede5bd9u // log10(e)
       , 0x3fb8aa3bu // log2(e)
     };
-} // namespace AVX
+}
+}
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+    alignas(64) unsigned int RandomState[16] = {
+        0x5a383a4fu, 0xc68bd45eu, 0x691d6d86u, 0xb367e14fu,
+        0xd689dbaau, 0xfde442aau, 0x3d265423u, 0x1a77885cu,
+        0x36ed2684u, 0xfb1f049du, 0x19e52f31u, 0x821e4dd7u,
+        0x23996d25u, 0x5962725au, 0x6aced4ceu, 0xd4c610f3u
+    };
+
+    alignas(32) const unsigned int AllBitsSet[8] = {
+        0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU
+    };
+
+    const char LIBRARY_VERSION[] = Vc_VERSION_STRING;
+    const unsigned int LIBRARY_VERSION_NUMBER = Vc_VERSION_NUMBER;
+    const unsigned int LIBRARY_ABI_VERSION = Vc_LIBRARY_ABI_VERSION;
+
+    void Vc_CDECL checkLibraryAbi(unsigned int compileTimeAbi, unsigned int versionNumber,
+                                  const char *compileTimeVersion)
+    {
+        if (LIBRARY_ABI_VERSION != compileTimeAbi || LIBRARY_VERSION_NUMBER < versionNumber) {
+            printf("The versions of libVc.a (%s) and Vc/version.h (%s) are incompatible. Aborting.\n", LIBRARY_VERSION, compileTimeVersion);
+            abort();
+        }
+    }
+}
+}
 
+namespace Vc_VERSIONED_NAMESPACE
+{
 namespace SSE
 {
+    using Detail::doubleConstant;
+    using Detail::floatConstant;
+
     // cacheline 1
-    V_ALIGN(64) const int c_general::absMaskFloat[4] = { 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff };
-    V_ALIGN(16) const unsigned int c_general::signMaskFloat[4] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
-    V_ALIGN(16) const unsigned int c_general::highMaskFloat[4] = { 0xfffff000u, 0xfffff000u, 0xfffff000u, 0xfffff000u };
-    V_ALIGN(16) const short c_general::minShort[8] = { -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000 };
-    V_ALIGN(16) extern const unsigned short _IndexesFromZero8[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+    alignas(64) const int c_general::absMaskFloat[4] = { 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff };
+    alignas(16) const unsigned int c_general::signMaskFloat[4] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
+    alignas(16) const unsigned int c_general::highMaskFloat[4] = { 0xfffff000u, 0xfffff000u, 0xfffff000u, 0xfffff000u };
+    alignas(16) const short c_general::minShort[8] = { -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000 };
+    alignas(16) extern const unsigned short _IndexesFromZero8[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
 
     // cacheline 2
-    V_ALIGN(16) extern const unsigned int   _IndexesFromZero4[4] = { 0, 1, 2, 3 };
-    V_ALIGN(16) const unsigned short c_general::one16[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-    V_ALIGN(16) const unsigned int c_general::one32[4] = { 1, 1, 1, 1 };
-    V_ALIGN(16) const float c_general::oneFloat[4] = { 1.f, 1.f, 1.f, 1.f };
+    alignas(16) extern const unsigned int   _IndexesFromZero4[4] = { 0, 1, 2, 3 };
+    alignas(16) const unsigned short c_general::one16[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
+    alignas(16) const unsigned int c_general::one32[4] = { 1, 1, 1, 1 };
+    alignas(16) const float c_general::oneFloat[4] = { 1.f, 1.f, 1.f, 1.f };
 
     // cacheline 3
-    V_ALIGN(16) const unsigned long long c_general::highMaskDouble[2] = { 0xfffffffff8000000ull, 0xfffffffff8000000ull };
-    V_ALIGN(16) const double c_general::oneDouble[2] = { 1., 1. };
-    V_ALIGN(16) const long long c_general::absMaskDouble[2] = { 0x7fffffffffffffffll, 0x7fffffffffffffffll };
-    V_ALIGN(16) const unsigned long long c_general::signMaskDouble[2] = { 0x8000000000000000ull, 0x8000000000000000ull };
-    V_ALIGN(16) const unsigned long long c_general::frexpMask[2] = { 0xbfefffffffffffffull, 0xbfefffffffffffffull };
-
-#define _2(x) x, x
-    template<> const double c_trig<double>::data[] = {
+    alignas(16) const unsigned long long c_general::highMaskDouble[2] = { 0xfffffffff8000000ull, 0xfffffffff8000000ull };
+    alignas(16) const double c_general::oneDouble[2] = { 1., 1. };
+    alignas(16) const long long c_general::absMaskDouble[2] = { 0x7fffffffffffffffll, 0x7fffffffffffffffll };
+    alignas(16) const unsigned long long c_general::signMaskDouble[2] = { 0x8000000000000000ull, 0x8000000000000000ull };
+    alignas(16) const unsigned long long c_general::frexpMask[2] = { 0xbfefffffffffffffull, 0xbfefffffffffffffull };
+
+#define Vc_2(x) x, x
+    template <>
+    alignas(64) const double c_trig<double>::data[] = {
     // cacheline 4
-        _2(Vc_buildDouble(1, 0x921fb54442d18ull, -1)), // π/4
-        _2(Vc_buildDouble(1, 0x921fb40000000ull, -1)), // π/4 - 30bits precision
-        _2(Vc_buildDouble(1, 0x4442d00000000ull, -25)), // π/4 remainder1 - 32bits precision
-        _2(Vc_buildDouble(1, 0x8469898cc5170ull, -49)), // π/4 remainder2
+        Vc_2((doubleConstant<1, 0x921fb54442d18ull, -1>())), // π/4
+        Vc_2((doubleConstant<1, 0x921fb40000000ull, -1>())), // π/4 - 30bits precision
+        Vc_2((doubleConstant<1, 0x4442d00000000ull, -25>())), // π/4 remainder1 - 32bits precision
+        Vc_2((doubleConstant<1, 0x8469898cc5170ull, -49>())), // π/4 remainder2
     // cacheline 5
-        _2(0.0625),
-        _2(16.),
-        _2(0.), // padding
-        _2(0.), // padding
+        Vc_2(0.0625),
+        Vc_2(16.),
+        Vc_2(0.), // padding
+        Vc_2(0.), // padding
     // cacheline 6
-        _2(Vc_buildDouble( 1, 0x555555555554bull,  -5)), // ~ 1/4!
-        _2(Vc_buildDouble(-1, 0x6c16c16c14f91ull, -10)), // ~-1/6!
-        _2(Vc_buildDouble( 1, 0xa01a019c844f5ull, -16)), // ~ 1/8!
-        _2(Vc_buildDouble(-1, 0x27e4f7eac4bc6ull, -22)), // ~-1/10!
+        Vc_2((doubleConstant< 1, 0x555555555554bull,  -5>())), // ~ 1/4!
+        Vc_2((doubleConstant<-1, 0x6c16c16c14f91ull, -10>())), // ~-1/6!
+        Vc_2((doubleConstant< 1, 0xa01a019c844f5ull, -16>())), // ~ 1/8!
+        Vc_2((doubleConstant<-1, 0x27e4f7eac4bc6ull, -22>())), // ~-1/10!
     // cacheline 7
-        _2(Vc_buildDouble( 1, 0x1ee9d7b4e3f05ull, -29)), // ~ 1/12!
-        _2(Vc_buildDouble(-1, 0x8fa49a0861a9bull, -37)), // ~-1/14!
-        _2(Vc_buildDouble(-1, 0x5555555555548ull,  -3)), // ~-1/3!
-        _2(Vc_buildDouble( 1, 0x111111110f7d0ull,  -7)), // ~ 1/5!
+        Vc_2((doubleConstant< 1, 0x1ee9d7b4e3f05ull, -29>())), // ~ 1/12!
+        Vc_2((doubleConstant<-1, 0x8fa49a0861a9bull, -37>())), // ~-1/14!
+        Vc_2((doubleConstant<-1, 0x5555555555548ull,  -3>())), // ~-1/3!
+        Vc_2((doubleConstant< 1, 0x111111110f7d0ull,  -7>())), // ~ 1/5!
     // cacheline 8
-        _2(Vc_buildDouble(-1, 0xa01a019bfdf03ull, -13)), // ~-1/7!
-        _2(Vc_buildDouble( 1, 0x71de3567d48a1ull, -19)), // ~ 1/9!
-        _2(Vc_buildDouble(-1, 0xae5e5a9291f5dull, -26)), // ~-1/11!
-        _2(Vc_buildDouble( 1, 0x5d8fd1fd19ccdull, -33)), // ~ 1/13!
+        Vc_2((doubleConstant<-1, 0xa01a019bfdf03ull, -13>())), // ~-1/7!
+        Vc_2((doubleConstant< 1, 0x71de3567d48a1ull, -19>())), // ~ 1/9!
+        Vc_2((doubleConstant<-1, 0xae5e5a9291f5dull, -26>())), // ~-1/11!
+        Vc_2((doubleConstant< 1, 0x5d8fd1fd19ccdull, -33>())), // ~ 1/13!
     // cacheline 9
-        _2(0.), // padding (for alignment with float)
-        _2(Vc_buildDouble(1, 0x8BE60DB939105ull,  0)), // 4/π
-        _2(Vc_buildDouble(1, 0x921fb54442d18ull,  0)), // π/2
-        _2(Vc_buildDouble(1, 0x921fb54442d18ull,  1)), // π
+        Vc_2(0.), // padding (for alignment with float)
+        Vc_2((doubleConstant<1, 0x8BE60DB939105ull,  0>())), // 4/π
+        Vc_2((doubleConstant<1, 0x921fb54442d18ull,  0>())), // π/2
+        Vc_2((doubleConstant<1, 0x921fb54442d18ull,  1>())), // π
     // cacheline 10
-        _2(Vc_buildDouble(-1, 0xc007fa1f72594ull, -1)), // atan P coefficients
-        _2(Vc_buildDouble(-1, 0x028545b6b807aull,  4)), // atan P coefficients
-        _2(Vc_buildDouble(-1, 0x2c08c36880273ull,  6)), // atan P coefficients
-        _2(Vc_buildDouble(-1, 0xeb8bf2d05ba25ull,  6)), // atan P coefficients
+        Vc_2((doubleConstant<-1, 0xc007fa1f72594ull, -1>())), // atan P coefficients
+        Vc_2((doubleConstant<-1, 0x028545b6b807aull,  4>())), // atan P coefficients
+        Vc_2((doubleConstant<-1, 0x2c08c36880273ull,  6>())), // atan P coefficients
+        Vc_2((doubleConstant<-1, 0xeb8bf2d05ba25ull,  6>())), // atan P coefficients
     // cacheline 11
-        _2(Vc_buildDouble(-1, 0x03669fd28ec8eull,  6)), // atan P coefficients
-        _2(Vc_buildDouble( 1, 0x8dbc45b14603cull,  4)), // atan Q coefficients
-        _2(Vc_buildDouble( 1, 0x4a0dd43b8fa25ull,  7)), // atan Q coefficients
-        _2(Vc_buildDouble( 1, 0xb0e18d2e2be3bull,  8)), // atan Q coefficients
+        Vc_2((doubleConstant<-1, 0x03669fd28ec8eull,  6>())), // atan P coefficients
+        Vc_2((doubleConstant< 1, 0x8dbc45b14603cull,  4>())), // atan Q coefficients
+        Vc_2((doubleConstant< 1, 0x4a0dd43b8fa25ull,  7>())), // atan Q coefficients
+        Vc_2((doubleConstant< 1, 0xb0e18d2e2be3bull,  8>())), // atan Q coefficients
     // cacheline 12
-        _2(Vc_buildDouble( 1, 0xe563f13b049eaull,  8)), // atan Q coefficients
-        _2(Vc_buildDouble( 1, 0x8519efbbd62ecull,  7)), // atan Q coefficients
-        _2(Vc_buildDouble( 1, 0x3504f333f9de6ull,  1)), // tan( 3/8 π )
-        _2(0.66),                                    // lower threshold for special casing in atan
+        Vc_2((doubleConstant< 1, 0xe563f13b049eaull,  8>())), // atan Q coefficients
+        Vc_2((doubleConstant< 1, 0x8519efbbd62ecull,  7>())), // atan Q coefficients
+        Vc_2((doubleConstant< 1, 0x3504f333f9de6ull,  1>())), // tan( 3/8 π )
+        Vc_2(0.66),                                    // lower threshold for special casing in atan
     // cacheline 13
-        _2(Vc_buildDouble(1, 0x1A62633145C07ull, -54)), // remainder of pi/2
-        _2(1.e-8), // small asin input threshold
-        _2(0.625), // large asin input threshold
-        _2(0.), // padding
+        Vc_2((doubleConstant<1, 0x1A62633145C07ull, -54>())), // remainder of pi/2
+        Vc_2(1.e-8), // small asin input threshold
+        Vc_2(0.625), // large asin input threshold
+        Vc_2(0.), // padding
     // cacheline 14
-        _2(Vc_buildDouble( 1, 0x84fc3988e9f08ull, -9)), // asinCoeff0
-        _2(Vc_buildDouble(-1, 0x2079259f9290full, -1)), // asinCoeff0
-        _2(Vc_buildDouble( 1, 0xbdff5baf33e6aull,  2)), // asinCoeff0
-        _2(Vc_buildDouble(-1, 0x991aaac01ab68ull,  4)), // asinCoeff0
+        Vc_2((doubleConstant< 1, 0x84fc3988e9f08ull, -9>())), // asinCoeff0
+        Vc_2((doubleConstant<-1, 0x2079259f9290full, -1>())), // asinCoeff0
+        Vc_2((doubleConstant< 1, 0xbdff5baf33e6aull,  2>())), // asinCoeff0
+        Vc_2((doubleConstant<-1, 0x991aaac01ab68ull,  4>())), // asinCoeff0
     // cacheline 15
-        _2(Vc_buildDouble( 1, 0xc896240f3081dull,  4)), // asinCoeff0
-        _2(Vc_buildDouble(-1, 0x5f2a2b6bf5d8cull,  4)), // asinCoeff1
-        _2(Vc_buildDouble( 1, 0x26219af6a7f42ull,  7)), // asinCoeff1
-        _2(Vc_buildDouble(-1, 0x7fe08959063eeull,  8)), // asinCoeff1
+        Vc_2((doubleConstant< 1, 0xc896240f3081dull,  4>())), // asinCoeff0
+        Vc_2((doubleConstant<-1, 0x5f2a2b6bf5d8cull,  4>())), // asinCoeff1
+        Vc_2((doubleConstant< 1, 0x26219af6a7f42ull,  7>())), // asinCoeff1
+        Vc_2((doubleConstant<-1, 0x7fe08959063eeull,  8>())), // asinCoeff1
     // cacheline 16
-        _2(Vc_buildDouble( 1, 0x56709b0b644beull,  8)), // asinCoeff1
-        _2(Vc_buildDouble( 1, 0x16b9b0bd48ad3ull, -8)), // asinCoeff2
-        _2(Vc_buildDouble(-1, 0x34341333e5c16ull, -1)), // asinCoeff2
-        _2(Vc_buildDouble( 1, 0x5c74b178a2dd9ull,  2)), // asinCoeff2
+        Vc_2((doubleConstant< 1, 0x56709b0b644beull,  8>())), // asinCoeff1
+        Vc_2((doubleConstant< 1, 0x16b9b0bd48ad3ull, -8>())), // asinCoeff2
+        Vc_2((doubleConstant<-1, 0x34341333e5c16ull, -1>())), // asinCoeff2
+        Vc_2((doubleConstant< 1, 0x5c74b178a2dd9ull,  2>())), // asinCoeff2
     // cacheline 17
-        _2(Vc_buildDouble(-1, 0x04331de27907bull,  4)), // asinCoeff2
-        _2(Vc_buildDouble( 1, 0x39007da779259ull,  4)), // asinCoeff2
-        _2(Vc_buildDouble(-1, 0x0656c06ceafd5ull,  3)), // asinCoeff2
-        _2(Vc_buildDouble(-1, 0xd7b590b5e0eabull,  3)), // asinCoeff3
+        Vc_2((doubleConstant<-1, 0x04331de27907bull,  4>())), // asinCoeff2
+        Vc_2((doubleConstant< 1, 0x39007da779259ull,  4>())), // asinCoeff2
+        Vc_2((doubleConstant<-1, 0x0656c06ceafd5ull,  3>())), // asinCoeff2
+        Vc_2((doubleConstant<-1, 0xd7b590b5e0eabull,  3>())), // asinCoeff3
     // cacheline 18
-        _2(Vc_buildDouble( 1, 0x19fc025fe9054ull,  6)), // asinCoeff3
-        _2(Vc_buildDouble(-1, 0x265bb6d3576d7ull,  7)), // asinCoeff3
-        _2(Vc_buildDouble( 1, 0x1705684ffbf9dull,  7)), // asinCoeff3
-        _2(Vc_buildDouble(-1, 0x898220a3607acull,  5)), // asinCoeff3
+        Vc_2((doubleConstant< 1, 0x19fc025fe9054ull,  6>())), // asinCoeff3
+        Vc_2((doubleConstant<-1, 0x265bb6d3576d7ull,  7>())), // asinCoeff3
+        Vc_2((doubleConstant< 1, 0x1705684ffbf9dull,  7>())), // asinCoeff3
+        Vc_2((doubleConstant<-1, 0x898220a3607acull,  5>())), // asinCoeff3
     };
-#undef _2
-#define _4(x) x, x, x, x
-    template<> const float c_trig<float>::data[] = {
-    // cacheline
-        _4(Vc_buildFloat( 1, 0x490FDB,  -1)), // π/4
-        _4(Vc_buildFloat( 1, 0x491000,  -1)), // π/4 - 12 bits precision
-        _4(Vc_buildFloat(-1, 0x157000, -19)), // π/4 remainder1 - 12 bits precision
-        _4(Vc_buildFloat(-1, 0x6F4B9F, -32)), // π/4 remainder2
-    // cacheline
-        _4(0.0625f),
-        _4(16.f),
-        _4(0.f), // padding
-        _4(0.f), // padding
-    // cacheline
-        _4(4.166664568298827e-2f),  // ~ 1/4!
-        _4(-1.388731625493765e-3f), // ~-1/6!
-        _4(2.443315711809948e-5f),  // ~ 1/8!
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(-1.6666654611e-1f), // ~-1/3!
-        _4(8.3321608736e-3f),  // ~ 1/5!
-    // cacheline
-        _4(-1.9515295891e-4f), // ~-1/7!
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(8192.f), // loss threshold
-        _4(Vc_buildFloat(1, 0x22F983, 0)), // 1.27323949337005615234375 = 4/π
-        _4(Vc_buildFloat(1, 0x490FDB, 0)), // π/2
-        _4(Vc_buildFloat(1, 0x490FDB, 1)), // π
-    // cacheline
-        _4(8.05374449538e-2f), // atan P coefficients
-        _4(1.38776856032e-1f), // atan P coefficients
-        _4(1.99777106478e-1f), // atan P coefficients
-        _4(3.33329491539e-1f), // atan P coefficients
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(2.414213562373095f), // tan( 3/8 π )
-        _4(0.414213562373095f), // tan( 1/8 π ) lower threshold for special casing in atan
-    // cacheline
-        _4(Vc_buildFloat(-1, 0x3BBD2E, -25)), // remainder of pi/2
-        _4(1.e-4f), // small asin input threshold
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(4.2163199048e-2f), // asinCoeff0
-        _4(2.4181311049e-2f), // asinCoeff0
-        _4(4.5470025998e-2f), // asinCoeff0
-        _4(7.4953002686e-2f), // asinCoeff0
-    // cacheline
-        _4(1.6666752422e-1f), // asinCoeff0
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-    // cacheline
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
-        _4(0.f), // padding (for alignment with double)
+#undef Vc_2
+#define Vc_4(x) x, x, x, x
+    template <>
+    alignas(64) const float c_trig<float>::data[] = {
+    // cacheline
+        Vc_4((floatConstant< 1, 0x490FDB,  -1>())), // π/4
+        Vc_4((floatConstant< 1, 0x491000,  -1>())), // π/4 - 12 bits precision
+        Vc_4((floatConstant<-1, 0x157000, -19>())), // π/4 remainder1 - 12 bits precision
+        Vc_4((floatConstant<-1, 0x6F4B9F, -32>())), // π/4 remainder2
+    // cacheline
+        Vc_4(0.0625f),
+        Vc_4(16.f),
+        Vc_4(0.f), // padding
+        Vc_4(0.f), // padding
+    // cacheline
+        Vc_4(4.166664568298827e-2f),  // ~ 1/4!
+        Vc_4(-1.388731625493765e-3f), // ~-1/6!
+        Vc_4(2.443315711809948e-5f),  // ~ 1/8!
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(-1.6666654611e-1f), // ~-1/3!
+        Vc_4(8.3321608736e-3f),  // ~ 1/5!
+    // cacheline
+        Vc_4(-1.9515295891e-4f), // ~-1/7!
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(8192.f), // loss threshold
+        Vc_4((floatConstant<1, 0x22F983, 0>())), // 1.27323949337005615234375 = 4/π
+        Vc_4((floatConstant<1, 0x490FDB, 0>())), // π/2
+        Vc_4((floatConstant<1, 0x490FDB, 1>())), // π
+    // cacheline
+        Vc_4(8.05374449538e-2f), // atan P coefficients
+        Vc_4(1.38776856032e-1f), // atan P coefficients
+        Vc_4(1.99777106478e-1f), // atan P coefficients
+        Vc_4(3.33329491539e-1f), // atan P coefficients
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(2.414213562373095f), // tan( 3/8 π )
+        Vc_4(0.414213562373095f), // tan( 1/8 π ) lower threshold for special casing in atan
+    // cacheline
+        Vc_4((floatConstant<-1, 0x3BBD2E, -25>())), // remainder of pi/2
+        Vc_4(1.e-4f), // small asin input threshold
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(4.2163199048e-2f), // asinCoeff0
+        Vc_4(2.4181311049e-2f), // asinCoeff0
+        Vc_4(4.5470025998e-2f), // asinCoeff0
+        Vc_4(7.4953002686e-2f), // asinCoeff0
+    // cacheline
+        Vc_4(1.6666752422e-1f), // asinCoeff0
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+    // cacheline
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
+        Vc_4(0.f), // padding (for alignment with double)
     };
-#undef _4
+#undef Vc_4
 
     // cacheline 8
-    V_ALIGN(16) extern const unsigned char _IndexesFromZero16[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    alignas(16) extern const unsigned char _IndexesFromZero16[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
 
-    V_ALIGN(64) const unsigned long long c_log<double>::data[21 * 2] = {
+    alignas(64) const unsigned long long c_log<double>::data[21 * 2] = {
       /* 0*/   0x000003ff000003ffull, 0x000003ff000003ffull // bias TODO: remove
       /* 1*/ , 0x7ff0000000000000ull, 0x7ff0000000000000ull // exponentMask (+inf)
 
@@ -462,7 +506,7 @@
       /*20*/ , 0x3ff71547652b82feull, 0x3ff71547652b82feull // log2(e)
     };
 
-    template<> V_ALIGN(64) const unsigned int c_log<float>::data[21 * 4] = {
+    template<> alignas(64) const unsigned int c_log<float>::data[21 * 4] = {
         0x0000007fu, 0x0000007fu, 0x0000007fu, 0x0000007fu, // bias TODO: remove
         0x7f800000u, 0x7f800000u, 0x7f800000u, 0x7f800000u, // exponentMask (+inf)
 
@@ -482,48 +526,21 @@
         0x00800000u, 0x00800000u, 0x00800000u, 0x00800000u, // min()
         0x3f3504f3u, 0x3f3504f3u, 0x3f3504f3u, 0x3f3504f3u, // 1/sqrt(2)
         // ln(2) = 0x3fe62e42fefa39ef
-        // ln(2) = Vc_buildDouble( 1, 0x00062e42fefa39ef, -1)
-        //       = Vc_buildFloat( 1, 0x00317217(f7d), -1) + Vc_buildFloat( 1, 0x0077d1cd, -25)
-        //       = Vc_buildFloat( 1, 0x00318000(000), -1) + Vc_buildFloat(-1, 0x005e8083, -13)
+        // ln(2) = doubleConstant< 1, 0x00062e42fefa39ef, -1>()
+        //       = floatConstant< 1, 0x00317217(f7d>(), -1) + floatConstant< 1, 0x0077d1cd, -25>()
+        //       = floatConstant< 1, 0x00318000(000>(), -1) + floatConstant<-1, 0x005e8083, -13>()
         0x3f318000u, 0x3f318000u, 0x3f318000u, 0x3f318000u, // round(ln(2) * 512) / 512
         0xb95e8083u, 0xb95e8083u, 0xb95e8083u, 0xb95e8083u, // ln(2) - round(ln(2) * 512) / 512
         0x3f000000u, 0x3f000000u, 0x3f000000u, 0x3f000000u, // 0.5
         0x3ede5bd9u, 0x3ede5bd9u, 0x3ede5bd9u, 0x3ede5bd9u, // log10(e)
         0x3fb8aa3bu, 0x3fb8aa3bu, 0x3fb8aa3bu, 0x3fb8aa3bu, // log2(e)
         // log10(2) = 0x3fd34413509f79ff
-        //          = Vc_buildDouble( 1, 0x00034413509f79ff, -2)
-        //          = Vc_buildFloat( 1, 0x001a209a(84fbcff8), -2) + Vc_buildFloat( 1, 0x0004fbcff(8), -26)
-        //Vc_buildFloat( 1, 0x001a209a, -2), // log10(2)
-        //Vc_buildFloat( 1, 0x001a209a, -2), // log10(2)
-        //Vc_buildFloat( 1, 0x001a209a, -2), // log10(2)
-        //Vc_buildFloat( 1, 0x001a209a, -2), // log10(2)
+        //          = doubleConstant< 1, 0x00034413509f79ff, -2>()
+        //          = floatConstant< 1, 0x001a209a(84fbcff8>(), -2) + floatConstant< 1, 0x0004fbcff(8>(), -26)
+        //floatConstant< 1, 0x001a209a, -2>(), // log10(2)
+        //floatConstant< 1, 0x001a209a, -2>(), // log10(2)
+        //floatConstant< 1, 0x001a209a, -2>(), // log10(2)
+        //floatConstant< 1, 0x001a209a, -2>(), // log10(2)
     };
-} // namespace SSE
-
-V_ALIGN(64) unsigned int RandomState[16] = {
-    0x5a383a4fu, 0xc68bd45eu, 0x691d6d86u, 0xb367e14fu,
-    0xd689dbaau, 0xfde442aau, 0x3d265423u, 0x1a77885cu,
-    0x36ed2684u, 0xfb1f049du, 0x19e52f31u, 0x821e4dd7u,
-    0x23996d25u, 0x5962725au, 0x6aced4ceu, 0xd4c610f3u
-};
-
-// dummy symbol to emit warnings with GCC 4.3
-namespace Warnings {
-    void _operator_bracket_warning() {}
-} // namespace Warnings
-
-const char LIBRARY_VERSION[] = VC_VERSION_STRING;
-const unsigned int LIBRARY_VERSION_NUMBER = VC_VERSION_NUMBER;
-const unsigned int LIBRARY_ABI_VERSION = VC_LIBRARY_ABI_VERSION;
-
-void checkLibraryAbi(unsigned int compileTimeAbi, unsigned int versionNumber, const char *compileTimeVersion) {
-    if (LIBRARY_ABI_VERSION != compileTimeAbi || LIBRARY_VERSION_NUMBER < versionNumber) {
-        printf("The versions of libVc.a (%s) and Vc/version.h (%s) are incompatible. Aborting.\n", LIBRARY_VERSION, compileTimeVersion);
-        abort();
-    }
 }
-
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#undef V_ALIGN
+}
diff -Nru vc-0.7.4/src/cpuid.cpp vc-1.3.0/src/cpuid.cpp
--- vc-0.7.4/src/cpuid.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/src/cpuid.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,32 +1,42 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include <Vc/cpuid.h>
 #include <Vc/global.h>
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
+
 CpuId::uint   CpuId::s_ecx0 = 0;
 CpuId::uint   CpuId::s_logicalProcessors = 0;
 CpuId::uint   CpuId::s_processorFeaturesC = 0;
 CpuId::uint   CpuId::s_processorFeaturesD = 0;
+CpuId::uint   CpuId::s_processorFeatures7B = 0;
+CpuId::uint   CpuId::s_processorFeatures7C = 0;
 CpuId::uint   CpuId::s_processorFeatures8C = 0;
 CpuId::uint   CpuId::s_processorFeatures8D = 0;
 CpuId::uint   CpuId::s_L1Instruction = 0;
@@ -40,7 +50,7 @@
 CpuId::uint   CpuId::s_L1Associativity = 0;
 CpuId::uint   CpuId::s_L2Associativity = 0;
 CpuId::uint   CpuId::s_L3Associativity = 0;
-CpuId::ushort CpuId::s_prefetch = 32; // The Intel ORM says that if CPUID(2) doesn't set the prefetch size it is 32
+CpuId::ushort CpuId::s_prefetch = 32; // The Intel ORM says that if Vc_CPUID(2) doesn't set the prefetch size it is 32
 CpuId::uchar  CpuId::s_brandIndex = 0;
 CpuId::uchar  CpuId::s_cacheLineSize = 0;
 CpuId::uchar  CpuId::s_processorModel = 0;
@@ -48,14 +58,15 @@
 CpuId::ProcessorType CpuId::s_processorType = CpuId::IntelReserved;
 bool   CpuId::s_noL2orL3 = false;
 
-#ifdef VC_MSVC
-} // better not include intrin.h inside the Vc namespace :)
-/*OUTER_NAMESPACE_END*/
+#ifdef _WIN32
+
+}
+// better not include intrin.h inside the Vc namespace :)
 #include <intrin.h>
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-#define CPUID(leaf) \
+
+#define Vc_CPUID(leaf) \
     do { \
         int out[4]; \
         __cpuid(out, leaf); \
@@ -64,14 +75,14 @@
         ecx = out[2]; \
         edx = out[3]; \
     } while (false)
-#define CPUID_C(leaf, _ecx_) \
-    do { \
-        int out[4]; \
-        __cpuidex(out, leaf, _ecx_); \
-        eax = out[0]; \
-        ebx = out[1]; \
-        ecx = out[2]; \
-        edx = out[3]; \
+#define Vc_CPUID_C(leaf, ecx_)                                                           \
+    do {                                                                                 \
+        int out[4];                                                                      \
+        __cpuidex(out, leaf, ecx_);                                                      \
+        eax = out[0];                                                                    \
+        ebx = out[1];                                                                    \
+        ecx = out[2];                                                                    \
+        edx = out[3];                                                                    \
     } while (false)
 #elif defined(__i386__) && defined(__PIC__)
 // %ebx may be the PIC register.
@@ -86,17 +97,17 @@
         : [leaf] "a"(leaf)
       );
 }
-#define CPUID(leaf) \
+#define Vc_CPUID(leaf) \
     ecx = 0; \
     _Vc_cpuid(leaf, eax, ebx, ecx, edx)
-#define CPUID_C(leaf, _ecx_) \
-    ecx = _ecx_; \
+#define Vc_CPUID_C(leaf, ecx_)                                                           \
+    ecx = ecx_;                                                                          \
     _Vc_cpuid(leaf, eax, ebx, ecx, edx)
 #else
-#define CPUID(leaf) \
+#define Vc_CPUID(leaf) \
     __asm__("cpuid" : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx) : "a"(leaf))
-#define CPUID_C(leaf, _ecx_) \
-    __asm__("cpuid" : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx) : "a"(leaf), "c"(_ecx_))
+#define Vc_CPUID_C(leaf, ecx_)                                                           \
+    __asm__("cpuid" : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx) : "a"(leaf), "c"(ecx_))
 #endif
 static unsigned int CpuIdAmdAssociativityTable(int bits)
 {
@@ -126,29 +137,34 @@
     }
     uint eax, ebx, ecx, edx;
 
-    CPUID(0);
+    Vc_CPUID(0);
     s_ecx0 = ecx;
 
-    CPUID(1);
+    Vc_CPUID(1);
     s_processorFeaturesC = ecx;
     s_processorFeaturesD = edx;
     s_processorModel  = (eax & 0x000000f0) >> 4;
     s_processorFamily = (eax & 0x00000f00) >> 8;
     if (isAmd()) {
         if (s_processorFamily >= 0xf) {
-            const uchar processorFamilyExt = (eax & 0x0ff00000) >> 20;
+            const uchar processorFamilyExt = (eax & 0x0ff00000) >> 16;
             s_processorFamily += processorFamilyExt;
             const uchar processorModelExt = (eax & 0x000f0000) >> 12;
             s_processorModel += processorModelExt;
         }
     } else if (s_processorFamily == 0xf) {
-        const uchar processorFamilyExt = (eax & 0x0ff00000) >> 20;
+        const uchar processorFamilyExt = (eax & 0x0ff00000) >> 16;
         s_processorFamily += processorFamilyExt;
         const uchar processorModelExt = (eax & 0x000f0000) >> 12;
         s_processorModel += processorModelExt;
     } else if (s_processorFamily == 0x6) {
         const uchar processorModelExt = (eax & 0x000f0000) >> 12;
         s_processorModel += processorModelExt;
+    } else if (s_processorFamily == 0xB) {
+        const uchar processorFamilyExt = (eax & 0x0ff00000) >> 16;
+        s_processorFamily += processorFamilyExt;
+        const uchar processorModelExt = (eax & 0x000f0000) >> 12;
+        s_processorModel += processorModelExt;
     }
     s_processorType = static_cast<ProcessorType>((eax & 0x00003000) >> 12);
 
@@ -158,21 +174,25 @@
     ebx >>= 8;
     s_logicalProcessors = ebx & 0xff;
 
-    CPUID(0x80000001);
+    Vc_CPUID_C(7, 0);
+    s_processorFeatures7B = ebx;
+    s_processorFeatures7C = ecx;
+
+    Vc_CPUID(0x80000001);
     s_processorFeatures8C = ecx;
     s_processorFeatures8D = edx;
 
     if (isAmd()) {
         s_prefetch = cacheLineSize();
 
-        CPUID(0x80000005);
+        Vc_CPUID(0x80000005);
         s_L1DataLineSize = ecx & 0xff;
         s_L1Data = (ecx >> 24) * 1024;
         s_L1Associativity = (ecx >> 16) & 0xff;
         s_L1InstructionLineSize = edx & 0xff;
         s_L1Instruction = (edx >> 24) * 1024;
 
-        CPUID(0x80000006);
+        Vc_CPUID(0x80000006);
         s_L2DataLineSize = ecx & 0xff;
         s_L2Data = (ecx >> 16) * 1024;
         s_L2Associativity = CpuIdAmdAssociativityTable((ecx >> 12) & 0xf);
@@ -186,8 +206,13 @@
     int repeat = 0;
     bool checkLeaf4 = false;
     do {
-        CPUID(2);
+        Vc_CPUID(2);
         if (repeat == 0) {
+            if (eax == 0 && ebx == 0 && ecx == 0 && edx == 0) {
+                // this is the case on MIC
+                checkLeaf4 = true;
+                break;
+            }
             repeat = eax & 0xff;
         }
         if (0 == (0x80000000u & eax)) {
@@ -222,7 +247,7 @@
         }
         eax = 1;
         for (int i = 0; eax & 0x1f; ++i) {
-            CPUID_C(4, i);
+            Vc_CPUID_C(4, i);
             const int cacheLevel = (eax >> 5) & 7;
             //const int sharedBy = 1 + ((eax >> 14) & 0xfff);
             const int linesize = 1 + (ebx & 0xfff);   ebx >>= 12;
@@ -610,14 +635,14 @@
         s_prefetch = 128;
         break;
     case 0xFF:
-        // we have to use CPUID(4) to find out
+        // we have to use Vc_CPUID(4) to find out
         *checkLeaf4 = true;
         break;
     default:
         break;
     }
 }
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+
+}
 
 // vim: sw=4 sts=4 et tw=100
diff -Nru vc-0.7.4/src/mic_const.cpp vc-1.3.0/src/mic_const.cpp
--- vc-0.7.4/src/mic_const.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/src/mic_const.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,88 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "mic/const_data.h"
+#include <Vc/version.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "common/macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+    alignas(16) extern const char _IndexesFromZero[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+
+    alignas(8) const unsigned       int c_general::absMaskFloat[2] = { 0xffffffffu, 0x7fffffffu };
+    alignas(8) const unsigned       int c_general::signMaskFloat[2] = { 0x0u, 0x80000000u };
+    const              float c_general::oneFloat = 1.f;
+    const unsigned       int c_general::highMaskFloat = 0xfffff000u;
+    alignas(4) const unsigned     short c_general::minShort[2] = { 0x8000u, 0x8000u };
+    alignas(4) const unsigned     short c_general::one16[2] = { 1, 1 };
+    const              float c_general::_2power31 = 1u << 31;
+
+    const             double c_general::oneDouble = 1.;
+    const unsigned long long c_general::frexpMask = 0xbfefffffffffffffull;
+    const unsigned long long c_general::highMaskDouble = 0xfffffffff8000000ull;
+
+    alignas(16) const unsigned char c_general::frexpAndMask[16] = {
+        1, 0, 2, 0, 4, 0, 8, 0, 16, 0, 32, 0, 64, 0, 128, 0
+    };
+}
+}
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Common
+{
+alignas(64) unsigned int RandomState[32] = {
+    0x5a383a4fu, 0xc68bd45eu, 0x691d6d86u, 0xb367e14fu,
+    0xd689dbaau, 0xfde442aau, 0x3d265423u, 0x1a77885cu,
+    0x36ed2684u, 0xfb1f049du, 0x19e52f31u, 0x821e4dd7u,
+    0x23996d25u, 0x5962725au, 0x6aced4ceu, 0xd4c610f3u,
+
+    0x6ac4c828u, 0x34fcb8a2u, 0x34fe32a9u, 0xdd6fba5du,
+    0x112df788u, 0xa8241de1u, 0x0e1d1b1du, 0x813c9552u,
+    0xb0f88feeu, 0x1e4364fbu, 0xdb759fb3u, 0xcc01a0f3u,
+    0xa94dc0a0u, 0xf6fef349u, 0xcaee8edbu, 0x74af8a26u
+};
+
+const char LIBRARY_VERSION[] = Vc_VERSION_STRING;
+const unsigned int LIBRARY_VERSION_NUMBER = Vc_VERSION_NUMBER;
+const unsigned int LIBRARY_ABI_VERSION = Vc_LIBRARY_ABI_VERSION;
+
+void checkLibraryAbi(unsigned int compileTimeAbi, unsigned int versionNumber, const char *compileTimeVersion) {
+    if (LIBRARY_ABI_VERSION != compileTimeAbi || LIBRARY_VERSION_NUMBER < versionNumber) {
+        printf("The versions of libVc.a (%s) and Vc/version.h (%s) are incompatible. Aborting.\n", LIBRARY_VERSION, compileTimeVersion);
+        abort();
+    }
+}
+}
+}
diff -Nru vc-0.7.4/src/mic_sorthelper.cpp vc-1.3.0/src/mic_sorthelper.cpp
--- vc-0.7.4/src/mic_sorthelper.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/src/mic_sorthelper.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,404 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <mic/intrinsics.h>
+#include <mic/casts.h>
+#include <mic/sorthelper.h>
+#include <mic/macros.h>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace MIC
+{
+
+// reference:
+//////////// bitonic merge kernel (Chhugani2008) ///////////////
+// There are two outgoing lines from every value-pair in the diagram below. The left line
+// signifies the min result, the right line the max result.
+//
+// Every variable vN, wN, xN, yN signifies a pair of values that is to be split into min
+// and max.
+//
+// a <= b <= c <= d <= e <= f <= g <= h
+// p => o => n => m => l => k => j => i
+// ap bo cn dm el fk gj hi (or: hi gj fk el dm cn bo ap)
+// v0 v1 v2 v3 v4 v5 v6 v7
+// │╲ │╲ │╲ │╲ ╱│ ╱│ ╱│ ╱│
+// │ ╲│ ╲│ ╲│ ╳ │╱ │╱ │╱ │
+// │  ╲  ╲  ╲╱ ╲╱  ╱  ╱  │
+// │  │╲ │╲ ╱╲ ╱╲ ╱│ ╱│  │
+// │  │ ╲│ ╳│ ╳ │╳ │╱ │  │
+// │  │  ╲╱ ╲╱ ╲╱ ╲╱  │  │
+// │  │  ╱╲ ╱╲ ╱╲ ╱╲  │  │
+// │  │ ╱│ ╳│ ╳ │╳ │╲ │  │
+// │  │╱ │╱ ╲╱ ╲╱ ╲│ ╲│  │
+// │  ╱  ╱  ╱╲ ╱╲  ╲  ╲  │
+// │ ╱│ ╱│ ╱│ ╳ │╲ │╲ │╲ │
+// │╱ │╱ │╱ │╱ ╲│ ╲│ ╲│ ╲│
+// w0 w1 w2 w3 w4 w5 w6 w7
+// │╲ │╲ ╱│ ╱│ │╲ │╲ ╱│ ╱│
+// │ ╲│ ╳ │╱ │ │ ╲│ ╳ │╱ │
+// │  ╲╱ ╲╱  │ │  ╲╱ ╲╱  │
+// │  ╱╲ ╱╲  │ │  ╱╲ ╱╲  │
+// │ ╱│ ╳ │╲ │ │ ╱│ ╳ │╲ │
+// │╱ │╱ ╲│ ╲│ │╱ │╱ ╲│ ╲│
+// x0 x1 x2 x3 x4 x5 x6 x7
+// │╲ ╱│ │╲ ╱│ │╲ ╱│ │╲ ╱│
+// │ ╳ │ │ ╳ │ │ ╳ │ │ ╳ │
+// │╱ ╲│ │╱ ╲│ │╱ ╲│ │╱ ╲│
+// y0 y1 y2 y3 y4 y5 y6 y7
+// || || || || || || || ||
+// ab cd ef gh ij kl mn op
+
+template <> __m512i SortHelper<int>::sort(VectorType in)
+{
+    //__int64 masks = 0x55559999aaaaf0f0;
+    //auto m0x5555 = _mm512_kextract_64(masks, 3);
+    //auto m0x9999 = _mm512_kextract_64(masks, 2);
+    //auto m0xaaaa = _mm512_kextract_64(masks, 1);
+    //auto m0xf0f0 = _mm512_kextract_64(masks, 0);
+
+    auto lh  = in; // dcba
+    auto min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↓dc ↓dc ↓ba ↓ba
+    auto max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↑dc ↑dc ↑ba ↑ba
+    lh = _mm512_mask_mov_epi32(min, 0xaaaa, max); // ↑dc ↓dc ↑ba ↓ba
+
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↓↑dc↑ba  ↓dcba  ↓↑dc↑ba  ↓dcba
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); //  ↑dcba  ↑↓dc↓ba  ↑dcba  ↑↓dc↓ba
+    lh = _mm512_mask_mov_epi32(min, 0x6666, max);                         //  ↑dcba   ↓dcba  ↓↑dc↑ba ↑↓dc↓ba
+    auto tmp = _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB);               //  ↓dcba   ↑dcba  ↑↓dc↓ba ↓↑dc↑ba
+    min = _mm512_min_epi32(lh, tmp); // ↓dcba ↓dcba ↓↑↓dc↓ba↓↑dc↑ba ↓↑↓dc↓ba↓↑dc↑ba  |  aabb
+    max = _mm512_max_epi32(lh, tmp); // ↑dcba ↑dcba ↑↑↓dc↓ba↓↑dc↑ba ↑↑↓dc↓ba↓↑dc↑ba  |  ddcc
+    lh  = _mm512_mask_mov_epi32(max, 0x6666, _mm512_swizzle_epi32(min, _MM_SWIZ_REG_DACB)); // hfeg|dbac
+
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_CDAB);
+    // a <= b <= c <= d
+    // e <= f <= g <= h
+    // bitonic merge 4+4 -> 8
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_BADC)); // ↓ed ↓gb ↓ha ↓fc ↓ed ↓gb ↓ha ↓fc
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_BADC)); // ↑ed ↑gb ↑ha ↑fc ↑ed ↑gb ↑ha ↑fc
+    lh  = _mm512_mask_mov_epi32(min, 0xf0f0, max);                         // ↑ed  ↑gb  ↑ha  ↑fc ↓ha  ↓fc  ↓ed  ↓gb
+                                                                           //  └╴x3╶┘    └╴x2╶┘   └╴x0╶┘    └╴x1╶┘
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↓x3 ↓x3 ↓x2 ↓x2 ↓x0 ↓x0 ↓x1 ↓x1
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↑x3 ↑x3 ↑x2 ↑x2 ↑x0 ↑x0 ↑x1 ↑x1
+    lh  = _mm512_mask_mov_epi32(min, 0xaaaa, max);                        // ↑x3 ↓x3 ↑x2 ↓x2 ↑x0 ↓x0 ↑x1 ↓x1
+                                                                          //  └──╴y3╶─┘   │   └──╴y1╶─┘   │
+                                                                          //      └──╴y2╶─┘       └──╴y0╶─┘
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↓y3 ↓y2 ↓y3 ↓y2 ↓y1 ↓y0 ↓y1 ↓y0
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↑y3 ↑y2 ↑y3 ↑y2 ↑y1 ↑y0 ↑y1 ↑y0
+    lh  = _mm512_mask_mov_epi32(min, 0x6666, max);                        // ↓y3 ↑y2 ↑y3 ↓y2 ↓y1 ↑y0 ↑y1 ↓y0 | onpm|kjli|gfhe|cbda (2130)
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_ABCD);                   //                                   cbda|gfhe|kjli|onpm
+                                                                          // required after swizzle:           bcad|...
+    // lh  = [8, 11, 9, 10, 12, 15, 13, 14, 0, 3, 1, 2, 4, 7, 5, 6]
+    // tmp = [4, 7, 5, 6, 0, 3, 1, 2, 12, 15, 13, 14, 8, 11, 9, 10]
+    // a <= b <= c <= d <= e <= f <= g <= h
+    // i <= j <= k <= l <= m <= n <= o <= p
+    // bitonic merge 8+8 -> 16
+    // needed compares: v7=pa v6=ob v5=nc v4=md v3=le v2=kf v1=jg v0=ih
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_CDAB)); // ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_CDAB)); // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0
+    lh  = _mm512_mask_mov_epi32(min, 0xff00, max);                            // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+                                                                              //  │   └───│───│w5╶│───┘   │   │   │   └───│───│w1╶│───┘   │   │
+                                                                              //  │       │   └───│──╴w4╶─│───┘   │       │   └───│──╴w0╶─│───┘
+                                                                              //  └──────╴w6╶─────┘       │       └──────╴w2╶─────┘       │
+                                                                              //          └──────╴w7╶─────┘               └──────╴w3╶─────┘
+    // lh  = [7, 4, 6, 5, 3, 0, 2, 1, 15, 12, 14, 13, 11, 8, 10, 9]
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_CDAB);
+    // tmp = [3, 0, 2, 1, 7, 4, 6, 5, 11, 8, 10, 9, 15, 12, 14, 13]
+
+    // bitonic merge 4+4 -> 8
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_DCBA)); // ↓w6 ↓w5 ↓w7 ↓w4 ↓w6 ↓w5 ↓w7 ↓w4 ...
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_DCBA)); // ↑w6 ↑w5 ↑w7 ↑w4 ↑w6 ↑w5 ↑w7 ↑w4 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xf0f0, max);                            // ↑w6 ↑w5 ↓w7 ↓w4 ↓w6 ↓w5 ↑w7 ↑w4 ...
+                                                                              //  │   └╴x7╶┘  │   │   └╴x5╶┘  │
+                                                                              //  └────╴x6╶───┘   └────╴x4╶───┘
+    lh  = _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_DACB);                        // ↑w6 ↓w4 ↑w5 ↓w7 ↓w6 ↑w4 ↓w5 ↑w7 ...
+                                                                              //  └╴x6╶┘  └╴x7╶┘  └╴x4╶┘  └╴x5╶┘
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB));  // ↓x6 ↓x6 ↓x7 ↓x7 ↓x4 ↓x4 ↓x5 ↓x5 ...
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB));  // ↑x6 ↑x6 ↑x7 ↑x7 ↑x4 ↑x4 ↑x5 ↑x5 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xaaaa, max);                            // ↑x6 ↓x6 ↑x7 ↓x7 ↑x4 ↓x4 ↑x5 ↓x5 ...
+                                                                              //  └──╴y7╶─┘   │   └──╴y5╶─┘   │
+                                                                              //      └──╴y6╶─┘       └──╴y4╶─┘
+    min = _mm512_min_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC));  // ↓y7 ↓y6 ↓y7 ↓y6 ...
+    max = _mm512_max_epi32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC));  // ↑y7 ↑y6 ↑y7 ↑y6 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xcccc, max);
+
+    return _mm512_shuffle_epi32(lh, _MM_PERM_DBCA);
+}
+
+template <> __m512i SortHelper<unsigned int>::sort(VectorType in)
+{
+    //__int64 masks = 0x55559999aaaaf0f0;
+    //auto m0x5555 = _mm512_kextract_64(masks, 3);
+    //auto m0x9999 = _mm512_kextract_64(masks, 2);
+    //auto m0xaaaa = _mm512_kextract_64(masks, 1);
+    //auto m0xf0f0 = _mm512_kextract_64(masks, 0);
+
+    auto lh  = in; // dcba
+    auto min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↓dc ↓dc ↓ba ↓ba
+    auto max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↑dc ↑dc ↑ba ↑ba
+    lh = _mm512_mask_mov_epi32(min, 0xaaaa, max); // ↑dc ↓dc ↑ba ↓ba
+
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↓↑dc↑ba  ↓dcba  ↓↑dc↑ba  ↓dcba
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); //  ↑dcba  ↑↓dc↓ba  ↑dcba  ↑↓dc↓ba
+    lh = _mm512_mask_mov_epi32(min, 0x6666, max);                         //  ↑dcba   ↓dcba  ↓↑dc↑ba ↑↓dc↓ba
+    auto tmp = _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB);               //  ↓dcba   ↑dcba  ↑↓dc↓ba ↓↑dc↑ba
+    min = _mm512_min_epu32(lh, tmp); // ↓dcba ↓dcba ↓↑↓dc↓ba↓↑dc↑ba ↓↑↓dc↓ba↓↑dc↑ba  |  aabb
+    max = _mm512_max_epu32(lh, tmp); // ↑dcba ↑dcba ↑↑↓dc↓ba↓↑dc↑ba ↑↑↓dc↓ba↓↑dc↑ba  |  ddcc
+    lh  = _mm512_mask_mov_epi32(max, 0x6666, _mm512_swizzle_epi32(min, _MM_SWIZ_REG_DACB)); // hfeg|dbac
+
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_CDAB);
+    // a <= b <= c <= d
+    // e <= f <= g <= h
+    // bitonic merge 4+4 -> 8
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_BADC)); // ↓ed ↓gb ↓ha ↓fc ↓ed ↓gb ↓ha ↓fc
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_BADC)); // ↑ed ↑gb ↑ha ↑fc ↑ed ↑gb ↑ha ↑fc
+    lh  = _mm512_mask_mov_epi32(min, 0xf0f0, max);                         // ↑ed  ↑gb  ↑ha  ↑fc ↓ha  ↓fc  ↓ed  ↓gb
+                                                                        //  └╴x3╶┘    └╴x2╶┘   └╴x0╶┘    └╴x1╶┘
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↓x3 ↓x3 ↓x2 ↓x2 ↓x0 ↓x0 ↓x1 ↓x1
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB)); // ↑x3 ↑x3 ↑x2 ↑x2 ↑x0 ↑x0 ↑x1 ↑x1
+    lh  = _mm512_mask_mov_epi32(min, 0xaaaa, max);                        // ↑x3 ↓x3 ↑x2 ↓x2 ↑x0 ↓x0 ↑x1 ↓x1
+                                                                       //  └──╴y3╶─┘   │   └──╴y1╶─┘   │
+                                                                       //      └──╴y2╶─┘       └──╴y0╶─┘
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↓y3 ↓y2 ↓y3 ↓y2 ↓y1 ↓y0 ↓y1 ↓y0
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC)); // ↑y3 ↑y2 ↑y3 ↑y2 ↑y1 ↑y0 ↑y1 ↑y0
+    lh  = _mm512_mask_mov_epi32(min, 0x6666, max);                        // ↓y3 ↑y2 ↑y3 ↓y2 ↓y1 ↑y0 ↑y1 ↓y0 | onpm|kjli|gfhe|cbda (2130)
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_ABCD);                   //                                   cbda|gfhe|kjli|onpm
+                                                                       // required after swizzle:           bcad|...
+    // lh  = [8, 11, 9, 10, 12, 15, 13, 14, 0, 3, 1, 2, 4, 7, 5, 6]
+    // tmp = [4, 7, 5, 6, 0, 3, 1, 2, 12, 15, 13, 14, 8, 11, 9, 10]
+    // a <= b <= c <= d <= e <= f <= g <= h
+    // i <= j <= k <= l <= m <= n <= o <= p
+    // bitonic merge 8+8 -> 16
+    // needed compares: v7=pa v6=ob v5=nc v4=md v3=le v2=kf v1=jg v0=ih
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_CDAB)); // ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_CDAB)); // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0
+    lh  = _mm512_mask_mov_epi32(min, 0xff00, max);                         // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+                                                                        //  │   └───│───│w5╶│───┘   │   │   │   └───│───│w1╶│───┘   │   │
+                                                                        //  │       │   └───│──╴w4╶─│───┘   │       │   └───│──╴w0╶─│───┘
+                                                                        //  └──────╴w6╶─────┘       │       └──────╴w2╶─────┘       │
+                                                                        //          └──────╴w7╶─────┘               └──────╴w3╶─────┘
+    // lh  = [7, 4, 6, 5, 3, 0, 2, 1, 15, 12, 14, 13, 11, 8, 10, 9]
+    tmp = _mm512_permute4f128_epi32(lh, _MM_PERM_CDAB);
+    // tmp = [3, 0, 2, 1, 7, 4, 6, 5, 11, 8, 10, 9, 15, 12, 14, 13]
+
+    // bitonic merge 4+4 -> 8
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_DCBA)); // ↓w6 ↓w5 ↓w7 ↓w4 ↓w6 ↓w5 ↓w7 ↓w4 ...
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(tmp, _MM_SWIZ_REG_DCBA)); // ↑w6 ↑w5 ↑w7 ↑w4 ↑w6 ↑w5 ↑w7 ↑w4 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xf0f0, max);                         // ↑w6 ↑w5 ↓w7 ↓w4 ↓w6 ↓w5 ↑w7 ↑w4 ...
+                                                                        //  │   └╴x7╶┘  │   │   └╴x5╶┘  │
+                                                                        //  └────╴x6╶───┘   └────╴x4╶───┘
+    lh  = _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_DACB);                     // ↑w6 ↓w4 ↑w5 ↓w7 ↓w6 ↑w4 ↓w5 ↑w7 ...
+                                                                        //  └╴x6╶┘  └╴x7╶┘  └╴x4╶┘  └╴x5╶┘
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB));  // ↓x6 ↓x6 ↓x7 ↓x7 ↓x4 ↓x4 ↓x5 ↓x5 ...
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_CDAB));  // ↑x6 ↑x6 ↑x7 ↑x7 ↑x4 ↑x4 ↑x5 ↑x5 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xaaaa, max);                         // ↑x6 ↓x6 ↑x7 ↓x7 ↑x4 ↓x4 ↑x5 ↓x5 ...
+                                                                        //  └──╴y7╶─┘   │   └──╴y5╶─┘   │
+                                                                        //      └──╴y6╶─┘       └──╴y4╶─┘
+    min = _mm512_min_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC));  // ↓y7 ↓y6 ↓y7 ↓y6 ...
+    max = _mm512_max_epu32(lh, _mm512_swizzle_epi32(lh, _MM_SWIZ_REG_BADC));  // ↑y7 ↑y6 ↑y7 ↑y6 ...
+    lh  = _mm512_mask_mov_epi32(min, 0xcccc, max);
+
+    return _mm512_shuffle_epi32(lh, _MM_PERM_DBCA);
+}
+
+template <> __m512i SortHelper<short>::sort(VectorType in)
+{
+    return SortHelper<int>::sort(in);
+}
+
+template <> __m512i SortHelper<unsigned short>::sort(VectorType in)
+{
+    return SortHelper<unsigned int>::sort(
+        _mm512_and_epi32(_mm512_set1_epi32(0xffff), in));
+}
+
+template <> __m512 SortHelper<float>::sort(VectorType in)
+{
+    const __int64 masks = 0xaaaa6666f0f0ff00ULL;
+    const auto m0xaaaa = _mm512_kextract_64(masks, 3);
+    const auto m0x6666 = _mm512_kextract_64(masks, 2);
+    const auto m0xf0f0 = _mm512_kextract_64(masks, 1);
+    const auto m0xff00 = _mm512_kextract_64(masks, 0);
+    const auto m0xcccc = _mm512_kxor(m0xaaaa, m0x6666);
+
+    auto lh  = in; // dcba
+    auto min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB)); // ↓dc ↓dc ↓ba ↓ba
+    auto max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB)); // ↑dc ↑dc ↑ba ↑ba
+    lh = _mm512_mask_mov_ps(min, m0xaaaa, max); // ↑dc ↓dc ↑ba ↓ba
+
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC)); // ↓↑dc↑ba  ↓dcba  ↓↑dc↑ba  ↓dcba
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC)); //  ↑dcba  ↑↓dc↓ba  ↑dcba  ↑↓dc↓ba
+    lh = _mm512_mask_mov_ps(min, m0x6666, max);                         //  ↑dcba   ↓dcba  ↓↑dc↑ba ↑↓dc↓ba
+    auto tmp = _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB);               //  ↓dcba   ↑dcba  ↑↓dc↓ba ↓↑dc↑ba
+    min = _mm512_gmin_ps(lh, tmp); // ↓dcba ↓dcba ↓↑↓dc↓ba↓↑dc↑ba ↓↑↓dc↓ba↓↑dc↑ba  |  aabb
+    max = _mm512_gmax_ps(lh, tmp); // ↑dcba ↑dcba ↑↑↓dc↓ba↓↑dc↑ba ↑↑↓dc↓ba↓↑dc↑ba  |  ddcc
+    lh  = _mm512_mask_mov_ps(max, m0x6666, _mm512_swizzle_ps(min, _MM_SWIZ_REG_DACB)); // hfeg|dbac
+
+    tmp = _mm512_permute4f128_ps(lh, _MM_PERM_CDAB);
+    // a <= b <= c <= d
+    // e <= f <= g <= h
+    // bitonic merge 4+4 -> 8
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_BADC)); // ↓ed ↓gb ↓ha ↓fc ↓ed ↓gb ↓ha ↓fc
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_BADC)); // ↑ed ↑gb ↑ha ↑fc ↑ed ↑gb ↑ha ↑fc
+    lh  = _mm512_mask_mov_ps(min, m0xf0f0, max);                         // ↑ed  ↑gb  ↑ha  ↑fc ↓ha  ↓fc  ↓ed  ↓gb
+                                                                        //  └╴x3╶┘    └╴x2╶┘   └╴x0╶┘    └╴x1╶┘
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB)); // ↓x3 ↓x3 ↓x2 ↓x2 ↓x0 ↓x0 ↓x1 ↓x1
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB)); // ↑x3 ↑x3 ↑x2 ↑x2 ↑x0 ↑x0 ↑x1 ↑x1
+    lh  = _mm512_mask_mov_ps(min, m0xaaaa, max);                        // ↑x3 ↓x3 ↑x2 ↓x2 ↑x0 ↓x0 ↑x1 ↓x1
+                                                                       //  └──╴y3╶─┘   │   └──╴y1╶─┘   │
+                                                                       //      └──╴y2╶─┘       └──╴y0╶─┘
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC)); // ↓y3 ↓y2 ↓y3 ↓y2 ↓y1 ↓y0 ↓y1 ↓y0
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC)); // ↑y3 ↑y2 ↑y3 ↑y2 ↑y1 ↑y0 ↑y1 ↑y0
+    lh  = _mm512_mask_mov_ps(min, m0x6666, max);                        // ↓y3 ↑y2 ↑y3 ↓y2 ↓y1 ↑y0 ↑y1 ↓y0 | onpm|kjli|gfhe|cbda (2130)
+    tmp = _mm512_permute4f128_ps(lh, _MM_PERM_ABCD);                   //                                   cbda|gfhe|kjli|onpm
+                                                                       // required after swizzle:           bcad|...
+    // lh  = [8, 11, 9, 10, 12, 15, 13, 14, 0, 3, 1, 2, 4, 7, 5, 6]
+    // tmp = [4, 7, 5, 6, 0, 3, 1, 2, 12, 15, 13, 14, 8, 11, 9, 10]
+    // a <= b <= c <= d <= e <= f <= g <= h
+    // i <= j <= k <= l <= m <= n <= o <= p
+    // bitonic merge 8+8 -> 16
+    // needed compares: v7=pa v6=ob v5=nc v4=md v3=le v2=kf v1=jg v0=ih
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_CDAB)); // ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_CDAB)); // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0
+    lh  = _mm512_mask_mov_ps(min, m0xff00, max);                         // ↑v6 ↑v5 ↑v7 ↑v4 ↑v2 ↑v1 ↑v3 ↑v0 ↓v6 ↓v5 ↓v7 ↓v4 ↓v2 ↓v1 ↓v3 ↓v0
+                                                                        //  │   └───│───│w5╶│───┘   │   │   │   └───│───│w1╶│───┘   │   │
+                                                                        //  │       │   └───│──╴w4╶─│───┘   │       │   └───│──╴w0╶─│───┘
+                                                                        //  └──────╴w6╶─────┘       │       └──────╴w2╶─────┘       │
+                                                                        //          └──────╴w7╶─────┘               └──────╴w3╶─────┘
+    // lh  = [7, 4, 6, 5, 3, 0, 2, 1, 15, 12, 14, 13, 11, 8, 10, 9]
+    tmp = _mm512_permute4f128_ps(lh, _MM_PERM_CDAB);
+    // tmp = [3, 0, 2, 1, 7, 4, 6, 5, 11, 8, 10, 9, 15, 12, 14, 13]
+
+    // bitonic merge 4+4 -> 8
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_DCBA)); // ↓w6 ↓w5 ↓w7 ↓w4 ↓w6 ↓w5 ↓w7 ↓w4 ...
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(tmp, _MM_SWIZ_REG_DCBA)); // ↑w6 ↑w5 ↑w7 ↑w4 ↑w6 ↑w5 ↑w7 ↑w4 ...
+    lh  = _mm512_mask_mov_ps(min, m0xf0f0, max);                         // ↑w6 ↑w5 ↓w7 ↓w4 ↓w6 ↓w5 ↑w7 ↑w4 ...
+                                                                        //  │   └╴x7╶┘  │   │   └╴x5╶┘  │
+                                                                        //  └────╴x6╶───┘   └────╴x4╶───┘
+    lh  = _mm512_swizzle_ps(lh, _MM_SWIZ_REG_DACB);                     // ↑w6 ↓w4 ↑w5 ↓w7 ↓w6 ↑w4 ↓w5 ↑w7 ...
+                                                                        //  └╴x6╶┘  └╴x7╶┘  └╴x4╶┘  └╴x5╶┘
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB));  // ↓x6 ↓x6 ↓x7 ↓x7 ↓x4 ↓x4 ↓x5 ↓x5 ...
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_CDAB));  // ↑x6 ↑x6 ↑x7 ↑x7 ↑x4 ↑x4 ↑x5 ↑x5 ...
+    lh  = _mm512_mask_mov_ps(min, m0xaaaa, max);                         // ↑x6 ↓x6 ↑x7 ↓x7 ↑x4 ↓x4 ↑x5 ↓x5 ...
+                                                                        //  └──╴y7╶─┘   │   └──╴y5╶─┘   │
+                                                                        //      └──╴y6╶─┘       └──╴y4╶─┘
+    min = _mm512_gmin_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC));  // ↓y7 ↓y6 ↓y7 ↓y6 ...
+    max = _mm512_gmax_ps(lh, _mm512_swizzle_ps(lh, _MM_SWIZ_REG_BADC));  // ↑y7 ↑y6 ↑y7 ↑y6 ...
+    lh  = _mm512_mask_mov_ps(min, m0xcccc, max);
+
+    return mic_cast<__m512>(_mm512_shuffle_epi32(mic_cast<__m512i>(lh), _MM_PERM_DBCA));
+}
+
+template <> __m512d SortHelper<double>::sort(VectorType in)
+{
+    // in = hgfe dcba
+
+    __int64 masks = 0x0055009900aa00f0;
+    //auto m0x55 = _mm512_kextract_64(masks, 3);
+    auto m0xaa = _mm512_kextract_64(masks, 1);
+    auto m0xf0 = _mm512_kextract_64(masks, 0);
+
+    /*
+    auto less = _mm512_cmplt_pd_mask(in, _mm512_swizzle_pd(in, _MM_SWIZ_REG_CDAB));
+    less ^= 0x55;
+    // __mmask8 is converted to GPR anyway... less = _mm512_kxor(less, m0x55);
+    auto lh = _mm512_mask_blend_pd(less, in, _mm512_swizzle_pd(in, _MM_SWIZ_REG_CDAB));
+    //   lh = ↑hg ↓hg ↑fe ↓fe ↑dc ↓dc ↑ba ↓ba
+
+    auto min = _mm512_gmin_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_BADC));
+    auto max = _mm512_gmax_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_BADC));
+    auto m0x99 = _mm512_kextract_64(masks, 2);
+    auto lh = _mm512_mask_mov_pd(min, m0x99, max);
+
+    min = _mm512_gmin_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_CDAB));
+    max = _mm512_gmax_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_CDAB));
+    lh  = _mm512_mask_mov_pd(min, m0xaa, max);
+    */
+
+    __m512d a, b, c = in;
+    __asm__("vgminpd %[c]{{cdab}},%[c],%[b]\n"
+            "kextract $1,%[masks],%%k7\n" // k7 = 0xaa
+            "vgmaxpd %[c]{{cdab}},%[c],%[b]{{%%k7}}\n"
+    // b   = ↑hg ↓hg ↑fe ↓fe ↑dc ↓dc ↑ba ↓ba
+            "vgminpd %[b]{{badc}},%[b],%[a]\n"
+            "kextract $2,%[masks],%%k6\n" // k6 = 0x99
+            "vgmaxpd %[b]{{badc}},%[b],%[a]{{%%k6}}\n"
+    // min = ↓↑hg↑fe ↓hgfe ↓↑hg↑fe ↓hgfe ↓↑dc↑ba ↓dcba ↓↑dc↑ba ↓dcba
+    // max = ↑hgfe ↑↓hg↓fe ↑hgfe ↑↓hg↓fe ↑dcba ↑↓dc↓ba ↑dcba ↑↓dc↓ba
+    // a   = ↑hgfe ↓hgfe ↓↑hg↑fe ↑↓hg↓fe ↑dcba ↓dcba ↓↑dc↑ba ↑↓dc↓ba
+    //           ✔      ✔     ✘       ✘      ✔     ✔      ✘       ✘
+            "vgminpd %[a]{{cdab}},%[a],%[b]\n"
+    // min = ↓hgfe X ↓↓↑hg↑fe↑↓hg↓fe X ↓dcba X ↓↓↑dc↑ba↑↓dc↓ba X
+    //         0   0        1        1   0   0        1        1
+            "vgmaxpd %[a]{{cdab}},%[a],%[b]{{%%k7}}\n"
+    // max = ↑hgfe X ↑↓↑hg↑fe↑↓hg↓fe X ↑dcba X ↑↓↑dc↑ba↑↓dc↓ba X
+    //         3   3        2        2   3   3        2        2
+    // b   = 3(hgfe) 0(hgfe) 2(hgfe) 1(hgfe) 3(dcba) 0(dcba) 2(dcba) 1(dcba)
+    //        h       e       g       f       d       a       c       b
+
+    // bitonic merge 4+4 -> 8
+            "vmovapd %[b]{{dacb}},%[b]"               "\n\t" // hfeg dbac
+            "vpermf32x4 $0x1b,%[b],%[c]"              "\n\t" // _MM_PERM_ABCD: acdb eghf
+            "vgminpd %[b],%[c],%[a]"                  "\n\t" // ↓(hfeg dbac, acdb eghf)
+            "kextract $0,%[masks],%%k5"               "\n\t" // k5 = 0xf0
+            "vgmaxpd %[b],%[c],%[a]{{%%k5}}"          "\n\t" // ↑ed  ↑gb  ↑ha  ↑fc ↓ha  ↓fc  ↓ed  ↓gb
+                                                             //  └╴x3╶┘    └╴x2╶┘   └╴x0╶┘    └╴x1╶┘
+            "vgminpd %[a]{{cdab}},%[a],%[b]"          "\n\t" // ↓x3 ↓x3 ↓x2 ↓x2 ↓x0 ↓x0 ↓x1 ↓x1
+            "vgmaxpd %[a]{{cdab}},%[a],%[b]{{%%k7}}"  "\n\t" // ↑x3 ↓x3 ↑x2 ↓x2 ↑x0 ↓x0 ↑x1 ↓x1
+                                                             //  └──╴y3╶─┘   │   └──╴y1╶─┘   │
+                                                             //      └──╴y2╶─┘       └──╴y0╶─┘
+            "vgminpd %[b]{{badc}},%[b],%[a]"          "\n\t" // ↓y3 ↓y2 ↓y3 ↓y2 ↓y1 ↓y0 ↓y1 ↓y0
+            "vgmaxpd %[b]{{badc}},%[b],%[b]"          "\n\t" // ↑y3 ↑y2 ↑y3 ↑y2 ↑y1 ↑y0 ↑y1 ↑y0
+            "vmovapd %[a]{{cdab}},%[a]"               "\n\t" // ↓y2 ↓y3 ↓y2 ↓y3 ↓y0 ↓y1 ↓y0 ↓y1
+            "vmovapd %[a]{{dacb}},%[c]"               "\n\t" // ↑y3 ↑y2 ↑y2 ↑y3 ↑y1 ↑y0 ↑y0 ↑y1
+            "vmovapd %[b]{{dacb}},%[c]{{%%k7}}"        "\n\t" // 
+            : [a]"=x"(a), [b]"=x"(b), [c]"+x"(c) : [masks]"r"(masks) : "k5", "k6", "k7");
+    return c;
+    /*
+    lh = _mm512_swizzle_pd(lh, _MM_SWIZ_REG_DACB); // hfeg dbac
+    auto tmp = mic_cast<__m512d>(_mm512_permute4f128_ps(mic_cast<__m512>(lh), _MM_PERM_ABCD)); // acdb eghf
+    auto lo  = _mm512_gmin_pd(lh, tmp); // ↓(hfeg dbac, acdb eghf)
+    auto hi  = _mm512_gmax_pd(lh, tmp); // ↑(hfeg dbac, acdb eghf)
+    lh = _mm512_mask_mov_pd(lo, m0xf0, hi); // ↑ed  ↑gb  ↑ha  ↑fc ↓ha  ↓fc  ↓ed  ↓gb
+                                           //   └╴x3╶┘    └╴x2╶┘   └╴x0╶┘    └╴x1╶┘
+    lo = _mm512_gmin_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_CDAB)); // ↓x3 ↓x3 ↓x2 ↓x2 ↓x0 ↓x0 ↓x1 ↓x1
+    hi = _mm512_gmax_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_CDAB)); // ↑x3 ↑x3 ↑x2 ↑x2 ↑x0 ↑x0 ↑x1 ↑x1
+    lh = _mm512_mask_mov_pd(lo, m0xaa, hi); // ↑x3 ↓x3 ↑x2 ↓x2 ↑x0 ↓x0 ↑x1 ↓x1
+                                            //  └──╴y3╶─┘   │   └──╴y1╶─┘   │
+                                            //      └──╴y2╶─┘       └──╴y0╶─┘
+
+    lo = _mm512_gmin_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_BADC)); // ↓y3 ↓y2 ↓y3 ↓y2 ↓y1 ↓y0 ↓y1 ↓y0
+    hi = _mm512_gmax_pd(lh, _mm512_swizzle_pd(lh, _MM_SWIZ_REG_BADC)); // ↑y3 ↑y2 ↑y3 ↑y2 ↑y1 ↑y0 ↑y1 ↑y0
+    lh = _mm512_mask_mov_pd(_mm512_swizzle_pd(hi, _MM_SWIZ_REG_DACB), 0x55,
+            _mm512_swizzle_pd(_mm512_swizzle_pd(lo, _MM_SWIZ_REG_CDAB), _MM_SWIZ_REG_DACB));
+                                                                      // ↑y3 ↓y3 ↑y2 ↓y2 ↑y1 ↓y1 ↑y0 ↓y0
+    */
+}
+
+}
+}
diff -Nru vc-0.7.4/src/sse_sorthelper.cpp vc-1.3.0/src/sse_sorthelper.cpp
--- vc-0.7.4/src/sse_sorthelper.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/src/sse_sorthelper.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,202 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <sse/vector.h>
+#include <sse/macros.h>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+template <>
+Vc_CONST SSE::short_v sorted<CurrentImplementation::current()>(SSE::short_v x_)
+{
+    __m128i lo, hi, y, x = x_.data();
+    // sort pairs
+    y = Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(x);
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+    x = SSE::blend_epi16<0xaa>(lo, hi);
+
+    // merge left and right quads
+    y = Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(x);
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+    x = SSE::blend_epi16<0xcc>(lo, hi);
+    y = _mm_srli_si128(x, 2);
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+    x = SSE::blend_epi16<0xaa>(lo, _mm_slli_si128(hi, 2));
+
+    // merge quads into octs
+    y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
+    y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+
+    x = _mm_unpacklo_epi16(lo, hi);
+    y = _mm_srli_si128(x, 8);
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+
+    x = _mm_unpacklo_epi16(lo, hi);
+    y = _mm_srli_si128(x, 8);
+    lo = _mm_min_epi16(x, y);
+    hi = _mm_max_epi16(x, y);
+
+    return _mm_unpacklo_epi16(lo, hi);
+}
+
+template <>
+Vc_CONST SSE::ushort_v sorted<CurrentImplementation::current()>(SSE::ushort_v x_)
+{
+    __m128i lo, hi, y, x = x_.data();
+    // sort pairs
+    y = Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(x);
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+    x = SSE::blend_epi16<0xaa>(lo, hi);
+
+    // merge left and right quads
+    y = Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(x);
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+    x = SSE::blend_epi16<0xcc>(lo, hi);
+    y = _mm_srli_si128(x, 2);
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+    x = SSE::blend_epi16<0xaa>(lo, _mm_slli_si128(hi, 2));
+
+    // merge quads into octs
+    y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
+    y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+
+    x = _mm_unpacklo_epi16(lo, hi);
+    y = _mm_srli_si128(x, 8);
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+
+    x = _mm_unpacklo_epi16(lo, hi);
+    y = _mm_srli_si128(x, 8);
+    lo = SSE::min_epu16(x, y);
+    hi = SSE::max_epu16(x, y);
+
+    return _mm_unpacklo_epi16(lo, hi);
+}
+
+template <> Vc_CONST SSE::int_v sorted<CurrentImplementation::current()>(SSE::int_v x_)
+{
+    __m128i x = x_.data();
+    /*
+    // in 16,67% of the cases the merge can be replaced by an append
+
+    // x = [a b c d]
+    // y = [c d a b]
+    __m128i y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
+    __m128i l = SSE::min_epi32(x, y); // min[ac bd ac bd]
+    __m128i h = SSE::max_epi32(x, y); // max[ac bd ac bd]
+    if (IS_UNLIKELY(_mm_cvtsi128_si32(h) <= l[1])) { // l[0] < h[0] < l[1] < h[1]
+        return _mm_unpacklo_epi32(l, h);
+    }
+    // h[0] > l[1]
+    */
+
+    // sort pairs
+    __m128i y = _mm_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1));
+    __m128i l = SSE::min_epi32(x, y);
+    __m128i h = SSE::max_epi32(x, y);
+    x = _mm_unpacklo_epi32(l, h);
+    y = _mm_unpackhi_epi32(h, l);
+
+    // sort quads
+    l = SSE::min_epi32(x, y);
+    h = SSE::max_epi32(x, y);
+    x = _mm_unpacklo_epi32(l, h);
+    y = _mm_unpackhi_epi64(x, x);
+
+    l = SSE::min_epi32(x, y);
+    h = SSE::max_epi32(x, y);
+    return _mm_unpacklo_epi32(l, h);
+}
+
+template <> Vc_CONST SSE::uint_v sorted<CurrentImplementation::current()>(SSE::uint_v x_)
+{
+    __m128i x = x_.data();
+    __m128i y = _mm_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1));
+    __m128i l = SSE::min_epu32(x, y);
+    __m128i h = SSE::max_epu32(x, y);
+    x = _mm_unpacklo_epi32(l, h);
+    y = _mm_unpackhi_epi32(h, l);
+
+    // sort quads
+    l = SSE::min_epu32(x, y);
+    h = SSE::max_epu32(x, y);
+    x = _mm_unpacklo_epi32(l, h);
+    y = _mm_unpackhi_epi64(x, x);
+
+    l = SSE::min_epu32(x, y);
+    h = SSE::max_epu32(x, y);
+    return _mm_unpacklo_epi32(l, h);
+}
+
+template <>
+Vc_CONST SSE::float_v sorted<CurrentImplementation::current()>(SSE::float_v x_)
+{
+    __m128 x = x_.data();
+    __m128 y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(2, 3, 0, 1));
+    __m128 l = _mm_min_ps(x, y);
+    __m128 h = _mm_max_ps(x, y);
+    x = _mm_unpacklo_ps(l, h);
+    y = _mm_unpackhi_ps(h, l);
+
+    l = _mm_min_ps(x, y);
+    h = _mm_max_ps(x, y);
+    x = _mm_unpacklo_ps(l, h);
+    y = _mm_movehl_ps(x, x);
+
+    l = _mm_min_ps(x, y);
+    h = _mm_max_ps(x, y);
+    return _mm_unpacklo_ps(l, h);
+    // X         __m128 k = _mm_cmpgt_ps(x, y);
+    // X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(2, 2, 0, 0));
+    // X         x = SSE::blendv_ps(x, y, k);
+    // X         y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(1, 0, 3, 2));
+    // X         k = _mm_cmpgt_ps(x, y);
+    // X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(1, 0, 1, 0));
+    // X         x = SSE::blendv_ps(x, y, k);
+    // X         y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(3, 1, 2, 0));
+    // X         k = _mm_cmpgt_ps(x, y);
+    // X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(0, 1, 1, 0));
+    // X         return SSE::blendv_ps(x, y, k);
+}
+
+}  // namespace Detail
+}  // namespace Vc
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/src/support.cpp vc-1.3.0/src/support.cpp
--- vc-0.7.4/src/support.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/src/support.cpp	1969-12-31 18:00:00.000000000 -0600
@@ -1,119 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include <Vc/global.h>
-#include <Vc/cpuid.h>
-#include <Vc/support.h>
-
-#ifdef VC_MSVC
-#include <intrin.h>
-#endif
-
-#if defined(VC_GCC) && VC_GCC >= 0x40400
-#define VC_TARGET_NO_SIMD __attribute__((target("no-sse2,no-avx")))
-#else
-#define VC_TARGET_NO_SIMD
-#endif
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-
-VC_TARGET_NO_SIMD
-static inline bool xgetbvCheck(unsigned int bits)
-{
-#if defined(VC_MSVC) && VC_MSVC >= 160040219 // MSVC 2010 SP1 introduced _xgetbv
-    unsigned long long xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
-    return (xcrFeatureMask & bits) == bits;
-#elif defined(VC_GNU_ASM) && !defined(VC_NO_XGETBV)
-    unsigned int eax;
-    asm("xgetbv" : "=a"(eax) : "c"(0) : "edx");
-    return (eax & bits) == bits;
-#else
-    // can't check, but if OSXSAVE is true let's assume it'll work
-    return bits > 0; // ignore 'warning: unused parameter'
-#endif
-}
-
-VC_TARGET_NO_SIMD
-bool isImplementationSupported(Implementation impl)
-{
-    CpuId::init();
-
-    switch (impl) {
-    case ScalarImpl:
-        return true;
-    case SSE2Impl:
-        return CpuId::hasSse2();
-    case SSE3Impl:
-        return CpuId::hasSse3();
-    case SSSE3Impl:
-        return CpuId::hasSsse3();
-    case SSE41Impl:
-        return CpuId::hasSse41();
-    case SSE42Impl:
-        return CpuId::hasSse42();
-    case AVXImpl:
-        return CpuId::hasOsxsave() && CpuId::hasAvx() && xgetbvCheck(0x6);
-    case AVX2Impl:
-        return false;
-    case ImplementationMask:
-        return false;
-    }
-    return false;
-}
-
-VC_TARGET_NO_SIMD
-Vc::Implementation bestImplementationSupported()
-{
-    CpuId::init();
-
-    if (!CpuId::hasSse2 ()) return Vc::ScalarImpl;
-    if (!CpuId::hasSse3 ()) return Vc::SSE2Impl;
-    if (!CpuId::hasSsse3()) return Vc::SSE3Impl;
-    if (!CpuId::hasSse41()) return Vc::SSSE3Impl;
-    if (!CpuId::hasSse42()) return Vc::SSE41Impl;
-    if (CpuId::hasAvx() && CpuId::hasOsxsave() && xgetbvCheck(0x6)) {
-        return Vc::AVXImpl;
-    }
-    return Vc::SSE42Impl;
-}
-
-VC_TARGET_NO_SIMD
-unsigned int extraInstructionsSupported()
-{
-    unsigned int flags = 0;
-    if (CpuId::hasF16c()) flags |= Vc::Float16cInstructions;
-    if (CpuId::hasFma4()) flags |= Vc::Fma4Instructions;
-    if (CpuId::hasXop ()) flags |= Vc::XopInstructions;
-    if (CpuId::hasPopcnt()) flags |= Vc::PopcntInstructions;
-    if (CpuId::hasSse4a()) flags |= Vc::Sse4aInstructions;
-    if (CpuId::hasFma ()) flags |= Vc::FmaInstructions;
-    //if (CpuId::hasPclmulqdq()) flags |= Vc::PclmulqdqInstructions;
-    //if (CpuId::hasAes()) flags |= Vc::AesInstructions;
-    //if (CpuId::hasRdrand()) flags |= Vc::RdrandInstructions;
-    return flags;
-}
-
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#undef VC_TARGET_NO_SIMD
-
-// vim: sw=4 sts=4 et tw=100
diff -Nru vc-0.7.4/src/support_x86.cpp vc-1.3.0/src/support_x86.cpp
--- vc-0.7.4/src/support_x86.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/src/support_x86.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,135 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <Vc/global.h>
+#include <Vc/cpuid.h>
+#include <Vc/support.h>
+
+#ifdef Vc_MSVC
+#include <intrin.h>
+#endif
+
+#if defined(Vc_GCC) && Vc_GCC >= 0x40400
+#define Vc_TARGET_NO_SIMD __attribute__((target("no-sse2,no-avx")))
+#else
+#define Vc_TARGET_NO_SIMD
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+
+Vc_TARGET_NO_SIMD
+static inline bool xgetbvCheck(unsigned int bits)
+{
+#if defined(Vc_MSVC) && Vc_MSVC >= 160040219 // MSVC 2010 SP1 introduced _xgetbv
+    unsigned long long xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
+    return (xcrFeatureMask & bits) == bits;
+#elif defined(Vc_GNU_ASM) && !defined(Vc_NO_XGETBV)
+    unsigned int eax;
+    asm("xgetbv" : "=a"(eax) : "c"(0) : "edx");
+    return (eax & bits) == bits;
+#else
+    // can't check, but if OSXSAVE is true let's assume it'll work
+    return bits > 0; // ignore 'warning: unused parameter'
+#endif
+}
+
+Vc_TARGET_NO_SIMD
+bool isImplementationSupported(Implementation impl)
+{
+    CpuId::init();
+
+    switch (impl) {
+    case ScalarImpl:
+        return true;
+    case SSE2Impl:
+        return CpuId::hasSse2();
+    case SSE3Impl:
+        return CpuId::hasSse3();
+    case SSSE3Impl:
+        return CpuId::hasSsse3();
+    case SSE41Impl:
+        return CpuId::hasSse41();
+    case SSE42Impl:
+        return CpuId::hasSse42();
+    case AVXImpl:
+        return CpuId::hasOsxsave() && CpuId::hasAvx() && xgetbvCheck(0x6);
+    case AVX2Impl:
+        return CpuId::hasOsxsave() && CpuId::hasAvx2() && xgetbvCheck(0x6);
+    case MICImpl:
+        return CpuId::processorFamily() == 0xB && CpuId::processorModel() == 0x1
+            && CpuId::isIntel();
+    case ImplementationMask:
+        return false;
+    }
+    return false;
+}
+
+Vc_TARGET_NO_SIMD
+Vc::Implementation bestImplementationSupported()
+{
+    CpuId::init();
+
+    if (CpuId::processorFamily() == 0xB && CpuId::processorModel() == 0x1
+            && CpuId::isIntel()) {
+        return Vc::MICImpl;
+    }
+    if (!CpuId::hasSse2 ()) return Vc::ScalarImpl;
+    if (!CpuId::hasSse3 ()) return Vc::SSE2Impl;
+    if (!CpuId::hasSsse3()) return Vc::SSE3Impl;
+    if (!CpuId::hasSse41()) return Vc::SSSE3Impl;
+    if (!CpuId::hasSse42()) return Vc::SSE41Impl;
+    if (CpuId::hasAvx() && CpuId::hasOsxsave() && xgetbvCheck(0x6)) {
+        if (!CpuId::hasAvx2()) return Vc::AVXImpl;
+        return Vc::AVX2Impl;
+    }
+    return Vc::SSE42Impl;
+}
+
+Vc_TARGET_NO_SIMD
+unsigned int extraInstructionsSupported()
+{
+    unsigned int flags = 0;
+    if (CpuId::hasF16c()) flags |= Vc::Float16cInstructions;
+    if (CpuId::hasFma4()) flags |= Vc::Fma4Instructions;
+    if (CpuId::hasXop ()) flags |= Vc::XopInstructions;
+    if (CpuId::hasPopcnt()) flags |= Vc::PopcntInstructions;
+    if (CpuId::hasSse4a()) flags |= Vc::Sse4aInstructions;
+    if (CpuId::hasFma ()) flags |= Vc::FmaInstructions;
+    if (CpuId::hasBmi2()) flags |= Vc::Bmi2Instructions;
+    if (CpuId::hasOsxsave() && CpuId::hasAvx() && xgetbvCheck(0x6)) flags |= Vc::VexInstructions;
+    //if (CpuId::hasPclmulqdq()) flags |= Vc::PclmulqdqInstructions;
+    //if (CpuId::hasAes()) flags |= Vc::AesInstructions;
+    //if (CpuId::hasRdrand()) flags |= Vc::RdrandInstructions;
+    return flags;
+}
+
+}
+
+#undef Vc_TARGET_NO_SIMD
+
+// vim: sw=4 sts=4 et tw=100
diff -Nru vc-0.7.4/src/trigonometric.cpp vc-1.3.0/src/trigonometric.cpp
--- vc-0.7.4/src/trigonometric.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/src/trigonometric.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,111 +1,140 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#include <Vc/Vc>
-#if defined(VC_IMPL_SSE) || defined(VC_IMPL_AVX)
+// enable bit operators for easier portable bit manipulation on floats
+#define Vc_ENABLE_FLOAT_BIT_OPERATORS 1
+
+#include <Vc/vector.h>
+#if defined(Vc_IMPL_SSE) || defined(Vc_IMPL_AVX)
 #include <common/macros.h>
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
+namespace Common
+{
+
 namespace
 {
-    using Vc::Vector;
-    using Vc::float_v;
-    using Vc::double_v;
-    using Vc::sfloat_v;
-
-    template<typename T> static Vc_ALWAYS_INLINE Vector<T> cosSeries(const Vector<T> &x)
-    {
-        typedef Const<T> C;
-        const Vector<T> x2 = x * x;
-        return ((C::cosCoeff(2)  * x2 +
-                 C::cosCoeff(1)) * x2 +
-                 C::cosCoeff(0)) * (x2 * x2)
-            - C::_1_2() * x2 + Vector<T>::One();
-    }
-    static Vc_ALWAYS_INLINE double_v cosSeries(const double_v &x)
-    {
-        typedef Const<double> C;
-        const double_v x2 = x * x;
-        return (((((C::cosCoeff(5)  * x2 +
-                    C::cosCoeff(4)) * x2 +
-                    C::cosCoeff(3)) * x2 +
-                    C::cosCoeff(2)) * x2 +
-                    C::cosCoeff(1)) * x2 +
-                    C::cosCoeff(0)) * (x2 * x2)
-            - C::_1_2() * x2 + double_v::One();
-    }
-    template<typename T> static Vc_ALWAYS_INLINE Vector<T> sinSeries(const Vector<T> &x)
-    {
-        typedef Const<T> C;
-        const Vector<T> x2 = x * x;
-        return ((C::sinCoeff(2)  * x2 +
-                 C::sinCoeff(1)) * x2 +
-                 C::sinCoeff(0)) * (x2 * x)
-            + x;
-    }
-    static Vc_ALWAYS_INLINE double_v sinSeries(const double_v &x)
-    {
-        typedef Const<double> C;
-        const double_v x2 = x * x;
-        return (((((C::sinCoeff(5)  * x2 +
-                    C::sinCoeff(4)) * x2 +
-                    C::sinCoeff(3)) * x2 +
-                    C::sinCoeff(2)) * x2 +
-                    C::sinCoeff(1)) * x2 +
-                    C::sinCoeff(0)) * (x2 * x)
-            + x;
-    }
-    template<typename V> struct signed_integer { typedef   int_v type; };
-    template<> struct signed_integer<sfloat_v> { typedef short_v type; };
+using Vc::Vector;
+template <typename Abi> using float_v_for = Vc::Vector<float, Abi>;
+template <typename Abi> using double_v_for = Vc::Vector<double, Abi>;
+template <typename T, typename Abi>
+using Const = typename std::conditional<std::is_same<Abi, VectorAbi::Avx>::value,
+                                        AVX::Const<T>, SSE::Const<T>>::type;
+
+template <typename V>
+using best_int_v_for =
+    typename std::conditional<(V::size() <= Vector<int, VectorAbi::Best<int>>::size()),
+                              Vector<int, VectorAbi::Best<int>>,
+                              SimdArray<int, V::size()>>::type;
+template <typename Abi> using float_int_v = best_int_v_for<float_v_for<Abi>>;
+template <typename Abi> using double_int_v = best_int_v_for<double_v_for<Abi>>;
+
+template <typename T, typename Abi>
+static Vc_ALWAYS_INLINE Vector<T, Abi> cosSeries(const Vector<T, Abi> &x)
+{
+    typedef Const<T, Abi> C;
+    const Vector<T, Abi> x2 = x * x;
+    return ((C::cosCoeff(2)  * x2 +
+             C::cosCoeff(1)) * x2 +
+             C::cosCoeff(0)) * (x2 * x2)
+        - C::_1_2() * x2 + Vector<T, Abi>::One();
+}
+template <typename Abi>
+static Vc_ALWAYS_INLINE double_v_for<Abi> cosSeries(const double_v_for<Abi> &x)
+{
+    typedef Const<double, Abi> C;
+    const double_v_for<Abi> x2 = x * x;
+    return (((((C::cosCoeff(5)  * x2 +
+                C::cosCoeff(4)) * x2 +
+                C::cosCoeff(3)) * x2 +
+                C::cosCoeff(2)) * x2 +
+                C::cosCoeff(1)) * x2 +
+                C::cosCoeff(0)) * (x2 * x2)
+        - C::_1_2() * x2 + double_v_for<Abi>::One();
+}
+template <typename T, typename Abi>
+static Vc_ALWAYS_INLINE Vector<T, Abi> sinSeries(const Vector<T, Abi> &x)
+{
+    typedef Const<T, Abi> C;
+    const Vector<T, Abi> x2 = x * x;
+    return ((C::sinCoeff(2)  * x2 +
+             C::sinCoeff(1)) * x2 +
+             C::sinCoeff(0)) * (x2 * x)
+        + x;
+}
+template <typename Abi>
+static Vc_ALWAYS_INLINE double_v_for<Abi> sinSeries(const double_v_for<Abi> &x)
+{
+    typedef Const<double, Abi> C;
+    const double_v_for<Abi> x2 = x * x;
+    return (((((C::sinCoeff(5)  * x2 +
+                C::sinCoeff(4)) * x2 +
+                C::sinCoeff(3)) * x2 +
+                C::sinCoeff(2)) * x2 +
+                C::sinCoeff(1)) * x2 +
+                C::sinCoeff(0)) * (x2 * x)
+        + x;
+}
 
-    template<typename _T, typename IV> static Vc_ALWAYS_INLINE Vector<_T> foldInput(const Vector<_T> &_x, IV &quadrant)
-    {
-        typedef Vector<_T> V;
-        typedef Const<_T> C;
-
-        const V x = abs(_x);
-#if defined(VC_IMPL_FMA4) || defined(VC_IMPL_FMA)
-        quadrant = static_cast<IV>(x * C::_4_pi() + V::One()); // prefer the fma here
+template <typename Abi>
+static Vc_ALWAYS_INLINE float_v_for<Abi> foldInput(float_v_for<Abi> x, float_int_v<Abi> &quadrant)
+{
+    typedef float_v_for<Abi> V;
+    typedef Const<float, Abi> C;
+    typedef float_int_v<Abi> IV;
+
+    x = abs(x);
+#if defined(Vc_IMPL_FMA4) || defined(Vc_IMPL_FMA)
+        quadrant = simd_cast<IV>(x * C::_4_pi() + V::One()); // prefer the fma here
         quadrant &= ~IV::One();
 #else
-        quadrant = static_cast<IV>(x * C::_4_pi());
+        quadrant = simd_cast<IV>(x * C::_4_pi());
         quadrant += quadrant & IV::One();
 #endif
-        const V y = static_cast<V>(quadrant);
+        const V y = simd_cast<V>(quadrant);
         quadrant &= 7;
 
         return ((x - y * C::_pi_4_hi()) - y * C::_pi_4_rem1()) - y * C::_pi_4_rem2();
     }
-    static Vc_ALWAYS_INLINE double_v foldInput(const double_v &_x, int_v &quadrant)
-    {
-        typedef double_v V;
-        typedef Const<double> C;
+template <typename Abi>
+static Vc_ALWAYS_INLINE double_v_for<Abi> foldInput(double_v_for<Abi> x,
+                                                double_int_v<Abi> &quadrant)
+{
+    typedef double_v_for<Abi> V;
+    typedef Const<double, Abi> C;
 
-        const V x = abs(_x);
+    x = abs(x);
         V y = trunc(x / C::_pi_4()); // * C::_4_pi() would work, but is >twice as imprecise
         V z = y - trunc(y * C::_1_16()) * C::_16(); // y modulo 16
-        quadrant = static_cast<int_v>(z);
-        int_m mask = (quadrant & int_v::One()) != int_v::Zero();
+        quadrant = simd_cast<double_int_v<Abi>>(z);
+        int_m mask = (quadrant & double_int_v<Abi>::One()) != double_int_v<Abi>::Zero();
         ++quadrant(mask);
-        y(static_cast<double_m>(mask)) += V::One();
+        y(simd_cast<double_m>(mask)) += V::One();
         quadrant &= 7;
 
         // since y is an integer we don't need to split y into low and high parts until the integer
@@ -130,120 +159,140 @@
  * Calculate Taylor series with tuned coefficients.
  * Fix sign.
  */
-template<> template<typename _T> Vector<_T> Trigonometric<Vc::Internal::TrigonometricImplementation>::sin(const Vector<_T> &_x)
+template <>
+template <>
+Vc::float_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::sin(const Vc::float_v &_x)
 {
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
-    typedef typename signed_integer<V>::type IV;
+    typedef Vc::float_v V;
+    typedef V::Mask M;
+    using IV = best_int_v_for<V>;
 
     IV quadrant;
     const V z = foldInput(_x, quadrant);
-    const M sign = (_x < V::Zero()) ^ static_cast<M>(quadrant > 3);
+    const M sign = (_x < V::Zero()) ^ simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
 
     V y = sinSeries(z);
-    y(quadrant == IV::One() || quadrant == 2) = cosSeries(z);
+    y(simd_cast<M>(quadrant == IV::One() || quadrant == 2)) = cosSeries(z);
     y(sign) = -y;
     return y;
 }
 
-template<> template<> double_v Trigonometric<Vc::Internal::TrigonometricImplementation>::sin(const double_v &_x)
+template <>
+template <>
+Vc::double_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::sin(const Vc::double_v &_x)
 {
-    typedef double_v V;
+    typedef Vc::double_v V;
     typedef V::Mask M;
 
-    int_v quadrant;
+    double_int_v<V::abi> quadrant;
     M sign = _x < V::Zero();
     const V x = foldInput(_x, quadrant);
-    sign ^= static_cast<M>(quadrant > 3);
+    sign ^= simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
 
     V y = sinSeries(x);
-    y(static_cast<M>(quadrant == int_v::One() || quadrant == 2)) = cosSeries(x);
+    y(simd_cast<M>(quadrant == double_int_v<V::abi>::One() || quadrant == 2)) = cosSeries(x);
     y(sign) = -y;
     return y;
 }
-template<> template<typename _T> Vector<_T> Trigonometric<Vc::Internal::TrigonometricImplementation>::cos(const Vector<_T> &_x) {
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
-    typedef typename signed_integer<V>::type IV;
+template <>
+template <>
+Vc::float_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::cos(const Vc::float_v &_x)
+{
+    typedef Vc::float_v V;
+    typedef V::Mask M;
+    using IV = best_int_v_for<V>;
 
     IV quadrant;
     const V x = foldInput(_x, quadrant);
-    M sign = quadrant > 3;
+    M sign = simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
-    sign ^= quadrant > IV::One();
+    sign ^= simd_cast<M>(quadrant > IV::One());
 
     V y = cosSeries(x);
-    y(quadrant == IV::One() || quadrant == 2) = sinSeries(x);
+    y(simd_cast<M>(quadrant == IV::One() || quadrant == 2)) = sinSeries(x);
     y(sign) = -y;
     return y;
 }
-template<> template<> double_v Trigonometric<Vc::Internal::TrigonometricImplementation>::cos(const double_v &_x)
+template<> template<> Vc::double_v Trigonometric<Vc::Detail::TrigonometricImplementation<Vc::CurrentImplementation::current()>>::cos(const Vc::double_v &_x)
 {
-    typedef double_v V;
+    typedef Vc::double_v V;
     typedef V::Mask M;
 
-    int_v quadrant;
+    double_int_v<V::abi> quadrant;
     const V x = foldInput(_x, quadrant);
-    M sign = static_cast<M>(quadrant > 3);
+    M sign = simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
-    sign ^= static_cast<M>(quadrant > int_v::One());
+    sign ^= simd_cast<M>(quadrant > double_int_v<V::abi>::One());
 
     V y = cosSeries(x);
-    y(static_cast<M>(quadrant == int_v::One() || quadrant == 2)) = sinSeries(x);
+    y(simd_cast<M>(quadrant == double_int_v<V::abi>::One() || quadrant == 2)) = sinSeries(x);
     y(sign) = -y;
     return y;
 }
-template<> template<typename _T> void Trigonometric<Vc::Internal::TrigonometricImplementation>::sincos(const Vector<_T> &_x, Vector<_T> *_sin, Vector<_T> *_cos) {
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
-    typedef typename signed_integer<V>::type IV;
+template <>
+template <>
+void Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::sincos(const Vc::float_v &_x, Vc::float_v *_sin, Vc::float_v *_cos)
+{
+    typedef Vc::float_v V;
+    typedef V::Mask M;
+    using IV = best_int_v_for<V>;
 
     IV quadrant;
     const V x = foldInput(_x, quadrant);
-    M sign = static_cast<M>(quadrant > 3);
+    M sign = simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
 
     const V cos_s = cosSeries(x);
     const V sin_s = sinSeries(x);
 
     V c = cos_s;
-    c(static_cast<M>(quadrant == IV::One() || quadrant == 2)) = sin_s;
-    c(sign ^ static_cast<M>(quadrant > IV::One())) = -c;
+    c(simd_cast<M>(quadrant == IV::One() || quadrant == 2)) = sin_s;
+    c(sign ^ simd_cast<M>(quadrant > IV::One())) = -c;
     *_cos = c;
 
     V s = sin_s;
-    s(static_cast<M>(quadrant == IV::One() || quadrant == 2)) = cos_s;
-    s(sign ^ static_cast<M>(_x < V::Zero())) = -s;
+    s(simd_cast<M>(quadrant == IV::One() || quadrant == 2)) = cos_s;
+    s(sign ^ simd_cast<M>(_x < V::Zero())) = -s;
     *_sin = s;
 }
-template<> template<> void Trigonometric<Vc::Internal::TrigonometricImplementation>::sincos(const double_v &_x, double_v *_sin, double_v *_cos) {
-    typedef double_v V;
+template<> template<> void Trigonometric<Vc::Detail::TrigonometricImplementation<Vc::CurrentImplementation::current()>>::sincos(const Vc::double_v &_x, Vc::double_v *_sin, Vc::double_v *_cos) {
+    typedef Vc::double_v V;
     typedef V::Mask M;
 
-    int_v quadrant;
+    double_int_v<V::abi> quadrant;
     const V x = foldInput(_x, quadrant);
-    M sign = static_cast<M>(quadrant > 3);
+    M sign = simd_cast<M>(quadrant > 3);
     quadrant(quadrant > 3) -= 4;
 
     const V cos_s = cosSeries(x);
     const V sin_s = sinSeries(x);
 
     V c = cos_s;
-    c(static_cast<M>(quadrant == int_v::One() || quadrant == 2)) = sin_s;
-    c(sign ^ static_cast<M>(quadrant > int_v::One())) = -c;
+    c(simd_cast<M>(quadrant == double_int_v<V::abi>::One() || quadrant == 2)) = sin_s;
+    c(sign ^ simd_cast<M>(quadrant > double_int_v<V::abi>::One())) = -c;
     *_cos = c;
 
     V s = sin_s;
-    s(static_cast<M>(quadrant == int_v::One() || quadrant == 2)) = cos_s;
-    s(sign ^ static_cast<M>(_x < V::Zero())) = -s;
+    s(simd_cast<M>(quadrant == double_int_v<V::abi>::One() || quadrant == 2)) = cos_s;
+    s(sign ^ simd_cast<M>(_x < V::Zero())) = -s;
     *_sin = s;
 }
-template<> template<typename _T> Vector<_T> Trigonometric<Vc::Internal::TrigonometricImplementation>::asin (const Vector<_T> &_x) {
-    typedef Const<_T> C;
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
+
+template <>
+template <>
+Vc::float_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::asin(const Vc::float_v &_x)
+{
+    typedef Vc::float_v V;
+    typedef V::EntryType T;
+    typedef Const<T, V::abi> C;
+    typedef V::Mask M;
 
     const M &negative = _x < V::Zero();
 
@@ -268,9 +317,9 @@
 
     return z;
 }
-template<> template<> double_v Trigonometric<Vc::Internal::TrigonometricImplementation>::asin (const double_v &_x) {
-    typedef Const<double> C;
-    typedef double_v V;
+template<> template<> Vc::double_v Trigonometric<Vc::Detail::TrigonometricImplementation<Vc::CurrentImplementation::current()>>::asin (const Vc::double_v &_x) {
+    typedef Vc::double_v V;
+    typedef Const<double, V::abi> C;
     typedef V::Mask M;
 
     const M negative = _x < V::Zero();
@@ -303,10 +352,15 @@
 
     return z;
 }
-template<> template<typename _T> Vector<_T> Trigonometric<Vc::Internal::TrigonometricImplementation>::atan (const Vector<_T> &_x) {
-    typedef Const<_T> C;
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
+template <>
+template <>
+Vc::float_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::atan(const Vc::float_v &_x)
+{
+    using V = Vc::float_v;
+    typedef V::EntryType T;
+    typedef Const<T, V::abi> C;
+    typedef V::Mask M;
     V x = abs(_x);
     const M &gt_tan_3pi_8 = x > C::atanThrsHi();
     const M &gt_tan_pi_8  = x > C::atanThrsLo() && !gt_tan_3pi_8;
@@ -325,9 +379,9 @@
     y.setQnan(isnan(_x));
     return y;
 }
-template<> template<> double_v Trigonometric<Vc::Internal::TrigonometricImplementation>::atan (const double_v &_x) {
-    typedef Const<double> C;
-    typedef double_v V;
+template<> template<> Vc::double_v Trigonometric<Vc::Detail::TrigonometricImplementation<Vc::CurrentImplementation::current()>>::atan (const Vc::double_v &_x) {
+    typedef Vc::double_v V;
+    typedef Const<double, V::abi> C;
     typedef V::Mask M;
 
     M sign = _x < V::Zero();
@@ -355,24 +409,30 @@
     ret.setQnan(isnan(_x));
     return ret;
 }
-template<> template<typename _T> Vector<_T> Trigonometric<Vc::Internal::TrigonometricImplementation>::atan2(const Vector<_T> &y, const Vector<_T> &x) {
-    typedef Const<_T> C;
-    typedef Vector<_T> V;
-    typedef typename V::Mask M;
+template <>
+template <>
+Vc::float_v Trigonometric<Vc::Detail::TrigonometricImplementation<
+    Vc::CurrentImplementation::current()>>::atan2(const Vc::float_v &y,
+                                                  const Vc::float_v &x)
+{
+    using V = Vc::float_v;
+    typedef V::EntryType T;
+    typedef Const<T, V::abi> C;
+    typedef V::Mask M;
 
     const M xZero = x == V::Zero();
     const M yZero = y == V::Zero();
-    const M xMinusZero = xZero && x.isNegative();
+    const M xMinusZero = xZero && isnegative(x);
     const M yNeg = y < V::Zero();
     const M xInf = !isfinite(x);
     const M yInf = !isfinite(y);
 
-    V a = C::_pi().copySign(y);
+    V a = copysign(C::_pi(), y);
     a.setZero(x >= V::Zero());
 
     // setting x to any finite value will have atan(y/x) return sign(y/x)*pi/2, just in case x is inf
     V _x = x;
-    _x(yInf) = V::One().copySign(x);
+    _x(yInf) = copysign(V::One(), x);
 
     a += atan(y / _x);
 
@@ -380,40 +440,40 @@
     a.setZero(xZero && yZero);
 
     // for x = -0 we add/subtract pi to get the correct result
-    a(xMinusZero) += C::_pi().copySign(y);
+    a(xMinusZero) += copysign(C::_pi(), y);
 
     // atan2(-Y, +/-0) = -pi/2
     a(xZero && yNeg) = -C::_pi_2();
 
     // if both inputs are inf the output is +/- (3)pi/4
-    a(xInf && yInf) += C::_pi_4().copySign(x ^ ~y);
+    a(xInf && yInf) += copysign(C::_pi_4(), x ^ ~y);
 
     // correct the sign of y if the result is 0
-    a(a == V::Zero()) = a.copySign(y);
+    a(a == V::Zero()) = copysign(a, y);
 
     // any NaN input will lead to NaN output
     a.setQnan(isnan(y) || isnan(x));
 
     return a;
 }
-template<> template<> double_v Trigonometric<Vc::Internal::TrigonometricImplementation>::atan2 (const double_v &y, const double_v &x) {
-    typedef Const<double> C;
-    typedef double_v V;
+template<> template<> Vc::double_v Trigonometric<Vc::Detail::TrigonometricImplementation<Vc::CurrentImplementation::current()>>::atan2 (const Vc::double_v &y, const Vc::double_v &x) {
+    typedef Vc::double_v V;
+    typedef Const<double, V::abi> C;
     typedef V::Mask M;
 
     const M xZero = x == V::Zero();
     const M yZero = y == V::Zero();
-    const M xMinusZero = xZero && x.isNegative();
+    const M xMinusZero = xZero && isnegative(x);
     const M yNeg = y < V::Zero();
     const M xInf = !isfinite(x);
     const M yInf = !isfinite(y);
 
-    V a = V(C::_pi()).copySign(y);
+    V a = copysign(V(C::_pi()), y);
     a.setZero(x >= V::Zero());
 
     // setting x to any finite value will have atan(y/x) return sign(y/x)*pi/2, just in case x is inf
     V _x = x;
-    _x(yInf) = V::One().copySign(x);
+    _x(yInf) = copysign(V::One(), x);
 
     a += atan(y / _x);
 
@@ -421,43 +481,24 @@
     a.setZero(xZero && yZero);
 
     // for x = -0 we add/subtract pi to get the correct result
-    a(xMinusZero) += C::_pi().copySign(y);
+    a(xMinusZero) += copysign(C::_pi(), y);
 
     // atan2(-Y, +/-0) = -pi/2
     a(xZero && yNeg) = -C::_pi_2();
 
     // if both inputs are inf the output is +/- (3)pi/4
-    a(xInf && yInf) += C::_pi_4().copySign(x ^ ~y);
+    a(xInf && yInf) += copysign(C::_pi_4(), x ^ ~y);
 
     // correct the sign of y if the result is 0
-    a(a == V::Zero()) = a.copySign(y);
+    a(a == V::Zero()) = copysign(a, y);
 
     // any NaN input will lead to NaN output
     a.setQnan(isnan(y) || isnan(x));
 
     return a;
 }
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include <common/undomacros.h>
-
-// instantiate the non-specialized template functions above
-template Vc::float_v  Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sin(const Vc::float_v  &);
-template Vc::sfloat_v Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sin(const Vc::sfloat_v &);
-
-template Vc::float_v  Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::cos(const Vc::float_v  &);
-template Vc::sfloat_v Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::cos(const Vc::sfloat_v &);
 
-template void Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sincos(const Vc::float_v  &, Vc::float_v  *, Vc::float_v  *);
-template void Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::sincos(const Vc::sfloat_v &, Vc::sfloat_v *, Vc::sfloat_v *);
-
-template Vc::float_v  Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::asin(const Vc::float_v  &);
-template Vc::sfloat_v Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::asin(const Vc::sfloat_v &);
-
-template Vc::float_v  Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan(const Vc::float_v  &);
-template Vc::sfloat_v Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan(const Vc::sfloat_v &);
+}
+}
 
-template Vc::float_v  Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan2(const Vc::float_v  &, const Vc::float_v  &);
-template Vc::sfloat_v Vc::Trigonometric<Vc::Internal::TrigonometricImplementation>::atan2(const Vc::sfloat_v &, const Vc::sfloat_v &);
 #endif
diff -Nru vc-0.7.4/sse/casts.h vc-1.3.0/sse/casts.h
--- vc-0.7.4/sse/casts.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/casts.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,104 +1,148 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_CASTS_H
-#define SSE_CASTS_H
+#ifndef VC_SSE_CASTS_H_
+#define VC_SSE_CASTS_H_
 
 #include "intrinsics.h"
 #include "types.h"
+#include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
-    template<typename To, typename From> static Vc_ALWAYS_INLINE To Vc_CONST mm128_reinterpret_cast(VC_ALIGNED_PARAMETER(From) v) { return v; }
-    template<> Vc_ALWAYS_INLINE _M128I Vc_CONST mm128_reinterpret_cast<_M128I, _M128 >(VC_ALIGNED_PARAMETER(_M128 ) v) { return _mm_castps_si128(v); }
-    template<> Vc_ALWAYS_INLINE _M128I Vc_CONST mm128_reinterpret_cast<_M128I, _M128D>(VC_ALIGNED_PARAMETER(_M128D) v) { return _mm_castpd_si128(v); }
-    template<> Vc_ALWAYS_INLINE _M128  Vc_CONST mm128_reinterpret_cast<_M128 , _M128D>(VC_ALIGNED_PARAMETER(_M128D) v) { return _mm_castpd_ps(v);    }
-    template<> Vc_ALWAYS_INLINE _M128  Vc_CONST mm128_reinterpret_cast<_M128 , _M128I>(VC_ALIGNED_PARAMETER(_M128I) v) { return _mm_castsi128_ps(v); }
-    template<> Vc_ALWAYS_INLINE _M128D Vc_CONST mm128_reinterpret_cast<_M128D, _M128I>(VC_ALIGNED_PARAMETER(_M128I) v) { return _mm_castsi128_pd(v); }
-    template<> Vc_ALWAYS_INLINE _M128D Vc_CONST mm128_reinterpret_cast<_M128D, _M128 >(VC_ALIGNED_PARAMETER(_M128 ) v) { return _mm_castps_pd(v);    }
-    template<typename To, typename From> static Vc_ALWAYS_INLINE To Vc_CONST sse_cast(VC_ALIGNED_PARAMETER(From) v) { return mm128_reinterpret_cast<To, From>(v); }
-
-    template<typename From, typename To> struct StaticCastHelper {};
-    template<> struct StaticCastHelper<float       , int         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128  &v) { return _mm_cvttps_epi32(v); } };
-    template<> struct StaticCastHelper<double      , int         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128D &v) { return _mm_cvttpd_epi32(v); } };
-    template<> struct StaticCastHelper<int         , int         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<unsigned int, int         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<float       , unsigned int> { static Vc_ALWAYS_INLINE _M128I cast(const _M128  &v) {
-        return _mm_castps_si128(mm_blendv_ps(
-                _mm_castsi128_ps(_mm_cvttps_epi32(v)),
-                _mm_castsi128_ps(_mm_add_epi32(_mm_cvttps_epi32(_mm_sub_ps(v, _mm_set1_ps(1u << 31))), _mm_set1_epi32(1 << 31))),
-                _mm_cmpge_ps(v, _mm_set1_ps(1u << 31))
-                ));
-
-    } };
-    template<> struct StaticCastHelper<double      , unsigned int> { static Vc_ALWAYS_INLINE _M128I cast(const _M128D &v) { return _mm_cvttpd_epi32(v); } };
-    template<> struct StaticCastHelper<int         , unsigned int> { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<unsigned int, unsigned int> { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<float       , float       > { static Vc_ALWAYS_INLINE _M128  cast(const _M128  &v) { return v; } };
-    template<> struct StaticCastHelper<double      , float       > { static Vc_ALWAYS_INLINE _M128  cast(const _M128D &v) { return _mm_cvtpd_ps(v); } };
-    template<> struct StaticCastHelper<int         , float       > { static Vc_ALWAYS_INLINE _M128  cast(const _M128I &v) { return _mm_cvtepi32_ps(v); } };
-    template<> struct StaticCastHelper<unsigned int, float       > { static Vc_ALWAYS_INLINE _M128  cast(const _M128I &v) {
-        return mm_blendv_ps(
-                _mm_cvtepi32_ps(v),
-                _mm_add_ps(_mm_cvtepi32_ps(_mm_sub_epi32(v, _mm_set1_epi32(1 << 31))), _mm_set1_ps(1u << 31)),
-                _mm_castsi128_ps(_mm_cmplt_epi32(v, _mm_setzero_si128()))
-                );
-    } };
-    template<> struct StaticCastHelper<float       , double      > { static Vc_ALWAYS_INLINE _M128D cast(const _M128  &v) { return _mm_cvtps_pd(v); } };
-    template<> struct StaticCastHelper<double      , double      > { static Vc_ALWAYS_INLINE _M128D cast(const _M128D &v) { return v; } };
-    template<> struct StaticCastHelper<int         , double      > { static Vc_ALWAYS_INLINE _M128D cast(const _M128I &v) { return _mm_cvtepi32_pd(v); } };
-    template<> struct StaticCastHelper<unsigned int, double      > { static Vc_ALWAYS_INLINE _M128D cast(const _M128I &v) { return _mm_cvtepi32_pd(v); } };
-
-    template<> struct StaticCastHelper<unsigned short, float8        > { static Vc_ALWAYS_INLINE  M256  cast(const _M128I &v) {
-        return M256::create(_mm_cvtepi32_ps(_mm_unpacklo_epi16(v, _mm_setzero_si128())),
-                    _mm_cvtepi32_ps(_mm_unpackhi_epi16(v, _mm_setzero_si128())));
-    } };
-    template<> struct StaticCastHelper<short         , float8        > { static Vc_ALWAYS_INLINE  M256  cast(const _M128I &v) {
-        const _M128I neg = _mm_cmplt_epi16(v, _mm_setzero_si128());
-        return M256::create(_mm_cvtepi32_ps(_mm_unpacklo_epi16(v, neg)),
-                    _mm_cvtepi32_ps(_mm_unpackhi_epi16(v, neg)));
-    } };
-    template<> struct StaticCastHelper<float8        , short         > { static Vc_ALWAYS_INLINE _M128I cast(const  M256  &v) { return _mm_packs_epi32(_mm_cvttps_epi32(v[0]), _mm_cvttps_epi32(v[1])); } };
-#ifdef VC_IMPL_SSE4_1
-    template<> struct StaticCastHelper<float8        , unsigned short> { static Vc_ALWAYS_INLINE _M128I cast(const  M256  &v) { return _mm_packus_epi32(_mm_cvttps_epi32(v[0]), _mm_cvttps_epi32(v[1])); } };
+using uint = unsigned int;
+using ushort = unsigned short;
+using uchar = unsigned char;
+using schar = signed char;
+
+// sse_cast {{{1
+template <typename To, typename From> Vc_ALWAYS_INLINE Vc_CONST To sse_cast(From v)
+{
+    return v;
+}
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128i sse_cast<__m128i, __m128 >(__m128  v) { return _mm_castps_si128(v); }
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128i sse_cast<__m128i, __m128d>(__m128d v) { return _mm_castpd_si128(v); }
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128  sse_cast<__m128 , __m128d>(__m128d v) { return _mm_castpd_ps(v);    }
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128  sse_cast<__m128 , __m128i>(__m128i v) { return _mm_castsi128_ps(v); }
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128d sse_cast<__m128d, __m128i>(__m128i v) { return _mm_castsi128_pd(v); }
+template<> Vc_ALWAYS_INLINE Vc_CONST __m128d sse_cast<__m128d, __m128 >(__m128  v) { return _mm_castps_pd(v);    }
+
+// convert {{{1
+template <typename From, typename To> struct ConvertTag
+{
+};
+template <typename From, typename To>
+Vc_INTRINSIC typename VectorTraits<To>::VectorType convert(
+    typename VectorTraits<From>::VectorType v)
+{
+    return convert(v, ConvertTag<From, To>());
+}
+
+Vc_INTRINSIC __m128i convert(__m128  v, ConvertTag<float , int   >) { return _mm_cvttps_epi32(v); }
+Vc_INTRINSIC __m128i convert(__m128d v, ConvertTag<double, int   >) { return _mm_cvttpd_epi32(v); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<int   , int   >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<uint  , int   >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<short , int   >) { return _mm_srai_epi32(_mm_unpacklo_epi16(v, v), 16); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<ushort, int   >) { return _mm_srli_epi32(_mm_unpacklo_epi16(v, v), 16); }
+Vc_INTRINSIC __m128i convert(__m128  v, ConvertTag<float , uint  >) {
+    return _mm_castps_si128(
+        blendv_ps(_mm_castsi128_ps(_mm_cvttps_epi32(v)),
+                  _mm_castsi128_ps(_mm_xor_si128(
+                      _mm_cvttps_epi32(_mm_sub_ps(v, _mm_set1_ps(1u << 31))),
+                      _mm_set1_epi32(1 << 31))),
+                  _mm_cmpge_ps(v, _mm_set1_ps(1u << 31))));
+}
+Vc_INTRINSIC __m128i convert(__m128d v, ConvertTag<double, uint  >) {
+#ifdef Vc_IMPL_SSE4_1
+    return _mm_xor_si128(_mm_cvttpd_epi32(_mm_sub_pd(_mm_floor_pd(v), _mm_set1_pd(0x80000000u))),
+                         _mm_cvtsi64_si128(0x8000000080000000ull));
 #else
-    template<> struct StaticCastHelper<float8        , unsigned short> { static Vc_ALWAYS_INLINE _M128I cast(const  M256  &v) {
-        return _mm_add_epi16(_mm_set1_epi16(-32768),
-                _mm_packs_epi32(
-                    _mm_add_epi32(_mm_set1_epi32(-32768), _mm_cvttps_epi32(v[0])),
-                    _mm_add_epi32(_mm_set1_epi32(-32768), _mm_cvttps_epi32(v[1]))
-                    )
-                );
-    } };
+    return blendv_epi8(_mm_cvttpd_epi32(v),
+                       _mm_xor_si128(_mm_cvttpd_epi32(_mm_sub_pd(v, _mm_set1_pd(0x80000000u))),
+                                     _mm_cvtsi64_si128(0x8000000080000000ull)),
+                       _mm_castpd_si128(_mm_cmpge_pd(v, _mm_set1_pd(0x80000000u))));
 #endif
+}
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<int   , uint  >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<uint  , uint  >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<short , uint  >) { return _mm_srai_epi32(_mm_unpacklo_epi16(v, v), 16); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<ushort, uint  >) { return _mm_srli_epi32(_mm_unpacklo_epi16(v, v), 16); }
+Vc_INTRINSIC __m128  convert(__m128  v, ConvertTag<float , float >) { return v; }
+Vc_INTRINSIC __m128  convert(__m128d v, ConvertTag<double, float >) { return _mm_cvtpd_ps(v); }
+Vc_INTRINSIC __m128  convert(__m128i v, ConvertTag<int   , float >) { return _mm_cvtepi32_ps(v); }
+Vc_INTRINSIC __m128  convert(__m128i v, ConvertTag<uint  , float >) {
+    // see AVX::convert<uint, float> for an explanation of the math behind the
+    // implementation
+    using namespace SSE;
+    return blendv_ps(_mm_cvtepi32_ps(v),
+        _mm_add_ps(_mm_cvtepi32_ps(_mm_and_si128(v, _mm_set1_epi32(0x7ffffe00))),
+                      _mm_add_ps(_mm_set1_ps(1u << 31), _mm_cvtepi32_ps(_mm_and_si128(
+                                                          v, _mm_set1_epi32(0x000001ff))))),
+        _mm_castsi128_ps(_mm_cmplt_epi32(v, _mm_setzero_si128())));
+}
+Vc_INTRINSIC __m128  convert(__m128i v, ConvertTag<short , float >) { return convert(convert(v, ConvertTag<short, int>()), ConvertTag<int, float>()); }
+Vc_INTRINSIC __m128  convert(__m128i v, ConvertTag<ushort, float >) { return convert(convert(v, ConvertTag<ushort, int>()), ConvertTag<int, float>()); }
+Vc_INTRINSIC __m128d convert(__m128  v, ConvertTag<float , double>) { return _mm_cvtps_pd(v); }
+Vc_INTRINSIC __m128d convert(__m128d v, ConvertTag<double, double>) { return v; }
+Vc_INTRINSIC __m128d convert(__m128i v, ConvertTag<int   , double>) { return _mm_cvtepi32_pd(v); }
+Vc_INTRINSIC __m128d convert(__m128i v, ConvertTag<uint  , double>) { return _mm_add_pd(_mm_cvtepi32_pd(_mm_xor_si128(v, setmin_epi32())), _mm_set1_pd(1u << 31)); }
+Vc_INTRINSIC __m128d convert(__m128i v, ConvertTag<short , double>) { return convert(convert(v, ConvertTag<short, int>()), ConvertTag<int, double>()); }
+Vc_INTRINSIC __m128d convert(__m128i v, ConvertTag<ushort, double>) { return convert(convert(v, ConvertTag<ushort, int>()), ConvertTag<int, double>()); }
+Vc_INTRINSIC __m128i convert(__m128  v, ConvertTag<float , short >) { return _mm_packs_epi32(_mm_cvttps_epi32(v), _mm_setzero_si128()); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<int   , short >) { return _mm_packs_epi32(v, _mm_setzero_si128()); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<uint  , short >) { return _mm_packs_epi32(v, _mm_setzero_si128()); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<short , short >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<ushort, short >) { return v; }
+Vc_INTRINSIC __m128i convert(__m128d v, ConvertTag<double, short >) { return convert(convert(v, ConvertTag<double, int>()), ConvertTag<int, short>()); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<int   , ushort>) {
+    auto tmp0 = _mm_unpacklo_epi16(v, _mm_setzero_si128());  // 0 4 X X 1 5 X X
+    auto tmp1 = _mm_unpackhi_epi16(v, _mm_setzero_si128());  // 2 6 X X 3 7 X X
+    auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);              // 0 2 4 6 X X X X
+    auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);              // 1 3 5 7 X X X X
+    return _mm_unpacklo_epi16(tmp2, tmp3);                   // 0 1 2 3 4 5 6 7
+}
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<uint  , ushort>) {
+    auto tmp0 = _mm_unpacklo_epi16(v, _mm_setzero_si128());  // 0 4 X X 1 5 X X
+    auto tmp1 = _mm_unpackhi_epi16(v, _mm_setzero_si128());  // 2 6 X X 3 7 X X
+    auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);              // 0 2 4 6 X X X X
+    auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);              // 1 3 5 7 X X X X
+    return _mm_unpacklo_epi16(tmp2, tmp3);                   // 0 1 2 3 4 5 6 7
+}
+Vc_INTRINSIC __m128i convert(__m128  v, ConvertTag<float , ushort>) { return convert(_mm_cvttps_epi32(v), ConvertTag<int, ushort>()); }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<short , ushort>) { return v; }
+Vc_INTRINSIC __m128i convert(__m128i v, ConvertTag<ushort, ushort>) { return v; }
+Vc_INTRINSIC __m128i convert(__m128d v, ConvertTag<double, ushort>) { return convert(convert(v, ConvertTag<double, int>()), ConvertTag<int, ushort>()); }
+
+// }}}1
+}  // namespace SSE
+}  // namespace Vc
 
-    template<> struct StaticCastHelper<float         , short         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128  &v) { return _mm_packs_epi32(_mm_cvttps_epi32(v), _mm_setzero_si128()); } };
-    template<> struct StaticCastHelper<short         , short         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<unsigned short, short         > { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<float         , unsigned short> { static Vc_ALWAYS_INLINE _M128I cast(const _M128  &v) { return _mm_packs_epi32(_mm_cvttps_epi32(v), _mm_setzero_si128()); } };
-    template<> struct StaticCastHelper<short         , unsigned short> { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-    template<> struct StaticCastHelper<unsigned short, unsigned short> { static Vc_ALWAYS_INLINE _M128I cast(const _M128I &v) { return v; } };
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+#endif // VC_SSE_CASTS_H_
 
-#endif // SSE_CASTS_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/const_data.h vc-1.3.0/sse/const_data.h
--- vc-0.7.4/sse/const_data.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/const_data.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,77 +1,83 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#ifndef VC_SSE_CONST_DATA_H
-#define VC_SSE_CONST_DATA_H
+#ifndef VC_SSE_CONST_DATA_H_
+#define VC_SSE_CONST_DATA_H_
 
+#include "../common/data.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
 
-ALIGN(16) extern const unsigned int   _IndexesFromZero4[4];
-ALIGN(16) extern const unsigned short _IndexesFromZero8[8];
-ALIGN(16) extern const unsigned char  _IndexesFromZero16[16];
+alignas(16) extern const unsigned int   _IndexesFromZero4[4];
+alignas(16) extern const unsigned short _IndexesFromZero8[8];
+alignas(16) extern const unsigned char  _IndexesFromZero16[16];
 
 struct c_general
 {
-    ALIGN(64) static const unsigned int allone[4];
-    ALIGN(16) static const unsigned short one16[8];
-    ALIGN(16) static const unsigned int one32[4];
-    ALIGN(16) static const float oneFloat[4];
-    ALIGN(16) static const double oneDouble[2];
-    ALIGN(16) static const int absMaskFloat[4];
-    ALIGN(16) static const long long absMaskDouble[2];
-    ALIGN(16) static const unsigned int signMaskFloat[4];
-    ALIGN(16) static const unsigned int highMaskFloat[4];
-    ALIGN(16) static const unsigned long long signMaskDouble[2];
-    ALIGN(16) static const unsigned long long highMaskDouble[2];
-    ALIGN(16) static const short minShort[8];
-    ALIGN(16) static const unsigned long long frexpMask[2];
+    alignas(64) static const int absMaskFloat[4];
+    alignas(16) static const unsigned int signMaskFloat[4];
+    alignas(16) static const unsigned int highMaskFloat[4];
+    alignas(16) static const short minShort[8];
+
+    alignas(16) static const unsigned short one16[8];
+    alignas(16) static const unsigned int one32[4];
+    alignas(16) static const float oneFloat[4];
+
+    alignas(16) static const unsigned long long highMaskDouble[2];
+    alignas(16) static const double oneDouble[2];
+    alignas(16) static const long long absMaskDouble[2];
+    alignas(16) static const unsigned long long signMaskDouble[2];
+    alignas(16) static const unsigned long long frexpMask[2];
 };
 
 template<typename T> struct c_trig
 {
-    ALIGN(64) static const T data[];
+    alignas(64) static const T data[];
 };
 
 template<typename T> struct c_log
 {
     enum VectorSize { Size = 16 / sizeof(T) };
     static Vc_ALWAYS_INLINE Vc_CONST const float *d(int i) { return reinterpret_cast<const  float *>(&data[i * Size]); }
-    ALIGN(64) static const unsigned int data[];
+    alignas(64) static const unsigned int data[];
 };
 
 template<> struct c_log<double>
 {
     enum VectorSize { Size = 16 / sizeof(double) };
     static Vc_ALWAYS_INLINE Vc_CONST const double *d(int i) { return reinterpret_cast<const double *>(&data[i * Size]); }
-    ALIGN(64) static const unsigned long long data[];
+    alignas(64) static const unsigned long long data[];
 };
 
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace SSE
+}  // namespace Vc
 
-#endif // VC_SSE_CONST_DATA_H
+#endif // VC_SSE_CONST_DATA_H_
diff -Nru vc-0.7.4/sse/const.h vc-1.3.0/sse/const.h
--- vc-0.7.4/sse/const.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/const.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,41 +1,45 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_CONST_H
-#define VC_SSE_CONST_H
+#ifndef VC_SSE_CONST_H_
+#define VC_SSE_CONST_H_
 
 #include "const_data.h"
 #include "vector.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
-    template<typename T> class Vector;
-
-    template<typename _T> struct Const
+    template<typename T> struct Const
     {
-        typedef Vector<_T> V;
-        typedef typename V::EntryType T;
-        typedef typename V::Mask M;
+        typedef Vector<T> V;
+        typedef Mask<T> M;
         enum Constants { Stride = 16 / sizeof(T) };
 
         static Vc_ALWAYS_INLINE Vc_CONST V _pi_4()        { return load(&c_trig<T>::data[0 * Stride]); }
@@ -81,28 +85,12 @@
         static Vc_ALWAYS_INLINE_L Vc_CONST_L V load(const T *mem) Vc_ALWAYS_INLINE_R Vc_CONST_R;
     };
     template<typename T> Vc_ALWAYS_INLINE Vc_CONST Vector<T> Const<T>::load(const T *mem) { return V(mem); }
-    template<> Vc_ALWAYS_INLINE Vc_CONST sfloat_v Const<Vc::sfloat>::load(const float *mem) { return M256::dup(float_v(mem).data()); }
 
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float> Const<float>::highMask() { return Vector<float>(reinterpret_cast<const float *>(&c_general::highMaskFloat)); }
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<double> Const<double>::highMask() { return Vector<double>(reinterpret_cast<const double *>(&c_general::highMaskDouble)); }
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float> Const<float>::highMask(int bits) { return _mm_castsi128_ps(_mm_slli_epi32(_mm_setallone_si128(), bits)); }
     template<> Vc_ALWAYS_INLINE Vc_CONST Vector<double> Const<double>::highMask(int bits) { return _mm_castsi128_pd(_mm_slli_epi64(_mm_setallone_si128(), bits)); }
-    template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float8> Const<float8>::highMask(int bits) {
-        return M256::dup(Const<float>::highMask(bits).data());
-    }
-    template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float8> Const<float8>::P(int i) {
-        return M256::dup(Const<float>::P(i).data());
-    }
-    template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float8> Const<float8>::Q(int i) {
-        return M256::dup(Const<float>::Q(i).data());
-    }
-    template<> Vc_ALWAYS_INLINE Vc_CONST Vector<float8>::Mask Const<float8>::exponentMask() {
-        return M256::dup(Const<float>::exponentMask().data());
-    }
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace SSE
+}  // namespace Vc
 
-#endif // VC_SSE_CONST_H
+#endif // VC_SSE_CONST_H_
diff -Nru vc-0.7.4/sse/debug.h vc-1.3.0/sse/debug.h
--- vc-0.7.4/sse/debug.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/debug.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,24 +1,32 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_DEBUG_H
-#define VC_SSE_DEBUG_H
+#ifndef VC_SSE_DEBUG_H_
+#define VC_SSE_DEBUG_H_
 
 #ifndef NDEBUG
 #include "types.h"
@@ -26,8 +34,7 @@
 #include <iomanip>
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
@@ -43,11 +50,21 @@
 class DebugStream
 {
     private:
+        static char hexChar(char x) { return x + (x > 9 ? 87 : 48); }
         template<typename T, typename V> static void printVector(V _x)
         {
+            std::cerr << "0x";
+            const auto bytes = reinterpret_cast<const std::uint8_t *>(&_x);
+            for (std::size_t i = 0; i < sizeof(V); ++i) {
+                std::cerr << hexChar(bytes[i] >> 4) << hexChar(bytes[i] & 0xf);
+                if (i % 4 == 3) {
+                    std::cerr << '\'';
+                }
+            }
+
             enum { Size = sizeof(V) / sizeof(T) };
             union { V v; T m[Size]; } x = { _x };
-            std::cerr << '[' << std::setprecision(24) << x.m[0];
+            std::cerr << " = [" << std::setprecision(24) << x.m[0];
             for (int i = 1; i < Size; ++i) {
                 std::cerr << ", " << std::setprecision(24) << x.m[i];
             }
@@ -70,7 +87,7 @@
             return *this;
         }
         DebugStream &operator<<(__m128i x) {
-            printVector<unsigned int, __m128i>(x);
+            printVector<int, __m128i>(x);
             return *this;
         }
 
@@ -81,10 +98,9 @@
 };
 #endif
 
-#define VC_DEBUG ::Vc::SSE::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)
+#define Vc_DEBUG Vc::SSE::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)
 
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace SSE
+}  // namespace Vc
 
-#endif // VC_SSE_DEBUG_H
+#endif // VC_SSE_DEBUG_H_
diff -Nru vc-0.7.4/sse/deinterleave.tcc vc-1.3.0/sse/deinterleave.tcc
--- vc-0.7.4/sse/deinterleave.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/deinterleave.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,24 +1,31 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
@@ -43,34 +50,6 @@
     b.data() = _mm_cvtepi32_ps(_mm_srli_epi32(tmp.data(), 16));
 }
 
-inline void deinterleave(Vector<float8> &a, Vector<float8> &b)
-{
-    _M128 tmp0 = _mm_unpacklo_ps(a.data()[0], a.data()[1]);
-    _M128 tmp1 = _mm_unpackhi_ps(a.data()[0], a.data()[1]);
-    _M128 tmp2 = _mm_unpacklo_ps(b.data()[0], b.data()[1]);
-    _M128 tmp3 = _mm_unpackhi_ps(b.data()[0], b.data()[1]);
-    a.data()[0] = _mm_unpacklo_ps(tmp0, tmp1);
-    b.data()[0] = _mm_unpackhi_ps(tmp0, tmp1);
-    a.data()[1] = _mm_unpacklo_ps(tmp2, tmp3);
-    b.data()[1] = _mm_unpackhi_ps(tmp2, tmp3);
-}
-
-inline void deinterleave(Vector<float8> &a, Vector<float8> &b, Vector<short>::AsArg tmp0, Vector<short>::AsArg tmp1)
-{
-    a.data()[0] = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_slli_epi32(tmp0.data(), 16), 16));
-    b.data()[0] = _mm_cvtepi32_ps(_mm_srai_epi32(tmp0.data(), 16));
-    a.data()[1] = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_slli_epi32(tmp1.data(), 16), 16));
-    b.data()[1] = _mm_cvtepi32_ps(_mm_srai_epi32(tmp1.data(), 16));
-}
-
-inline void deinterleave(Vector<float8> &a, Vector<float8> &b, Vector<unsigned short>::AsArg tmp0, Vector<unsigned short>::AsArg tmp1)
-{
-    a.data()[0] = _mm_cvtepi32_ps(_mm_srli_epi32(_mm_slli_epi32(tmp0.data(), 16), 16));
-    b.data()[0] = _mm_cvtepi32_ps(_mm_srli_epi32(tmp0.data(), 16));
-    a.data()[1] = _mm_cvtepi32_ps(_mm_srli_epi32(_mm_slli_epi32(tmp1.data(), 16), 16));
-    b.data()[1] = _mm_cvtepi32_ps(_mm_srli_epi32(tmp1.data(), 16));
-}
-
 inline void deinterleave(Vector<double> &a, Vector<double> &b)
 {
     _M128D tmp = _mm_unpacklo_pd(a.data(), b.data());
@@ -126,112 +105,86 @@
     b.data() = _mm_srli_epi32(tmp.data(), 16);
 }
 
-} // namespace SSE
-
-
-namespace Internal
-{
-
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        float_v &a, float_v &b, const float *m, A align)
-{
-    a.load(m, align);
-    b.load(m + float_v::Size, align);
-    Vc::SSE::deinterleave(a, b);
 }
-
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        float_v &a, float_v &b, const short *m, A align)
-{
-    short_v tmp(m, align);
-    Vc::SSE::deinterleave(a, b, tmp);
 }
-
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        float_v &a, float_v &b, const unsigned short *m, A align)
+namespace Vc_VERSIONED_NAMESPACE
 {
-    ushort_v tmp(m, align);
-    Vc::SSE::deinterleave(a, b, tmp);
-}
-
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        sfloat_v &a, sfloat_v &b, const float *m, A align)
+namespace Detail
+{
+template<typename A> inline void deinterleave(
+        SSE::float_v &a, SSE::float_v &b, const float *m, A align)
 {
     a.load(m, align);
-    b.load(m + sfloat_v::Size, align);
+    b.load(m + SSE::float_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        sfloat_v &a, sfloat_v &b, const short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::float_v &a, SSE::float_v &b, const short *m, A align)
 {
-    short_v tmp0(m, align);
-    short_v tmp1(m + short_v::Size, align);
-    Vc::SSE::deinterleave(a, b, tmp0, tmp1);
+    SSE::short_v tmp(m, align);
+    Vc::SSE::deinterleave(a, b, tmp);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        sfloat_v &a, sfloat_v &b, const unsigned short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::float_v &a, SSE::float_v &b, const unsigned short *m, A align)
 {
-    ushort_v tmp0(m, align);
-    ushort_v tmp1(m + short_v::Size, align);
-    Vc::SSE::deinterleave(a, b, tmp0, tmp1);
+    SSE::ushort_v tmp(m, align);
+    Vc::SSE::deinterleave(a, b, tmp);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        double_v &a, double_v &b, const double *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::double_v &a, SSE::double_v &b, const double *m, A align)
 {
     a.load(m, align);
-    b.load(m + double_v::Size, align);
+    b.load(m + SSE::double_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        int_v &a, int_v &b, const int *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::int_v &a, SSE::int_v &b, const int *m, A align)
 {
     a.load(m, align);
-    b.load(m + int_v::Size, align);
+    b.load(m + SSE::int_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        int_v &a, int_v &b, const short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::int_v &a, SSE::int_v &b, const short *m, A align)
 {
-    short_v tmp(m, align);
+    SSE::short_v tmp(m, align);
     Vc::SSE::deinterleave(a, b, tmp);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        uint_v &a, uint_v &b, const unsigned int *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::uint_v &a, SSE::uint_v &b, const unsigned int *m, A align)
 {
     a.load(m, align);
-    b.load(m + uint_v::Size, align);
+    b.load(m + SSE::uint_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        uint_v &a, uint_v &b, const unsigned short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::uint_v &a, SSE::uint_v &b, const unsigned short *m, A align)
 {
-    ushort_v tmp(m, align);
+    SSE::ushort_v tmp(m, align);
     Vc::SSE::deinterleave(a, b, tmp);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        short_v &a, short_v &b, const short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::short_v &a, SSE::short_v &b, const short *m, A align)
 {
     a.load(m, align);
-    b.load(m + short_v::Size, align);
+    b.load(m + SSE::short_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
 
-template<typename A> inline void HelperImpl<Vc::SSE2Impl>::deinterleave(
-        ushort_v &a, ushort_v &b, const unsigned short *m, A align)
+template<typename A> inline void deinterleave(
+        SSE::ushort_v &a, SSE::ushort_v &b, const unsigned short *m, A align)
 {
     a.load(m, align);
-    b.load(m + ushort_v::Size, align);
+    b.load(m + SSE::ushort_v::Size, align);
     Vc::SSE::deinterleave(a, b);
 }
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Detail
+}  // namespace Vc
diff -Nru vc-0.7.4/sse/detail.h vc-1.3.0/sse/detail.h
--- vc-0.7.4/sse/detail.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/sse/detail.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,1502 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SSE_DETAIL_H_
+#define VC_SSE_DETAIL_H_
+
+#include "casts.h"
+#ifdef Vc_IMPL_AVX
+#include "../avx/intrinsics.h"
+#endif
+#include "vectorhelper.h"
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+// (converting) load functions {{{1
+template <typename V, typename DstT> struct LoadTag
+{
+};
+
+// when_(un)aligned{{{2
+class when_aligned
+{
+public:
+    template <typename F> constexpr when_aligned(F, typename F::EnableIfAligned = nullptr)
+    {
+    }
+};
+
+class when_unaligned
+{
+public:
+    template <typename F>
+    constexpr when_unaligned(F, typename F::EnableIfUnaligned = nullptr)
+    {
+    }
+};
+
+class when_streaming
+{
+public:
+    template <typename F>
+    constexpr when_streaming(F, typename F::EnableIfStreaming = nullptr)
+    {
+    }
+};
+
+// load16{{{2
+Vc_INTRINSIC __m128 load16(const float *mem, when_aligned)
+{
+    return _mm_load_ps(mem);
+}
+Vc_INTRINSIC __m128 load16(const float *mem, when_unaligned)
+{
+    return _mm_loadu_ps(mem);
+}
+Vc_INTRINSIC __m128 load16(const float *mem, when_streaming)
+{
+    return SseIntrinsics::_mm_stream_load(mem);
+}
+Vc_INTRINSIC __m128d load16(const double *mem, when_aligned)
+{
+    return _mm_load_pd(mem);
+}
+Vc_INTRINSIC __m128d load16(const double *mem, when_unaligned)
+{
+    return _mm_loadu_pd(mem);
+}
+Vc_INTRINSIC __m128d load16(const double *mem, when_streaming)
+{
+    return SseIntrinsics::_mm_stream_load(mem);
+}
+template <class T> Vc_INTRINSIC __m128i load16(const T *mem, when_aligned)
+{
+    static_assert(std::is_integral<T>::value, "load16<T> is only intended for integral T");
+    return _mm_load_si128(reinterpret_cast<const __m128i *>(mem));
+}
+template <class T> Vc_INTRINSIC __m128i load16(const T *mem, when_unaligned)
+{
+    static_assert(std::is_integral<T>::value, "load16<T> is only intended for integral T");
+    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(mem));
+}
+template <class T> Vc_INTRINSIC __m128i load16(const T *mem, when_streaming)
+{
+    static_assert(std::is_integral<T>::value, "load16<T> is only intended for integral T");
+    return SseIntrinsics::_mm_stream_load(mem);
+}
+
+// MSVC workarounds{{{2
+#ifdef Vc_MSVC
+// work around: "fatal error C1001: An internal error has occurred in the compiler."
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128d load(const double *mem, F f,
+                          enable_if<(std::is_same<DstT, double>::value &&
+                                     std::is_same<V, __m128d>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128 load(const float *mem, F f,
+                         enable_if<(std::is_same<DstT, float>::value &&
+                                    std::is_same<V, __m128>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128i load(const uint *mem, F f,
+                          enable_if<(std::is_same<DstT, uint>::value &&
+                                     std::is_same<V, __m128i>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128i load(const int *mem, F f,
+                          enable_if<(std::is_same<DstT, int>::value &&
+                                     std::is_same<V, __m128i>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128i load(const short *mem, F f,
+                          enable_if<(std::is_same<DstT, short>::value &&
+                                     std::is_same<V, __m128i>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+
+template <typename V, typename DstT, typename F>
+Vc_INTRINSIC __m128i load(const ushort *mem, F f,
+                          enable_if<(std::is_same<DstT, ushort>::value &&
+                                     std::is_same<V, __m128i>::value)> = nullarg)
+{
+    return load16(mem, f);
+}
+#endif  // Vc_MSVC
+
+// generic load{{{2
+template <typename V, typename DstT, typename SrcT, typename Flags,
+          typename = enable_if<
+#ifdef Vc_MSVC
+              !std::is_same<DstT, SrcT>::value &&
+#endif
+              (!std::is_integral<DstT>::value || !std::is_integral<SrcT>::value ||
+               sizeof(DstT) >= sizeof(SrcT))>>
+Vc_INTRINSIC V load(const SrcT *mem, Flags flags)
+{
+    return load(mem, flags, LoadTag<V, DstT>());
+}
+
+// no conversion load from any T {{{2
+template <typename V, typename T, typename Flags>
+Vc_INTRINSIC V
+    load(const T *mem, Flags, LoadTag<V, T>, enable_if<sizeof(V) == 16> = nullarg)
+{
+    return SSE::VectorHelper<V>::template load<Flags>(mem);
+}
+
+// short {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const ushort *mem, Flags, LoadTag<__m128i, short>)
+{
+    return SSE::VectorHelper<__m128i>::load<Flags>(mem);
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const uchar *mem, Flags, LoadTag<__m128i, short>)
+{
+    // the only available streaming load loads 16 bytes - twice as much as we need =>
+    // can't use it, or we risk an out-of-bounds read and an unaligned load exception
+    return SSE::cvtepu8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const schar *mem, Flags, LoadTag<__m128i, short>)
+{
+    // the only available streaming load loads 16 bytes - twice as much as we need =>
+    // can't use it, or we risk an out-of-bounds read and an unaligned load exception
+    return SSE::cvtepi8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+
+// ushort {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const uchar *mem, Flags, LoadTag<__m128i, ushort>)
+{
+    // the only available streaming load loads 16 bytes - twice as much as we need =>
+    // can't use it, or we risk an out-of-bounds read and an unaligned load exception
+    return SSE::cvtepu8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+
+// int {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const uint *mem, Flags, LoadTag<__m128i, int>)
+{
+    return SSE::VectorHelper<__m128i>::load<Flags>(mem);
+}
+// no difference between streaming and alignment, because the
+// 32/64 bit loads are not available as streaming loads, and can always be unaligned
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const ushort *mem, Flags, LoadTag<__m128i, int>)
+{
+    return SSE::cvtepu16_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const short *mem, Flags, LoadTag<__m128i, int>)
+{
+    return SSE::cvtepi16_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const uchar *mem, Flags, LoadTag<__m128i, int>)
+{
+    return SSE::cvtepu8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const schar *mem, Flags, LoadTag<__m128i, int>)
+{
+    return SSE::cvtepi8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(mem)));
+}
+
+// uint {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const ushort *mem, Flags, LoadTag<__m128i, uint>)
+{
+    return SSE::cvtepu16_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128i load(const uchar *mem, Flags, LoadTag<__m128i, uint>)
+{
+    return SSE::cvtepu8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(mem)));
+}
+
+// double {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const float *mem, Flags, LoadTag<__m128d, double>)
+{
+    return SSE::convert<float, double>(
+        _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<const __m64 *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const uint *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<uint, double>(
+        _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const int *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<int, double>(
+        _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const ushort *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<ushort, double>(
+        _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const short *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<short, double>(
+        _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const uchar *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<uchar, double>(
+        _mm_set1_epi16(*reinterpret_cast<const MayAlias<short> *>(mem)));
+}
+template <typename Flags>
+Vc_INTRINSIC __m128d load(const schar *mem, Flags f, LoadTag<__m128d, double>)
+{
+    return SSE::convert<char, double>(
+        _mm_set1_epi16(*reinterpret_cast<const MayAlias<short> *>(mem)));
+}
+
+// float {{{2
+template <typename Flags>
+Vc_INTRINSIC __m128 load(const double *mem, Flags, LoadTag<__m128, float>)
+{
+#ifdef Vc_IMPL_AVX
+    if (Flags::IsUnaligned) {
+        return _mm256_cvtpd_ps(_mm256_loadu_pd(mem));
+    } else if (Flags::IsStreaming) {
+        return _mm256_cvtpd_ps(AvxIntrinsics::stream_load<__m256d>(mem));
+    } else {  // Flags::IsAligned
+        return _mm256_cvtpd_ps(_mm256_load_pd(mem));
+    }
+#else
+    return _mm_movelh_ps(_mm_cvtpd_ps(SSE::VectorHelper<__m128d>::load<Flags>(&mem[0])),
+                         _mm_cvtpd_ps(SSE::VectorHelper<__m128d>::load<Flags>(&mem[2])));
+#endif
+}
+template <typename Flags>
+Vc_INTRINSIC __m128 load(const uint *mem, Flags f, LoadTag<__m128, float>)
+{
+    return SSE::convert<uint, float>(load<__m128i, uint>(mem, f));
+}
+template <typename T, typename Flags,
+          typename = enable_if<!std::is_same<T, float>::value>>
+Vc_INTRINSIC __m128 load(const T *mem, Flags f, LoadTag<__m128, float>)
+{
+    return _mm_cvtepi32_ps(load<__m128i, int>(mem, f));
+}
+
+// shifted{{{1
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<amount == 0, T> shifted(T k)
+{
+    return k;
+}
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 16 && amount > 0), T> shifted(T k)
+{
+    return _mm_srli_si128(k, amount);
+}
+template <int amount, typename T>
+Vc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 16 && amount < 0), T> shifted(T k)
+{
+    return _mm_slli_si128(k, -amount);
+}
+
+// IndexesFromZero{{{1
+template <typename T, int Size> Vc_INTRINSIC Vc_CONST const T *IndexesFromZero()
+{
+    if (Size == 4) {
+        return reinterpret_cast<const T *>(SSE::_IndexesFromZero4);
+    } else if (Size == 8) {
+        return reinterpret_cast<const T *>(SSE::_IndexesFromZero8);
+    } else if (Size == 16) {
+        return reinterpret_cast<const T *>(SSE::_IndexesFromZero16);
+    }
+    return 0;
+}
+
+// popcnt{{{1
+Vc_INTRINSIC Vc_CONST unsigned int popcnt4(unsigned int n)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(n);
+#else
+    n = (n & 0x5U) + ((n >> 1) & 0x5U);
+    n = (n & 0x3U) + ((n >> 2) & 0x3U);
+    return n;
+#endif
+}
+Vc_INTRINSIC Vc_CONST unsigned int popcnt8(unsigned int n)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(n);
+#else
+    n = (n & 0x55U) + ((n >> 1) & 0x55U);
+    n = (n & 0x33U) + ((n >> 2) & 0x33U);
+    n = (n & 0x0fU) + ((n >> 4) & 0x0fU);
+    return n;
+#endif
+}
+Vc_INTRINSIC Vc_CONST unsigned int popcnt16(unsigned int n)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(n);
+#else
+    n = (n & 0x5555U) + ((n >> 1) & 0x5555U);
+    n = (n & 0x3333U) + ((n >> 2) & 0x3333U);
+    n = (n & 0x0f0fU) + ((n >> 4) & 0x0f0fU);
+    n = (n & 0x00ffU) + ((n >> 8) & 0x00ffU);
+    return n;
+#endif
+}
+Vc_INTRINSIC Vc_CONST unsigned int popcnt32(unsigned int n)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(n);
+#else
+    n = (n & 0x55555555U) + ((n >> 1) & 0x55555555U);
+    n = (n & 0x33333333U) + ((n >> 2) & 0x33333333U);
+    n = (n & 0x0f0f0f0fU) + ((n >> 4) & 0x0f0f0f0fU);
+    n = (n & 0x00ff00ffU) + ((n >> 8) & 0x00ff00ffU);
+    n = (n & 0x0000ffffU) + ((n >>16) & 0x0000ffffU);
+    return n;
+#endif
+}
+
+// mask_cast{{{1
+template<size_t From, size_t To, typename R> Vc_INTRINSIC Vc_CONST R mask_cast(__m128i k)
+{
+    static_assert(From == To, "Incorrect mask cast.");
+    static_assert(std::is_same<R, __m128>::value, "Incorrect mask cast.");
+    return SSE::sse_cast<__m128>(k);
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<2, 4, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(_mm_packs_epi16(k, _mm_setzero_si128()));
+}
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<2, 8, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(
+        _mm_packs_epi16(_mm_packs_epi16(k, _mm_setzero_si128()), _mm_setzero_si128()));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 2, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi32(k, k));
+}
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 8, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(_mm_packs_epi16(k, _mm_setzero_si128()));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 2, __m128>(__m128i k)
+{
+    const auto tmp = _mm_unpacklo_epi16(k, k);
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi32(tmp, tmp));
+}
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 4, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi16(k, k));
+}
+
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<16, 8, __m128>(__m128i k)
+{
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi8(k, k));
+}
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<16, 4, __m128>(__m128i k)
+{
+    const auto tmp = SSE::sse_cast<__m128i>(mask_cast<16, 8, __m128>(k));
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi16(tmp, tmp));
+}
+template<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<16, 2, __m128>(__m128i k)
+{
+    const auto tmp = SSE::sse_cast<__m128i>(mask_cast<16, 4, __m128>(k));
+    return SSE::sse_cast<__m128>(_mm_unpacklo_epi32(tmp, tmp));
+}
+
+// allone{{{1
+template <typename V> Vc_INTRINSIC_L Vc_CONST_L V allone() Vc_INTRINSIC_R Vc_CONST_R;
+template<> Vc_INTRINSIC Vc_CONST __m128  allone<__m128 >() { return SSE::_mm_setallone_ps(); }
+template<> Vc_INTRINSIC Vc_CONST __m128i allone<__m128i>() { return SSE::_mm_setallone_si128(); }
+template<> Vc_INTRINSIC Vc_CONST __m128d allone<__m128d>() { return SSE::_mm_setallone_pd(); }
+
+// zero{{{1
+template <typename V> inline V zero();
+template<> Vc_INTRINSIC Vc_CONST __m128  zero<__m128 >() { return _mm_setzero_ps(); }
+template<> Vc_INTRINSIC Vc_CONST __m128i zero<__m128i>() { return _mm_setzero_si128(); }
+template<> Vc_INTRINSIC Vc_CONST __m128d zero<__m128d>() { return _mm_setzero_pd(); }
+
+// negate{{{1
+Vc_ALWAYS_INLINE Vc_CONST __m128 negate(__m128 v, std::integral_constant<std::size_t, 4>)
+{
+    return _mm_xor_ps(v, SSE::_mm_setsignmask_ps());
+}
+Vc_ALWAYS_INLINE Vc_CONST __m128d negate(__m128d v, std::integral_constant<std::size_t, 8>)
+{
+    return _mm_xor_pd(v, SSE::_mm_setsignmask_pd());
+}
+Vc_ALWAYS_INLINE Vc_CONST __m128i negate(__m128i v, std::integral_constant<std::size_t, 4>)
+{
+#ifdef Vc_IMPL_SSSE3
+    return _mm_sign_epi32(v, allone<__m128i>());
+#else
+    return _mm_sub_epi32(_mm_setzero_si128(), v);
+#endif
+}
+Vc_ALWAYS_INLINE Vc_CONST __m128i negate(__m128i v, std::integral_constant<std::size_t, 2>)
+{
+#ifdef Vc_IMPL_SSSE3
+    return _mm_sign_epi16(v, allone<__m128i>());
+#else
+    return _mm_sub_epi16(_mm_setzero_si128(), v);
+#endif
+}
+
+// xor_{{{1
+Vc_INTRINSIC __m128 xor_(__m128 a, __m128 b) { return _mm_xor_ps(a, b); }
+Vc_INTRINSIC __m128d xor_(__m128d a, __m128d b) { return _mm_xor_pd(a, b); }
+Vc_INTRINSIC __m128i xor_(__m128i a, __m128i b) { return _mm_xor_si128(a, b); }
+
+// or_{{{1
+Vc_INTRINSIC __m128 or_(__m128 a, __m128 b) { return _mm_or_ps(a, b); }
+Vc_INTRINSIC __m128d or_(__m128d a, __m128d b) { return _mm_or_pd(a, b); }
+Vc_INTRINSIC __m128i or_(__m128i a, __m128i b) { return _mm_or_si128(a, b); }
+
+// and_{{{1
+Vc_INTRINSIC __m128 and_(__m128 a, __m128 b) { return _mm_and_ps(a, b); }
+Vc_INTRINSIC __m128d and_(__m128d a, __m128d b) { return _mm_and_pd(a, b); }
+Vc_INTRINSIC __m128i and_(__m128i a, __m128i b) { return _mm_and_si128(a, b); }
+
+// andnot_{{{1
+Vc_INTRINSIC __m128 andnot_(__m128 a, __m128 b) { return _mm_andnot_ps(a, b); }
+Vc_INTRINSIC __m128d andnot_(__m128d a, __m128d b) { return _mm_andnot_pd(a, b); }
+Vc_INTRINSIC __m128i andnot_(__m128i a, __m128i b) { return _mm_andnot_si128(a, b); }
+
+// not_{{{1
+Vc_INTRINSIC __m128  not_(__m128  a) { return andnot_(a, allone<__m128 >()); }
+Vc_INTRINSIC __m128d not_(__m128d a) { return andnot_(a, allone<__m128d>()); }
+Vc_INTRINSIC __m128i not_(__m128i a) { return andnot_(a, allone<__m128i>()); }
+
+// add{{{1
+Vc_INTRINSIC __m128  add(__m128  a, __m128  b,  float) { return _mm_add_ps(a, b); }
+Vc_INTRINSIC __m128d add(__m128d a, __m128d b, double) { return _mm_add_pd(a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b,    int) { return _mm_add_epi32(a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b,   uint) { return _mm_add_epi32(a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b,  short) { return _mm_add_epi16(a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b, ushort) { return _mm_add_epi16(a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b,  schar) { return _mm_add_epi8 (a, b); }
+Vc_INTRINSIC __m128i add(__m128i a, __m128i b,  uchar) { return _mm_add_epi8 (a, b); }
+
+// sub{{{1
+Vc_INTRINSIC __m128  sub(__m128  a, __m128  b,  float) { return _mm_sub_ps(a, b); }
+Vc_INTRINSIC __m128d sub(__m128d a, __m128d b, double) { return _mm_sub_pd(a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b,    int) { return _mm_sub_epi32(a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b,   uint) { return _mm_sub_epi32(a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b,  short) { return _mm_sub_epi16(a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b, ushort) { return _mm_sub_epi16(a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b,  schar) { return _mm_sub_epi8 (a, b); }
+Vc_INTRINSIC __m128i sub(__m128i a, __m128i b,  uchar) { return _mm_sub_epi8 (a, b); }
+
+// mul{{{1
+Vc_INTRINSIC __m128  mul(__m128  a, __m128  b,  float) { return _mm_mul_ps(a, b); }
+Vc_INTRINSIC __m128d mul(__m128d a, __m128d b, double) { return _mm_mul_pd(a, b); }
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b,    int) {
+#ifdef Vc_IMPL_SSE4_1
+    return _mm_mullo_epi32(a, b);
+#else
+    const __m128i aShift = _mm_srli_si128(a, 4);
+    const __m128i ab02 = _mm_mul_epu32(a, b);  // [a0 * b0, a2 * b2]
+    const __m128i bShift = _mm_srli_si128(b, 4);
+    const __m128i ab13 = _mm_mul_epu32(aShift, bShift);  // [a1 * b1, a3 * b3]
+    return _mm_unpacklo_epi32(_mm_shuffle_epi32(ab02, 8), _mm_shuffle_epi32(ab13, 8));
+#endif
+}
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b,   uint) { return mul(a, b, int()); }
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b,  short) { return _mm_mullo_epi16(a, b); }
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b, ushort) { return _mm_mullo_epi16(a, b); }
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b,  schar) {
+#ifdef Vc_USE_BUILTIN_VECTOR_TYPES
+    using B = Common::BuiltinType<schar, 16>;
+    const auto x = reinterpret_cast<const MayAlias<B> &>(a) *
+                   reinterpret_cast<const MayAlias<B> &>(b);
+    return reinterpret_cast<const __m128i &>(x);
+#else
+    return or_(
+        and_(_mm_mullo_epi16(a, b), _mm_slli_epi16(allone<__m128i>(), 8)),
+        _mm_slli_epi16(_mm_mullo_epi16(_mm_srli_si128(a, 1), _mm_srli_si128(b, 1)), 8));
+#endif
+}
+Vc_INTRINSIC __m128i mul(__m128i a, __m128i b,  uchar) {
+#ifdef Vc_USE_BUILTIN_VECTOR_TYPES
+    using B = Common::BuiltinType<uchar, 16>;
+    const auto x = reinterpret_cast<const MayAlias<B> &>(a) *
+                   reinterpret_cast<const MayAlias<B> &>(b);
+    return reinterpret_cast<const __m128i &>(x);
+#else
+    return or_(
+        and_(_mm_mullo_epi16(a, b), _mm_slli_epi16(allone<__m128i>(), 8)),
+        _mm_slli_epi16(_mm_mullo_epi16(_mm_srli_si128(a, 1), _mm_srli_si128(b, 1)), 8));
+#endif
+}
+
+// div{{{1
+Vc_INTRINSIC __m128  div(__m128  a, __m128  b,  float) { return _mm_div_ps(a, b); }
+Vc_INTRINSIC __m128d div(__m128d a, __m128d b, double) { return _mm_div_pd(a, b); }
+
+// TODO: fma{{{1
+//Vc_INTRINSIC __m128  fma(__m128  a, __m128  b, __m128  c,  float) { return _mm_mul_ps(a, b); }
+//Vc_INTRINSIC __m128d fma(__m128d a, __m128d b, __m128d c, double) { return _mm_mul_pd(a, b); }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c,    int) { }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c,   uint) { return fma(a, b, int()); }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c,  short) { return _mm_mullo_epi16(a, b); }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c, ushort) { return _mm_mullo_epi16(a, b); }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c,  schar) { }
+//Vc_INTRINSIC __m128i fma(__m128i a, __m128i b, __m128i c,  uchar) { }
+
+// min{{{1
+Vc_INTRINSIC __m128  min(__m128  a, __m128  b,  float) { return _mm_min_ps(a, b); }
+Vc_INTRINSIC __m128d min(__m128d a, __m128d b, double) { return _mm_min_pd(a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b,    int) { return SSE::min_epi32(a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b,   uint) { return SSE::min_epu32(a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b,  short) { return _mm_min_epi16(a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b, ushort) { return SSE::min_epu16(a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b,  schar) { return SSE::min_epi8 (a, b); }
+Vc_INTRINSIC __m128i min(__m128i a, __m128i b,  uchar) { return _mm_min_epu8 (a, b); }
+
+// max{{{1
+Vc_INTRINSIC __m128  max(__m128  a, __m128  b,  float) { return _mm_max_ps(a, b); }
+Vc_INTRINSIC __m128d max(__m128d a, __m128d b, double) { return _mm_max_pd(a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b,    int) { return SSE::max_epi32(a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b,   uint) { return SSE::max_epu32(a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b,  short) { return _mm_max_epi16(a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b, ushort) { return SSE::max_epu16(a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b,  schar) { return SSE::max_epi8 (a, b); }
+Vc_INTRINSIC __m128i max(__m128i a, __m128i b,  uchar) { return _mm_max_epu8 (a, b); }
+
+// horizontal add{{{1
+Vc_INTRINSIC  float add(__m128  a,  float) {
+    a = _mm_add_ps(a, _mm_movehl_ps(a, a));
+    a = _mm_add_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+    return _mm_cvtss_f32(a);
+}
+Vc_INTRINSIC double add(__m128d a, double) {
+    a = _mm_add_sd(a, _mm_unpackhi_pd(a, a));
+    return _mm_cvtsd_f64(a);
+}
+Vc_INTRINSIC    int add(__m128i a,    int) {
+    a = add(a, _mm_srli_si128(a, 8), int());
+    a = add(a, _mm_srli_si128(a, 4), int());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC   uint add(__m128i a,   uint) { return add(a, int()); }
+Vc_INTRINSIC  short add(__m128i a,  short) {
+    a = add(a, _mm_srli_si128(a, 8), short());
+    a = add(a, _mm_srli_si128(a, 4), short());
+    a = add(a, _mm_srli_si128(a, 2), short());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC ushort add(__m128i a, ushort) { return add(a, short()); }
+Vc_INTRINSIC  schar add(__m128i a,  schar) {
+    a = add(a, _mm_srli_si128(a, 8), schar());
+    a = add(a, _mm_srli_si128(a, 4), schar());
+    a = add(a, _mm_srli_si128(a, 2), schar());
+    a = add(a, _mm_srli_si128(a, 1), schar());
+    return _mm_cvtsi128_si32(a);  // & 0xff is implicit
+}
+Vc_INTRINSIC  uchar add(__m128i a,  uchar) { return add(a, schar()); }
+
+// horizontal mul{{{1
+Vc_INTRINSIC  float mul(__m128  a,  float) {
+    a = _mm_mul_ps(a, _mm_movehl_ps(a, a));
+    a = _mm_mul_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+    return _mm_cvtss_f32(a);
+}
+Vc_INTRINSIC double mul(__m128d a, double) {
+    a = _mm_mul_sd(a, _mm_unpackhi_pd(a, a));
+    return _mm_cvtsd_f64(a);
+}
+Vc_INTRINSIC    int mul(__m128i a,    int) {
+    a = mul(a, _mm_srli_si128(a, 8), int());
+    a = mul(a, _mm_srli_si128(a, 4), int());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC   uint mul(__m128i a,   uint) { return mul(a, int()); }
+Vc_INTRINSIC  short mul(__m128i a,  short) {
+    a = mul(a, _mm_srli_si128(a, 8), short());
+    a = mul(a, _mm_srli_si128(a, 4), short());
+    a = mul(a, _mm_srli_si128(a, 2), short());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC ushort mul(__m128i a, ushort) { return mul(a, short()); }
+Vc_INTRINSIC  schar mul(__m128i a,  schar) {
+    // convert to two short vectors, multiply them and then do horizontal reduction
+    const __m128i s0 = _mm_srai_epi16(a, 1);
+    const __m128i s1 = Detail::and_(a, _mm_set1_epi32(0x0f0f0f0f));
+    return mul(mul(s0, s1, short()), short());
+}
+Vc_INTRINSIC  uchar mul(__m128i a,  uchar) { return mul(a, schar()); }
+
+// horizontal min{{{1
+Vc_INTRINSIC  float min(__m128  a,  float) {
+    a = _mm_min_ps(a, _mm_movehl_ps(a, a));
+    a = _mm_min_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+    return _mm_cvtss_f32(a);
+}
+Vc_INTRINSIC double min(__m128d a, double) {
+    a = _mm_min_sd(a, _mm_unpackhi_pd(a, a));
+    return _mm_cvtsd_f64(a);
+}
+Vc_INTRINSIC    int min(__m128i a,    int) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), int());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), int());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC   uint min(__m128i a,   uint) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), uint());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), uint());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC  short min(__m128i a,  short) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), short());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), short());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), short());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC ushort min(__m128i a, ushort) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), ushort());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), ushort());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), ushort());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC  schar min(__m128i a,  schar) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), schar());
+    return std::min(schar(_mm_cvtsi128_si32(a) >> 8), schar(_mm_cvtsi128_si32(a)));
+}
+Vc_INTRINSIC  uchar min(__m128i a,  uchar) {
+    a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = min(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), schar());
+    return std::min((_mm_cvtsi128_si32(a) >> 8) & 0xff, _mm_cvtsi128_si32(a) & 0xff);
+}
+
+// horizontal max{{{1
+Vc_INTRINSIC  float max(__m128  a,  float) {
+    a = _mm_max_ps(a, _mm_movehl_ps(a, a));
+    a = _mm_max_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+    return _mm_cvtss_f32(a);
+}
+Vc_INTRINSIC double max(__m128d a, double) {
+    a = _mm_max_sd(a, _mm_unpackhi_pd(a, a));
+    return _mm_cvtsd_f64(a);
+}
+Vc_INTRINSIC    int max(__m128i a,    int) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), int());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), int());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC   uint max(__m128i a,   uint) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), uint());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), uint());
+    return _mm_cvtsi128_si32(a);
+}
+Vc_INTRINSIC  short max(__m128i a,  short) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), short());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), short());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), short());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC ushort max(__m128i a, ushort) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), ushort());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), ushort());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), ushort());
+    return _mm_cvtsi128_si32(a);  // & 0xffff is implicit
+}
+Vc_INTRINSIC  schar max(__m128i a,  schar) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), schar());
+    return std::max(schar(_mm_cvtsi128_si32(a) >> 8), schar(_mm_cvtsi128_si32(a)));
+}
+Vc_INTRINSIC  uchar max(__m128i a,  uchar) {
+    a = max(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)), schar());
+    a = max(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)), schar());
+    return std::max((_mm_cvtsi128_si32(a) >> 8) & 0xff, _mm_cvtsi128_si32(a) & 0xff);
+}
+
+// sorted{{{1
+template <Vc::Implementation, typename T>
+Vc_CONST_L SSE::Vector<T> sorted(SSE::Vector<T> x) Vc_CONST_R;
+template <typename T> Vc_INTRINSIC Vc_CONST SSE::Vector<T> sorted(SSE::Vector<T> x)
+{
+    static_assert(!CurrentImplementation::is(ScalarImpl),
+                  "Detail::sorted can only be instantiated if a non-Scalar "
+                  "implementation is selected.");
+    return sorted < CurrentImplementation::is_between(SSE2Impl, SSSE3Impl)
+               ? SSE2Impl
+               : CurrentImplementation::is_between(SSE41Impl, SSE42Impl)
+                     ? SSE41Impl
+                     : CurrentImplementation::current() > (x);
+}
+
+// sanitize{{{1
+template <typename V> constexpr int sanitize(int n)
+{
+    return (n >= int(sizeof(V)) || n <= -int(sizeof(V))) ? 0 : n;
+}
+
+// rotated{{{1
+template <typename T, size_t N, typename V>
+static Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 16), V> rotated(V v, int amount)
+{
+    using namespace SSE;
+    switch (static_cast<unsigned int>(amount) % N) {
+    case 0:
+        return v;
+    case 1:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(1 * sizeof(T))));
+    case 2:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(2 * sizeof(T))));
+    case 3:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(3 * sizeof(T))));
+    case 4:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(4 * sizeof(T))));
+    case 5:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(5 * sizeof(T))));
+    case 6:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(6 * sizeof(T))));
+    case 7:
+        return sse_cast<V>(_mm_alignr_epi8(v, v, sanitize<V>(7 * sizeof(T))));
+    }
+    return sse_cast<V>(_mm_setzero_si128());
+}
+
+//InterleaveImpl{{{1
+template<typename V, int Size, size_t VSize> struct InterleaveImpl;
+template<typename V> struct InterleaveImpl<V, 8, 16> {
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v1.data());
+        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v1.data());
+#ifdef __x86_64__
+        const long long tmp00 = _mm_cvtsi128_si64(tmp0);
+        const long long tmp01 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp0, tmp0));
+        const long long tmp10 = _mm_cvtsi128_si64(tmp1);
+        const long long tmp11 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp1, tmp1));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[0]]) = tmp00;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[1]]) = tmp00 >> 32;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[2]]) = tmp01;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[3]]) = tmp01 >> 32;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[4]]) = tmp10;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[5]]) = tmp10 >> 32;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[6]]) = tmp11;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[7]]) = tmp11 >> 32;
+#elif defined(Vc_IMPL_SSE4_1)
+        using namespace SseIntrinsics;
+        *reinterpret_cast<MayAlias<int> *>(&data[i[0]]) = _mm_cvtsi128_si32(tmp0);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[1]]) = extract_epi32<1>(tmp0);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[2]]) = extract_epi32<2>(tmp0);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[3]]) = extract_epi32<3>(tmp0);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[4]]) = _mm_cvtsi128_si32(tmp1);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[5]]) = extract_epi32<1>(tmp1);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[6]]) = extract_epi32<2>(tmp1);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[7]]) = extract_epi32<3>(tmp1);
+#else
+        *reinterpret_cast<MayAlias<int> *>(&data[i[0]]) = _mm_cvtsi128_si32(tmp0);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[1]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 4));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[2]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 8));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[3]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 12));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[4]]) = _mm_cvtsi128_si32(tmp1);
+        *reinterpret_cast<MayAlias<int> *>(&data[i[5]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 4));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[6]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 8));
+        *reinterpret_cast<MayAlias<int> *>(&data[i[7]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 12));
+#endif
+    }/*}}}*/
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v1.data());
+        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v1.data());
+        V(tmp0).store(&data[i[0]], Vc::Unaligned);
+        V(tmp1).store(&data[i[4]], Vc::Unaligned);
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
+    {
+#if defined Vc_USE_MASKMOV_SCATTER && !defined Vc_MSVC
+        // MSVC fails to compile the MMX intrinsics
+        const __m64 mask = _mm_set_pi16(0, -1, -1, -1);
+        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
+        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
+        const __m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v1.data());
+        const __m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v1.data());
+
+        const __m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
+        const __m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
+        const __m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
+        const __m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
+
+        _mm_maskmove_si64(_mm_movepi64_pi64(tmp4), mask, reinterpret_cast<char *>(&data[i[0]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(_mm_srli_si128(tmp4, 8)), mask, reinterpret_cast<char *>(&data[i[1]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(tmp5), mask, reinterpret_cast<char *>(&data[i[2]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(_mm_srli_si128(tmp5, 8)), mask, reinterpret_cast<char *>(&data[i[3]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(tmp6), mask, reinterpret_cast<char *>(&data[i[4]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(_mm_srli_si128(tmp6, 8)), mask, reinterpret_cast<char *>(&data[i[5]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(tmp7), mask, reinterpret_cast<char *>(&data[i[6]]));
+        _mm_maskmove_si64(_mm_movepi64_pi64(_mm_srli_si128(tmp7, 8)), mask, reinterpret_cast<char *>(&data[i[7]]));
+        _mm_empty();
+#else
+        interleave(data, i, v0, v1);
+        v2.scatter(data + 2, i);
+#endif
+    }/*}}}*/
+    template<typename I> static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1,
+            const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
+        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
+        const __m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v3.data());
+        const __m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v3.data());
+
+        const __m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
+        const __m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
+        const __m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
+        const __m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
+
+        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[0]]), tmp4);
+        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[2]]), tmp5);
+        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[4]]), tmp6);
+        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[6]]), tmp7);
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), _mm_castsi128_ps(tmp4));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), _mm_castsi128_ps(tmp5));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), _mm_castsi128_ps(tmp6));
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), _mm_castsi128_ps(tmp7));
+    }/*}}}*/
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<4> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1,
+            const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
+        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
+        const __m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v3.data());
+        const __m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v3.data());
+
+        const __m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
+        const __m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
+        const __m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
+        const __m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
+
+        V(tmp4).store(&data[i[0]], ::Vc::Unaligned);
+        V(tmp5).store(&data[i[2]], ::Vc::Unaligned);
+        V(tmp6).store(&data[i[4]], ::Vc::Unaligned);
+        V(tmp7).store(&data[i[6]], ::Vc::Unaligned);
+    }/*}}}*/
+    template <typename I>  // interleave 5 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args{{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data, /*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        const __m128i a = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[0]]));
+        const __m128i b = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[1]]));
+        const __m128i c = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[2]]));
+        const __m128i d = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[3]]));
+        const __m128i e = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[4]]));
+        const __m128i f = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[5]]));
+        const __m128i g = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[6]]));
+        const __m128i h = _mm_cvtsi32_si128(*reinterpret_cast<const MayAlias<int> *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        const __m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        const __m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+        v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+        v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
+        v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+        v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
+        v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
+        v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+        const __m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
+        const __m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+        v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
+        v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
+        v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
+        v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[0]]));
+        const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[1]]));
+        const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[2]]));
+        const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[3]]));
+        const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[4]]));
+        const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[5]]));
+        const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[6]]));
+        const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&data[i[7]]));
+
+        const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
+        const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
+        const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
+        const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
+        const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
+        const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
+        const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
+        const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
+
+        const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
+        const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
+        const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
+        const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
+        const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
+        const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
+        const __m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
+        const __m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
+
+        v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
+        v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
+        v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
+        v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
+        v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
+        v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
+        v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
+        v7.data() = _mm_unpackhi_epi16(tmp14, tmp15);
+    }/*}}}*/
+};
+template<typename V> struct InterleaveImpl<V, 4, 16> {
+    static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/
+            const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[0]]), tmp0);
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[2]]), tmp1);
+    }/*}}}*/
+    template <typename I>  // interleave 2 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), tmp0);
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), tmp0);
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), tmp1);
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), tmp1);
+    }
+    template <typename I>  // interleave 3 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2)
+    {
+#ifdef Vc_USE_MASKMOV_SCATTER
+        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()), SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()), SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp2 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v2.data()), SSE::sse_cast<__m128>(v2.data()));
+        const __m128 tmp3 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v2.data()), SSE::sse_cast<__m128>(v2.data()));
+        const __m128i mask = _mm_set_epi32(0, -1, -1, -1);
+        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp0, tmp2)), mask, reinterpret_cast<char *>(&data[i[0]]));
+        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp2, tmp0)), mask, reinterpret_cast<char *>(&data[i[1]]));
+        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp1, tmp3)), mask, reinterpret_cast<char *>(&data[i[2]]));
+        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp3, tmp1)), mask, reinterpret_cast<char *>(&data[i[3]]));
+#else
+        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), tmp0);
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), tmp0);
+        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), tmp1);
+        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), tmp1);
+        v2.scatter(data + 2, i);
+#endif
+    }
+    template <typename I>  // interleave 4 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
+        const __m128 tmp2 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v2.data()),SSE::sse_cast<__m128>(v3.data()));
+        const __m128 tmp3 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v2.data()),SSE::sse_cast<__m128>(v3.data()));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[0]]), _mm_movelh_ps(tmp0, tmp2));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[1]]), _mm_movehl_ps(tmp2, tmp0));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[2]]), _mm_movelh_ps(tmp1, tmp3));
+        _mm_storeu_ps(reinterpret_cast<MayAlias<float> *>(&data[i[3]]), _mm_movehl_ps(tmp3, tmp1));
+    }
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        const __m128 a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const MayAlias<double> *>(&data[i[0]])));
+        const __m128 b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const MayAlias<double> *>(&data[i[1]])));
+        const __m128 c = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const MayAlias<double> *>(&data[i[2]])));
+        const __m128 d = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const MayAlias<double> *>(&data[i[3]])));
+
+        const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
+        const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
+
+        v0.data() = SSE::sse_cast<typename V::VectorType>(_mm_movelh_ps(tmp0, tmp1));
+        v1.data() = SSE::sse_cast<typename V::VectorType>(_mm_movehl_ps(tmp1, tmp0));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        const __m128 a = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]]));
+        const __m128 b = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[1]]));
+        const __m128 c = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[2]]));
+        const __m128 d = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[3]]));
+
+        const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
+        const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
+        const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 XX XX]
+        const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 XX XX]
+
+        v0.data() = SSE::sse_cast<typename V::VectorType>(_mm_movelh_ps(tmp0, tmp1));
+        v1.data() = SSE::sse_cast<typename V::VectorType>(_mm_movehl_ps(tmp1, tmp0));
+        v2.data() = SSE::sse_cast<typename V::VectorType>(_mm_movelh_ps(tmp2, tmp3));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        const __m128 a = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[0]]));
+        const __m128 b = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[1]]));
+        const __m128 c = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[2]]));
+        const __m128 d = _mm_loadu_ps(reinterpret_cast<const MayAlias<float> *>(&data[i[3]]));
+
+        const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
+        const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
+        const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 d0 d1]
+        const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 d2 d3]
+
+        v0.data() = SSE::sse_cast<typename V::VectorType>(_mm_movelh_ps(tmp0, tmp1));
+        v1.data() = SSE::sse_cast<typename V::VectorType>(_mm_movehl_ps(tmp1, tmp0));
+        v2.data() = SSE::sse_cast<typename V::VectorType>(_mm_movelh_ps(tmp2, tmp3));
+        v3.data() = SSE::sse_cast<typename V::VectorType>(_mm_movehl_ps(tmp3, tmp2));
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        v4.gather(data + 4, i);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        deinterleave(data, i, v0, v1, v2, v3);
+        deinterleave(data + 4, i, v4, v5, v6, v7);
+    }/*}}}*/
+};
+template<typename V> struct InterleaveImpl<V, 2, 16> {
+    template <typename I>  // interleave 2 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1)
+    {
+        const __m128d tmp0 = _mm_unpacklo_pd(v0.data(), v1.data());
+        const __m128d tmp1 = _mm_unpackhi_pd(v0.data(), v1.data());
+        _mm_storeu_pd(&data[i[0]], tmp0);
+        _mm_storeu_pd(&data[i[1]], tmp1);
+    }
+    template <typename I>  // interleave 3 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2)
+    {
+        interleave(data, i, v0, v1);
+        v2.scatter(data + 2, i);
+    }
+    template <typename I>  // interleave 4 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3)
+    {
+        interleave(data, i, v0, v1);
+        interleave(data + 2, i, v2, v3);
+    }
+    template <typename I>  // interleave 5 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        v4.scatter(data + 4, i);
+    }
+    template <typename I>  // interleave 6 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5);
+    }
+    template <typename I>  // interleave 7 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6);
+    }
+    template <typename I>  // interleave 8 args {{{2
+    static inline void interleave(typename V::EntryType *const data, const I &i,
+                                  const typename V::AsArg v0, const typename V::AsArg v1,
+                                  const typename V::AsArg v2, const typename V::AsArg v3,
+                                  const typename V::AsArg v4, const typename V::AsArg v5,
+                                  const typename V::AsArg v6, const typename V::AsArg v7)
+    {
+        interleave(data, i, v0, v1, v2, v3);
+        interleave(data + 4, i, v4, v5, v6, v7);
+    }
+    //}}}2
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1)
+    {
+        const __m128d a = _mm_loadu_pd(&data[i[0]]);
+        const __m128d b = _mm_loadu_pd(&data[i[1]]);
+
+        v0.data() = _mm_unpacklo_pd(a, b);
+        v1.data() = _mm_unpackhi_pd(a, b);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2)
+    {
+        v2.gather(data + 2, i);
+        deinterleave(data, i, v0, v1);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        v4.gather(data + 4, i);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+        v6.gather(data + 6, i);
+    }/*}}}*/
+    template<typename I> static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/
+            const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)
+    {
+        deinterleave(data, i, v0, v1);
+        deinterleave(data + 2, i, v2, v3);
+        deinterleave(data + 4, i, v4, v5);
+        deinterleave(data + 6, i, v6, v7);
+    }/*}}}*/
+};
+
+//}}}1
+}  // namespace Detail
+}  // namespace Vc
+
+#endif  // VC_SSE_DETAIL_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/forceToRegisters.tcc vc-1.3.0/sse/forceToRegisters.tcc
--- vc-0.7.4/sse/forceToRegisters.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/forceToRegisters.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,141 +0,0 @@
-#ifdef VC_GNU_ASM
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x1.data()));
-}
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x1.data()));
-}
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x2.data()), "x"(x1.data()));
-}
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T7> &x7, const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x7.data()), "x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T7> &x7, Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x7.data()), "+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T8> &x8, const Vector<T7> &x7, const Vector<T6> &x6, const Vector<T5> &x5, const Vector<T4> &x4, const Vector<T3> &x3, const Vector<T2> &x2, const Vector<T1> &x1) {
-  __asm__ __volatile__(""::"x"(x8.data()), "x"(x7.data()), "x"(x6.data()), "x"(x5.data()), "x"(x4.data()), "x"(x3.data()), "x"(x2.data()), "x"(x1.data()));
-}
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T8> &x8, Vector<T7> &x7, Vector<T6> &x6, Vector<T5> &x5, Vector<T4> &x4, Vector<T3> &x3, Vector<T2> &x2, Vector<T1> &x1) {
-  __asm__ __volatile__("":"+x"(x8.data()), "+x"(x7.data()), "+x"(x6.data()), "+x"(x5.data()), "+x"(x4.data()), "+x"(x3.data()), "+x"(x2.data()), "+x"(x1.data()));
-}
-#elif defined(VC_MSVC)
-#pragma optimize("g", off)
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T7> &/*x7*/, const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T7> &/*x7*/, Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#pragma optimize("g", off)
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegisters(const Vector<T8> &/*x8*/, const Vector<T7> &/*x7*/, const Vector<T6> &/*x6*/, const Vector<T5> &/*x5*/, const Vector<T4> &/*x4*/, const Vector<T3> &/*x3*/, const Vector<T2> &/*x2*/, const Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", off)
-template<typename T8, typename T7, typename T6, typename T5, typename T4, typename T3, typename T2, typename T1>
-static Vc_ALWAYS_INLINE void forceToRegistersDirty(Vector<T8> &/*x8*/, Vector<T7> &/*x7*/, Vector<T6> &/*x6*/, Vector<T5> &/*x5*/, Vector<T4> &/*x4*/, Vector<T3> &/*x3*/, Vector<T2> &/*x2*/, Vector<T1> &/*x1*/) {
-}
-#pragma optimize("g", on)
-#else
-#error "forceToRegisters unsupported on this compiler"
-#endif
diff -Nru vc-0.7.4/sse/helperimpl.h vc-1.3.0/sse/helperimpl.h
--- vc-0.7.4/sse/helperimpl.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/helperimpl.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,87 +1,69 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_DEINTERLEAVE_H
-#define VC_SSE_DEINTERLEAVE_H
+#ifndef VC_SSE_DEINTERLEAVE_H_
+#define VC_SSE_DEINTERLEAVE_H_
 
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Internal
-{
-
-template<> struct HelperImpl<Vc::SSE2Impl>
+namespace Detail
 {
-    typedef SSE::Vector<float> float_v;
-    typedef SSE::Vector<SSE::float8> sfloat_v;
-    typedef SSE::Vector<double> double_v;
-    typedef SSE::Vector<int> int_v;
-    typedef SSE::Vector<unsigned int> uint_v;
-    typedef SSE::Vector<short> short_v;
-    typedef SSE::Vector<unsigned short> ushort_v;
-
-    template<typename A> static void deinterleave(float_v &, float_v &, const float *, A);
-    template<typename A> static void deinterleave(float_v &, float_v &, const short *, A);
-    template<typename A> static void deinterleave(float_v &, float_v &, const unsigned short *, A);
-
-    template<typename A> static void deinterleave(sfloat_v &, sfloat_v &, const float *, A);
-    template<typename A> static void deinterleave(sfloat_v &, sfloat_v &, const short *, A);
-    template<typename A> static void deinterleave(sfloat_v &, sfloat_v &, const unsigned short *, A);
-
-    template<typename A> static void deinterleave(double_v &, double_v &, const double *, A);
-
-    template<typename A> static void deinterleave(int_v &, int_v &, const int *, A);
-    template<typename A> static void deinterleave(int_v &, int_v &, const short *, A);
-
-    template<typename A> static void deinterleave(uint_v &, uint_v &, const unsigned int *, A);
-    template<typename A> static void deinterleave(uint_v &, uint_v &, const unsigned short *, A);
-
-    template<typename A> static void deinterleave(short_v &, short_v &, const short *, A);
-
-    template<typename A> static void deinterleave(ushort_v &, ushort_v &, const unsigned short *, A);
-
-    static Vc_ALWAYS_INLINE_L void prefetchForOneRead(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchForModify(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchClose(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchMid(const void *addr) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void prefetchFar(const void *addr) Vc_ALWAYS_INLINE_R;
-
-    template<Vc::MallocAlignment A>
-    static Vc_ALWAYS_INLINE_L void *malloc(size_t n) Vc_ALWAYS_INLINE_R;
-    static Vc_ALWAYS_INLINE_L void free(void *p) Vc_ALWAYS_INLINE_R;
-};
-
-template<> struct HelperImpl<SSE3Impl> : public HelperImpl<SSE2Impl> {};
-template<> struct HelperImpl<SSSE3Impl> : public HelperImpl<SSE3Impl> {};
-template<> struct HelperImpl<SSE41Impl> : public HelperImpl<SSSE3Impl> {};
-template<> struct HelperImpl<SSE42Impl> : public HelperImpl<SSE41Impl> {};
-
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+template <typename A>
+inline void deinterleave(SSE::float_v &, SSE::float_v &, const float *, A);
+template <typename A>
+inline void deinterleave(SSE::float_v &, SSE::float_v &, const short *, A);
+template <typename A>
+inline void deinterleave(SSE::float_v &, SSE::float_v &, const ushort *, A);
+template <typename A>
+inline void deinterleave(SSE::double_v &, SSE::double_v &, const double *, A);
+template <typename A>
+inline void deinterleave(SSE::int_v &, SSE::int_v &, const int *, A);
+template <typename A>
+inline void deinterleave(SSE::int_v &, SSE::int_v &, const short *, A);
+template <typename A>
+inline void deinterleave(SSE::uint_v &, SSE::uint_v &, const uint *, A);
+template <typename A>
+inline void deinterleave(SSE::uint_v &, SSE::uint_v &, const ushort *, A);
+template <typename A>
+inline void deinterleave(SSE::short_v &, SSE::short_v &, const short *, A);
+template <typename A>
+inline void deinterleave(SSE::ushort_v &, SSE::ushort_v &, const ushort *, A);
+
+Vc_ALWAYS_INLINE_L void prefetchForOneRead(const void *addr, VectorAbi::Sse) Vc_ALWAYS_INLINE_R;
+Vc_ALWAYS_INLINE_L void prefetchForModify(const void *addr, VectorAbi::Sse) Vc_ALWAYS_INLINE_R;
+Vc_ALWAYS_INLINE_L void prefetchClose(const void *addr, VectorAbi::Sse) Vc_ALWAYS_INLINE_R;
+Vc_ALWAYS_INLINE_L void prefetchMid(const void *addr, VectorAbi::Sse) Vc_ALWAYS_INLINE_R;
+Vc_ALWAYS_INLINE_L void prefetchFar(const void *addr, VectorAbi::Sse) Vc_ALWAYS_INLINE_R;
+}  // namespace Detail
+}  // namespace Vc
 
 #include "deinterleave.tcc"
 #include "prefetches.tcc"
-#include "helperimpl.tcc"
-#include "undomacros.h"
 
-#endif // VC_SSE_DEINTERLEAVE_H
+#endif // VC_SSE_DEINTERLEAVE_H_
diff -Nru vc-0.7.4/sse/helperimpl.tcc vc-1.3.0/sse/helperimpl.tcc
--- vc-0.7.4/sse/helperimpl.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/helperimpl.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,66 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_HELPERIMPL_TCC
-#define VC_SSE_HELPERIMPL_TCC
-
-#include <cstdio>
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Internal
-{
-
-template<size_t X>
-static _VC_CONSTEXPR size_t nextMultipleOf(size_t value)
-{
-    return (value % X) > 0 ? value + X - (value % X) : value;
-}
-
-template<Vc::MallocAlignment A>
-Vc_ALWAYS_INLINE void *HelperImpl<SSE2Impl>::malloc(size_t n)
-{
-    switch (A) {
-        case Vc::AlignOnVector:
-            return _mm_malloc(nextMultipleOf<Vc::SSE::VectorAlignment>(n), Vc::SSE::VectorAlignment);
-        case Vc::AlignOnCacheline:
-            // TODO: hardcoding 64 is not such a great idea
-            return _mm_malloc(nextMultipleOf<64>(n), 64);
-        case Vc::AlignOnPage:
-            // TODO: hardcoding 4096 is not such a great idea
-            return _mm_malloc(nextMultipleOf<4096>(n), 4096);
-        default:
-#ifndef NDEBUG
-            abort();
-#endif
-            return _mm_malloc(n, 8);
-    }
-}
-
-Vc_ALWAYS_INLINE void HelperImpl<SSE2Impl>::free(void *p)
-{
-    _mm_free(p);
-}
-
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_SSE_HELPERIMPL_TCC
diff -Nru vc-0.7.4/sse/interleavedmemory.tcc vc-1.3.0/sse/interleavedmemory.tcc
--- vc-0.7.4/sse/interleavedmemory.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/interleavedmemory.tcc	1969-12-31 18:00:00.000000000 -0600
@@ -1,1014 +0,0 @@
-/*  This file is part of the Vc library. {{{
-
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-}}}*/
-
-#ifndef VC_SSE_INTERLEAVEDMEMORY_TCC
-#define VC_SSE_INTERLEAVEDMEMORY_TCC
-
-#include "macros.h"
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace Common
-{
-
-namespace
-{
-template<typename V, int Size> struct InterleaveImpl;
-template<> struct InterleaveImpl<SSE::sfloat_v, 8> {
-    static inline void interleave(float *const data, const SSE::sfloat_v::IndexType &i,/*{{{*/
-            const SSE::sfloat_v::AsArg v0, const SSE::sfloat_v::AsArg v1)
-    {
-        const __m128 tmp0 = _mm_unpacklo_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp1 = _mm_unpackhi_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp2 = _mm_unpacklo_ps(v0.data()[1], v1.data()[1]);
-        const __m128 tmp3 = _mm_unpackhi_ps(v0.data()[1], v1.data()[1]);
-
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), tmp0);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), tmp0);
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), tmp1);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), tmp1);
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[4]]), tmp2);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), tmp2);
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[6]]), tmp3);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), tmp3);
-    }/*}}}*/
-    static inline void interleave(float *const data, const SSE::sfloat_v::IndexType &i,/*{{{*/
-            const SSE::sfloat_v::AsArg v0, const SSE::sfloat_v::AsArg v1, const SSE::sfloat_v::AsArg v2)
-    {
-#ifdef VC_USE_MASKMOV_SCATTER
-        const __m128i mask = _mm_set_epi32(0, -1, -1, -1);
-
-        const __m128 tmp0 = _mm_unpacklo_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp1 = _mm_unpackhi_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp2 = _mm_unpacklo_ps(v2.data()[0], v2.data()[0]);
-        const __m128 tmp3 = _mm_unpackhi_ps(v2.data()[0], v2.data()[0]);
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp0, tmp2)), mask, reinterpret_cast<char *>(&data[i[0]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp2, tmp0)), mask, reinterpret_cast<char *>(&data[i[1]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp1, tmp3)), mask, reinterpret_cast<char *>(&data[i[2]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp3, tmp1)), mask, reinterpret_cast<char *>(&data[i[3]]));
-
-        const __m128 tmp8 = _mm_unpacklo_ps(v0.data()[1], v1.data()[1]);
-        const __m128 tmp9 = _mm_unpackhi_ps(v0.data()[1], v1.data()[1]);
-        const __m128 tmp10 = _mm_unpacklo_ps(v2.data()[1], v2.data()[1]);
-        const __m128 tmp11 = _mm_unpackhi_ps(v2.data()[1], v2.data()[1]);
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp8, tmp10)), mask, reinterpret_cast<char *>(&data[i[4]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp10, tmp8)), mask, reinterpret_cast<char *>(&data[i[5]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp9, tmp11)), mask, reinterpret_cast<char *>(&data[i[6]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp11, tmp9)), mask, reinterpret_cast<char *>(&data[i[7]]));
-#else
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(float *const data, const SSE::sfloat_v::IndexType &i,/*{{{*/
-            const SSE::sfloat_v::AsArg v0, const SSE::sfloat_v::AsArg v1,
-            const SSE::sfloat_v::AsArg v2, const SSE::sfloat_v::AsArg v3)
-    {
-        const __m128 tmp0 = _mm_unpacklo_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp1 = _mm_unpackhi_ps(v0.data()[0], v1.data()[0]);
-        const __m128 tmp2 = _mm_unpacklo_ps(v2.data()[0], v3.data()[0]);
-        const __m128 tmp3 = _mm_unpackhi_ps(v2.data()[0], v3.data()[0]);
-        _mm_storeu_ps(&data[i[0]], _mm_movelh_ps(tmp0, tmp2));
-        _mm_storeu_ps(&data[i[1]], _mm_movehl_ps(tmp2, tmp0));
-        _mm_storeu_ps(&data[i[2]], _mm_movelh_ps(tmp1, tmp3));
-        _mm_storeu_ps(&data[i[3]], _mm_movehl_ps(tmp3, tmp1));
-
-        const __m128 tmp8 = _mm_unpacklo_ps(v0.data()[1], v1.data()[1]);
-        const __m128 tmp9 = _mm_unpackhi_ps(v0.data()[1], v1.data()[1]);
-        const __m128 tmp10 = _mm_unpacklo_ps(v2.data()[1], v3.data()[1]);
-        const __m128 tmp11 = _mm_unpackhi_ps(v2.data()[1], v3.data()[1]);
-        _mm_storeu_ps(&data[i[4]], _mm_movelh_ps(tmp8, tmp10));
-        _mm_storeu_ps(&data[i[5]], _mm_movehl_ps(tmp10, tmp8));
-        _mm_storeu_ps(&data[i[6]], _mm_movelh_ps(tmp9, tmp11));
-        _mm_storeu_ps(&data[i[7]], _mm_movehl_ps(tmp11, tmp9));
-    }/*}}}*/
-};
-template<typename V> struct InterleaveImpl<V, 8> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v1.data());
-        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v1.data());
-#ifdef __x86_64__
-        const long long tmp00 = _mm_cvtsi128_si64(tmp0);
-        const long long tmp01 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp0, tmp0));
-        const long long tmp10 = _mm_cvtsi128_si64(tmp1);
-        const long long tmp11 = _mm_cvtsi128_si64(_mm_unpackhi_epi64(tmp1, tmp1));
-        *reinterpret_cast<int *>(&data[i[0]]) = tmp00;
-        *reinterpret_cast<int *>(&data[i[1]]) = tmp00 >> 32;
-        *reinterpret_cast<int *>(&data[i[2]]) = tmp01;
-        *reinterpret_cast<int *>(&data[i[3]]) = tmp01 >> 32;
-        *reinterpret_cast<int *>(&data[i[4]]) = tmp10;
-        *reinterpret_cast<int *>(&data[i[5]]) = tmp10 >> 32;
-        *reinterpret_cast<int *>(&data[i[6]]) = tmp11;
-        *reinterpret_cast<int *>(&data[i[7]]) = tmp11 >> 32;
-#elif defined(VC_IMPL_SSE4_1)
-        *reinterpret_cast<int *>(&data[i[0]]) = _mm_cvtsi128_si32(tmp0);
-        *reinterpret_cast<int *>(&data[i[1]]) = _mm_extract_epi32(tmp0, 1);
-        *reinterpret_cast<int *>(&data[i[2]]) = _mm_extract_epi32(tmp0, 2);
-        *reinterpret_cast<int *>(&data[i[3]]) = _mm_extract_epi32(tmp0, 3);
-        *reinterpret_cast<int *>(&data[i[4]]) = _mm_cvtsi128_si32(tmp1);
-        *reinterpret_cast<int *>(&data[i[5]]) = _mm_extract_epi32(tmp1, 1);
-        *reinterpret_cast<int *>(&data[i[6]]) = _mm_extract_epi32(tmp1, 2);
-        *reinterpret_cast<int *>(&data[i[7]]) = _mm_extract_epi32(tmp1, 3);
-#else
-        *reinterpret_cast<int *>(&data[i[0]]) = _mm_cvtsi128_si32(tmp0);
-        *reinterpret_cast<int *>(&data[i[1]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 4));
-        *reinterpret_cast<int *>(&data[i[2]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 8));
-        *reinterpret_cast<int *>(&data[i[3]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp0, 12));
-        *reinterpret_cast<int *>(&data[i[4]]) = _mm_cvtsi128_si32(tmp1);
-        *reinterpret_cast<int *>(&data[i[5]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 4));
-        *reinterpret_cast<int *>(&data[i[6]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 8));
-        *reinterpret_cast<int *>(&data[i[7]]) = _mm_cvtsi128_si32(_mm_srli_si128(tmp1, 12));
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-#ifdef VC_USE_MASKMOV_SCATTER
-        const __m128i maskLo = _mm_set_epi16(0, 0, 0, 0, 0, -1, -1, -1);
-        const __m128i maskHi = _mm_set_epi16(0, -1, -1, -1, 0, 0, 0, 0);
-        typename V::EntryType *const dataHi = data - 4;
-        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
-        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
-        const __m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v1.data());
-        const __m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v1.data());
-
-        const __m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
-        const __m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
-        const __m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
-        const __m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
-        _mm_maskmoveu_si128(tmp4, maskLo, reinterpret_cast<char *>(&data[i[0]]));
-        _mm_maskmoveu_si128(tmp4, maskHi, reinterpret_cast<char *>(&dataHi[i[1]]));
-        _mm_maskmoveu_si128(tmp5, maskLo, reinterpret_cast<char *>(&data[i[2]]));
-        _mm_maskmoveu_si128(tmp5, maskHi, reinterpret_cast<char *>(&dataHi[i[3]]));
-        _mm_maskmoveu_si128(tmp6, maskLo, reinterpret_cast<char *>(&data[i[4]]));
-        _mm_maskmoveu_si128(tmp6, maskHi, reinterpret_cast<char *>(&dataHi[i[5]]));
-        _mm_maskmoveu_si128(tmp7, maskLo, reinterpret_cast<char *>(&data[i[6]]));
-        _mm_maskmoveu_si128(tmp7, maskHi, reinterpret_cast<char *>(&dataHi[i[7]]));
-#else
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        const __m128i tmp0 = _mm_unpacklo_epi16(v0.data(), v2.data());
-        const __m128i tmp1 = _mm_unpackhi_epi16(v0.data(), v2.data());
-        const __m128i tmp2 = _mm_unpacklo_epi16(v1.data(), v3.data());
-        const __m128i tmp3 = _mm_unpackhi_epi16(v1.data(), v3.data());
-
-        const __m128i tmp4 = _mm_unpacklo_epi16(tmp0, tmp2);
-        const __m128i tmp5 = _mm_unpackhi_epi16(tmp0, tmp2);
-        const __m128i tmp6 = _mm_unpacklo_epi16(tmp1, tmp3);
-        const __m128i tmp7 = _mm_unpackhi_epi16(tmp1, tmp3);
-
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[0]]), tmp4);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[2]]), tmp5);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[4]]), tmp6);
-        _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[6]]), tmp7);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), _mm_castsi128_ps(tmp4));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), _mm_castsi128_ps(tmp5));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), _mm_castsi128_ps(tmp6));
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), _mm_castsi128_ps(tmp7));
-    }/*}}}*/
-};
-template<typename V> struct InterleaveImpl<V, 4> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), tmp0);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), tmp0);
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), tmp1);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), tmp1);
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-#ifdef VC_USE_MASKMOV_SCATTER
-        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()), SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()), SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp2 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v2.data()), SSE::sse_cast<__m128>(v2.data()));
-        const __m128 tmp3 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v2.data()), SSE::sse_cast<__m128>(v2.data()));
-        const __m128i mask = _mm_set_epi32(0, -1, -1, -1);
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp0, tmp2)), mask, reinterpret_cast<char *>(&data[i[0]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp2, tmp0)), mask, reinterpret_cast<char *>(&data[i[1]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movelh_ps(tmp1, tmp3)), mask, reinterpret_cast<char *>(&data[i[2]]));
-        _mm_maskmoveu_si128(_mm_castps_si128(_mm_movehl_ps(tmp3, tmp1)), mask, reinterpret_cast<char *>(&data[i[3]]));
-#else
-        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), tmp0);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), tmp0);
-        _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), tmp1);
-        _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), tmp1);
-        v2.scatter(data + 2, i);
-#endif
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        const __m128 tmp0 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp1 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v0.data()),SSE::sse_cast<__m128>(v1.data()));
-        const __m128 tmp2 = _mm_unpacklo_ps(SSE::sse_cast<__m128>(v2.data()),SSE::sse_cast<__m128>(v3.data()));
-        const __m128 tmp3 = _mm_unpackhi_ps(SSE::sse_cast<__m128>(v2.data()),SSE::sse_cast<__m128>(v3.data()));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[0]]), _mm_movelh_ps(tmp0, tmp2));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[1]]), _mm_movehl_ps(tmp2, tmp0));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[2]]), _mm_movelh_ps(tmp1, tmp3));
-        _mm_storeu_ps(reinterpret_cast<float *>(&data[i[3]]), _mm_movehl_ps(tmp3, tmp1));
-    }/*}}}*/
-};
-template<typename V> struct InterleaveImpl<V, 2> {
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1)
-    {
-        const __m128d tmp0 = _mm_unpacklo_pd(v0.data(), v1.data());
-        const __m128d tmp1 = _mm_unpackhi_pd(v0.data(), v1.data());
-        _mm_storeu_pd(&data[i[0]], tmp0);
-        _mm_storeu_pd(&data[i[1]], tmp1);
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)
-    {
-        interleave(data, i, v0, v1);
-        v2.scatter(data + 2, i);
-    }/*}}}*/
-    static inline void interleave(typename V::EntryType *const data, const typename V::IndexType &i,/*{{{*/
-            const typename V::AsArg v0, const typename V::AsArg v1,
-            const typename V::AsArg v2, const typename V::AsArg v3)
-    {
-        interleave(data, i, v0, v1);
-        interleave(data + 2, i, v2, v3);
-    }/*}}}*/
-};
-} // anonymous namespace
-
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data, m_indexes, v0, v1);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data, m_indexes, v0, v1, v2);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data, m_indexes, v0, v1, v2, v3);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data, m_indexes, v0, v1, v2, v3);
-    v4.scatter(m_data + 4, m_indexes);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data    , m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size>::interleave(m_data + 4, m_indexes, v4, v5);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data + 0, m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size>::interleave(m_data + 4, m_indexes, v4, v5, v6);
-}/*}}}*/
-template<typename V> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::interleave(const typename V::AsArg v0,/*{{{*/
-        const typename V::AsArg v1, const typename V::AsArg v2, const typename V::AsArg v3, const typename V::AsArg v4,
-        const typename V::AsArg v5, const typename V::AsArg v6, const typename V::AsArg v7)
-{
-    InterleaveImpl<V, V::Size>::interleave(m_data + 0, m_indexes, v0, v1, v2, v3);
-    InterleaveImpl<V, V::Size>::interleave(m_data + 4, m_indexes, v4, v5, v6, v7);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1) const/*{{{*/
-{
-    const __m128 a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[0]])));
-    const __m128 b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[1]])));
-    const __m128 c = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[2]])));
-    const __m128 d = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[3]])));
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2) const/*{{{*/
-{
-    const __m128 a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 b = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 c = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 d = _mm_loadu_ps(&m_data[m_indexes[3]]);
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-    const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 XX XX]
-    const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 XX XX]
-
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-    v2.data() = _mm_movelh_ps(tmp2, tmp3);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3) const/*{{{*/
-{
-    const __m128 a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 b = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 c = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 d = _mm_loadu_ps(&m_data[m_indexes[3]]);
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-    const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 d0 d1]
-    const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 d2 d3]
-
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-    v2.data() = _mm_movelh_ps(tmp2, tmp3);
-    v3.data() = _mm_movehl_ps(tmp3, tmp2);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4) const/*{{{*/
-{
-    v4.gather(m_data, m_indexes + I(4));
-    deinterleave(v0, v1, v2, v3);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5) const/*{{{*/
-{
-    const __m128 a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 e = _mm_loadu_ps(&m_data[4 + m_indexes[0]]);
-    const __m128 b = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 f = _mm_loadu_ps(&m_data[4 + m_indexes[1]]);
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 d0 d1]
-    const __m128 tmp4 = _mm_unpacklo_ps(e, f); // [a0 a1 b0 b1]
-
-    const __m128 c = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 g = _mm_loadu_ps(&m_data[4 + m_indexes[2]]);
-    const __m128 d = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 h = _mm_loadu_ps(&m_data[4 + m_indexes[3]]);
-
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-
-    const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 d2 d3]
-    v2.data() = _mm_movelh_ps(tmp2, tmp3);
-    v3.data() = _mm_movehl_ps(tmp3, tmp2);
-
-    const __m128 tmp5 = _mm_unpacklo_ps(g, h); // [a2 a3 b2 b3]
-    v4.data() = _mm_movelh_ps(tmp4, tmp5);
-    v5.data() = _mm_movehl_ps(tmp5, tmp4);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5, float_v &v6) const/*{{{*/
-{
-    const __m128 a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 e = _mm_loadu_ps(&m_data[4 + m_indexes[0]]);
-    const __m128 b = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 f = _mm_loadu_ps(&m_data[4 + m_indexes[1]]);
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 d0 d1]
-    const __m128 tmp4 = _mm_unpacklo_ps(e, f); // [a0 a1 b0 b1]
-    const __m128 tmp6 = _mm_unpackhi_ps(e, f); // [c0 c1 d0 d1]
-
-    const __m128 c = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 g = _mm_loadu_ps(&m_data[4 + m_indexes[2]]);
-    const __m128 d = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 h = _mm_loadu_ps(&m_data[4 + m_indexes[3]]);
-
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-
-    const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 d2 d3]
-    v2.data() = _mm_movelh_ps(tmp2, tmp3);
-    v3.data() = _mm_movehl_ps(tmp3, tmp2);
-
-    const __m128 tmp5 = _mm_unpacklo_ps(g, h); // [a2 a3 b2 b3]
-    v4.data() = _mm_movelh_ps(tmp4, tmp5);
-    v5.data() = _mm_movehl_ps(tmp5, tmp4);
-
-    const __m128 tmp7 = _mm_unpackhi_ps(g, h); // [c2 c3 d2 d3]
-    v6.data() = _mm_movelh_ps(tmp6, tmp7);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<float_v>::deinterleave(float_v &v0, float_v &v1, float_v &v2, float_v &v3, float_v &v4, float_v &v5, float_v &v6, float_v &v7) const/*{{{*/
-{
-    const __m128 a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 e = _mm_loadu_ps(&m_data[4 + m_indexes[0]]);
-    const __m128 b = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 f = _mm_loadu_ps(&m_data[4 + m_indexes[1]]);
-
-    const __m128 tmp0 = _mm_unpacklo_ps(a, b); // [a0 a1 b0 b1]
-    const __m128 tmp2 = _mm_unpackhi_ps(a, b); // [c0 c1 d0 d1]
-    const __m128 tmp4 = _mm_unpacklo_ps(e, f); // [a0 a1 b0 b1]
-    const __m128 tmp6 = _mm_unpackhi_ps(e, f); // [c0 c1 d0 d1]
-
-    const __m128 c = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 g = _mm_loadu_ps(&m_data[4 + m_indexes[2]]);
-    const __m128 d = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 h = _mm_loadu_ps(&m_data[4 + m_indexes[3]]);
-
-    const __m128 tmp1 = _mm_unpacklo_ps(c, d); // [a2 a3 b2 b3]
-    v0.data() = _mm_movelh_ps(tmp0, tmp1);
-    v1.data() = _mm_movehl_ps(tmp1, tmp0);
-
-    const __m128 tmp3 = _mm_unpackhi_ps(c, d); // [c2 c3 d2 d3]
-    v2.data() = _mm_movelh_ps(tmp2, tmp3);
-    v3.data() = _mm_movehl_ps(tmp3, tmp2);
-
-    const __m128 tmp5 = _mm_unpacklo_ps(g, h); // [a2 a3 b2 b3]
-    v4.data() = _mm_movelh_ps(tmp4, tmp5);
-    v5.data() = _mm_movehl_ps(tmp5, tmp4);
-
-    const __m128 tmp7 = _mm_unpackhi_ps(g, h); // [c2 c3 d2 d3]
-    v6.data() = _mm_movelh_ps(tmp6, tmp7);
-    v7.data() = _mm_movehl_ps(tmp7, tmp6);
-}/*}}}*/
-
-static inline void _sse_deinterleave_double(const double *VC_RESTRICT data, const uint_v &indexes, double_v &v0, double_v &v1)/*{{{*/
-{
-    const __m128d a = _mm_loadu_pd(&data[indexes[0]]);
-    const __m128d b = _mm_loadu_pd(&data[indexes[1]]);
-
-    v0.data() = _mm_unpacklo_pd(a, b);
-    v1.data() = _mm_unpackhi_pd(a, b);
-}/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1) const {/*{{{*/
-    _sse_deinterleave_double(m_data, m_indexes, v0, v1);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2) const {
-    v2.gather(m_data + 2, m_indexes);
-    _sse_deinterleave_double(m_data, m_indexes, v0, v1);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2, double_v &v3) const {
-    _sse_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _sse_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2, double_v &v3, double_v &v4) const {
-    v4.gather(m_data + 4, m_indexes);
-    _sse_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _sse_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2, double_v &v3, double_v &v4, double_v &v5) const {
-    _sse_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _sse_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _sse_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2, double_v &v3, double_v &v4, double_v &v5, double_v &v6) const {
-    v6.gather(m_data + 6, m_indexes);
-    _sse_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _sse_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _sse_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-}
-/*}}}*/
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<double_v>::deinterleave(double_v &v0, double_v &v1,/*{{{*/
-        double_v &v2, double_v &v3, double_v &v4, double_v &v5, double_v &v6, double_v &v7) const {
-    _sse_deinterleave_double(m_data    , m_indexes, v0, v1);
-    _sse_deinterleave_double(m_data + 2, m_indexes, v2, v3);
-    _sse_deinterleave_double(m_data + 4, m_indexes, v4, v5);
-    _sse_deinterleave_double(m_data + 6, m_indexes, v6, v7);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1) const {/*{{{*/
-    const __m128i a = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2) const {
-    const __m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3) const {
-    const __m128i a = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4) const {
-    const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5) const {
-    const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5, short_v &v6) const {
-    const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-    const __m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
-    const __m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-    v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
-}/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<short_v>::deinterleave(short_v &v0, short_v &v1,/*{{{*/
-        short_v &v2, short_v &v3, short_v &v4, short_v &v5, short_v &v6, short_v &v7) const {
-    const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[0]]));
-    const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[1]]));
-    const __m128i c = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[2]]));
-    const __m128i d = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[3]]));
-    const __m128i e = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[4]]));
-    const __m128i f = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[5]]));
-    const __m128i g = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[6]]));
-    const __m128i h = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&m_data[m_indexes[7]]));
-
-    const __m128i tmp2  = _mm_unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4
-    const __m128i tmp4  = _mm_unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5
-    const __m128i tmp3  = _mm_unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6
-    const __m128i tmp5  = _mm_unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7
-    const __m128i tmp10 = _mm_unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4
-    const __m128i tmp11 = _mm_unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5
-    const __m128i tmp12 = _mm_unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6
-    const __m128i tmp13 = _mm_unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7
-
-    const __m128i tmp0  = _mm_unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6
-    const __m128i tmp1  = _mm_unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7
-    const __m128i tmp6  = _mm_unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6
-    const __m128i tmp7  = _mm_unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7
-    const __m128i tmp8  = _mm_unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6
-    const __m128i tmp9  = _mm_unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7
-    const __m128i tmp14 = _mm_unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6
-    const __m128i tmp15 = _mm_unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7
-
-    v0.data() = _mm_unpacklo_epi16(tmp0, tmp1);
-    v1.data() = _mm_unpackhi_epi16(tmp0, tmp1);
-    v2.data() = _mm_unpacklo_epi16(tmp6, tmp7);
-    v3.data() = _mm_unpackhi_epi16(tmp6, tmp7);
-    v4.data() = _mm_unpacklo_epi16(tmp8, tmp9);
-    v5.data() = _mm_unpackhi_epi16(tmp8, tmp9);
-    v6.data() = _mm_unpacklo_epi16(tmp14, tmp15);
-    v7.data() = _mm_unpackhi_epi16(tmp14, tmp15);
-}/*}}}*/
-
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1) const/*{{{*/
-{
-    const __m128 i0a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[0]])));
-    const __m128 i1a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[1]])));
-    const __m128 i2a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[2]])));
-    const __m128 i3a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[3]])));
-    const __m128 i4a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[4]])));
-    const __m128 i5a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[5]])));
-    const __m128 i6a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[6]])));
-    const __m128 i7a = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[7]])));
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-    v3.data() = Vc::SSE::M256::create(_mm_movehl_ps(cd23, cd01), _mm_movehl_ps(cd67, cd45));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-    v4.gather(m_data + float_v::Size, m_indexes);
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-    v3.data() = Vc::SSE::M256::create(_mm_movehl_ps(cd23, cd01), _mm_movehl_ps(cd67, cd45));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-    const __m128 i0b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[0] + float_v::Size])));
-    const __m128 i1b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[1] + float_v::Size])));
-    const __m128 i2b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[2] + float_v::Size])));
-    const __m128 i3b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[3] + float_v::Size])));
-    const __m128 i4b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[4] + float_v::Size])));
-    const __m128 i5b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[5] + float_v::Size])));
-    const __m128 i6b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[6] + float_v::Size])));
-    const __m128 i7b = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double *>(&m_data[m_indexes[7] + float_v::Size])));
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-    v3.data() = Vc::SSE::M256::create(_mm_movehl_ps(cd23, cd01), _mm_movehl_ps(cd67, cd45));
-
-    const __m128 ef01 = _mm_unpacklo_ps(i0b, i1b); // [e0 e1 f0 f1]
-    const __m128 ef23 = _mm_unpacklo_ps(i2b, i3b); // [e2 e3 f2 f3]
-    const __m128 ef45 = _mm_unpacklo_ps(i4b, i5b); // [e4 e5 f4 f5]
-    const __m128 ef67 = _mm_unpacklo_ps(i6b, i7b); // [e6 e7 f6 f7]
-    v4.data() = Vc::SSE::M256::create(_mm_movelh_ps(ef01, ef23), _mm_movelh_ps(ef45, ef67));
-    v5.data() = Vc::SSE::M256::create(_mm_movehl_ps(ef23, ef01), _mm_movehl_ps(ef67, ef45));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5, sfloat_v &v6) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i0b = _mm_loadu_ps(&m_data[m_indexes[0] + float_v::Size]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i1b = _mm_loadu_ps(&m_data[m_indexes[1] + float_v::Size]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i2b = _mm_loadu_ps(&m_data[m_indexes[2] + float_v::Size]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i3b = _mm_loadu_ps(&m_data[m_indexes[3] + float_v::Size]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i4b = _mm_loadu_ps(&m_data[m_indexes[4] + float_v::Size]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i5b = _mm_loadu_ps(&m_data[m_indexes[5] + float_v::Size]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i6b = _mm_loadu_ps(&m_data[m_indexes[6] + float_v::Size]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-    const __m128 i7b = _mm_loadu_ps(&m_data[m_indexes[7] + float_v::Size]);
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-    v3.data() = Vc::SSE::M256::create(_mm_movehl_ps(cd23, cd01), _mm_movehl_ps(cd67, cd45));
-
-    const __m128 ef01 = _mm_unpacklo_ps(i0b, i1b); // [e0 e1 f0 f1]
-    const __m128 ef23 = _mm_unpacklo_ps(i2b, i3b); // [e2 e3 f2 f3]
-    const __m128 ef45 = _mm_unpacklo_ps(i4b, i5b); // [e4 e5 f4 f5]
-    const __m128 ef67 = _mm_unpacklo_ps(i6b, i7b); // [e6 e7 f6 f7]
-    v4.data() = Vc::SSE::M256::create(_mm_movelh_ps(ef01, ef23), _mm_movelh_ps(ef45, ef67));
-    v5.data() = Vc::SSE::M256::create(_mm_movehl_ps(ef23, ef01), _mm_movehl_ps(ef67, ef45));
-
-    const __m128 gh01 = _mm_unpackhi_ps(i0b, i1b); // [g0 g1 h0 h1]
-    const __m128 gh23 = _mm_unpackhi_ps(i2b, i3b); // [g2 g3 h2 h3]
-    const __m128 gh45 = _mm_unpackhi_ps(i4b, i5b); // [g4 g5 h4 h5]
-    const __m128 gh67 = _mm_unpackhi_ps(i6b, i7b); // [g6 g7 h6 h7]
-    v6.data() = Vc::SSE::M256::create(_mm_movelh_ps(gh01, gh23), _mm_movelh_ps(gh45, gh67));
-}
-/*}}}*/
-template<> inline void InterleavedMemoryAccessBase<sfloat_v>::deinterleave(sfloat_v &v0, sfloat_v &v1, sfloat_v &v2, sfloat_v &v3, sfloat_v &v4, sfloat_v &v5, sfloat_v &v6, sfloat_v &v7) const/*{{{*/
-{
-    const __m128 i0a = _mm_loadu_ps(&m_data[m_indexes[0]]);
-    const __m128 i0b = _mm_loadu_ps(&m_data[m_indexes[0] + float_v::Size]);
-    const __m128 i1a = _mm_loadu_ps(&m_data[m_indexes[1]]);
-    const __m128 i1b = _mm_loadu_ps(&m_data[m_indexes[1] + float_v::Size]);
-    const __m128 i2a = _mm_loadu_ps(&m_data[m_indexes[2]]);
-    const __m128 i2b = _mm_loadu_ps(&m_data[m_indexes[2] + float_v::Size]);
-    const __m128 i3a = _mm_loadu_ps(&m_data[m_indexes[3]]);
-    const __m128 i3b = _mm_loadu_ps(&m_data[m_indexes[3] + float_v::Size]);
-    const __m128 i4a = _mm_loadu_ps(&m_data[m_indexes[4]]);
-    const __m128 i4b = _mm_loadu_ps(&m_data[m_indexes[4] + float_v::Size]);
-    const __m128 i5a = _mm_loadu_ps(&m_data[m_indexes[5]]);
-    const __m128 i5b = _mm_loadu_ps(&m_data[m_indexes[5] + float_v::Size]);
-    const __m128 i6a = _mm_loadu_ps(&m_data[m_indexes[6]]);
-    const __m128 i6b = _mm_loadu_ps(&m_data[m_indexes[6] + float_v::Size]);
-    const __m128 i7a = _mm_loadu_ps(&m_data[m_indexes[7]]);
-    const __m128 i7b = _mm_loadu_ps(&m_data[m_indexes[7] + float_v::Size]);
-
-    const __m128 ab01 = _mm_unpacklo_ps(i0a, i1a); // [a0 a1 b0 b1]
-    const __m128 ab23 = _mm_unpacklo_ps(i2a, i3a); // [a2 a3 b2 b3]
-    const __m128 ab45 = _mm_unpacklo_ps(i4a, i5a); // [a4 a5 b4 b5]
-    const __m128 ab67 = _mm_unpacklo_ps(i6a, i7a); // [a6 a7 b6 b7]
-    v0.data() = Vc::SSE::M256::create(_mm_movelh_ps(ab01, ab23), _mm_movelh_ps(ab45, ab67));
-    v1.data() = Vc::SSE::M256::create(_mm_movehl_ps(ab23, ab01), _mm_movehl_ps(ab67, ab45));
-
-    const __m128 cd01 = _mm_unpackhi_ps(i0a, i1a); // [c0 c1 d0 d1]
-    const __m128 cd23 = _mm_unpackhi_ps(i2a, i3a); // [c2 c3 d2 d3]
-    const __m128 cd45 = _mm_unpackhi_ps(i4a, i5a); // [c4 c5 d4 d5]
-    const __m128 cd67 = _mm_unpackhi_ps(i6a, i7a); // [c6 c7 d6 d7]
-    v2.data() = Vc::SSE::M256::create(_mm_movelh_ps(cd01, cd23), _mm_movelh_ps(cd45, cd67));
-    v3.data() = Vc::SSE::M256::create(_mm_movehl_ps(cd23, cd01), _mm_movehl_ps(cd67, cd45));
-
-    const __m128 ef01 = _mm_unpacklo_ps(i0b, i1b); // [e0 e1 f0 f1]
-    const __m128 ef23 = _mm_unpacklo_ps(i2b, i3b); // [e2 e3 f2 f3]
-    const __m128 ef45 = _mm_unpacklo_ps(i4b, i5b); // [e4 e5 f4 f5]
-    const __m128 ef67 = _mm_unpacklo_ps(i6b, i7b); // [e6 e7 f6 f7]
-    v4.data() = Vc::SSE::M256::create(_mm_movelh_ps(ef01, ef23), _mm_movelh_ps(ef45, ef67));
-    v5.data() = Vc::SSE::M256::create(_mm_movehl_ps(ef23, ef01), _mm_movehl_ps(ef67, ef45));
-
-    const __m128 gh01 = _mm_unpackhi_ps(i0b, i1b); // [g0 g1 h0 h1]
-    const __m128 gh23 = _mm_unpackhi_ps(i2b, i3b); // [g2 g3 h2 h3]
-    const __m128 gh45 = _mm_unpackhi_ps(i4b, i5b); // [g4 g5 h4 h5]
-    const __m128 gh67 = _mm_unpackhi_ps(i6b, i7b); // [g6 g7 h6 h7]
-    v6.data() = Vc::SSE::M256::create(_mm_movelh_ps(gh01, gh23), _mm_movelh_ps(gh45, gh67));
-    v7.data() = Vc::SSE::M256::create(_mm_movehl_ps(gh23, gh01), _mm_movehl_ps(gh67, gh45));
-}/*}}}*/
-
-// forward types of equal size - ugly, but it works/*{{{*/
-#define _forward(V, V2) \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5, V &v6) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5), reinterpret_cast<V2 &>(v6)); \
-} \
-template<> Vc_ALWAYS_INLINE void InterleavedMemoryAccessBase<V>::deinterleave(V &v0, V &v1, V &v2, V &v3, \
-        V &v4, V &v5, V &v6, V &v7) const { \
-    reinterpret_cast<const InterleavedMemoryAccessBase<V2> *>(this)->deinterleave(reinterpret_cast<V2 &>(v0), reinterpret_cast<V2 &>(v1), \
-            reinterpret_cast<V2 &>(v2), reinterpret_cast<V2 &>(v3), reinterpret_cast<V2 &>(v4), \
-            reinterpret_cast<V2 &>(v5), reinterpret_cast<V2 &>(v6), reinterpret_cast<V2 &>(v7)); \
-}
-_forward( int_v, float_v)
-_forward(uint_v, float_v)
-_forward(ushort_v, short_v)
-#undef _forward/*}}}*/
-
-} // namespace Common
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
-
-#endif // VC_SSE_INTERLEAVEDMEMORY_TCC
-
-// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/intrinsics.h vc-1.3.0/sse/intrinsics.h
--- vc-0.7.4/sse/intrinsics.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/intrinsics.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,60 +1,60 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+#ifndef VC_SSE_INTRINSICS_H_
+#define VC_SSE_INTRINSICS_H_
 
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_INTRINSICS_H
-#define SSE_INTRINSICS_H
-
-#include "../common/windows_fix_intrin.h"
-
-// The GCC xxxintrin.h headers do not make sure that the intrinsics have C linkage. This not really
-// a problem, unless there is another place where the exact same functions are declared. Then the
-// linkage must be the same, otherwise it won't compile. Such a case occurs on Windows, where the
-// intrin.h header (included indirectly via unistd.h) declares many SSE intrinsics again.
-extern "C" {
-// MMX
-#include <mmintrin.h>
-// SSE
-#include <xmmintrin.h>
-// SSE2
-#include <emmintrin.h>
-}
-
-#include "../common/fix_clang_emmintrin.h"
+#ifdef Vc_MSVC
+#include <intrin.h>
+#else
+#include <x86intrin.h>
+#endif
 
+#include "../common/storage.h"
 #include "const_data.h"
 #include <cstdlib>
-#include "macros.h"
+#include "types.h"
+#include "debug.h"
 
-#ifdef __3dNOW__
-extern "C" {
-#include <mm3dnow.h>
-}
+#if defined(Vc_GCC) && !defined(__OPTIMIZE__)
+// GCC uses lots of old-style-casts in macros that disguise as intrinsics
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace SseIntrinsics
 {
-    enum VectorAlignmentEnum { VectorAlignment = 16 };
+    using SSE::c_general;
 
-#if defined(VC_GCC) && VC_GCC < 0x40600 && !defined(VC_DONT_FIX_SSE_SHIFT)
+    constexpr std::size_t VectorAlignment = 16;
+
+#if defined(Vc_GCC) && Vc_GCC < 0x40600 && !defined(Vc_DONT_FIX_SSE_SHIFT)
     static Vc_INTRINSIC Vc_CONST __m128i _mm_sll_epi16(__m128i a, __m128i count) { __asm__("psllw %1,%0" : "+x"(a) : "x"(count)); return a; }
     static Vc_INTRINSIC Vc_CONST __m128i _mm_sll_epi32(__m128i a, __m128i count) { __asm__("pslld %1,%0" : "+x"(a) : "x"(count)); return a; }
     static Vc_INTRINSIC Vc_CONST __m128i _mm_sll_epi64(__m128i a, __m128i count) { __asm__("psllq %1,%0" : "+x"(a) : "x"(count)); return a; }
@@ -63,7 +63,7 @@
     static Vc_INTRINSIC Vc_CONST __m128i _mm_srl_epi64(__m128i a, __m128i count) { __asm__("psrlq %1,%0" : "+x"(a) : "x"(count)); return a; }
 #endif
 
-#ifdef VC_GCC
+#ifdef Vc_GCC
     // Redefine the mul/add/sub intrinsics to use GCC-specific operators instead of builtin
     // functions. This way the fp-contraction optimization step kicks in and creates FMAs! :)
     static Vc_INTRINSIC Vc_CONST __m128d _mm_mul_pd(__m128d a, __m128d b) { return static_cast<__m128d>(static_cast<__v2df>(a) * static_cast<__v2df>(b)); }
@@ -74,14 +74,9 @@
     static Vc_INTRINSIC Vc_CONST __m128  _mm_sub_ps(__m128  a, __m128  b) { return static_cast<__m128 >(static_cast<__v4sf>(a) - static_cast<__v4sf>(b)); }
 #endif
 
-#if defined(VC_GNU_ASM) && !defined(NVALGRIND)
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_setallone() { __m128i r; __asm__("pcmpeqb %0,%0":"=x"(r)); return r; }
-#else
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_setallone() { __m128i r = _mm_setzero_si128(); return _mm_cmpeq_epi8(r, r); }
-#endif
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_setallone_si128() { return _mm_setallone(); }
-    static Vc_INTRINSIC __m128d Vc_CONST _mm_setallone_pd() { return _mm_castsi128_pd(_mm_setallone()); }
-    static Vc_INTRINSIC __m128  Vc_CONST _mm_setallone_ps() { return _mm_castsi128_ps(_mm_setallone()); }
+    static Vc_INTRINSIC Vc_CONST __m128i _mm_setallone_si128() { return _mm_load_si128(reinterpret_cast<const __m128i *>(Common::AllBitsSet)); }
+    static Vc_INTRINSIC Vc_CONST __m128d _mm_setallone_pd() { return _mm_load_pd(reinterpret_cast<const double *>(Common::AllBitsSet)); }
+    static Vc_INTRINSIC Vc_CONST __m128  _mm_setallone_ps() { return _mm_load_ps(reinterpret_cast<const float *>(Common::AllBitsSet)); }
 
     static Vc_INTRINSIC __m128i Vc_CONST _mm_setone_epi8 ()  { return _mm_set1_epi8(1); }
     static Vc_INTRINSIC __m128i Vc_CONST _mm_setone_epu8 ()  { return _mm_setone_epi8(); }
@@ -98,67 +93,108 @@
     static Vc_INTRINSIC __m128d Vc_CONST _mm_setsignmask_pd(){ return _mm_load_pd(reinterpret_cast<const double *>(c_general::signMaskDouble)); }
     static Vc_INTRINSIC __m128  Vc_CONST _mm_setsignmask_ps(){ return _mm_load_ps(reinterpret_cast<const float *>(c_general::signMaskFloat)); }
 
-    //X         static Vc_INTRINSIC __m128i Vc_CONST _mm_setmin_epi8 () { return _mm_slli_epi8 (_mm_setallone_si128(),  7); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_setmin_epi16() { return _mm_load_si128(reinterpret_cast<const __m128i *>(c_general::minShort)); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_setmin_epi32() { return _mm_load_si128(reinterpret_cast<const __m128i *>(c_general::signMaskFloat)); }
-
-    //X         static Vc_INTRINSIC __m128i Vc_CONST _mm_cmplt_epu8 (__m128i a, __m128i b) { return _mm_cmplt_epi8 (
-    //X                 _mm_xor_si128(a, _mm_setmin_epi8 ()), _mm_xor_si128(b, _mm_setmin_epi8 ())); }
-    //X         static Vc_INTRINSIC __m128i Vc_CONST _mm_cmpgt_epu8 (__m128i a, __m128i b) { return _mm_cmpgt_epi8 (
-    //X                 _mm_xor_si128(a, _mm_setmin_epi8 ()), _mm_xor_si128(b, _mm_setmin_epi8 ())); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_cmplt_epu16(__m128i a, __m128i b) { return _mm_cmplt_epi16(
-            _mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16())); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_cmpgt_epu16(__m128i a, __m128i b) { return _mm_cmpgt_epi16(
-            _mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16())); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_cmplt_epu32(__m128i a, __m128i b) { return _mm_cmplt_epi32(
-            _mm_xor_si128(a, _mm_setmin_epi32()), _mm_xor_si128(b, _mm_setmin_epi32())); }
-    static Vc_INTRINSIC __m128i Vc_CONST _mm_cmpgt_epu32(__m128i a, __m128i b) { return _mm_cmpgt_epi32(
-            _mm_xor_si128(a, _mm_setmin_epi32()), _mm_xor_si128(b, _mm_setmin_epi32())); }
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-// SSE3
-#ifdef VC_IMPL_SSE3
-extern "C" {
-#include <pmmintrin.h>
-}
+    static Vc_INTRINSIC __m128i Vc_CONST setmin_epi8 () { return _mm_set1_epi8(-0x80); }
+    static Vc_INTRINSIC __m128i Vc_CONST setmin_epi16() { return _mm_load_si128(reinterpret_cast<const __m128i *>(c_general::minShort)); }
+    static Vc_INTRINSIC __m128i Vc_CONST setmin_epi32() { return _mm_load_si128(reinterpret_cast<const __m128i *>(c_general::signMaskFloat)); }
+    static Vc_INTRINSIC __m128i Vc_CONST setmin_epi64() { return _mm_load_si128(reinterpret_cast<const __m128i *>(c_general::signMaskDouble)); }
+
+#if defined(Vc_IMPL_XOP)
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu8(__m128i a, __m128i b) { return _mm_comlt_epu8(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu8(__m128i a, __m128i b) { return _mm_comgt_epu8(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu16(__m128i a, __m128i b) { return _mm_comlt_epu16(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu16(__m128i a, __m128i b) { return _mm_comgt_epu16(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu32(__m128i a, __m128i b) { return _mm_comlt_epu32(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu32(__m128i a, __m128i b) { return _mm_comgt_epu32(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu64(__m128i a, __m128i b) { return _mm_comlt_epu64(a, b); }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu64(__m128i a, __m128i b) { return _mm_comgt_epu64(a, b); }
+#else
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu8(__m128i a, __m128i b)
+    {
+        return _mm_cmplt_epi8(_mm_xor_si128(a, setmin_epi8()),
+                              _mm_xor_si128(b, setmin_epi8()));
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu8(__m128i a, __m128i b)
+    {
+        return _mm_cmpgt_epi8(_mm_xor_si128(a, setmin_epi8()),
+                              _mm_xor_si128(b, setmin_epi8()));
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu16(__m128i a, __m128i b)
+    {
+        return _mm_cmplt_epi16(_mm_xor_si128(a, setmin_epi16()),
+                               _mm_xor_si128(b, setmin_epi16()));
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu16(__m128i a, __m128i b)
+    {
+        return _mm_cmpgt_epi16(_mm_xor_si128(a, setmin_epi16()),
+                               _mm_xor_si128(b, setmin_epi16()));
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmplt_epu32(__m128i a, __m128i b)
+    {
+        return _mm_cmplt_epi32(_mm_xor_si128(a, setmin_epi32()),
+                               _mm_xor_si128(b, setmin_epi32()));
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu32(__m128i a, __m128i b)
+    {
+        return _mm_cmpgt_epi32(_mm_xor_si128(a, setmin_epi32()),
+                               _mm_xor_si128(b, setmin_epi32()));
+    }
+    Vc_INTRINSIC __m128i Vc_CONST cmpgt_epi64(__m128i a, __m128i b)
+    {
+#ifdef Vc_IMPL_SSE4_2
+        return _mm_cmpgt_epi64(a, b);
+#else
+        const auto aa = _mm_xor_si128(a, _mm_srli_epi64(setmin_epi32(),32));
+        const auto bb = _mm_xor_si128(b, _mm_srli_epi64(setmin_epi32(),32));
+        const auto gt = _mm_cmpgt_epi32(aa, bb);
+        const auto eq = _mm_cmpeq_epi32(aa, bb);
+        // Algorithm:
+        // 1. if the high 32 bits of gt are true, make the full 64 bits true
+        // 2. if the high 32 bits of gt are false and the high 32 bits of eq are true,
+        //    duplicate the low 32 bits of gt to the high 32 bits (note that this requires
+        //    unsigned compare on the lower 32 bits, which is the reason for the xors
+        //    above)
+        // 3. else make the full 64 bits false
+
+        const auto gt2 =
+            _mm_shuffle_epi32(gt, 0xf5);  // dup the high 32 bits to the low 32 bits
+        const auto lo =
+            _mm_shuffle_epi32(_mm_and_si128(_mm_srli_epi64(eq, 32), gt), 0xa0);
+        return _mm_or_si128(gt2, lo);
+#endif
+    }
+    static Vc_INTRINSIC __m128i Vc_CONST cmpgt_epu64(__m128i a, __m128i b)
+    {
+        return cmpgt_epi64(_mm_xor_si128(a, setmin_epi64()),
+                           _mm_xor_si128(b, setmin_epi64()));
+    }
 #endif
+}  // namespace SseIntrinsics
+}  // namespace Vc
+
 // SSSE3
-#ifdef VC_IMPL_SSSE3
-extern "C" {
-#include <tmmintrin.h>
-}
-#define mm_abs_epi8  _mm_abs_epi8
-#define mm_abs_epi16 _mm_abs_epi16
-#define mm_abs_epi32 _mm_abs_epi32
-#define mm_alignr_epi8 _mm_alignr_epi8
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+#ifdef Vc_IMPL_SSSE3
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace SseIntrinsics
 {
-
     // not overriding _mm_set1_epi8 because this one should only be used for non-constants
-    static Vc_INTRINSIC __m128i Vc_CONST set1_epi8(int a) {
-#if defined(VC_GCC) && VC_GCC < 0x40500
-        return _mm_shuffle_epi8(_mm_cvtsi32_si128(a), _mm_setzero_si128());
-#else
-        // GCC 4.5 nows about the pshufb improvement
-        return _mm_set1_epi8(a);
-#endif
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi8(__m128i a) { return _mm_abs_epi8(a); }
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi16(__m128i a) { return _mm_abs_epi16(a); }
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi32(__m128i a) { return _mm_abs_epi32(a); }
+    template <int s> Vc_INTRINSIC Vc_CONST __m128i alignr_epi8(__m128i a, __m128i b)
+    {
+        return _mm_alignr_epi8(a, b, s & 0x1fu);
     }
+}  // namespace SseIntrinsics
+}  // namespace Vc
 
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
 #else
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace SseIntrinsics
 {
-    static Vc_INTRINSIC __m128i Vc_CONST mm_abs_epi8 (__m128i a) {
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi8 (__m128i a) {
         __m128i negative = _mm_cmplt_epi8 (a, _mm_setzero_si128());
         return _mm_add_epi8 (_mm_xor_si128(a, negative), _mm_and_si128(negative,  _mm_setone_epi8()));
     }
@@ -172,19 +208,17 @@
     //   a xor -1 -> -a - 1
     //   -1 >> 31 -> 1
     //   -a - 1 + 1 -> -a
-    static Vc_INTRINSIC __m128i Vc_CONST mm_abs_epi16(__m128i a) {
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi16(__m128i a) {
         __m128i negative = _mm_cmplt_epi16(a, _mm_setzero_si128());
         return _mm_add_epi16(_mm_xor_si128(a, negative), _mm_srli_epi16(negative, 15));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_abs_epi32(__m128i a) {
+    Vc_INTRINSIC Vc_CONST __m128i abs_epi32(__m128i a) {
         __m128i negative = _mm_cmplt_epi32(a, _mm_setzero_si128());
         return _mm_add_epi32(_mm_xor_si128(a, negative), _mm_srli_epi32(negative, 31));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST set1_epi8(int a) {
-        return _mm_set1_epi8(a);
-    }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_alignr_epi8(__m128i a, __m128i b, const int s) {
-        switch (s) {
+    template <int s> Vc_INTRINSIC Vc_CONST __m128i alignr_epi8(__m128i a, __m128i b)
+    {
+        switch (s & 0x1fu) {
             case  0: return b;
             case  1: return _mm_or_si128(_mm_slli_si128(a, 15), _mm_srli_si128(b,  1));
             case  2: return _mm_or_si128(_mm_slli_si128(a, 14), _mm_srli_si128(b,  2));
@@ -220,72 +254,143 @@
         }
         return _mm_setzero_si128();
     }
-
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
+}  // namespace SseIntrinsics
+}  // namespace Vc
 #endif
 
 // SSE4.1
-#ifdef VC_IMPL_SSE4_1
-extern "C" {
-#include <smmintrin.h>
+#ifdef Vc_IMPL_SSE4_1
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace SseIntrinsics
+{
+Vc_INTRINSIC Vc_CONST __m128i cmpeq_epi64(__m128i a, __m128i b)
+{
+    return _mm_cmpeq_epi64(a, b);
 }
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+template <int index> Vc_INTRINSIC Vc_CONST int extract_epi32(__m128i v)
 {
-namespace SSE
+    return _mm_extract_epi32(v, index);
+}
+Vc_INTRINSIC Vc_CONST __m128d blendv_pd(__m128d a, __m128d b, __m128d c)
+{
+    return _mm_blendv_pd(a, b, c);
+}
+Vc_INTRINSIC Vc_CONST __m128 blendv_ps(__m128 a, __m128 b, __m128 c)
+{
+    return _mm_blendv_ps(a, b, c);
+}
+Vc_INTRINSIC Vc_CONST __m128i blendv_epi8(__m128i a, __m128i b, __m128i c)
+{
+    return _mm_blendv_epi8(a, b, c);
+}
+template <int mask> Vc_INTRINSIC Vc_CONST __m128d blend_pd(__m128d a, __m128d b)
+{
+    return _mm_blend_pd(a, b, mask);
+}
+template <int mask> Vc_INTRINSIC Vc_CONST __m128 blend_ps(__m128 a, __m128 b)
+{
+    return _mm_blend_ps(a, b, mask);
+}
+template <int mask> Vc_INTRINSIC Vc_CONST __m128i blend_epi16(__m128i a, __m128i b)
+{
+    return _mm_blend_epi16(a, b, mask);
+}
+Vc_INTRINSIC Vc_CONST __m128i max_epi8(__m128i a, __m128i b)
+{
+    return _mm_max_epi8(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i max_epi32(__m128i a, __m128i b)
+{
+    return _mm_max_epi32(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i max_epu16(__m128i a, __m128i b)
+{
+    return _mm_max_epu16(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i max_epu32(__m128i a, __m128i b)
+{
+    return _mm_max_epu32(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i min_epu16(__m128i a, __m128i b)
+{
+    return _mm_min_epu16(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i min_epu32(__m128i a, __m128i b)
 {
-#define mm_blendv_pd _mm_blendv_pd
-#define mm_blendv_ps _mm_blendv_ps
-#define mm_blendv_epi8 _mm_blendv_epi8
-#define mm_blend_epi16 _mm_blend_epi16
-#define mm_blend_ps _mm_blend_ps
-#define mm_blend_pd _mm_blend_pd
-
-#define mm_min_epi32 _mm_min_epi32
-#define mm_max_epi32 _mm_max_epi32
-#define mm_min_epu32 _mm_min_epu32
-#define mm_max_epu32 _mm_max_epu32
-//#define mm_min_epi16 _mm_min_epi16
-//#define mm_max_epi16 _mm_max_epi16
-#define mm_min_epu16 _mm_min_epu16
-#define mm_max_epu16 _mm_max_epu16
-#define mm_min_epi8  _mm_min_epi8
-#define mm_max_epi8  _mm_max_epi8
-
-#define mm_cvtepu16_epi32 _mm_cvtepu16_epi32
-#define mm_cvtepu8_epi16 _mm_cvtepu8_epi16
-#define mm_cvtepi8_epi16 _mm_cvtepi8_epi16
-#define mm_cvtepu16_epi32 _mm_cvtepu16_epi32
-#define mm_cvtepi16_epi32 _mm_cvtepi16_epi32
-#define mm_cvtepu8_epi32 _mm_cvtepu8_epi32
-#define mm_cvtepi8_epi32 _mm_cvtepi8_epi32
-#define mm_stream_load_si128 _mm_stream_load_si128
-// TODO
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+    return _mm_min_epu32(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i min_epi8(__m128i a, __m128i b)
+{
+    return _mm_min_epi8(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i min_epi32(__m128i a, __m128i b)
+{
+    return _mm_min_epi32(a, b);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepu8_epi16(__m128i epu8)
+{
+    return _mm_cvtepu8_epi16(epu8);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepi8_epi16(__m128i epi8)
+{
+    return _mm_cvtepi8_epi16(epi8);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepu16_epi32(__m128i epu16)
+{
+    return _mm_cvtepu16_epi32(epu16);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepi16_epi32(__m128i epu16)
+{
+    return _mm_cvtepi16_epi32(epu16);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepu8_epi32(__m128i epu8)
+{
+    return _mm_cvtepu8_epi32(epu8);
+}
+Vc_INTRINSIC Vc_CONST __m128i cvtepi8_epi32(__m128i epi8)
+{
+    return _mm_cvtepi8_epi32(epi8);
+}
+Vc_INTRINSIC Vc_PURE __m128i stream_load_si128(__m128i *mem)
+{
+    return _mm_stream_load_si128(mem);
+}
+}  // namespace SseIntrinsics
+}  // namespace Vc
 #else
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace SseIntrinsics
 {
-    static Vc_INTRINSIC __m128d mm_blendv_pd(__m128d a, __m128d b, __m128d c) {
+    Vc_INTRINSIC Vc_CONST __m128i cmpeq_epi64(__m128i a, __m128i b) {
+        auto tmp = _mm_cmpeq_epi32(a, b);
+        return _mm_and_si128(tmp, _mm_shuffle_epi32(tmp, 1*1 + 0*4 + 3*16 + 2*64));
+    }
+    template <int index> Vc_INTRINSIC Vc_CONST int extract_epi32(__m128i v)
+    {
+#ifdef Vc_USE_BUILTIN_VECTOR_TYPES
+        typedef int int32v4 __attribute__((__vector_size__(16)));
+        return reinterpret_cast<const MayAlias<int32v4> &>(v)[index];
+#else
+        return _mm_cvtsi128_si32(_mm_srli_si128(v, index * 4));
+#endif
+    }
+    Vc_INTRINSIC Vc_CONST __m128d blendv_pd(__m128d a, __m128d b, __m128d c) {
         return _mm_or_pd(_mm_andnot_pd(c, a), _mm_and_pd(c, b));
     }
-    static Vc_INTRINSIC __m128  mm_blendv_ps(__m128  a, __m128  b, __m128  c) {
+    Vc_INTRINSIC Vc_CONST __m128  blendv_ps(__m128  a, __m128  b, __m128  c) {
         return _mm_or_ps(_mm_andnot_ps(c, a), _mm_and_ps(c, b));
     }
-    static Vc_INTRINSIC __m128i mm_blendv_epi8(__m128i a, __m128i b, __m128i c) {
+    Vc_INTRINSIC Vc_CONST __m128i blendv_epi8(__m128i a, __m128i b, __m128i c) {
         return _mm_or_si128(_mm_andnot_si128(c, a), _mm_and_si128(c, b));
     }
 
     // only use the following blend functions with immediates as mask and, of course, compiling
     // with optimization
-    static Vc_INTRINSIC __m128d mm_blend_pd(__m128d a, __m128d b, const int mask) {
+    template <int mask> Vc_INTRINSIC Vc_CONST __m128d blend_pd(__m128d a, __m128d b)
+    {
         switch (mask) {
         case 0x0:
             return a;
@@ -300,7 +405,8 @@
             return a; // should never be reached, but MSVC needs it else it warns about 'not all control paths return a value'
         }
     }
-    static Vc_INTRINSIC __m128  mm_blend_ps(__m128  a, __m128  b, const int mask) {
+    template <int mask> Vc_INTRINSIC Vc_CONST __m128 blend_ps(__m128 a, __m128 b)
+    {
         __m128i c;
         switch (mask) {
         case 0x0:
@@ -357,7 +463,8 @@
         __m128 _c = _mm_castsi128_ps(c);
         return _mm_or_ps(_mm_andnot_ps(_c, a), _mm_and_ps(_c, b));
     }
-    static Vc_INTRINSIC __m128i mm_blend_epi16(__m128i a, __m128i b, const int mask) {
+    template <int mask> Vc_INTRINSIC Vc_CONST __m128i blend_epi16(__m128i a, __m128i b)
+    {
         __m128i c;
         switch (mask) {
         case 0x00:
@@ -417,80 +524,67 @@
         return _mm_or_si128(_mm_andnot_si128(c, a), _mm_and_si128(c, b));
     }
 
-    static Vc_INTRINSIC __m128i Vc_CONST mm_max_epi8 (__m128i a, __m128i b) {
-        return mm_blendv_epi8(b, a, _mm_cmpgt_epi8 (a, b));
+    Vc_INTRINSIC Vc_CONST __m128i max_epi8 (__m128i a, __m128i b) {
+        return blendv_epi8(b, a, _mm_cmpgt_epi8 (a, b));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_max_epi32(__m128i a, __m128i b) {
-        return mm_blendv_epi8(b, a, _mm_cmpgt_epi32(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i max_epi32(__m128i a, __m128i b) {
+        return blendv_epi8(b, a, _mm_cmpgt_epi32(a, b));
     }
-//X         static Vc_INTRINSIC __m128i Vc_CONST mm_max_epu8 (__m128i a, __m128i b) {
-//X             return mm_blendv_epi8(b, a, _mm_cmpgt_epu8 (a, b));
+//X         Vc_INTRINSIC Vc_CONST __m128i max_epu8 (__m128i a, __m128i b) {
+//X             return _mm_blendv_epi8(b, a, cmpgt_epu8 (a, b));
 //X         }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_max_epu16(__m128i a, __m128i b) {
-        return mm_blendv_epi8(b, a, _mm_cmpgt_epu16(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i max_epu16(__m128i a, __m128i b) {
+        return blendv_epi8(b, a, cmpgt_epu16(a, b));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_max_epu32(__m128i a, __m128i b) {
-        return mm_blendv_epi8(b, a, _mm_cmpgt_epu32(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i max_epu32(__m128i a, __m128i b) {
+        return blendv_epi8(b, a, cmpgt_epu32(a, b));
     }
-//X         static Vc_INTRINSIC __m128i Vc_CONST mm_min_epu8 (__m128i a, __m128i b) {
-//X             return mm_blendv_epi8(a, b, _mm_cmpgt_epu8 (a, b));
+//X         Vc_INTRINSIC Vc_CONST __m128i _mm_min_epu8 (__m128i a, __m128i b) {
+//X             return _mm_blendv_epi8(a, b, cmpgt_epu8 (a, b));
 //X         }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_min_epu16(__m128i a, __m128i b) {
-        return mm_blendv_epi8(a, b, _mm_cmpgt_epu16(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i min_epu16(__m128i a, __m128i b) {
+        return blendv_epi8(a, b, cmpgt_epu16(a, b));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_min_epu32(__m128i a, __m128i b) {
-        return mm_blendv_epi8(a, b, _mm_cmpgt_epu32(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i min_epu32(__m128i a, __m128i b) {
+        return blendv_epi8(a, b, cmpgt_epu32(a, b));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_min_epi8 (__m128i a, __m128i b) {
-        return mm_blendv_epi8(a, b, _mm_cmpgt_epi8 (a, b));
+    Vc_INTRINSIC Vc_CONST __m128i min_epi8 (__m128i a, __m128i b) {
+        return blendv_epi8(a, b, _mm_cmpgt_epi8 (a, b));
     }
-    static Vc_INTRINSIC __m128i Vc_CONST mm_min_epi32(__m128i a, __m128i b) {
-        return mm_blendv_epi8(a, b, _mm_cmpgt_epi32(a, b));
+    Vc_INTRINSIC Vc_CONST __m128i min_epi32(__m128i a, __m128i b) {
+        return blendv_epi8(a, b, _mm_cmpgt_epi32(a, b));
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepu8_epi16(__m128i epu8) {
+    Vc_INTRINSIC Vc_CONST __m128i cvtepu8_epi16(__m128i epu8) {
         return _mm_unpacklo_epi8(epu8, _mm_setzero_si128());
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepi8_epi16(__m128i epi8) {
+    Vc_INTRINSIC Vc_CONST __m128i cvtepi8_epi16(__m128i epi8) {
         return _mm_unpacklo_epi8(epi8, _mm_cmplt_epi8(epi8, _mm_setzero_si128()));
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepu16_epi32(__m128i epu16) {
+    Vc_INTRINSIC Vc_CONST __m128i cvtepu16_epi32(__m128i epu16) {
         return _mm_unpacklo_epi16(epu16, _mm_setzero_si128());
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepi16_epi32(__m128i epu16) {
+    Vc_INTRINSIC Vc_CONST __m128i cvtepi16_epi32(__m128i epu16) {
         return _mm_unpacklo_epi16(epu16, _mm_cmplt_epi16(epu16, _mm_setzero_si128()));
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepu8_epi32(__m128i epu8) {
-        return mm_cvtepu16_epi32(mm_cvtepu8_epi16(epu8));
+    Vc_INTRINSIC Vc_CONST __m128i cvtepu8_epi32(__m128i epu8) {
+        return cvtepu16_epi32(cvtepu8_epi16(epu8));
     }
-    static Vc_INTRINSIC Vc_CONST __m128i mm_cvtepi8_epi32(__m128i epi8) {
+    Vc_INTRINSIC Vc_CONST __m128i cvtepi8_epi32(__m128i epi8) {
         const __m128i neg = _mm_cmplt_epi8(epi8, _mm_setzero_si128());
         const __m128i epi16 = _mm_unpacklo_epi8(epi8, neg);
         return _mm_unpacklo_epi16(epi16, _mm_unpacklo_epi8(neg, neg));
     }
-    static Vc_INTRINSIC Vc_PURE __m128i mm_stream_load_si128(__m128i *mem) {
+    Vc_INTRINSIC Vc_PURE __m128i stream_load_si128(__m128i *mem) {
         return _mm_load_si128(mem);
     }
-
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-#endif
-
-#ifdef VC_IMPL_POPCNT
-#include <popcntintrin.h>
+}  // namespace SseIntrinsics
+}  // namespace Vc
 #endif
 
 // SSE4.2
-#ifdef VC_IMPL_SSE4_2
-extern "C" {
-#include <nmmintrin.h>
-}
-#endif
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace SseIntrinsics
 {
     static Vc_INTRINSIC Vc_CONST float extract_float_imm(const __m128 v, const size_t i) {
         float f;
@@ -498,9 +592,9 @@
         case 0:
             f = _mm_cvtss_f32(v);
             break;
-#if defined VC_IMPL_SSE4_1 && !defined VC_MSVC
+#if defined Vc_IMPL_SSE4_1 && !defined Vc_MSVC
         default:
-#ifdef VC_GCC
+#ifdef Vc_GCC
             f = __builtin_ia32_vec_ext_v4sf(static_cast<__v4sf>(v), (i));
 #else
             // MSVC fails to compile this because it can't optimize i to an immediate
@@ -528,7 +622,7 @@
         return _mm_cvtsd_f64(_mm_castps_pd(_mm_movehl_ps(_mm_castpd_ps(v), _mm_castpd_ps(v))));
     }
     static Vc_INTRINSIC Vc_CONST float extract_float(const __m128 v, const size_t i) {
-#ifdef VC_GCC
+#ifdef Vc_GCC
         if (__builtin_constant_p(i)) {
             return extract_float_imm(v, i);
 //X         if (index <= 1) {
@@ -550,21 +644,21 @@
     }
 
     static Vc_INTRINSIC Vc_PURE __m128  _mm_stream_load(const float *mem) {
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
         return _mm_castsi128_ps(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<float *>(mem))));
 #else
         return _mm_load_ps(mem);
 #endif
     }
     static Vc_INTRINSIC Vc_PURE __m128d _mm_stream_load(const double *mem) {
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
         return _mm_castsi128_pd(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<double *>(mem))));
 #else
         return _mm_load_pd(mem);
 #endif
     }
     static Vc_INTRINSIC Vc_PURE __m128i _mm_stream_load(const int *mem) {
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
         return _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast<int *>(mem)));
 #else
         return _mm_load_si128(reinterpret_cast<const __m128i *>(mem));
@@ -585,18 +679,70 @@
     static Vc_INTRINSIC Vc_PURE __m128i _mm_stream_load(const unsigned char *mem) {
         return _mm_stream_load(reinterpret_cast<const int *>(mem));
     }
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-// XOP / FMA4
-#if defined(VC_IMPL_XOP) || defined(VC_IMPL_FMA4)
-extern "C" {
-#include <x86intrin.h>
-}
+
+#ifndef __x86_64__
+    Vc_INTRINSIC Vc_PURE __m128i _mm_cvtsi64_si128(int64_t x) {
+        return _mm_castpd_si128(_mm_load_sd(reinterpret_cast<const double *>(&x)));
+    }
+#endif
+
+}  // namespace SseIntrinsics
+}  // namespace Vc
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace SSE
+{
+using namespace SseIntrinsics;
+
+template <typename T> struct ParameterHelper
+{
+    typedef T ByValue;
+    typedef T &Reference;
+    typedef const T &ConstRef;
+};
+
+template <typename T> struct VectorHelper
+{
+};
+
+template <typename T> struct VectorTypeHelper
+{
+    typedef __m128i Type;
+};
+template <> struct VectorTypeHelper<double>
+{
+    typedef __m128d Type;
+};
+template <> struct VectorTypeHelper<float>
+{
+    typedef __m128 Type;
+};
+
+template <typename T> struct DetermineGatherMask
+{
+    typedef T Type;
+};
+
+template <typename T> struct VectorTraits
+{
+    typedef typename VectorTypeHelper<T>::Type VectorType;
+    Vc_ALIGNED_TYPEDEF(sizeof(T), T, EntryType);
+    static constexpr size_t Size = sizeof(VectorType) / sizeof(EntryType);
+    enum Constants { HasVectorDivision = !std::is_integral<T>::value };
+    typedef Mask<T> MaskType;
+    typedef typename DetermineGatherMask<MaskType>::Type GatherMaskType;
+    typedef Common::VectorMemoryUnion<VectorType, EntryType> StorageType;
+};
+
+template <typename T> struct VectorHelperSize;
+}  // namespace SSE
+}  // namespace Vc
+
+#if defined(Vc_GCC) && !defined(__OPTIMIZE__)
+#pragma GCC diagnostic pop
 #endif
 
-#include "undomacros.h"
 #include "shuffle.h"
 
-#endif // SSE_INTRINSICS_H
+#endif // VC_SSE_INTRINSICS_H_
diff -Nru vc-0.7.4/sse/limits.h vc-1.3.0/sse/limits.h
--- vc-0.7.4/sse/limits.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/limits.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,24 +1,32 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_LIMITS_H
-#define VC_SSE_LIMITS_H
+#ifndef VC_SSE_LIMITS_H_
+#define VC_SSE_LIMITS_H_
 
 #include "intrinsics.h"
 #include "types.h"
@@ -28,54 +36,52 @@
 {
 template<> struct numeric_limits< ::Vc::SSE::ushort_v> : public numeric_limits<unsigned short>
 {
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v max()           _VC_NOEXCEPT { return ::Vc::SSE::_mm_setallone_si128(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v min()           _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v lowest()        _VC_NOEXCEPT { return min(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v epsilon()       _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v round_error()   _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v infinity()      _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v quiet_NaN()     _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v signaling_NaN() _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v denorm_min()    _VC_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v max()           Vc_NOEXCEPT { return ::Vc::SSE::_mm_setallone_si128(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v min()           Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v lowest()        Vc_NOEXCEPT { return min(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v epsilon()       Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v round_error()   Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v infinity()      Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v quiet_NaN()     Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v signaling_NaN() Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::ushort_v denorm_min()    Vc_NOEXCEPT { return ::Vc::SSE::ushort_v::Zero(); }
 };
 template<> struct numeric_limits< ::Vc::SSE::short_v> : public numeric_limits<short>
 {
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v max()           _VC_NOEXCEPT { return _mm_srli_epi16(::Vc::SSE::_mm_setallone_si128(), 1); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v min()           _VC_NOEXCEPT { return ::Vc::SSE::_mm_setmin_epi16(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v lowest()        _VC_NOEXCEPT { return min(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v epsilon()       _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v round_error()   _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v infinity()      _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v quiet_NaN()     _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v signaling_NaN() _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v denorm_min()    _VC_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v max()           Vc_NOEXCEPT { return _mm_srli_epi16(::Vc::SSE::_mm_setallone_si128(), 1); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v min()           Vc_NOEXCEPT { return ::Vc::SSE::setmin_epi16(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v lowest()        Vc_NOEXCEPT { return min(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v epsilon()       Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v round_error()   Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v infinity()      Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v quiet_NaN()     Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v signaling_NaN() Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::short_v denorm_min()    Vc_NOEXCEPT { return ::Vc::SSE::short_v::Zero(); }
 };
 template<> struct numeric_limits< ::Vc::SSE::uint_v> : public numeric_limits<unsigned int>
 {
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v max()           _VC_NOEXCEPT { return ::Vc::SSE::_mm_setallone_si128(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v min()           _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v lowest()        _VC_NOEXCEPT { return min(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v epsilon()       _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v round_error()   _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v infinity()      _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v quiet_NaN()     _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v signaling_NaN() _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v denorm_min()    _VC_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v max()           Vc_NOEXCEPT { return ::Vc::SSE::_mm_setallone_si128(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v min()           Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v lowest()        Vc_NOEXCEPT { return min(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v epsilon()       Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v round_error()   Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v infinity()      Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v quiet_NaN()     Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v signaling_NaN() Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::uint_v denorm_min()    Vc_NOEXCEPT { return ::Vc::SSE::uint_v::Zero(); }
 };
 template<> struct numeric_limits< ::Vc::SSE::int_v> : public numeric_limits<int>
 {
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v max()           _VC_NOEXCEPT { return _mm_srli_epi32(::Vc::SSE::_mm_setallone_si128(), 1); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v min()           _VC_NOEXCEPT { return ::Vc::SSE::_mm_setmin_epi32(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v lowest()        _VC_NOEXCEPT { return min(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v epsilon()       _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v round_error()   _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v infinity()      _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v quiet_NaN()     _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v signaling_NaN() _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
-    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v denorm_min()    _VC_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v max()           Vc_NOEXCEPT { return _mm_srli_epi32(::Vc::SSE::_mm_setallone_si128(), 1); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v min()           Vc_NOEXCEPT { return ::Vc::SSE::setmin_epi32(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v lowest()        Vc_NOEXCEPT { return min(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v epsilon()       Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v round_error()   Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v infinity()      Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v quiet_NaN()     Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v signaling_NaN() Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
+    static Vc_INTRINSIC Vc_CONST ::Vc::SSE::int_v denorm_min()    Vc_NOEXCEPT { return ::Vc::SSE::int_v::Zero(); }
 };
 } // namespace std
 
-#include "undomacros.h"
-
-#endif // VC_SSE_LIMITS_H
+#endif // VC_SSE_LIMITS_H_
diff -Nru vc-0.7.4/sse/macros.h vc-1.3.0/sse/macros.h
--- vc-0.7.4/sse/macros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/macros.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,27 +1,34 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "../common/macros.h"
 
-#ifndef VC_SSE_MACROS_H
-#define VC_SSE_MACROS_H
-#undef VC_SSE_UNDOMACROS_H
+#ifndef VC_SSE_MACROS_H_
+#define VC_SSE_MACROS_H_
 
 #ifndef _M128
 # define _M128 __m128
@@ -35,13 +42,8 @@
 # define _M128D __m128d
 #endif
 
-#define STORE_VECTOR(type, name, vec) \
-    union { __m128i p; type v[16 / sizeof(type)]; } CAT(u, __LINE__); \
-    _mm_store_si128(&CAT(u, __LINE__).p, vec); \
-    const type *const name = &CAT(u, __LINE__).v[0]
-
-#if defined(VC_IMPL_SSE4_1) && !defined(VC_DISABLE_PTEST)
-#define VC_USE_PTEST
+#if defined(Vc_IMPL_SSE4_1) && !defined(Vc_DISABLE_PTEST)
+#define Vc_USE_PTEST
 #endif
 
-#endif // VC_SSE_MACROS_H
+#endif // VC_SSE_MACROS_H_
diff -Nru vc-0.7.4/sse/mask.h vc-1.3.0/sse/mask.h
--- vc-0.7.4/sse/mask.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/mask.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,578 +1,261 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_MASK_H
-#define SSE_MASK_H
+#ifndef VC_SSE_MASK_H_
+#define VC_SSE_MASK_H_
 
 #include "intrinsics.h"
+#include "../common/maskbool.h"
+#include "detail.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+namespace Detail
 {
-
-template<unsigned int Size1> struct MaskHelper;
-template<> struct MaskHelper<2> {
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpeq (_M128 k1, _M128 k2) { return _mm_movemask_pd(_mm_castps_pd(k1)) == _mm_movemask_pd(_mm_castps_pd(k2)); }
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpneq(_M128 k1, _M128 k2) { return _mm_movemask_pd(_mm_castps_pd(k1)) != _mm_movemask_pd(_mm_castps_pd(k2)); }
-};
-template<> struct MaskHelper<4> {
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpeq (_M128 k1, _M128 k2) { return _mm_movemask_ps(k1) == _mm_movemask_ps(k2); }
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpneq(_M128 k1, _M128 k2) { return _mm_movemask_ps(k1) != _mm_movemask_ps(k2); }
-};
-template<> struct MaskHelper<8> {
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpeq (_M128 k1, _M128 k2) { return _mm_movemask_epi8(_mm_castps_si128(k1)) == _mm_movemask_epi8(_mm_castps_si128(k2)); }
-    static Vc_ALWAYS_INLINE Vc_CONST bool cmpneq(_M128 k1, _M128 k2) { return _mm_movemask_epi8(_mm_castps_si128(k1)) != _mm_movemask_epi8(_mm_castps_si128(k2)); }
-};
-
-class Float8Mask;
-template<unsigned int VectorSize> class Mask
-{
-    friend class Mask<2u>;
-    friend class Mask<4u>;
-    friend class Mask<8u>;
-    friend class Mask<16u>;
-    friend class Float8Mask;
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(16)
+template <size_t Size>
+Vc_INTRINSIC_L Vc_CONST_L int mask_count(__m128i) Vc_INTRINSIC_R Vc_CONST_R;
+template <size_t Size>
+Vc_INTRINSIC_L Vc_CONST_L int mask_to_int(__m128i) Vc_INTRINSIC_R Vc_CONST_R;
+template <size_t Size>
+Vc_INTRINSIC_L Vc_CONST_L bool is_equal(__m128, __m128) Vc_INTRINSIC_R Vc_CONST_R;
+template <size_t Size>
+Vc_INTRINSIC_L Vc_CONST_L bool is_not_equal(__m128, __m128) Vc_INTRINSIC_R Vc_CONST_R;
+}  // namespace Detail
+
+using SSE::sse_cast;
+
+template <typename T> class Mask<T, VectorAbi::Sse>
+{
+    using abi = VectorAbi::Sse;
+    friend class Mask<  double, abi>;
+    friend class Mask<   float, abi>;
+    friend class Mask< int32_t, abi>;
+    friend class Mask<uint32_t, abi>;
+    friend class Mask< int16_t, abi>;
+    friend class Mask<uint16_t, abi>;
+
+    /**
+     * A helper type for aliasing the entries in the mask but behaving like a bool.
+     */
+    typedef Common::MaskBool<sizeof(T)> MaskBool;
+
+    typedef Common::Storage<T, SSE::VectorTraits<T>::Size> Storage;
+
+public:
+
+    /**
+     * The \c EntryType of masks is always bool, independent of \c T.
+     */
+    typedef bool EntryType;
+    using value_type = EntryType;
+
+    /**
+     * The return type of the non-const subscript operator.
+     */
+    using EntryReference = Detail::ElementReference<Mask>;
+    using reference = EntryReference;
+
+    /**
+     * The \c VectorEntryType, in contrast to \c EntryType, reveals information about the SIMD
+     * implementation. This type is useful for the \c sizeof operator in generic functions.
+     */
+    typedef MaskBool VectorEntryType;
+
+    /**
+     * The \c VectorType reveals the implementation-specific internal type used for the SIMD type.
+     */
+    using VectorType = typename Storage::VectorType;
+
+    /**
+     * The associated Vector<T> type.
+     */
+    using Vector = SSE::Vector<T>;
+
+public:
+    Vc_FREE_STORE_OPERATORS_ALIGNED(16);
+    static constexpr size_t Size = SSE::VectorTraits<T>::Size;
+    static constexpr size_t MemoryAlignment = Size;
+    static constexpr std::size_t size() { return Size; }
 
         // abstracts the way Masks are passed to functions, it can easily be changed to const ref here
-        // Also Float8Mask requires const ref on MSVC 32bit.
-#if defined VC_MSVC && defined _WIN32
-        typedef const Mask<VectorSize> &Argument;
+#if defined Vc_MSVC && defined _WIN32
+        typedef const Mask &Argument;
 #else
-        typedef Mask<VectorSize> Argument;
+        typedef Mask Argument;
 #endif
 
-        Vc_ALWAYS_INLINE Mask() {}
-        Vc_ALWAYS_INLINE Mask(const __m128  &x) : k(x) {}
-        Vc_ALWAYS_INLINE Mask(const __m128d &x) : k(_mm_castpd_ps(x)) {}
-        Vc_ALWAYS_INLINE Mask(const __m128i &x) : k(_mm_castsi128_ps(x)) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerZero::ZEnum) : k(_mm_setzero_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(VectorSpecialInitializerOne::OEnum) : k(_mm_setallone_ps()) {}
-        Vc_ALWAYS_INLINE explicit Mask(bool b) : k(b ? _mm_setallone_ps() : _mm_setzero_ps()) {}
-        Vc_ALWAYS_INLINE Mask(const Mask &rhs) : k(rhs.k) {}
-        Vc_ALWAYS_INLINE Mask(const Mask<VectorSize / 2> *a)
-          : k(_mm_castsi128_ps(_mm_packs_epi16(a[0].dataI(), a[1].dataI()))) {}
-        Vc_ALWAYS_INLINE explicit Mask(const Float8Mask &m);
-
-        template<unsigned int OtherSize> Vc_ALWAYS_INLINE_L explicit Mask(const Mask<OtherSize> &x) Vc_ALWAYS_INLINE_R;
-//X         {
-//X             _M128I tmp = x.dataI();
-//X             if (OtherSize < VectorSize) {
-//X                 tmp = _mm_packs_epi16(tmp, _mm_setzero_si128());
-//X                 if (VectorSize / OtherSize >= 4u) { tmp = _mm_packs_epi16(tmp, _mm_setzero_si128()); }
-//X                 if (VectorSize / OtherSize >= 8u) { tmp = _mm_packs_epi16(tmp, _mm_setzero_si128()); }
-//X             } else if (OtherSize > VectorSize) {
-//X                 tmp = _mm_unpacklo_epi8(tmp, tmp);
-//X                 if (OtherSize / VectorSize >= 4u) { tmp = _mm_unpacklo_epi8(tmp, tmp); }
-//X                 if (OtherSize / VectorSize >= 8u) { tmp = _mm_unpacklo_epi8(tmp, tmp); }
-//X             }
-//X             k = _mm_castsi128_ps(tmp);
-//X         }
-
-        inline void expand(Mask<VectorSize / 2> *x) const;
-
-        Vc_ALWAYS_INLINE Vc_PURE bool operator==(const Mask &rhs) const { return MaskHelper<VectorSize>::cmpeq (k, rhs.k); }
-        Vc_ALWAYS_INLINE Vc_PURE bool operator!=(const Mask &rhs) const { return MaskHelper<VectorSize>::cmpneq(k, rhs.k); }
-
-        Vc_ALWAYS_INLINE Vc_PURE Mask operator!() const { return _mm_andnot_si128(dataI(), _mm_setallone_si128()); }
-
-        Vc_ALWAYS_INLINE Mask &operator&=(const Mask &rhs) { k = _mm_and_ps(k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator|=(const Mask &rhs) { k = _mm_or_ps (k, rhs.k); return *this; }
-        Vc_ALWAYS_INLINE Mask &operator^=(const Mask &rhs) { k = _mm_xor_ps(k, rhs.k); return *this; }
+        Vc_INTRINSIC Mask() {}
+        Vc_INTRINSIC Mask(const __m128  &x) : d(sse_cast<VectorType>(x)) {}
+        Vc_INTRINSIC Mask(const __m128d &x) : d(sse_cast<VectorType>(x)) {}
+        Vc_INTRINSIC Mask(const __m128i &x) : d(sse_cast<VectorType>(x)) {}
+        Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero) : Mask(_mm_setzero_ps()) {}
+        Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne) : Mask(SSE::_mm_setallone_ps()) {}
+        Vc_INTRINSIC explicit Mask(bool b) : Mask(b ? SSE::_mm_setallone_ps() : _mm_setzero_ps()) {}
+        Vc_INTRINSIC static Mask Zero() { return Mask{Vc::Zero}; }
+        Vc_INTRINSIC static Mask One() { return Mask{Vc::One}; }
 
-        Vc_ALWAYS_INLINE Vc_PURE bool isFull () const { return
-#ifdef VC_USE_PTEST
-            _mm_testc_si128(dataI(), _mm_setallone_si128()); // return 1 if (0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff) == (~0 & k)
-#else
-            _mm_movemask_epi8(dataI()) == 0xffff;
-#endif
-        }
-        Vc_ALWAYS_INLINE Vc_PURE bool isEmpty() const { return
-#ifdef VC_USE_PTEST
-            _mm_testz_si128(dataI(), dataI()); // return 1 if (0, 0, 0, 0) == (k & k)
-#else
-            _mm_movemask_epi8(dataI()) == 0x0000;
-#endif
-        }
-        Vc_ALWAYS_INLINE Vc_PURE bool isMix() const {
-#ifdef VC_USE_PTEST
-            return _mm_test_mix_ones_zeros(dataI(), _mm_setallone_si128());
-#else
-            const int tmp = _mm_movemask_epi8(dataI());
-            return tmp != 0 && (tmp ^ 0xffff) != 0;
-#endif
+        // implicit cast
+        template <typename U>
+        Vc_INTRINSIC Mask(U &&rhs,
+                          Common::enable_if_mask_converts_implicitly<T, U> = nullarg)
+            : d(sse_cast<VectorType>(
+                  Detail::mask_cast<Traits::simd_vector_size<U>::value, Size, __m128>(
+                      rhs.dataI())))
+        {
         }
 
-#ifndef VC_NO_AUTOMATIC_BOOL_FROM_MASK
-        Vc_ALWAYS_INLINE Vc_PURE operator bool() const { return isFull(); }
+#if Vc_IS_VERSION_1
+        // explicit cast, implemented via simd_cast (implementation in sse/simd_cast.h)
+        template <typename U>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "mask types") Vc_INTRINSIC
+            explicit Mask(U &&rhs,
+                          Common::enable_if_mask_converts_explicitly<T, U> = nullarg);
 #endif
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int shiftMask() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int toInt() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-        Vc_ALWAYS_INLINE Vc_PURE _M128  data () const { return k; }
-        Vc_ALWAYS_INLINE Vc_PURE _M128I dataI() const { return _mm_castps_si128(k); }
-        Vc_ALWAYS_INLINE Vc_PURE _M128D dataD() const { return _mm_castps_pd(k); }
+        Vc_ALWAYS_INLINE explicit Mask(const bool *mem) { load(mem); }
+        template<typename Flags> Vc_ALWAYS_INLINE explicit Mask(const bool *mem, Flags f) { load(mem, f); }
 
-        template<unsigned int OtherSize> Vc_ALWAYS_INLINE Vc_PURE Mask<OtherSize> cast() const { return Mask<OtherSize>(k); }
+        Vc_ALWAYS_INLINE_L void load(const bool *mem) Vc_ALWAYS_INLINE_R;
+        template<typename Flags> Vc_ALWAYS_INLINE void load(const bool *mem, Flags) { load(mem); }
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L bool operator[](int index) const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        Vc_ALWAYS_INLINE_L void store(bool *) const Vc_ALWAYS_INLINE_R;
+        template<typename Flags> Vc_ALWAYS_INLINE void store(bool *mem, Flags) const { store(mem); }
 
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int count() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-        /**
-         * Returns the index of the first one in the mask.
-         *
-         * The return value is undefined if the mask is empty.
-         */
-        Vc_ALWAYS_INLINE_L Vc_PURE_L int firstOne() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
-
-    private:
-#ifdef VC_COMPILE_BENCHMARKS
-    public:
-#endif
-        _M128 k;
-};
-
-struct ForeachHelper
-{
-    _long mask;
-    bool brk;
-    bool outerBreak;
-    Vc_ALWAYS_INLINE ForeachHelper(_long _mask) : mask(_mask), brk(false), outerBreak(false) {}
-    Vc_ALWAYS_INLINE bool outer() const { return (mask != 0) && !outerBreak; }
-    Vc_ALWAYS_INLINE bool inner() { return (brk = !brk); }
-    Vc_ALWAYS_INLINE void noBreak() { outerBreak = false; }
-    Vc_ALWAYS_INLINE _long next() {
-        outerBreak = true;
-#ifdef VC_GNU_ASM
-        const _long bit = __builtin_ctzl(mask);
-        __asm__("btr %1,%0" : "+r"(mask) : "r"(bit));
-#elif defined(_WIN64)
-       unsigned long bit;
-       _BitScanForward64(&bit, mask);
-       _bittestandreset64(&mask, bit);
-#elif defined(_WIN32)
-       unsigned long bit;
-       _BitScanForward(&bit, mask);
-       _bittestandreset(&mask, bit);
-#else
-#error "Not implemented yet. Please contact vc-devel@compeng.uni-frankfurt.de"
-#endif
-        return bit;
-    }
-};
-
-#define Vc_foreach_bit(_it_, _mask_) \
-    for (Vc::SSE::ForeachHelper Vc__make_unique(foreach_bit_obj)((_mask_).toInt()); Vc__make_unique(foreach_bit_obj).outer(); ) \
-        for (_it_ = Vc__make_unique(foreach_bit_obj).next(); Vc__make_unique(foreach_bit_obj).inner(); Vc__make_unique(foreach_bit_obj).noBreak())
-
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size>::shiftMask() const
-{
-    return _mm_movemask_epi8(dataI());
-}
-
-template<> template<> Vc_ALWAYS_INLINE Mask<2>::Mask(const Mask<4> &x) {
-    k = _mm_unpacklo_ps(x.data(), x.data());
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<2>::Mask(const Mask<8> &x) {
-    _M128I tmp = _mm_unpacklo_epi16(x.dataI(), x.dataI());
-    k = _mm_castsi128_ps(_mm_unpacklo_epi32(tmp, tmp));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<2>::Mask(const Mask<16> &x) {
-    _M128I tmp = _mm_unpacklo_epi8(x.dataI(), x.dataI());
-    tmp = _mm_unpacklo_epi16(tmp, tmp);
-    k = _mm_castsi128_ps(_mm_unpacklo_epi32(tmp, tmp));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<4>::Mask(const Mask<2> &x) {
-    k = _mm_castsi128_ps(_mm_packs_epi16(x.dataI(), _mm_setzero_si128()));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<4>::Mask(const Mask<8> &x) {
-    k = _mm_castsi128_ps(_mm_unpacklo_epi16(x.dataI(), x.dataI()));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<4>::Mask(const Mask<16> &x) {
-    _M128I tmp = _mm_unpacklo_epi8(x.dataI(), x.dataI());
-    k = _mm_castsi128_ps(_mm_unpacklo_epi16(tmp, tmp));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<8>::Mask(const Mask<2> &x) {
-    _M128I tmp = _mm_packs_epi16(x.dataI(), x.dataI());
-    k = _mm_castsi128_ps(_mm_packs_epi16(tmp, tmp));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<8>::Mask(const Mask<4> &x) {
-    k = _mm_castsi128_ps(_mm_packs_epi16(x.dataI(), x.dataI()));
-}
-template<> template<> Vc_ALWAYS_INLINE Mask<8>::Mask(const Mask<16> &x) {
-    k = _mm_castsi128_ps(_mm_unpacklo_epi8(x.dataI(), x.dataI()));
-}
-
-template<> inline void Mask< 4>::expand(Mask<2> *x) const {
-    x[0].k = _mm_unpacklo_ps(data(), data());
-    x[1].k = _mm_unpackhi_ps(data(), data());
-}
-template<> inline void Mask< 8>::expand(Mask<4> *x) const {
-    x[0].k = _mm_castsi128_ps(_mm_unpacklo_epi16(dataI(), dataI()));
-    x[1].k = _mm_castsi128_ps(_mm_unpackhi_epi16(dataI(), dataI()));
-}
-template<> inline void Mask<16>::expand(Mask<8> *x) const {
-    x[0].k = _mm_castsi128_ps(_mm_unpacklo_epi8 (dataI(), dataI()));
-    x[1].k = _mm_castsi128_ps(_mm_unpackhi_epi8 (dataI(), dataI()));
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 2>::toInt() const { return _mm_movemask_pd(dataD()); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 4>::toInt() const { return _mm_movemask_ps(data ()); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask< 8>::toInt() const { return _mm_movemask_epi8(_mm_packs_epi16(dataI(), _mm_setzero_si128())); }
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<16>::toInt() const { return _mm_movemask_epi8(dataI()); }
-
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 2>::operator[](int index) const { return toInt() & (1 << index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 4>::operator[](int index) const { return toInt() & (1 << index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask< 8>::operator[](int index) const { return shiftMask() & (1 << 2 * index); }
-template<> Vc_ALWAYS_INLINE Vc_PURE bool Mask<16>::operator[](int index) const { return toInt() & (1 << index); }
-
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<2>::count() const
-{
-    int mask = _mm_movemask_pd(dataD());
-    return (mask & 1) + (mask >> 1);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<4>::count() const
-{
-#ifdef VC_IMPL_POPCNT
-    return _mm_popcnt_u32(_mm_movemask_ps(data()));
-//X     tmp = (tmp & 5) + ((tmp >> 1) & 5);
-//X     return (tmp & 3) + ((tmp >> 2) & 3);
-#else
-    _M128I x = _mm_srli_epi32(dataI(), 31);
-    x = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(0, 1, 2, 3)));
-    x = _mm_add_epi32(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(1, 0, 3, 2)));
-    return _mm_cvtsi128_si32(x);
-#endif
-}
+        Vc_ALWAYS_INLINE Vc_PURE bool operator==(const Mask &rhs) const
+        {
+            return Detail::is_equal<Size>(data(), rhs.data());
+        }
+        Vc_ALWAYS_INLINE Vc_PURE bool operator!=(const Mask &rhs) const
+        {
+            return Detail::is_not_equal<Size>(data(), rhs.data());
+        }
 
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<8>::count() const
-{
-#ifdef VC_IMPL_POPCNT
-    return _mm_popcnt_u32(_mm_movemask_epi8(dataI())) / 2;
-#else
-//X     int tmp = _mm_movemask_epi8(dataI());
-//X     tmp = (tmp & 0x1111) + ((tmp >> 2) & 0x1111);
-//X     tmp = (tmp & 0x0303) + ((tmp >> 4) & 0x0303);
-//X     return (tmp & 0x000f) + ((tmp >> 8) & 0x000f);
-    _M128I x = _mm_srli_epi16(dataI(), 15);
-    x = _mm_add_epi16(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(0, 1, 2, 3)));
-    x = _mm_add_epi16(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(0, 1, 2, 3)));
-    x = _mm_add_epi16(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(2, 3, 0, 1)));
-    return _mm_extract_epi16(x, 0);
-#endif
-}
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator!() const { return _mm_andnot_si128(dataI(), SSE::_mm_setallone_si128()); }
 
-template<> Vc_ALWAYS_INLINE Vc_PURE int Mask<16>::count() const
-{
-    int tmp = _mm_movemask_epi8(dataI());
-#ifdef VC_IMPL_POPCNT
-    return _mm_popcnt_u32(tmp);
-#else
-    tmp = (tmp & 0x5555) + ((tmp >> 1) & 0x5555);
-    tmp = (tmp & 0x3333) + ((tmp >> 2) & 0x3333);
-    tmp = (tmp & 0x0f0f) + ((tmp >> 4) & 0x0f0f);
-    return (tmp & 0x00ff) + ((tmp >> 8) & 0x00ff);
-#endif
-}
+        Vc_ALWAYS_INLINE Mask &operator&=(const Mask &rhs) { d.v() = SSE::sse_cast<VectorType>(_mm_and_ps(data(), rhs.data())); return *this; }
+        Vc_ALWAYS_INLINE Mask &operator|=(const Mask &rhs) { d.v() = SSE::sse_cast<VectorType>(_mm_or_ps (data(), rhs.data())); return *this; }
+        Vc_ALWAYS_INLINE Mask &operator^=(const Mask &rhs) { d.v() = SSE::sse_cast<VectorType>(_mm_xor_ps(data(), rhs.data())); return *this; }
 
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator&(const Mask &rhs) const { return _mm_and_ps(data(), rhs.data()); }
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator|(const Mask &rhs) const { return _mm_or_ps (data(), rhs.data()); }
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator^(const Mask &rhs) const { return _mm_xor_ps(data(), rhs.data()); }
 
-class Float8Mask
-{
-    enum Constants {
-        PartialSize = 4,
-        VectorSize = 8
-    };
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(16)
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator&&(const Mask &rhs) const { return _mm_and_ps(data(), rhs.data()); }
+        Vc_ALWAYS_INLINE Vc_PURE Mask operator||(const Mask &rhs) const { return _mm_or_ps (data(), rhs.data()); }
 
-        // abstracts the way Masks are passed to functions, it can easily be changed to const ref here
-        // Also Float8Mask requires const ref on MSVC 32bit.
-#if defined VC_MSVC && defined _WIN32
-        typedef const Float8Mask & Argument;
+        Vc_ALWAYS_INLINE Vc_PURE bool isFull () const { return
+#ifdef Vc_USE_PTEST
+            _mm_testc_si128(dataI(), SSE::_mm_setallone_si128()); // return 1 if (0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff) == (~0 & d.v())
 #else
-        typedef Float8Mask Argument;
+            _mm_movemask_epi8(dataI()) == 0xffff;
 #endif
-
-        Vc_ALWAYS_INLINE Float8Mask() {}
-        Vc_ALWAYS_INLINE Float8Mask(const M256 &x) : k(x) {}
-        Vc_ALWAYS_INLINE explicit Float8Mask(VectorSpecialInitializerZero::ZEnum) {
-            k[0] = _mm_setzero_ps();
-            k[1] = _mm_setzero_ps();
-        }
-        Vc_ALWAYS_INLINE explicit Float8Mask(VectorSpecialInitializerOne::OEnum) {
-            k[0] = _mm_setallone_ps();
-            k[1] = _mm_setallone_ps();
-        }
-        Vc_ALWAYS_INLINE explicit Float8Mask(bool b) {
-            const __m128 tmp = b ? _mm_setallone_ps() : _mm_setzero_ps();
-            k[0] = tmp;
-            k[1] = tmp;
-        }
-        Vc_ALWAYS_INLINE Float8Mask(const Mask<VectorSize> &a) {
-            k[0] = _mm_castsi128_ps(_mm_unpacklo_epi16(a.dataI(), a.dataI()));
-            k[1] = _mm_castsi128_ps(_mm_unpackhi_epi16(a.dataI(), a.dataI()));
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE bool operator==(const Float8Mask &rhs) const {
-            return MaskHelper<PartialSize>::cmpeq (k[0], rhs.k[0])
-                && MaskHelper<PartialSize>::cmpeq (k[1], rhs.k[1]);
         }
-        Vc_ALWAYS_INLINE Vc_PURE bool operator!=(const Float8Mask &rhs) const {
-            return MaskHelper<PartialSize>::cmpneq(k[0], rhs.k[0])
-                || MaskHelper<PartialSize>::cmpneq(k[1], rhs.k[1]);
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator&&(const Float8Mask &rhs) const {
-            Float8Mask r;
-            r.k[0] = _mm_and_ps(k[0], rhs.k[0]);
-            r.k[1] = _mm_and_ps(k[1], rhs.k[1]);
-            return r;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator& (const Float8Mask &rhs) const {
-            Float8Mask r;
-            r.k[0] = _mm_and_ps(k[0], rhs.k[0]);
-            r.k[1] = _mm_and_ps(k[1], rhs.k[1]);
-            return r;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator||(const Float8Mask &rhs) const {
-            Float8Mask r;
-            r.k[0] = _mm_or_ps(k[0], rhs.k[0]);
-            r.k[1] = _mm_or_ps(k[1], rhs.k[1]);
-            return r;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator| (const Float8Mask &rhs) const {
-            Float8Mask r;
-            r.k[0] = _mm_or_ps(k[0], rhs.k[0]);
-            r.k[1] = _mm_or_ps(k[1], rhs.k[1]);
-            return r;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator^ (const Float8Mask &rhs) const {
-            Float8Mask r;
-            r.k[0] = _mm_xor_ps(k[0], rhs.k[0]);
-            r.k[1] = _mm_xor_ps(k[1], rhs.k[1]);
-            return r;
-        }
-        Vc_ALWAYS_INLINE Vc_PURE Float8Mask operator!() const {
-            Float8Mask r;
-            r.k[0] = _mm_andnot_ps(k[0], _mm_setallone_ps());
-            r.k[1] = _mm_andnot_ps(k[1], _mm_setallone_ps());
-            return r;
-        }
-        Vc_ALWAYS_INLINE Float8Mask &operator&=(const Float8Mask &rhs) {
-            k[0] = _mm_and_ps(k[0], rhs.k[0]);
-            k[1] = _mm_and_ps(k[1], rhs.k[1]);
-            return *this;
-        }
-        Vc_ALWAYS_INLINE Float8Mask &operator|=(const Float8Mask &rhs) {
-            k[0] = _mm_or_ps (k[0], rhs.k[0]);
-            k[1] = _mm_or_ps (k[1], rhs.k[1]);
-            return *this;
-        }
-        Vc_ALWAYS_INLINE Float8Mask &operator^=(const Float8Mask &rhs) {
-            k[0] = _mm_xor_ps(k[0], rhs.k[0]);
-            k[1] = _mm_xor_ps(k[1], rhs.k[1]);
-            return *this;
-        }
-
-        Vc_ALWAYS_INLINE Vc_PURE bool isFull () const {
-            const _M128 tmp = _mm_and_ps(k[0], k[1]);
-#ifdef VC_USE_PTEST
-            return _mm_testc_si128(_mm_castps_si128(tmp), _mm_setallone_si128());
+        Vc_ALWAYS_INLINE Vc_PURE bool isNotEmpty() const { return
+#ifdef Vc_USE_PTEST
+            0 == _mm_testz_si128(dataI(), dataI()); // return 1 if (0, 0, 0, 0) == (d.v() & d.v())
 #else
-            return _mm_movemask_ps(tmp) == 0xf;
-            //_mm_movemask_ps(k[0]) == 0xf &&
-            //_mm_movemask_ps(k[1]) == 0xf;
+            _mm_movemask_epi8(dataI()) != 0x0000;
 #endif
         }
-        Vc_ALWAYS_INLINE Vc_PURE bool isEmpty() const {
-            const _M128 tmp = _mm_or_ps(k[0], k[1]);
-#ifdef VC_USE_PTEST
-            return _mm_testz_si128(_mm_castps_si128(tmp), _mm_castps_si128(tmp));
+        Vc_ALWAYS_INLINE Vc_PURE bool isEmpty() const { return
+#ifdef Vc_USE_PTEST
+            0 != _mm_testz_si128(dataI(), dataI()); // return 1 if (0, 0, 0, 0) == (d.v() & d.v())
 #else
-            return _mm_movemask_ps(tmp) == 0x0;
-            //_mm_movemask_ps(k[0]) == 0x0 &&
-            //_mm_movemask_ps(k[1]) == 0x0;
+            _mm_movemask_epi8(dataI()) == 0x0000;
 #endif
         }
         Vc_ALWAYS_INLINE Vc_PURE bool isMix() const {
-            // consider [1111 0000]
-            // solution:
-            // if k[0] != k[1] => return true
-            // if k[0] == k[1] => return k[0].isMix
-#ifdef VC_USE_PTEST
-            __m128i tmp = _mm_castps_si128(_mm_xor_ps(k[0], k[1]));
-            // tmp == 0 <=> k[0] == k[1]
-            return !_mm_testz_si128(tmp, tmp) ||
-                _mm_test_mix_ones_zeros(_mm_castps_si128(k[0]), _mm_setallone_si128());
+#ifdef Vc_USE_PTEST
+            return _mm_test_mix_ones_zeros(dataI(), SSE::_mm_setallone_si128());
 #else
-            const int tmp = _mm_movemask_ps(k[0]) + _mm_movemask_ps(k[1]);
-            return tmp > 0x0 && tmp < (0xf + 0xf);
+            const int tmp = _mm_movemask_epi8(dataI());
+            return tmp != 0 && (tmp ^ 0xffff) != 0;
 #endif
         }
 
-#ifndef VC_NO_AUTOMATIC_BOOL_FROM_MASK
-        Vc_ALWAYS_INLINE Vc_PURE operator bool() const { return isFull(); }
-#endif
+        Vc_ALWAYS_INLINE Vc_PURE int shiftMask() const { return _mm_movemask_epi8(dataI()); }
 
-        Vc_ALWAYS_INLINE Vc_PURE int shiftMask() const {
-            return (_mm_movemask_ps(k[1]) << 4) + _mm_movemask_ps(k[0]);
-        }
-        Vc_ALWAYS_INLINE Vc_PURE int toInt() const { return (_mm_movemask_ps(k[1]) << 4) + _mm_movemask_ps(k[0]); }
+        Vc_ALWAYS_INLINE Vc_PURE int toInt() const { return Detail::mask_to_int<Size>(dataI()); }
 
-        Vc_ALWAYS_INLINE Vc_PURE const M256 &data () const { return k; }
+        Vc_ALWAYS_INLINE Vc_PURE __m128  data () const { return SSE::sse_cast<__m128 >(d.v()); }
+        Vc_ALWAYS_INLINE Vc_PURE __m128i dataI() const { return SSE::sse_cast<__m128i>(d.v()); }
+        Vc_ALWAYS_INLINE Vc_PURE __m128d dataD() const { return SSE::sse_cast<__m128d>(d.v()); }
+
+private:
+    friend reference;
+    static Vc_INTRINSIC Vc_PURE value_type get(const Mask &m, int i) noexcept
+    {
+        return MaskBool(m.d.m(i));
+    }
+    template <typename U>
+    static Vc_INTRINSIC void set(Mask &m, int i,
+                                 U &&v) noexcept(noexcept(MaskBool(std::declval<U>())))
+    {
+        m.d.set(i, MaskBool(std::forward<U>(v)));
+    }
 
-        Vc_ALWAYS_INLINE Vc_PURE bool operator[](int index) const {
-            return (toInt() & (1 << index)) != 0;
-        }
+public:
+    Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+    {
+        return {*this, int(index)};
+    }
+    Vc_ALWAYS_INLINE Vc_PURE value_type operator[](size_t index) const noexcept
+    {
+        return get(*this, index);
+    }
 
-        Vc_ALWAYS_INLINE Vc_PURE int count() const {
-#ifdef VC_IMPL_POPCNT
-		return _mm_popcnt_u32(toInt());
-#else
-//X             int tmp1 = _mm_movemask_ps(k[0]);
-//X             int tmp2 = _mm_movemask_ps(k[1]);
-//X             tmp1 = (tmp1 & 5) + ((tmp1 >> 1) & 5);
-//X             tmp2 = (tmp2 & 5) + ((tmp2 >> 1) & 5);
-//X             return (tmp1 & 3) + (tmp2 & 3) + ((tmp1 >> 2) & 3) + ((tmp2 >> 2) & 3);
-            _M128I x = _mm_add_epi32(_mm_srli_epi32(_mm_castps_si128(k[0]), 31),
-                                     _mm_srli_epi32(_mm_castps_si128(k[1]), 31));
-            x = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(0, 1, 2, 3)));
-            x = _mm_add_epi32(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(1, 0, 3, 2)));
-            return _mm_cvtsi128_si32(x);
-#endif
+        Vc_ALWAYS_INLINE Vc_PURE int count() const
+        {
+            return Detail::mask_count<Size>(dataI());
         }
 
+        /**
+         * Returns the index of the first one in the mask.
+         *
+         * The return value is undefined if the mask is empty.
+         */
         Vc_ALWAYS_INLINE_L Vc_PURE_L int firstOne() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
 
+        template <typename G> static Vc_INTRINSIC_L Mask generate(G &&gen) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vc_PURE_L Mask shifted(int amount) const Vc_INTRINSIC_R Vc_PURE_R;
+
     private:
-#ifdef VC_COMPILE_BENCHMARKS
+#ifdef Vc_COMPILE_BENCHMARKS
     public:
 #endif
-        M256 k;
-};
-
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE int Mask<Size>::firstOne() const
-{
-    const int mask = toInt();
-#ifdef _MSC_VER
-    unsigned long bit;
-    _BitScanForward(&bit, mask);
-#else
-    int bit;
-    __asm__("bsf %1,%0" : "=&r"(bit) : "r"(mask));
-#endif
-    return bit;
-}
-Vc_ALWAYS_INLINE Vc_PURE int Float8Mask::firstOne() const
-{
-    const int mask = toInt();
-#ifdef _MSC_VER
-    unsigned long bit;
-    _BitScanForward(&bit, mask);
-#else
-    int bit;
-    __asm__("bsf %1,%0" : "=&r"(bit) : "r"(mask));
-#endif
-    return bit;
-}
-
-template<unsigned int VectorSize>
-Vc_ALWAYS_INLINE Mask<VectorSize>::Mask(const Float8Mask &m)
-    : k(_mm_castsi128_ps(_mm_packs_epi32(_mm_castps_si128(m.data()[0]), _mm_castps_si128(m.data()[1])))) {}
-
-class Float8GatherMask
-{
-    public:
-        Float8GatherMask(const Mask<8u> &k)   : mask(k.toInt()) {}
-        Float8GatherMask(const Float8Mask &k) : mask(k.toInt()) {}
-        int toInt() const { return mask; }
-    private:
-        const int mask;
+        Storage d;
 };
+template <typename T> constexpr size_t Mask<T, VectorAbi::Sse>::Size;
+template <typename T> constexpr size_t Mask<T, VectorAbi::Sse>::MemoryAlignment;
 
-/**
- * Loop over all set bits in the mask. The iterator variable will be set to the position of the set
- * bits. A mask of e.g. 00011010 would result in the loop being called with the iterator being set to
- * 1, 3, and 4.
- *
- * This allows you to write:
- * \code
- * float_v a = ...;
- * foreach_bit(int i, a < 0.f) {
- *   std::cout << a[i] << "\n";
- * }
- * \endcode
- * The example prints all the values in \p a that are negative, and only those.
- *
- * \param it   The iterator variable. For example "int i".
- * \param mask The mask to iterate over. You can also just write a vector operation that returns a
- *             mask.
- */
-//X #define foreach_bit(it, mask)
-//X     for (int _sse_vector_foreach_inner = 1, ForeachScope _sse_vector_foreach_scope(mask.toInt()), int it = _sse_vector_foreach_scope.bit(); _sse_vector_foreach_inner; --_sse_vector_foreach_inner)
-//X     for (int _sse_vector_foreach_mask = (mask).toInt(), int _sse_vector_foreach_it = _sse_bitscan(mask.toInt());
-//X             _sse_vector_foreach_it > 0;
-//X             _sse_vector_foreach_it = _sse_bitscan_initialized(_sse_vector_foreach_it, mask.data()))
-//X         for (int _sse_vector_foreach_inner = 1, it = _sse_vector_foreach_it; _sse_vector_foreach_inner; --_sse_vector_foreach_inner)
-
-// Operators
-// let binary and/or/xor work for any combination of masks (as long as they have the same sizeof)
-template<unsigned int LSize, unsigned int RSize> Mask<LSize> operator& (const Mask<LSize> &lhs, const Mask<RSize> &rhs) { return _mm_and_ps(lhs.data(), rhs.data()); }
-template<unsigned int LSize, unsigned int RSize> Mask<LSize> operator| (const Mask<LSize> &lhs, const Mask<RSize> &rhs) { return _mm_or_ps (lhs.data(), rhs.data()); }
-template<unsigned int LSize, unsigned int RSize> Mask<LSize> operator^ (const Mask<LSize> &lhs, const Mask<RSize> &rhs) { return _mm_xor_ps(lhs.data(), rhs.data()); }
-
-// binary and/or/xor cannot work with one operand larger than the other
-template<unsigned int Size> void operator& (const Mask<Size> &lhs, const Float8Mask &rhs);
-template<unsigned int Size> void operator| (const Mask<Size> &lhs, const Float8Mask &rhs);
-template<unsigned int Size> void operator^ (const Mask<Size> &lhs, const Float8Mask &rhs);
-template<unsigned int Size> void operator& (const Float8Mask &rhs, const Mask<Size> &lhs);
-template<unsigned int Size> void operator| (const Float8Mask &rhs, const Mask<Size> &lhs);
-template<unsigned int Size> void operator^ (const Float8Mask &rhs, const Mask<Size> &lhs);
-
-// disable logical and/or for incompatible masks
-template<unsigned int LSize, unsigned int RSize> void operator&&(const Mask<LSize> &lhs, const Mask<RSize> &rhs);
-template<unsigned int LSize, unsigned int RSize> void operator||(const Mask<LSize> &lhs, const Mask<RSize> &rhs);
-template<unsigned int Size> void operator&&(const Mask<Size> &lhs, const Float8Mask &rhs);
-template<unsigned int Size> void operator||(const Mask<Size> &lhs, const Float8Mask &rhs);
-template<unsigned int Size> void operator&&(const Float8Mask &rhs, const Mask<Size> &lhs);
-template<unsigned int Size> void operator||(const Float8Mask &rhs, const Mask<Size> &lhs);
-
-// logical and/or for compatible masks
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE Mask<Size> operator&&(const Mask<Size> &lhs, const Mask<Size> &rhs) { return _mm_and_ps(lhs.data(), rhs.data()); }
-template<unsigned int Size> Vc_ALWAYS_INLINE Vc_PURE Mask<Size> operator||(const Mask<Size> &lhs, const Mask<Size> &rhs) { return _mm_or_ps (lhs.data(), rhs.data()); }
-Vc_ALWAYS_INLINE Vc_PURE Mask<8> operator&&(const Float8Mask &rhs, const Mask<8> &lhs) { return static_cast<Mask<8> >(rhs) && lhs; }
-Vc_ALWAYS_INLINE Vc_PURE Mask<8> operator||(const Float8Mask &rhs, const Mask<8> &lhs) { return static_cast<Mask<8> >(rhs) || lhs; }
-Vc_ALWAYS_INLINE Vc_PURE Mask<8> operator&&(const Mask<8> &rhs, const Float8Mask &lhs) { return rhs && static_cast<Mask<8> >(lhs); }
-Vc_ALWAYS_INLINE Vc_PURE Mask<8> operator||(const Mask<8> &rhs, const Float8Mask &lhs) { return rhs || static_cast<Mask<8> >(lhs); }
-
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+}  // namespace Vc
 
-#include "undomacros.h"
+#include "mask.tcc"
 
-#endif // SSE_MASK_H
+#endif // VC_SSE_MASK_H_
diff -Nru vc-0.7.4/sse/mask.tcc vc-1.3.0/sse/mask.tcc
--- vc-0.7.4/sse/mask.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/sse/mask.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,307 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Detail
+{
+/*mask_count{{{*/
+template<> Vc_INTRINSIC Vc_CONST int mask_count<2>(__m128i k)
+{
+    int mask = _mm_movemask_pd(_mm_castsi128_pd(k));
+    return (mask & 1) + (mask >> 1);
+}
+
+template<> Vc_INTRINSIC Vc_CONST int mask_count<4>(__m128i k)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(_mm_movemask_ps(_mm_castsi128_ps(k)));
+#else
+    auto x = _mm_srli_epi32(k, 31);
+    x = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(0, 1, 2, 3)));
+    x = _mm_add_epi32(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(1, 0, 3, 2)));
+    return _mm_cvtsi128_si32(x);
+#endif
+}
+
+template<> Vc_INTRINSIC Vc_CONST int mask_count<8>(__m128i k)
+{
+#ifdef Vc_IMPL_POPCNT
+    return _mm_popcnt_u32(_mm_movemask_epi8(k)) / 2;
+#else
+    auto x = _mm_srli_epi16(k, 15);
+    x = _mm_add_epi16(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(0, 1, 2, 3)));
+    x = _mm_add_epi16(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(0, 1, 2, 3)));
+    x = _mm_add_epi16(x, _mm_shufflelo_epi16(x, _MM_SHUFFLE(2, 3, 0, 1)));
+    return _mm_extract_epi16(x, 0);
+#endif
+}
+
+template<> Vc_INTRINSIC Vc_CONST int mask_count<16>(__m128i k)
+{
+    return Detail::popcnt16(_mm_movemask_epi8(k));
+}
+/*}}}*/
+// mask_to_int/*{{{*/
+template<> Vc_INTRINSIC Vc_CONST int mask_to_int<2>(__m128i k)
+{
+    return _mm_movemask_pd(_mm_castsi128_pd(k));
+}
+template<> Vc_INTRINSIC Vc_CONST int mask_to_int<4>(__m128i k)
+{
+    return _mm_movemask_ps(_mm_castsi128_ps(k));
+}
+template<> Vc_INTRINSIC Vc_CONST int mask_to_int<8>(__m128i k)
+{
+    return _mm_movemask_epi8(_mm_packs_epi16(k, _mm_setzero_si128()));
+}
+template<> Vc_INTRINSIC Vc_CONST int mask_to_int<16>(__m128i k)
+{
+    return _mm_movemask_epi8(k);
+}
+/*}}}*/
+// mask_store/*{{{*/
+template <size_t> Vc_ALWAYS_INLINE void mask_store(__m128i k, bool *mem);
+template <> Vc_ALWAYS_INLINE void mask_store<16>(__m128i k, bool *mem)
+{
+    _mm_store_si128(reinterpret_cast<__m128i *>(mem), _mm_and_si128(k, _mm_set1_epi8(1)));
+}
+template <> Vc_ALWAYS_INLINE void mask_store<8>(__m128i k, bool *mem)
+{
+    k = _mm_srli_epi16(k, 15);
+    const auto k2 = _mm_packs_epi16(k, _mm_setzero_si128());
+#ifdef __x86_64__
+    *reinterpret_cast<MayAlias<int64_t> *>(mem) = _mm_cvtsi128_si64(k2);
+#else
+    _mm_store_sd(reinterpret_cast<MayAlias<double> *>(mem), _mm_castsi128_pd(k2));
+#endif
+}
+template <> Vc_ALWAYS_INLINE void mask_store<4>(__m128i k, bool *mem)
+{
+    *reinterpret_cast<MayAlias<int32_t> *>(mem) = _mm_cvtsi128_si32(
+        _mm_packs_epi16(_mm_srli_epi16(_mm_packs_epi32(k, _mm_setzero_si128()), 15),
+                        _mm_setzero_si128()));
+}
+template <> Vc_ALWAYS_INLINE void mask_store<2>(__m128i k, bool *mem)
+{
+    mem[0] = -SseIntrinsics::extract_epi32<1>(k);
+    mem[1] = -SseIntrinsics::extract_epi32<3>(k);
+}
+/*}}}*/
+// mask_load/*{{{*/
+template<size_t> Vc_ALWAYS_INLINE __m128 mask_load(const bool *mem);
+template<> Vc_ALWAYS_INLINE __m128 mask_load<16>(const bool *mem)
+{
+    return sse_cast<__m128>(_mm_cmpgt_epi8(
+        _mm_load_si128(reinterpret_cast<const __m128i *>(mem)), _mm_setzero_si128()));
+}
+template<> Vc_ALWAYS_INLINE __m128 mask_load<8>(const bool *mem)
+{
+#ifdef __x86_64__
+    __m128i k = _mm_cvtsi64_si128(*reinterpret_cast<const int64_t *>(mem));
+#else
+    __m128i k = _mm_castpd_si128(_mm_load_sd(reinterpret_cast<const double *>(mem)));
+#endif
+    return sse_cast<__m128>(_mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128()));
+}
+template<> Vc_ALWAYS_INLINE __m128 mask_load<4>(const bool *mem)
+{
+    __m128i k = _mm_cvtsi32_si128(*reinterpret_cast<const int *>(mem));
+    k = _mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128());
+    return sse_cast<__m128>(_mm_unpacklo_epi16(k, k));
+}
+template<> Vc_ALWAYS_INLINE __m128 mask_load<2>(const bool *mem)
+{
+    return sse_cast<__m128>(
+        _mm_set_epi32(-int(mem[1]), -int(mem[1]), -int(mem[0]), -int(mem[0])));
+}
+/*}}}*/
+// is_equal{{{
+template <> Vc_INTRINSIC Vc_CONST bool is_equal<2>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_pd(_mm_castps_pd(k1)) == _mm_movemask_pd(_mm_castps_pd(k2));
+}
+template <> Vc_INTRINSIC Vc_CONST bool is_not_equal<2>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_pd(_mm_castps_pd(k1)) != _mm_movemask_pd(_mm_castps_pd(k2));
+}
+
+template <> Vc_INTRINSIC Vc_CONST bool is_equal<4>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_ps(k1) == _mm_movemask_ps(k2);
+}
+template <> Vc_INTRINSIC Vc_CONST bool is_not_equal<4>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_ps(k1) != _mm_movemask_ps(k2);
+}
+
+template <> Vc_INTRINSIC Vc_CONST bool is_equal<8>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_epi8(_mm_castps_si128(k1)) ==
+           _mm_movemask_epi8(_mm_castps_si128(k2));
+}
+template <> Vc_INTRINSIC Vc_CONST bool is_not_equal<8>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_epi8(_mm_castps_si128(k1)) !=
+           _mm_movemask_epi8(_mm_castps_si128(k2));
+}
+
+template <> Vc_INTRINSIC Vc_CONST bool is_equal<16>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_epi8(_mm_castps_si128(k1)) ==
+           _mm_movemask_epi8(_mm_castps_si128(k2));
+}
+template <> Vc_INTRINSIC Vc_CONST bool is_not_equal<16>(__m128 k1, __m128 k2)
+{
+    return _mm_movemask_epi8(_mm_castps_si128(k1)) !=
+           _mm_movemask_epi8(_mm_castps_si128(k2));
+}
+
+// }}}
+}  // namespace Detail
+
+template<> Vc_ALWAYS_INLINE void SSE::double_m::store(bool *mem) const
+{
+    typedef uint16_t boolAlias Vc_MAY_ALIAS;
+    boolAlias *ptr = reinterpret_cast<boolAlias *>(mem);
+    *ptr = _mm_movemask_epi8(dataI()) & 0x0101;
+}
+template<typename T> Vc_ALWAYS_INLINE void Mask<T, VectorAbi::Sse>::store(bool *mem) const
+{
+    Detail::mask_store<Size>(dataI(), mem);
+}
+template<> Vc_ALWAYS_INLINE void SSE::double_m::load(const bool *mem)
+{
+    d.set(0, MaskBool(mem[0]));
+    d.set(1, MaskBool(mem[1]));
+}
+template <typename T> Vc_ALWAYS_INLINE void Mask<T, VectorAbi::Sse>::load(const bool *mem)
+{
+    d.v() = sse_cast<VectorType>(Detail::mask_load<Size>(mem));
+}
+
+// get / operator[] {{{1
+template <>
+Vc_INTRINSIC Vc_PURE bool SSE::short_m::get(const SSE::short_m &m, int index) noexcept
+{
+    return m.shiftMask() & (1 << 2 * index);
+}
+template <>
+Vc_INTRINSIC Vc_PURE bool SSE::ushort_m::get(const SSE::ushort_m &m, int index) noexcept
+{
+    return m.shiftMask() & (1 << 2 * index);
+}
+
+// firstOne {{{1
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE int Mask<T, VectorAbi::Sse>::firstOne() const
+{
+    const int mask = toInt();
+#ifdef _MSC_VER
+    unsigned long bit;
+    _BitScanForward(&bit, mask);
+#else
+    int bit;
+    __asm__("bsf %1,%0" : "=&r"(bit) : "r"(mask));
+#endif
+    return bit;
+}
+
+// generate {{{1
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 2>)
+{
+    return _mm_set_epi64x(gen(1) ? 0xffffffffffffffffull : 0,
+                          gen(0) ? 0xffffffffffffffffull : 0);
+}
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 4>)
+{
+    return _mm_setr_epi32(gen(0) ? 0xfffffffful : 0, gen(1) ? 0xfffffffful : 0,
+                          gen(2) ? 0xfffffffful : 0, gen(3) ? 0xfffffffful : 0);
+}
+template <typename M, typename G>
+Vc_INTRINSIC M generate_impl(G &&gen, std::integral_constant<int, 8>)
+{
+    return _mm_setr_epi16(gen(0) ? 0xffffu : 0, gen(1) ? 0xffffu : 0,
+                          gen(2) ? 0xffffu : 0, gen(3) ? 0xffffu : 0,
+                          gen(4) ? 0xffffu : 0, gen(5) ? 0xffffu : 0,
+                          gen(6) ? 0xffffu : 0, gen(7) ? 0xffffu : 0);
+}
+template <typename T>
+template <typename G>
+Vc_INTRINSIC Mask<T, VectorAbi::Sse> Mask<T, VectorAbi::Sse>::generate(G &&gen)
+{
+    return generate_impl<Mask<T, VectorAbi::Sse>>(std::forward<G>(gen),
+                                  std::integral_constant<int, Size>());
+}
+// shifted {{{1
+template <typename T> Vc_INTRINSIC Vc_PURE Mask<T, VectorAbi::Sse> Mask<T, VectorAbi::Sse>::shifted(int amount) const
+{
+    switch (amount * int(sizeof(VectorEntryType))) {
+    case   0: return *this;
+    case   1: return Detail::shifted<  1>(dataI());
+    case   2: return Detail::shifted<  2>(dataI());
+    case   3: return Detail::shifted<  3>(dataI());
+    case   4: return Detail::shifted<  4>(dataI());
+    case   5: return Detail::shifted<  5>(dataI());
+    case   6: return Detail::shifted<  6>(dataI());
+    case   7: return Detail::shifted<  7>(dataI());
+    case   8: return Detail::shifted<  8>(dataI());
+    case   9: return Detail::shifted<  9>(dataI());
+    case  10: return Detail::shifted< 10>(dataI());
+    case  11: return Detail::shifted< 11>(dataI());
+    case  12: return Detail::shifted< 12>(dataI());
+    case  13: return Detail::shifted< 13>(dataI());
+    case  14: return Detail::shifted< 14>(dataI());
+    case  15: return Detail::shifted< 15>(dataI());
+    case  16: return Detail::shifted< 16>(dataI());
+    case  -1: return Detail::shifted< -1>(dataI());
+    case  -2: return Detail::shifted< -2>(dataI());
+    case  -3: return Detail::shifted< -3>(dataI());
+    case  -4: return Detail::shifted< -4>(dataI());
+    case  -5: return Detail::shifted< -5>(dataI());
+    case  -6: return Detail::shifted< -6>(dataI());
+    case  -7: return Detail::shifted< -7>(dataI());
+    case  -8: return Detail::shifted< -8>(dataI());
+    case  -9: return Detail::shifted< -9>(dataI());
+    case -10: return Detail::shifted<-10>(dataI());
+    case -11: return Detail::shifted<-11>(dataI());
+    case -12: return Detail::shifted<-12>(dataI());
+    case -13: return Detail::shifted<-13>(dataI());
+    case -14: return Detail::shifted<-14>(dataI());
+    case -15: return Detail::shifted<-15>(dataI());
+    case -16: return Detail::shifted<-16>(dataI());
+    }
+    return Zero();
+}
+// }}}1
+
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/math.h vc-1.3.0/sse/math.h
--- vc-0.7.4/sse/math.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/math.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,217 +1,212 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_MATH_H
-#define VC_SSE_MATH_H
+#ifndef VC_SSE_MATH_H_
+#define VC_SSE_MATH_H_
 
 #include "const.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
+// copysign {{{1
+Vc_INTRINSIC Vc_CONST SSE::float_v copysign(SSE::float_v mag, SSE::float_v sign)
 {
-    /**
-     * splits \p v into exponent and mantissa, the sign is kept with the mantissa
-     *
-     * The return value will be in the range [0.5, 1.0[
-     * The \p e value will be an integer defining the power-of-two exponent
-     */
-    inline double_v frexp(const double_v &v, int_v *e) {
-        const __m128i exponentBits = Const<double>::exponentMask().dataI();
-        const __m128i exponentPart = _mm_and_si128(_mm_castpd_si128(v.data()), exponentBits);
-        *e = _mm_sub_epi32(_mm_srli_epi64(exponentPart, 52), _mm_set1_epi32(0x3fe));
-        const __m128d exponentMaximized = _mm_or_pd(v.data(), _mm_castsi128_pd(exponentBits));
-        double_v ret = _mm_and_pd(exponentMaximized, _mm_load_pd(reinterpret_cast<const double *>(&c_general::frexpMask[0])));
-        double_m zeroMask = v == double_v::Zero();
-        ret(isnan(v) || !isfinite(v) || zeroMask) = v;
-        e->setZero(zeroMask.data());
-        return ret;
-    }
-    inline float_v frexp(const float_v &v, int_v *e) {
-        const __m128i exponentBits = Const<float>::exponentMask().dataI();
-        const __m128i exponentPart = _mm_and_si128(_mm_castps_si128(v.data()), exponentBits);
-        *e = _mm_sub_epi32(_mm_srli_epi32(exponentPart, 23), _mm_set1_epi32(0x7e));
-        const __m128 exponentMaximized = _mm_or_ps(v.data(), _mm_castsi128_ps(exponentBits));
-        float_v ret = _mm_and_ps(exponentMaximized, _mm_castsi128_ps(_mm_set1_epi32(0xbf7fffffu)));
-        ret(isnan(v) || !isfinite(v) || v == float_v::Zero()) = v;
-        e->setZero(v == float_v::Zero());
-        return ret;
-    }
-    inline sfloat_v frexp(const sfloat_v &v, short_v *e) {
-        const __m128i exponentBits = Const<float>::exponentMask().dataI();
-        const __m128i exponentPart0 = _mm_and_si128(_mm_castps_si128(v.data()[0]), exponentBits);
-        const __m128i exponentPart1 = _mm_and_si128(_mm_castps_si128(v.data()[1]), exponentBits);
-        *e = _mm_sub_epi16(_mm_packs_epi32(_mm_srli_epi32(exponentPart0, 23), _mm_srli_epi32(exponentPart1, 23)),
-                _mm_set1_epi16(0x7e));
-        const __m128 exponentMaximized0 = _mm_or_ps(v.data()[0], _mm_castsi128_ps(exponentBits));
-        const __m128 exponentMaximized1 = _mm_or_ps(v.data()[1], _mm_castsi128_ps(exponentBits));
-        sfloat_v ret = M256::create(
-                _mm_and_ps(exponentMaximized0, _mm_castsi128_ps(_mm_set1_epi32(0xbf7fffffu))),
-                _mm_and_ps(exponentMaximized1, _mm_castsi128_ps(_mm_set1_epi32(0xbf7fffffu)))
-                );
-        sfloat_m zeroMask = v == sfloat_v::Zero();
-        ret(isnan(v) || !isfinite(v) || zeroMask) = v;
-        e->setZero(static_cast<short_m>(zeroMask));
-        return ret;
-    }
+    return _mm_or_ps(_mm_and_ps(sign.data(), SSE::_mm_setsignmask_ps()),
+                     _mm_and_ps(mag.data(), SSE::_mm_setabsmask_ps()));
+}
+Vc_INTRINSIC Vc_CONST SSE::double_v copysign(SSE::double_v mag, SSE::double_v sign)
+{
+    return _mm_or_pd(_mm_and_pd(sign.data(), SSE::_mm_setsignmask_pd()),
+                     _mm_and_pd(mag.data(), SSE::_mm_setabsmask_pd()));
+}
+
+//}}}1
+
+/**
+ * splits \p v into exponent and mantissa, the sign is kept with the mantissa
+ *
+ * The return value will be in the range [0.5, 1.0[
+ * The \p e value will be an integer defining the power-of-two exponent
+ */
+inline SSE::double_v frexp(const SSE::double_v &v,
+                           SimdArray<int, 2, Scalar::int_v, 1> *e)
+{
+    const __m128i exponentBits = SSE::Const<double>::exponentMask().dataI();
+    const __m128i exponentPart = _mm_and_si128(_mm_castpd_si128(v.data()), exponentBits);
+    SSE::int_v exponent =
+        _mm_sub_epi32(_mm_srli_epi64(exponentPart, 52), _mm_set1_epi32(0x3fe));
+    const __m128d exponentMaximized = _mm_or_pd(v.data(), _mm_castsi128_pd(exponentBits));
+    SSE::double_v ret = _mm_and_pd(
+        exponentMaximized,
+        _mm_load_pd(reinterpret_cast<const double *>(&SSE::c_general::frexpMask[0])));
+    SSE::double_m zeroMask = v == SSE::double_v::Zero();
+    ret(isnan(v) || !isfinite(v) || zeroMask) = v;
+    exponent.setZero(zeroMask.data());
+    (*e)[0] = exponent[0];
+    (*e)[1] = exponent[2];
+    return ret;
+}
+inline SSE::float_v frexp(const SSE::float_v &v, SimdArray<int, 4, SSE::int_v, 4> *e)
+{
+    const __m128i exponentBits = SSE::Const<float>::exponentMask().dataI();
+    const __m128i exponentPart = _mm_and_si128(_mm_castps_si128(v.data()), exponentBits);
+    internal_data(*e) =
+        _mm_sub_epi32(_mm_srli_epi32(exponentPart, 23), _mm_set1_epi32(0x7e));
+    const __m128 exponentMaximized = _mm_or_ps(v.data(), _mm_castsi128_ps(exponentBits));
+    SSE::float_v ret =
+        _mm_and_ps(exponentMaximized, _mm_castsi128_ps(_mm_set1_epi32(0xbf7fffffu)));
+    ret(isnan(v) || !isfinite(v) || v == SSE::float_v::Zero()) = v;
+    e->setZero(v == SSE::float_v::Zero());
+    return ret;
+}
+
+/*             -> x * 2^e
+ * x == NaN    -> NaN
+ * x == (-)inf -> (-)inf
+ */
+inline SSE::double_v ldexp(SSE::double_v::AsArg v,
+                           const SimdArray<int, 2, Scalar::int_v, 1> &_e)
+{
+    SSE::int_v e = _mm_setr_epi32(_e[0], 0, _e[1], 0);
+    e.setZero((v == SSE::double_v::Zero()).dataI());
+    const __m128i exponentBits = _mm_slli_epi64(e.data(), 52);
+    return _mm_castsi128_pd(_mm_add_epi64(_mm_castpd_si128(v.data()), exponentBits));
+}
+inline SSE::float_v ldexp(SSE::float_v::AsArg v,
+                          const SimdArray<int, 4, SSE::int_v, 4> &_e)
+{
+    SSE::int_v e = internal_data(_e);
+    e.setZero(simd_cast<SSE::int_m>(v == SSE::float_v::Zero()));
+    return reinterpret_components_cast<SSE::float_v>(
+        reinterpret_components_cast<SSE::int_v>(v) + (e << 23));
+}
+
+#ifdef Vc_IMPL_SSE4_1
+inline SSE::double_v trunc(SSE::double_v::AsArg v) { return _mm_round_pd(v.data(), 0x3); }
+inline SSE::float_v trunc(SSE::float_v::AsArg v) { return _mm_round_ps(v.data(), 0x3); }
 
-    /*             -> x * 2^e
-     * x == NaN    -> NaN
-     * x == (-)inf -> (-)inf
-     */
-    inline double_v ldexp(double_v::AsArg v, int_v::AsArg _e) {
-        int_v e = _e;
-        e.setZero((v == double_v::Zero()).dataI());
-        const __m128i exponentBits = _mm_slli_epi64(e.data(), 52);
-        return _mm_castsi128_pd(_mm_add_epi64(_mm_castpd_si128(v.data()), exponentBits));
-    }
-    inline float_v ldexp(float_v::AsArg v, int_v::AsArg _e) {
-        int_v e = _e;
-        e.setZero(static_cast<int_m>(v == float_v::Zero()));
-        return (v.reinterpretCast<int_v>() + (e << 23)).reinterpretCast<float_v>();
-    }
-    inline sfloat_v ldexp(sfloat_v::AsArg v, short_v::AsArg _e) {
-        short_v e = _e;
-        e.setZero(static_cast<short_m>(v == sfloat_v::Zero()));
-        e <<= (23 - 16);
-        const __m128i exponentBits0 = _mm_unpacklo_epi16(_mm_setzero_si128(), e.data());
-        const __m128i exponentBits1 = _mm_unpackhi_epi16(_mm_setzero_si128(), e.data());
-        return M256::create(_mm_castsi128_ps(_mm_add_epi32(_mm_castps_si128(v.data()[0]), exponentBits0)),
-                _mm_castsi128_ps(_mm_add_epi32(_mm_castps_si128(v.data()[1]), exponentBits1)));
-    }
+inline SSE::double_v floor(SSE::double_v::AsArg v) { return _mm_floor_pd(v.data()); }
+inline SSE::float_v floor(SSE::float_v::AsArg v) { return _mm_floor_ps(v.data()); }
 
-#ifdef VC_IMPL_SSE4_1
-    inline double_v trunc(double_v::AsArg v) { return _mm_round_pd(v.data(), 0x3); }
-    inline float_v trunc(float_v::AsArg v) { return _mm_round_ps(v.data(), 0x3); }
-    inline sfloat_v trunc(sfloat_v::AsArg v) { return M256::create(_mm_round_ps(v.data()[0], 0x3),
-            _mm_round_ps(v.data()[1], 0x3)); }
-
-    inline double_v floor(double_v::AsArg v) { return _mm_floor_pd(v.data()); }
-    inline float_v floor(float_v::AsArg v) { return _mm_floor_ps(v.data()); }
-    inline sfloat_v floor(sfloat_v::AsArg v) { return M256::create(_mm_floor_ps(v.data()[0]),
-            _mm_floor_ps(v.data()[1])); }
-
-    inline double_v ceil(double_v::AsArg v) { return _mm_ceil_pd(v.data()); }
-    inline float_v ceil(float_v::AsArg v) { return _mm_ceil_ps(v.data()); }
-    inline sfloat_v ceil(sfloat_v::AsArg v) { return M256::create(_mm_ceil_ps(v.data()[0]),
-            _mm_ceil_ps(v.data()[1])); }
+inline SSE::double_v ceil(SSE::double_v::AsArg v) { return _mm_ceil_pd(v.data()); }
+inline SSE::float_v ceil(SSE::float_v::AsArg v) { return _mm_ceil_ps(v.data()); }
 #else
-    static inline void floor_shift(float_v &v, float_v::AsArg e)
-    {
-        int_v x = _mm_setallone_si128();
-        x <<= 23;
-        x >>= static_cast<int_v>(e);
-        v &= x.reinterpretCast<float_v>();
-    }
-
-    static inline void floor_shift(sfloat_v &v, sfloat_v::AsArg e)
-    {
-        int_v x = _mm_setallone_si128();
-        x <<= 23;
-        int_v y = x;
-        x >>= _mm_cvttps_epi32(e.data()[0]);
-        y >>= _mm_cvttps_epi32(e.data()[1]);
-        v.data()[0] = _mm_and_ps(v.data()[0], _mm_castsi128_ps(x.data()));
-        v.data()[1] = _mm_and_ps(v.data()[1], _mm_castsi128_ps(y.data()));
-    }
+namespace Detail
+{
+static inline void floor_shift(SSE::float_v &v, SSE::float_v::AsArg e)
+{
+    SSE::int_v x = SSE::_mm_setallone_si128();
+    x <<= 23;
+    x >>= simd_cast<SSE::int_v>(e);
+    v = Detail::operator&(v, reinterpret_components_cast<SSE::float_v>(x));
+}
 
-    static inline void floor_shift(double_v &v, double_v::AsArg e)
+static inline void floor_shift(SSE::double_v &v, SSE::double_v::AsArg e)
+{
+    const long long initialMask = 0xfff0000000000000ull;
+    const SSE::uint_v shifts = simd_cast<SSE::uint_v>(e);
+    union d_ll
     {
-        const long long initialMask = 0xfff0000000000000ull;
-        const uint_v shifts = static_cast<uint_v>(e);
-        union d_ll {
-            long long ll;
-            double d;
-        };
-        d_ll mask0 = { initialMask >> shifts[0] };
-        d_ll mask1 = { initialMask >> shifts[1] };
-        v &= double_v(_mm_setr_pd(mask0.d, mask1.d));
-    }
+        long long ll;
+        double d;
+    };
+    d_ll mask0 = {initialMask >> shifts[0]};
+    d_ll mask1 = {initialMask >> shifts[1]};
+    v = Detail::operator&(v, SSE::double_v(_mm_setr_pd(mask0.d, mask1.d)));
+}
+}  // namespace Detail
 
-    template<typename T>
-    inline Vector<T> trunc(VC_ALIGNED_PARAMETER(Vector<T>) _v) {
-        typedef Vector<T> V;
+template <typename T> inline SSE::Vector<T> trunc(SSE::Vector<T> _v)
+{
+        typedef SSE::Vector<T> V;
         typedef typename V::Mask M;
 
         V v = _v;
-        V e = abs(v).exponent();
+        V e = exponent(abs(v));
         const M negativeExponent = e < 0;
         e.setZero(negativeExponent);
         //const M negativeInput = v < V::Zero();
 
-        floor_shift(v, e);
+        Detail::floor_shift(v, e);
 
         v.setZero(negativeExponent);
         //v(negativeInput && _v != v) -= V::One();
         return v;
     }
 
-    template<typename T>
-    inline Vector<T> floor(VC_ALIGNED_PARAMETER(Vector<T>) _v) {
-        typedef Vector<T> V;
+template <typename T> inline SSE::Vector<T> floor(SSE::Vector<T> _v)
+{
+        typedef SSE::Vector<T> V;
         typedef typename V::Mask M;
 
         V v = _v;
-        V e = abs(v).exponent();
+        V e = exponent(abs(v));
         const M negativeExponent = e < 0;
         e.setZero(negativeExponent);
         const M negativeInput = v < V::Zero();
 
-        floor_shift(v, e);
+        Detail::floor_shift(v, e);
 
         v.setZero(negativeExponent);
         v(negativeInput && _v != v) -= V::One();
         return v;
     }
 
-    template<typename T>
-    inline Vector<T> ceil(VC_ALIGNED_PARAMETER(Vector<T>) _v) {
-        typedef Vector<T> V;
+template <typename T> inline SSE::Vector<T> ceil(SSE::Vector<T> _v)
+{
+        typedef SSE::Vector<T> V;
         typedef typename V::Mask M;
 
         V v = _v;
-        V e = abs(v).exponent();
+        V e = exponent(abs(v));
         const M negativeExponent = e < 0;
         e.setZero(negativeExponent);
         const M positiveInput = v > V::Zero();
 
-        floor_shift(v, e);
+        Detail::floor_shift(v, e);
 
         v.setZero(negativeExponent);
         v(positiveInput && _v != v) += V::One();
         return v;
     }
 #endif
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
-
-#define VC__USE_NAMESPACE SSE
-#include "../common/trigonometric.h"
-#define VC__USE_NAMESPACE SSE
-#include "../common/logarithm.h"
-#define VC__USE_NAMESPACE SSE
-#include "../common/exponential.h"
-#undef VC__USE_NAMESPACE
+// fma {{{1
+template <typename T>
+Vc_ALWAYS_INLINE Vector<T, VectorAbi::Sse> fma(Vector<T, VectorAbi::Sse> a,
+                                               Vector<T, VectorAbi::Sse> b,
+                                               Vector<T, VectorAbi::Sse> c)
+{
+    SSE::VectorHelper<T>::fma(a.data(), b.data(), c.data());
+    return a;
+}
+// }}}1
+}  // namespace Vc
+
+#endif // VC_SSE_MATH_H_
 
-#endif // VC_SSE_MATH_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/prefetches.tcc vc-1.3.0/sse/prefetches.tcc
--- vc-0.7.4/sse/prefetches.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/prefetches.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,58 +1,62 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+#ifndef VC_SSE_PREFETCHES_TCC_
+#define VC_SSE_PREFETCHES_TCC_
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_PREFETCHES_TCC
-#define VC_SSE_PREFETCHES_TCC
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace Internal
+namespace Detail
 {
-
-Vc_ALWAYS_INLINE void HelperImpl<Vc::SSE2Impl>::prefetchForOneRead(const void *addr)
+Vc_ALWAYS_INLINE void prefetchForOneRead(const void *addr, VectorAbi::Sse)
 {
     _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_NTA);
 }
-Vc_ALWAYS_INLINE void HelperImpl<Vc::SSE2Impl>::prefetchClose(const void *addr)
+Vc_ALWAYS_INLINE void prefetchClose(const void *addr, VectorAbi::Sse)
 {
     _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
 }
-Vc_ALWAYS_INLINE void HelperImpl<Vc::SSE2Impl>::prefetchMid(const void *addr)
+Vc_ALWAYS_INLINE void prefetchMid(const void *addr, VectorAbi::Sse)
 {
     _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T1);
 }
-Vc_ALWAYS_INLINE void HelperImpl<Vc::SSE2Impl>::prefetchFar(const void *addr)
+Vc_ALWAYS_INLINE void prefetchFar(const void *addr, VectorAbi::Sse)
 {
     _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T2);
 }
-Vc_ALWAYS_INLINE void HelperImpl<Vc::SSE2Impl>::prefetchForModify(const void *addr)
+Vc_ALWAYS_INLINE void prefetchForModify(const void *addr, VectorAbi::Sse)
 {
-#if defined(__3dNOW__) && (!defined(VC_CLANG) || VC_CLANG >= 0x30200)
+#ifdef __3dNOW__
     _m_prefetchw(const_cast<void *>(addr));
 #else
     _mm_prefetch(static_cast<char *>(const_cast<void *>(addr)), _MM_HINT_T0);
 #endif
 }
+}  // namespace Detail
+}  // namespace Vc
 
-} // namespace Internal
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#endif // VC_SSE_PREFETCHES_TCC
+#endif // VC_SSE_PREFETCHES_TCC_
diff -Nru vc-0.7.4/sse/shuffle.h vc-1.3.0/sse/shuffle.h
--- vc-0.7.4/sse/shuffle.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/shuffle.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,124 +1,138 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_SHUFFLE_H
-#define VC_SSE_SHUFFLE_H
+#ifndef VC_SSE_SHUFFLE_H_
+#define VC_SSE_SHUFFLE_H_
 
+#include "intrinsics.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
     enum VecPos {
         X0, X1, X2, X3, X4, X5, X6, X7,
-        Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7
+        Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7,
+        Const0
     };
 
-    namespace Mem
-    {
+namespace Mem
+{
         // shuffle<X1, X2, Y0, Y2>([x0 x1 x2 x3], [y0 y1 y2 y3]) = [x1 x2 y0 y2]
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128 Vc_CONST shuffle(__m128 x, __m128 y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm_shuffle_ps(x, y, Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64);
         }
 
         // shuffle<X1, Y0>([x0 x1], [y0 y1]) = [x1 y0]
         template<VecPos Dst0, VecPos Dst1> static Vc_ALWAYS_INLINE __m128d Vc_CONST shuffle(__m128d x, __m128d y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X1 && Dst1 <= Y1, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= Y0, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= Y1, "Incorrect_Range");
             return _mm_shuffle_pd(x, y, Dst0 + (Dst1 - Y0) * 2);
         }
 
-#if !defined(VC_IMPL_SSE4_1) && !defined(VC_IMPL_AVX)
-#define Vc_MAKE_INTRINSIC__(name__) Vc::SSE::_VC_CAT(m,m,_,name__)
-#else
-#define Vc_MAKE_INTRINSIC__(name__) _VC_CAT(_,mm,_,name__)
-#endif
+        // shuffle<X1, X2, Y0, Y2>([x0 x1 x2 x3], [y0 y1 y2 y3]) = [x1 x2 y0 y2]
+        template <VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3>
+        Vc_INTRINSIC Vc_CONST __m128i shuffle(__m128i x, __m128i y)
+        {
+            return _mm_castps_si128(shuffle<Dst0, Dst1, Dst2, Dst3>(_mm_castsi128_ps(x),
+                                                                    _mm_castsi128_ps(y)));
+        }
 
         // blend<X0, Y1>([x0 x1], [y0, y1]) = [x0 y1]
         template<VecPos Dst0, VecPos Dst1> static Vc_ALWAYS_INLINE __m128d Vc_CONST blend(__m128d x, __m128d y) {
-            VC_STATIC_ASSERT(Dst0 == X0 || Dst0 == Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst1 == X1 || Dst1 == Y1, Incorrect_Range);
-            return Vc_MAKE_INTRINSIC__(blend_pd)(x, y, (Dst0 / Y0) + (Dst1 / Y0) * 2);
+            static_assert(Dst0 == X0 || Dst0 == Y0, "Incorrect_Range");
+            static_assert(Dst1 == X1 || Dst1 == Y1, "Incorrect_Range");
+            return Vc::SseIntrinsics::blend_pd<(Dst0 / Y0) + (Dst1 / Y0) * 2>(x, y);
         }
 
         // blend<X0, Y1>([x0 x1], [y0, y1]) = [x0 y1]
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128 Vc_CONST blend(__m128 x, __m128 y) {
-            VC_STATIC_ASSERT(Dst0 == X0 || Dst0 == Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst1 == X1 || Dst1 == Y1, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst2 == X2 || Dst2 == Y2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst3 == X3 || Dst3 == Y3, Incorrect_Range);
-            return Vc_MAKE_INTRINSIC__(blend_ps)(x, y,
-                    (Dst0 / Y0) *  1 + (Dst1 / Y1) *  2 +
-                    (Dst2 / Y2) *  4 + (Dst3 / Y3) *  8);
+            static_assert(Dst0 == X0 || Dst0 == Y0, "Incorrect_Range");
+            static_assert(Dst1 == X1 || Dst1 == Y1, "Incorrect_Range");
+            static_assert(Dst2 == X2 || Dst2 == Y2, "Incorrect_Range");
+            static_assert(Dst3 == X3 || Dst3 == Y3, "Incorrect_Range");
+            return Vc::SseIntrinsics::blend_ps<(Dst0 / Y0) * 1 + (Dst1 / Y1) * 2 +
+                                               (Dst2 / Y2) * 4 + (Dst3 / Y3) * 8>(x, y);
         }
 
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7>
         static Vc_ALWAYS_INLINE __m128i Vc_CONST blend(__m128i x, __m128i y) {
-            VC_STATIC_ASSERT(Dst0 == X0 || Dst0 == Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst1 == X1 || Dst1 == Y1, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst2 == X2 || Dst2 == Y2, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst3 == X3 || Dst3 == Y3, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst4 == X4 || Dst4 == Y4, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst5 == X5 || Dst5 == Y5, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst6 == X6 || Dst6 == Y6, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst7 == X7 || Dst7 == Y7, Incorrect_Range);
-            return Vc_MAKE_INTRINSIC__(blend_epi16)(x, y,
-                    (Dst0 / Y0) *  1 + (Dst1 / Y1) *  2 +
-                    (Dst2 / Y2) *  4 + (Dst3 / Y3) *  8 +
-                    (Dst4 / Y4) * 16 + (Dst5 / Y5) * 32 +
-                    (Dst6 / Y6) * 64 + (Dst7 / Y7) *128
-                    );
+            static_assert(Dst0 == X0 || Dst0 == Y0, "Incorrect_Range");
+            static_assert(Dst1 == X1 || Dst1 == Y1, "Incorrect_Range");
+            static_assert(Dst2 == X2 || Dst2 == Y2, "Incorrect_Range");
+            static_assert(Dst3 == X3 || Dst3 == Y3, "Incorrect_Range");
+            static_assert(Dst4 == X4 || Dst4 == Y4, "Incorrect_Range");
+            static_assert(Dst5 == X5 || Dst5 == Y5, "Incorrect_Range");
+            static_assert(Dst6 == X6 || Dst6 == Y6, "Incorrect_Range");
+            static_assert(Dst7 == X7 || Dst7 == Y7, "Incorrect_Range");
+            return Vc::SseIntrinsics::blend_epi16<
+                (Dst0 / Y0) * 1 + (Dst1 / Y1) * 2 + (Dst2 / Y2) * 4 + (Dst3 / Y3) * 8 +
+                (Dst4 / Y4) * 16 + (Dst5 / Y5) * 32 + (Dst6 / Y6) * 64 +
+                (Dst7 / Y7) * 128>(x, y);
         }
 
         // permute<X1, X2, Y0, Y2>([x0 x1 x2 x3], [y0 y1 y2 y3]) = [x1 x2 y0 y2]
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128 Vc_CONST permute(__m128 x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm_shuffle_ps(x, x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
 
+        template<VecPos Dst0, VecPos Dst1> static Vc_ALWAYS_INLINE Vc_CONST __m128d permute(__m128d x) {
+            static_assert(Dst0 >= X0 && Dst1 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X1 && Dst1 <= X1, "Incorrect_Range");
+            return _mm_shuffle_pd(x, x, Dst0 + Dst1 * 4);
+        }
+
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128i Vc_CONST permute(__m128i x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm_shuffle_epi32(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
 
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128i Vc_CONST permuteLo(__m128i x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm_shufflelo_epi16(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
 
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3> static Vc_ALWAYS_INLINE __m128i Vc_CONST permuteHi(__m128i x) {
-            VC_STATIC_ASSERT(Dst0 >= X4 && Dst1 >= X4 && Dst2 >= X4 && Dst3 >= X4, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X7 && Dst1 <= X7 && Dst2 <= X7 && Dst3 <= X7, Incorrect_Range);
+            static_assert(Dst0 >= X4 && Dst1 >= X4 && Dst2 >= X4 && Dst3 >= X4, "Incorrect_Range");
+            static_assert(Dst0 <= X7 && Dst1 <= X7 && Dst2 <= X7 && Dst3 <= X7, "Incorrect_Range");
             return _mm_shufflehi_epi16(x, (Dst0 - X4) + (Dst1 - X4) * 4 + (Dst2 - X4) * 16 + (Dst3 - X4) * 64);
         }
 
         template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7>
             static Vc_ALWAYS_INLINE __m128i Vc_CONST permute(__m128i x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst4 >= X4 && Dst5 >= X4 && Dst6 >= X4 && Dst7 >= X4, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst4 <= X7 && Dst5 <= X7 && Dst6 <= X7 && Dst7 <= X7, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
+            static_assert(Dst4 >= X4 && Dst5 >= X4 && Dst6 >= X4 && Dst7 >= X4, "Incorrect_Range");
+            static_assert(Dst4 <= X7 && Dst5 <= X7 && Dst6 <= X7 && Dst7 <= X7, "Incorrect_Range");
             if (Dst0 != X0 || Dst1 != X1 || Dst2 != X2 || Dst3 != X3) {
                 x = _mm_shufflelo_epi16(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
             }
@@ -127,10 +141,11 @@
             }
             return x;
         }
-    } // namespace Mem
+}  // namespace Mem
+
     // The shuffles and permutes above use memory ordering. The ones below use register ordering:
-    namespace Reg
-    {
+namespace Reg
+{
         // shuffle<Y2, Y0, X2, X1>([x3 x2 x1 x0], [y3 y2 y1 y0]) = [y2 y0 x2 x1]
         template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128 Vc_CONST shuffle(__m128 x, __m128 y) {
             return Mem::shuffle<Dst0, Dst1, Dst2, Dst3>(x, y);
@@ -143,15 +158,15 @@
 
         // shuffle<X3, X0, X2, X1>([x3 x2 x1 x0]) = [x3 x0 x2 x1]
         template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128i Vc_CONST permute(__m128i x) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, "Incorrect_Range");
             return _mm_shuffle_epi32(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);
         }
 
         // shuffle<Y2, Y0, X2, X1>([x3 x2 x1 x0], [y3 y2 y1 y0]) = [y2 y0 x2 x1]
         template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128i Vc_CONST shuffle(__m128i x, __m128i y) {
-            VC_STATIC_ASSERT(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, Incorrect_Range);
-            VC_STATIC_ASSERT(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, Incorrect_Range);
+            static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, "Incorrect_Range");
+            static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, "Incorrect_Range");
             return _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(x), _mm_castsi128_ps(y), Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64));
         }
 
@@ -163,10 +178,7 @@
         template<VecPos Dst3, VecPos Dst2, VecPos Dst1, VecPos Dst0> static Vc_ALWAYS_INLINE __m128 Vc_CONST blend(__m128 x, __m128 y) {
             return Mem::blend<Dst0, Dst1, Dst2, Dst3>(x, y);
         }
-    } // namespace Reg
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+}  // namespace Reg
+}  // namespace Vc
 
-#endif // VC_SSE_SHUFFLE_H
+#endif // VC_SSE_SHUFFLE_H_
diff -Nru vc-0.7.4/sse/simd_cast_caller.tcc vc-1.3.0/sse/simd_cast_caller.tcc
--- vc-0.7.4/sse/simd_cast_caller.tcc	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/sse/simd_cast_caller.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,47 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef Vc_SSE_SIMD_CAST_CALLER_TCC_
+#define Vc_SSE_SIMD_CAST_CALLER_TCC_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+#if Vc_IS_VERSION_1
+template <typename T>
+template <typename U>
+Vc_INTRINSIC Mask<T, VectorAbi::Sse>::Mask(U &&rhs, Common::enable_if_mask_converts_explicitly<T, U>)
+    : Mask(Vc::simd_cast<Mask>(std::forward<U>(rhs)))
+{
+}
+#endif
+}
+
+#endif  // Vc_SSE_SIMD_CAST_CALLER_TCC_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/simd_cast.h vc-1.3.0/sse/simd_cast.h
--- vc-0.7.4/sse/simd_cast.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/sse/simd_cast.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,907 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SSE_SIMD_CAST_H_
+#define VC_SSE_SIMD_CAST_H_
+
+#include "../common/utility.h"
+#ifdef Vc_IMPL_AVX
+#include "../avx/casts.h"
+#endif
+
+#ifndef VC_SSE_VECTOR_H_
+#error "Vc/sse/vector.h needs to be included before Vc/sse/simd_cast.h"
+#endif
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace SSE
+{
+
+// Declarations: helper macros Vc_SIMD_CAST_[1248] {{{1
+#define Vc_SIMD_CAST_1(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x, enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_2(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_4(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3,                                          \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+#define Vc_SIMD_CAST_8(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(                                                  \
+        from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, from_ x6, from_ x7,  \
+        enable_if<std::is_same<To, to_>::value> = nullarg)
+
+// Declarations: Vector casts without offset {{{1
+// 1 SSE::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_1( float_v,    int_v);
+Vc_SIMD_CAST_1(double_v,    int_v);
+Vc_SIMD_CAST_1(  uint_v,    int_v);
+Vc_SIMD_CAST_1( short_v,    int_v);
+Vc_SIMD_CAST_1(ushort_v,    int_v);
+Vc_SIMD_CAST_1( float_v,   uint_v);
+Vc_SIMD_CAST_1(double_v,   uint_v);
+Vc_SIMD_CAST_1(   int_v,   uint_v);
+Vc_SIMD_CAST_1( short_v,   uint_v);
+Vc_SIMD_CAST_1(ushort_v,   uint_v);
+Vc_SIMD_CAST_1(double_v,  float_v);
+Vc_SIMD_CAST_1(   int_v,  float_v);
+Vc_SIMD_CAST_1(  uint_v,  float_v);
+Vc_SIMD_CAST_1( short_v,  float_v);
+Vc_SIMD_CAST_1(ushort_v,  float_v);
+Vc_SIMD_CAST_1( float_v, double_v);
+Vc_SIMD_CAST_1(   int_v, double_v);
+Vc_SIMD_CAST_1(  uint_v, double_v);
+Vc_SIMD_CAST_1( short_v, double_v);
+Vc_SIMD_CAST_1(ushort_v, double_v);
+Vc_SIMD_CAST_1(   int_v,  short_v);
+Vc_SIMD_CAST_1(  uint_v,  short_v);
+Vc_SIMD_CAST_1( float_v,  short_v);
+Vc_SIMD_CAST_1(double_v,  short_v);
+Vc_SIMD_CAST_1(ushort_v,  short_v);
+Vc_SIMD_CAST_1(   int_v, ushort_v);
+Vc_SIMD_CAST_1(  uint_v, ushort_v);
+Vc_SIMD_CAST_1( float_v, ushort_v);
+Vc_SIMD_CAST_1(double_v, ushort_v);
+Vc_SIMD_CAST_1( short_v, ushort_v);
+
+// 2 SSE::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_2(double_v,    int_v);
+Vc_SIMD_CAST_2(double_v,   uint_v);
+Vc_SIMD_CAST_2(double_v,  float_v);
+Vc_SIMD_CAST_2(   int_v,  short_v);
+Vc_SIMD_CAST_2(  uint_v,  short_v);
+Vc_SIMD_CAST_2( float_v,  short_v);
+Vc_SIMD_CAST_2(double_v,  short_v);
+Vc_SIMD_CAST_2(   int_v, ushort_v);
+Vc_SIMD_CAST_2(  uint_v, ushort_v);
+Vc_SIMD_CAST_2( float_v, ushort_v);
+Vc_SIMD_CAST_2(double_v, ushort_v);
+
+// 3 SSE::Vector to 1 SSE::Vector {{{2
+#define Vc_CAST_(To_)                                                                    \
+    template <typename Return>                                                           \
+    Vc_INTRINSIC Vc_CONST enable_if<std::is_same<Return, To_>::value, Return>
+Vc_CAST_(short_v) simd_cast(double_v a, double_v b, double_v c);
+Vc_CAST_(ushort_v) simd_cast(double_v a, double_v b, double_v c);
+
+// 4 SSE::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_4(double_v,  short_v);
+Vc_SIMD_CAST_4(double_v, ushort_v);
+//}}}2
+}  // namespace SSE
+using SSE::simd_cast;
+
+// 1 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::float_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 2 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::double_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::float_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 3 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::float_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 4 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::float_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::int_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::uint_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 5 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 6 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 7 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// 8 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, SSE::short_v>::value> = nullarg);
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, Scalar::Vector<T> x7,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value> = nullarg);
+
+// SSE::Vector to Scalar::Vector {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To
+simd_cast(SSE::Vector<FromT> x, enable_if<Scalar::is_vector<To>::value> = nullarg);
+
+// helper macros Vc_SIMD_CAST_[1248] {{{1
+#undef Vc_SIMD_CAST_1
+#undef Vc_SIMD_CAST_2
+#undef Vc_SIMD_CAST_4
+#undef Vc_SIMD_CAST_8
+#define Vc_SIMD_CAST_1(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x, enable_if<std::is_same<To, to_>::value>)
+
+#define Vc_SIMD_CAST_2(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1,                               \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#define Vc_SIMD_CAST_4(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3,           \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+#define Vc_SIMD_CAST_8(from_, to_)                                                       \
+    template <typename To>                                                               \
+    Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \
+                                       from_ x5, from_ x6, from_ x7,                     \
+                                       enable_if<std::is_same<To, to_>::value>)
+
+// Vector casts without offset {{{1
+namespace SSE
+{
+// helper functions {{{2
+Vc_INTRINSIC __m128i convert_int32_to_int16(__m128i a, __m128i b)
+{
+    auto tmp0 = _mm_unpacklo_epi16(a, b);        // 0 4 X X 1 5 X X
+    auto tmp1 = _mm_unpackhi_epi16(a, b);        // 2 6 X X 3 7 X X
+    auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);  // 0 2 4 6 X X X X
+    auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);  // 1 3 5 7 X X X X
+    return _mm_unpacklo_epi16(tmp2, tmp3);       // 0 1 2 3 4 5 6 7
+}
+
+// 1 SSE::Vector to 1 SSE::Vector {{{2
+// to int_v {{{3
+Vc_SIMD_CAST_1( float_v,    int_v) { return convert< float, int>(x.data()); }
+Vc_SIMD_CAST_1(double_v,    int_v) { return convert<double, int>(x.data()); }
+Vc_SIMD_CAST_1(  uint_v,    int_v) { return convert<  uint, int>(x.data()); }
+Vc_SIMD_CAST_1( short_v,    int_v) { return convert< short, int>(x.data()); }
+Vc_SIMD_CAST_1(ushort_v,    int_v) { return convert<ushort, int>(x.data()); }
+// to uint_v {{{3
+Vc_SIMD_CAST_1( float_v,   uint_v) { return convert< float, uint>(x.data()); }
+Vc_SIMD_CAST_1(double_v,   uint_v) { return convert<double, uint>(x.data()); }
+Vc_SIMD_CAST_1(   int_v,   uint_v) { return convert<   int, uint>(x.data()); }
+Vc_SIMD_CAST_1( short_v,   uint_v) { return convert< short, uint>(x.data()); }
+Vc_SIMD_CAST_1(ushort_v,   uint_v) { return convert<ushort, uint>(x.data()); }
+// to float_v {{{3
+Vc_SIMD_CAST_1(double_v,  float_v) { return convert<double, float>(x.data()); }
+Vc_SIMD_CAST_1(   int_v,  float_v) { return convert<   int, float>(x.data()); }
+Vc_SIMD_CAST_1(  uint_v,  float_v) { return convert<  uint, float>(x.data()); }
+Vc_SIMD_CAST_1( short_v,  float_v) { return convert< short, float>(x.data()); }
+Vc_SIMD_CAST_1(ushort_v,  float_v) { return convert<ushort, float>(x.data()); }
+// to double_v {{{3
+Vc_SIMD_CAST_1( float_v, double_v) { return convert< float, double>(x.data()); }
+Vc_SIMD_CAST_1(   int_v, double_v) { return convert<   int, double>(x.data()); }
+Vc_SIMD_CAST_1(  uint_v, double_v) { return convert<  uint, double>(x.data()); }
+Vc_SIMD_CAST_1( short_v, double_v) { return convert< short, double>(x.data()); }
+Vc_SIMD_CAST_1(ushort_v, double_v) { return convert<ushort, double>(x.data()); }
+// to short_v {{{3
+/*
+ * §4.7 p3 (integral conversions)
+ *  If the destination type is signed, the value is unchanged if it can be represented in the
+ *  destination type (and bit-field width); otherwise, the value is implementation-defined.
+ *
+ * See also below for the Vc_SIMD_CAST_2
+ *
+ * the alternative, which is probably incorrect for all compilers out there:
+    Vc_SIMD_CAST_1(   int_v,  short_v) { return _mm_packs_epi32(x.data(), _mm_setzero_si128()); }
+    Vc_SIMD_CAST_1(  uint_v,  short_v) { return _mm_packs_epi32(x.data(), _mm_setzero_si128()); }
+    Vc_SIMD_CAST_2(   int_v,  short_v) { return _mm_packs_epi32(x0.data(), x1.data()); }
+    Vc_SIMD_CAST_2(  uint_v,  short_v) { return _mm_packs_epi32(x0.data(), x1.data()); }
+ */
+Vc_SIMD_CAST_1(   int_v,  short_v) { return SSE::convert_int32_to_int16(x.data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1(  uint_v,  short_v) { return SSE::convert_int32_to_int16(x.data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1( float_v,  short_v) { return _mm_packs_epi32(simd_cast<SSE::int_v>(x).data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1(double_v,  short_v) { return _mm_packs_epi32(simd_cast<SSE::int_v>(x).data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1(ushort_v,  short_v) { return x.data(); }
+// to ushort_v {{{3
+Vc_SIMD_CAST_1(   int_v, ushort_v) { return SSE::convert_int32_to_int16(x.data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1(  uint_v, ushort_v) { return SSE::convert_int32_to_int16(x.data(), _mm_setzero_si128()); }
+Vc_SIMD_CAST_1( float_v, ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE::int_v>(x)); }
+Vc_SIMD_CAST_1(double_v, ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE::int_v>(x)); }
+Vc_SIMD_CAST_1( short_v, ushort_v) { return x.data(); }
+// 2 SSE::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_2(double_v,    int_v) {
+#ifdef Vc_IMPL_AVX
+    return AVX::convert<double, int>(AVX::concat(x0.data(), x1.data()));
+#else
+    return _mm_unpacklo_epi64(convert<double, int>(x0.data()), convert<double, int>(x1.data()));
+#endif
+}
+Vc_SIMD_CAST_2(double_v,   uint_v) {
+#ifdef Vc_IMPL_AVX
+    return AVX::convert<double, uint>(AVX::concat(x0.data(), x1.data()));
+#else
+    return _mm_unpacklo_epi64(convert<double, uint>(x0.data()), convert<double, uint>(x1.data()));
+#endif
+}
+Vc_SIMD_CAST_2(double_v,  float_v) {
+#ifdef Vc_IMPL_AVX
+    return _mm256_cvtpd_ps(AVX::concat(x0.data(), x1.data()));
+#else
+    return _mm_movelh_ps(_mm_cvtpd_ps(x0.data()), _mm_cvtpd_ps(x1.data()));
+#endif
+}
+
+Vc_SIMD_CAST_2(   int_v,  short_v) { return SSE::convert_int32_to_int16(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(  uint_v,  short_v) { return SSE::convert_int32_to_int16(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2( float_v,  short_v) { return _mm_packs_epi32(simd_cast<SSE::int_v>(x0).data(), simd_cast<SSE::int_v>(x1).data()); }
+Vc_SIMD_CAST_2(double_v,  short_v) { return _mm_packs_epi32(simd_cast<SSE::int_v>(x0, x1).data(), _mm_setzero_si128()); }
+
+Vc_SIMD_CAST_2(   int_v, ushort_v) { return SSE::convert_int32_to_int16(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2(  uint_v, ushort_v) { return SSE::convert_int32_to_int16(x0.data(), x1.data()); }
+Vc_SIMD_CAST_2( float_v, ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE::int_v>(x0), simd_cast<SSE::int_v>(x1)); }
+Vc_SIMD_CAST_2(double_v, ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE::int_v>(x0, x1)); }
+
+// 3 SSE::Vector to 1 SSE::Vector {{{2
+Vc_CAST_(short_v) simd_cast(double_v a, double_v b, double_v c)
+{
+    return simd_cast<short_v>(simd_cast<int_v>(a, b), simd_cast<int_v>(c));
+}
+Vc_CAST_(ushort_v) simd_cast(double_v a, double_v b, double_v c)
+{
+    return simd_cast<ushort_v>(simd_cast<int_v>(a, b), simd_cast<int_v>(c));
+}
+#undef Vc_CAST_
+
+// 4 SSE::Vector to 1 SSE::Vector {{{2
+Vc_SIMD_CAST_4(double_v,  short_v) { return _mm_packs_epi32(simd_cast<SSE::int_v>(x0, x1).data(), simd_cast<SSE::int_v>(x2, x3).data()); }
+Vc_SIMD_CAST_4(double_v, ushort_v) { return simd_cast<SSE::ushort_v>(simd_cast<SSE::int_v>(x0, x1), simd_cast<SSE::int_v>(x2, x3)); }
+}  // namespace SSE
+
+// 1 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::double_v>::value> )
+{
+    return _mm_setr_pd(x.data(), 0.);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::float_v>::value> )
+{
+    return _mm_setr_ps(x.data(), 0.f, 0.f, 0.f);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::int_v>::value> )
+{
+    return _mm_setr_epi32(x.data(), 0, 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::uint_v>::value> )
+{
+    return _mm_setr_epi32(uint(x.data()), 0, 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::short_v>::value> )
+{
+    return _mm_setr_epi16(
+        x.data(), 0, 0, 0, 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x,
+              enable_if<std::is_same<Return, SSE::ushort_v>::value> )
+{
+    return _mm_setr_epi16(
+        x.data(), 0, 0, 0, 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+
+// 2 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::double_v>::value> )
+{
+    return _mm_setr_pd(x0.data(), x1.data());  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::float_v>::value> )
+{
+    return _mm_setr_ps(x0.data(), x1.data(), 0.f, 0.f);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::int_v>::value> )
+{
+    return _mm_setr_epi32(x0.data(), x1.data(), 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::uint_v>::value> )
+{
+    return _mm_setr_epi32(uint(x0.data()), uint(x1.data()), 0,
+                          0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::short_v>::value> )
+{
+    return _mm_setr_epi16(
+        x0.data(), x1.data(), 0, 0, 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              enable_if<std::is_same<Return, SSE::ushort_v>::value> )
+{
+    return _mm_setr_epi16(
+        x0.data(), x1.data(), 0, 0, 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+
+// 3 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, SSE::float_v>::value>)
+{
+    return _mm_setr_ps(x0.data(), x1.data(), x2.data(), 0.f);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, SSE::int_v>::value>)
+{
+    return _mm_setr_epi32(x0.data(), x1.data(), x2.data(), 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, SSE::uint_v>::value>)
+{
+    return _mm_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                          0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, SSE::short_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0);
+}
+
+// 4 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              enable_if<std::is_same<Return, SSE::float_v>::value> )
+{
+    return _mm_setr_ps(
+        x0.data(), x1.data(), x2.data(), x3.data());  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              enable_if<std::is_same<Return, SSE::int_v>::value> )
+{
+    return _mm_setr_epi32(
+        x0.data(), x1.data(), x2.data(), x3.data());  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              enable_if<std::is_same<Return, SSE::uint_v>::value> )
+{
+    return _mm_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),
+                          uint(x3.data()));  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              enable_if<std::is_same<Return, SSE::short_v>::value> )
+{
+    return _mm_setr_epi16(
+        x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              enable_if<std::is_same<Return, SSE::ushort_v>::value> )
+{
+    return _mm_setr_epi16(
+        x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0);  // FIXME: use register-register mov
+}
+
+// 5 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, SSE::short_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);
+}
+
+// 6 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, SSE::short_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), 0, 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          enable_if<std::is_same<Return, SSE::ushort_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), 0, 0);
+}
+
+// 7 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, enable_if<std::is_same<Return, SSE::short_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), 0);
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+simd_cast(Scalar::Vector<T> x0, Scalar::Vector<T> x1, Scalar::Vector<T> x2,
+          Scalar::Vector<T> x3, Scalar::Vector<T> x4, Scalar::Vector<T> x5,
+          Scalar::Vector<T> x6, enable_if<std::is_same<Return, SSE::ushort_v>::value>)
+{
+    return _mm_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),
+                          x5.data(), x6.data(), 0);
+}
+
+// 8 Scalar::Vector to 1 SSE::Vector {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              Scalar::Vector<T> x4,
+              Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6,
+              Scalar::Vector<T> x7,
+              enable_if<std::is_same<Return, SSE::short_v>::value> )
+{
+    return _mm_setr_epi16(x0.data(),
+                          x1.data(),
+                          x2.data(),
+                          x3.data(),
+                          x4.data(),
+                          x5.data(),
+                          x6.data(),
+                          x7.data());  // FIXME: use register-register mov
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Vector<T> x0,
+              Scalar::Vector<T> x1,
+              Scalar::Vector<T> x2,
+              Scalar::Vector<T> x3,
+              Scalar::Vector<T> x4,
+              Scalar::Vector<T> x5,
+              Scalar::Vector<T> x6,
+              Scalar::Vector<T> x7,
+              enable_if<std::is_same<Return, SSE::ushort_v>::value> )
+{
+    return _mm_setr_epi16(x0.data(),
+                          x1.data(),
+                          x2.data(),
+                          x3.data(),
+                          x4.data(),
+                          x5.data(),
+                          x6.data(),
+                          x7.data());  // FIXME: use register-register mov
+}
+
+// SSE::Vector to Scalar::Vector {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To
+    simd_cast(SSE::Vector<FromT> x, enable_if<Scalar::is_vector<To>::value> )
+{
+    return static_cast<To>(x[0]);
+}
+
+// Mask casts without offset {{{1
+// 1 SSE Mask to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(SSE::Mask<T> x, enable_if<SSE::is_mask<Return>::value> = nullarg)
+{
+    using M = SSE::Mask<T>;
+    return {Detail::mask_cast<M::Size, Return::Size, __m128>(x.dataI())};
+}
+// 2 SSE Masks to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    SSE::Mask<T> x0,
+    SSE::Mask<T> x1,
+    enable_if<SSE::is_mask<Return>::value && Mask<T, VectorAbi::Sse>::Size * 2 == Return::Size> = nullarg)
+{
+    return SSE::sse_cast<__m128>(_mm_packs_epi16(x0.dataI(), x1.dataI()));
+}
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    SSE::Mask<T> x0,
+    SSE::Mask<T> x1,
+    enable_if<SSE::is_mask<Return>::value && Mask<T, VectorAbi::Sse>::Size * 4 == Return::Size> = nullarg)
+{
+    return SSE::sse_cast<__m128>(
+        _mm_packs_epi16(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_setzero_si128()));
+}
+// 4 SSE Masks to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    SSE::Mask<T> x0,
+    SSE::Mask<T> x1,
+    SSE::Mask<T> x2,
+    SSE::Mask<T> x3,
+    enable_if<SSE::is_mask<Return>::value && Mask<T, VectorAbi::Sse>::Size * 4 == Return::Size> = nullarg)
+{
+    return SSE::sse_cast<__m128>(_mm_packs_epi16(_mm_packs_epi16(x0.dataI(), x1.dataI()),
+                                                 _mm_packs_epi16(x2.dataI(), x3.dataI())));
+}
+
+// 1 Scalar Mask to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Mask<T> x, enable_if<SSE::is_mask<Return>::value> = nullarg)
+{
+    Return m(false);
+    m[0] = x[0];
+    return m;
+}
+// 2 Scalar Masks to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(Scalar::Mask<T> x0, Scalar::Mask<T> x1, enable_if<SSE::is_mask<Return>::value> = nullarg)
+{
+    Return m(false);
+    m[0] = x0[0];
+    m[1] = x1[0];
+    return m;
+}
+// 4 Scalar Masks to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(Scalar::Mask<T> x0,
+                                       Scalar::Mask<T> x1,
+                                       Scalar::Mask<T> x2,
+                                       Scalar::Mask<T> x3,
+                                       enable_if<SSE::is_mask<Return>::value> = nullarg)
+{
+    Return m(false);
+    m[0] = x0[0];
+    m[1] = x1[0];
+    if (Return::Size >= 4) {
+        m[2] = x2[0];
+        m[3] = x3[0];
+    }
+    return m;
+}
+// 8 Scalar Masks to 1 SSE Mask {{{2
+template <typename Return, typename T>
+Vc_INTRINSIC Vc_CONST Return simd_cast(Scalar::Mask<T> x0,
+                                       Scalar::Mask<T> x1,
+                                       Scalar::Mask<T> x2,
+                                       Scalar::Mask<T> x3,
+                                       Scalar::Mask<T> x4,
+                                       Scalar::Mask<T> x5,
+                                       Scalar::Mask<T> x6,
+                                       Scalar::Mask<T> x7,
+                                       enable_if<SSE::is_mask<Return>::value> = nullarg)
+{
+    Return m(false);
+    m[0] = x0[0];
+    m[1] = x1[0];
+    if (Return::Size >= 4) {
+        m[2] = x2[0];
+        m[3] = x3[0];
+    }
+    if (Return::Size >= 8) {
+        m[4] = x4[0];
+        m[5] = x5[0];
+        m[6] = x6[0];
+        m[7] = x7[0];
+    }
+    return m;
+}
+
+// 1 SSE::Mask to 1 Scalar::Mask {{{2
+template <typename To, typename FromT>
+Vc_INTRINSIC Vc_CONST To
+    simd_cast(SSE::Mask<FromT> x, enable_if<Scalar::is_mask<To>::value> = nullarg)
+{
+    return static_cast<To>(x[0]);
+}
+// offset == 0 | convert from SSE::Mask/Vector to SSE::Mask/Vector {{{1
+template <typename Return, int offset, typename V>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(V &&x, enable_if<offset == 0 && ((SSE::is_vector<Traits::decay<V>>::value &&
+                                                SSE::is_vector<Return>::value) ||
+                                               (SSE::is_mask<Traits::decay<V>>::value &&
+                                                SSE::is_mask<Return>::value))> = nullarg)
+{
+    return simd_cast<Return>(x);
+}
+
+template <typename Return, int offset, typename V>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(V &&x,
+              enable_if<offset == 0 && ((Scalar::is_vector<Traits::decay<V>>::value &&
+                                         SSE::is_vector<Return>::value) ||
+                                        (Scalar::is_mask<Traits::decay<V>>::value &&
+                                         SSE::is_mask<Return>::value))> = nullarg)
+{
+    return simd_cast<Return>(x);
+}
+
+// Vector casts with offset {{{1
+// SSE to SSE (Vector) {{{2
+template <typename Return, int offset, typename V>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    V x,
+    enable_if<offset != 0 && (SSE::is_vector<Return>::value && SSE::is_vector<V>::value)> = nullarg)
+{
+    constexpr int shift = (sizeof(V) / V::Size) * offset * Return::Size;
+    static_assert(shift > 0 && shift < 16, "");
+    return simd_cast<Return>(V{SSE::sse_cast<typename V::VectorType>(
+        _mm_srli_si128(SSE::sse_cast<__m128i>(x.data()), shift & 0xff))});
+}
+
+// SSE to Scalar (Vector) {{{2
+template <typename Return, int offset, typename T>
+Vc_INTRINSIC Vc_CONST Return
+    simd_cast(SSE::Vector<T> x,
+              enable_if<offset != 0 && Scalar::is_vector<Return>::value> = nullarg)
+{
+    return static_cast<typename Return::EntryType>(x[offset]);
+}
+
+// Mask casts with offset {{{1
+// SSE to SSE (Mask)
+template <typename Return, int offset, typename V>
+Vc_INTRINSIC Vc_CONST Return simd_cast(
+    V x,
+    enable_if<offset != 0 && (SSE::is_mask<Return>::value && SSE::is_mask<V>::value)> = nullarg)
+{
+    constexpr int shift = (sizeof(V) / V::Size) * offset * Return::Size;
+    static_assert(shift > 0 && shift < 16, "");
+    return simd_cast<Return>(V{SSE::sse_cast<typename V::VectorType>(
+        _mm_srli_si128(SSE::sse_cast<__m128i>(x.data()), shift & 0xff))});
+}
+
+// undef Vc_SIMD_CAST_[1248] {{{1
+#undef Vc_SIMD_CAST_1
+#undef Vc_SIMD_CAST_2
+#undef Vc_SIMD_CAST_4
+#undef Vc_SIMD_CAST_8
+// }}}1
+
+}  // namespace Vc
+
+#endif // VC_SSE_SIMD_CAST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/types.h vc-1.3.0/sse/types.h
--- vc-0.7.4/sse/types.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/types.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,163 +1,77 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_TYPES_H
-#define SSE_TYPES_H
-
-#include "intrinsics.h"
-#include "../common/storage.h"
-
-#define VC_DOUBLE_V_SIZE 2
-#define VC_FLOAT_V_SIZE 4
-#define VC_SFLOAT_V_SIZE 8
-#define VC_INT_V_SIZE 4
-#define VC_UINT_V_SIZE 4
-#define VC_SHORT_V_SIZE 8
-#define VC_USHORT_V_SIZE 8
-
-#include "../common/types.h"
-#include "macros.h"
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "../scalar/types.h"
+
+#ifndef VC_SSE_TYPES_H_
+#define VC_SSE_TYPES_H_
+
+#ifdef Vc_DEFAULT_IMPL_SSE
+#define Vc_DOUBLE_V_SIZE 2
+#define Vc_FLOAT_V_SIZE 4
+#define Vc_INT_V_SIZE 4
+#define Vc_UINT_V_SIZE 4
+#define Vc_SHORT_V_SIZE 8
+#define Vc_USHORT_V_SIZE 8
+#endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
-    template<typename T> class Vector;
-    template<typename T> class WriteMaskedVector;
+template <typename T> using Vector = Vc::Vector<T, VectorAbi::Sse>;
+typedef Vector<double>         double_v;
+typedef Vector<float>           float_v;
+typedef Vector<int>               int_v;
+typedef Vector<unsigned int>     uint_v;
+typedef Vector<short>           short_v;
+typedef Vector<unsigned short> ushort_v;
+
+template <typename T> using Mask = Vc::Mask<T, VectorAbi::Sse>;
+typedef Mask<double>         double_m;
+typedef Mask<float>           float_m;
+typedef Mask<int>               int_m;
+typedef Mask<unsigned int>     uint_m;
+typedef Mask<short>           short_m;
+typedef Mask<unsigned short> ushort_m;
+
+template <typename T> struct Const;
+
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace SSE
 
-    // define our own long because on Windows64 long == int while on Linux long == max. register width
-    // since we want to have a type that depends on 32 vs. 64 bit we need to do some special casing on Windows
-#ifdef _WIN64
-    typedef __int64 _long;
-    typedef unsigned __int64 _ulong;
-#else
-    typedef long _long;
-    typedef unsigned long _ulong;
-#endif
-
-
-    class Float8Mask;
-    class Float8GatherMask;
-    template<unsigned int VectorSize> class Mask;
-
-    /*
-     * Hack to create a vector object with 8 floats
-     */
-    typedef Vc::sfloat float8;
-
-    class M256 {
-        public:
-            //Vc_INTRINSIC M256() {}
-            //Vc_INTRINSIC M256(_M128 a, _M128 b) { d[0] = a; d[1] = b; }
-            static Vc_INTRINSIC Vc_CONST M256 dup(_M128 a) { M256 r; r.d[0] = a; r.d[1] = a; return r; }
-            static Vc_INTRINSIC Vc_CONST M256 create(_M128 a, _M128 b) { M256 r; r.d[0] = a; r.d[1] = b; return r; }
-            Vc_INTRINSIC _M128 &operator[](int i) { return d[i]; }
-            Vc_INTRINSIC const _M128 &operator[](int i) const { return d[i]; }
-        private:
-#ifdef VC_COMPILE_BENCHMARKS
-        public:
-#endif
-            _M128 d[2];
-    };
-#ifdef VC_CHECK_ALIGNMENT
-static Vc_ALWAYS_INLINE void assertCorrectAlignment(const M256 *ptr)
+namespace Traits
 {
-    const size_t s = sizeof(__m128);
-    if((reinterpret_cast<size_t>(ptr) & ((s ^ (s & (s - 1))) - 1)) != 0) {
-        fprintf(stderr, "A vector with incorrect alignment has just been created. Look at the stacktrace to find the guilty object.\n");
-        abort();
-    }
-}
-#endif
-
-    template<typename T> struct ParameterHelper {
-        typedef T ByValue;
-        typedef T & Reference;
-        typedef const T & ConstRef;
-    };
-#if defined VC_MSVC && !defined _WIN64
-    // The calling convention on WIN32 can't guarantee alignment.
-    // An exception are the first three arguments, which may be passed in a register.
-    template<> struct ParameterHelper<M256> {
-        typedef const M256 & ByValue;
-        typedef M256 & Reference;
-        typedef const M256 & ConstRef;
-    };
-#endif
-
-    template<typename T> struct VectorHelper {};
-
-    template<unsigned int Size> struct IndexTypeHelper;
-    template<> struct IndexTypeHelper<2u> { typedef unsigned int   Type; };
-    template<> struct IndexTypeHelper<4u> { typedef unsigned int   Type; };
-    template<> struct IndexTypeHelper<8u> { typedef unsigned short Type; };
-    template<> struct IndexTypeHelper<16u>{ typedef unsigned char  Type; };
-
-    template<typename T> struct CtorTypeHelper { typedef T Type; };
-    template<> struct CtorTypeHelper<short> { typedef int Type; };
-    template<> struct CtorTypeHelper<unsigned short> { typedef unsigned int Type; };
-    template<> struct CtorTypeHelper<float> { typedef double Type; };
-
-    template<typename T> struct ExpandTypeHelper { typedef T Type; };
-    template<> struct ExpandTypeHelper<short> { typedef int Type; };
-    template<> struct ExpandTypeHelper<unsigned short> { typedef unsigned int Type; };
-    template<> struct ExpandTypeHelper<float> { typedef double Type; };
-
-    template<typename T> struct VectorTypeHelper { typedef __m128i Type; };
-    template<> struct VectorTypeHelper<double>   { typedef __m128d Type; };
-    template<> struct VectorTypeHelper< float>   { typedef __m128  Type; };
-    template<> struct VectorTypeHelper<sfloat>   { typedef   M256  Type; };
-
-    template<typename T, unsigned int Size> struct DetermineMask { typedef Mask<Size> Type; };
-    template<> struct DetermineMask<sfloat, 8> { typedef Float8Mask Type; };
-
-    template<typename T> struct DetermineGatherMask { typedef T Type; };
-    template<> struct DetermineGatherMask<Float8Mask> { typedef Float8GatherMask Type; };
-
-    template<typename T> struct VectorTraits
-    {
-        typedef typename VectorTypeHelper<T>::Type VectorType;
-        typedef typename DetermineEntryType<T>::Type EntryType;
-        enum Constants {
-            Size = sizeof(VectorType) / sizeof(EntryType),
-            HasVectorDivision = !IsInteger<T>::Value
-        };
-        typedef typename DetermineMask<T, Size>::Type MaskType;
-        typedef typename DetermineGatherMask<MaskType>::Type GatherMaskType;
-        typedef Vector<typename IndexTypeHelper<Size>::Type> IndexType;
-        typedef Common::VectorMemoryUnion<VectorType, EntryType> StorageType;
-    };
-
-    template<typename T> struct VectorHelperSize;
-
-    template<typename V = Vector<float> >
-    class STRUCT_ALIGN1(16) VectorAlignedBaseT
-    {
-        public:
-            FREE_STORE_OPERATORS_ALIGNED(16)
-    } STRUCT_ALIGN2(16);
-
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include "undomacros.h"
+template <typename T> struct is_simd_mask_internal<SSE::Mask<T>> : public std::true_type {};
+template <typename T> struct is_simd_vector_internal<SSE::Vector<T>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace Vc
 
-#endif // SSE_TYPES_H
+#endif // VC_SSE_TYPES_H_
diff -Nru vc-0.7.4/sse/type_traits.h vc-1.3.0/sse/type_traits.h
--- vc-0.7.4/sse/type_traits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/sse/type_traits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_SSE_TYPE_TRAITS_H_
+#define VC_SSE_TYPE_TRAITS_H_
+
+#include "macros.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace SSE
+{
+namespace Traits
+{
+template <typename T> struct is_vector : public std::false_type {};
+template <typename T> struct is_vector<Vector<T>> : public std::true_type {};
+
+template <typename T> struct is_mask : public std::false_type {};
+template <typename T> struct is_mask<Mask<T>> : public std::true_type {};
+}  // namespace Traits
+}  // namespace SSE
+}  // namespace Vc
+
+#endif  // VC_SSE_TYPE_TRAITS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/sse/undomacros.h vc-1.3.0/sse/undomacros.h
--- vc-0.7.4/sse/undomacros.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/undomacros.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,32 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2010 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef VC_SSE_UNDOMACROS_H
-#define VC_SSE_UNDOMACROS_H
-#undef VC_SSE_MACROS_H
-
-#undef STORE_VECTOR
-
-#ifdef VC_USE_PTEST
-#undef VC_USE_PTEST
-#endif
-
-#endif // VC_SSE_UNDOMACROS_H
-
-#include "../common/undomacros.h"
diff -Nru vc-0.7.4/sse/vector.h vc-1.3.0/sse/vector.h
--- vc-0.7.4/sse/vector.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/vector.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,33 +1,45 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_VECTOR_H
-#define SSE_VECTOR_H
+#ifndef VC_SSE_VECTOR_H_
+#define VC_SSE_VECTOR_H_
 
+#include "../scalar/vector.h"
 #include "intrinsics.h"
 #include "types.h"
 #include "vectorhelper.h"
 #include "mask.h"
+#include "../common/writemaskedvector.h"
 #include "../common/aliasingentryhelper.h"
 #include "../common/memoryfwd.h"
+#include "../common/loadstoreflags.h"
 #include <algorithm>
 #include <cmath>
+#include "detail.h"
 
 #include "macros.h"
 
@@ -38,371 +50,219 @@
 #undef isnan
 #endif
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
-namespace SSE
-{
-template<typename T>
-class WriteMaskedVector
-{
-    friend class Vector<T>;
-    typedef typename VectorTraits<T>::MaskType Mask;
-    typedef typename Vector<T>::EntryType EntryType;
-    public:
-        FREE_STORE_OPERATORS_ALIGNED(16)
-        //prefix
-        Vc_INTRINSIC Vector<T> &operator++() {
-            vec->data() = VectorHelper<T>::add(vec->data(),
-                    VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-                    );
-            return *vec;
-        }
-        Vc_INTRINSIC Vector<T> &operator--() {
-            vec->data() = VectorHelper<T>::sub(vec->data(),
-                    VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-                    );
-            return *vec;
-        }
-        //postfix
-        Vc_INTRINSIC Vector<T> operator++(int) {
-            Vector<T> ret(*vec);
-            vec->data() = VectorHelper<T>::add(vec->data(),
-                    VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-                    );
-            return ret;
-        }
-        Vc_INTRINSIC Vector<T> operator--(int) {
-            Vector<T> ret(*vec);
-            vec->data() = VectorHelper<T>::sub(vec->data(),
-                    VectorHelper<T>::notMaskedToZero(VectorHelper<T>::one(), mask.data())
-                    );
-            return ret;
-        }
-
-        Vc_INTRINSIC Vector<T> &operator+=(const Vector<T> &x) {
-            vec->data() = VectorHelper<T>::add(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
-            return *vec;
-        }
-        Vc_INTRINSIC Vector<T> &operator-=(const Vector<T> &x) {
-            vec->data() = VectorHelper<T>::sub(vec->data(), VectorHelper<T>::notMaskedToZero(x.data(), mask.data()));
-            return *vec;
-        }
-        Vc_INTRINSIC Vector<T> &operator*=(const Vector<T> &x) {
-            vec->assign(VectorHelper<T>::mul(vec->data(), x.data()), mask);
-            return *vec;
-        }
-        Vc_INTRINSIC Vector<T> &operator/=(const Vector<T> &x);
-
-        Vc_INTRINSIC Vector<T> &operator+=(EntryType x) {
-            return operator+=(Vector<T>(x));
-        }
-        Vc_INTRINSIC Vector<T> &operator-=(EntryType x) {
-            return operator-=(Vector<T>(x));
-        }
-        Vc_INTRINSIC Vector<T> &operator*=(EntryType x) {
-            return operator*=(Vector<T>(x));
-        }
-        Vc_INTRINSIC Vector<T> &operator/=(EntryType x) {
-            return operator/=(Vector<T>(x));
-        }
-
-        Vc_INTRINSIC Vector<T> &operator=(const Vector<T> &x) {
-            vec->assign(x, mask);
-            return *vec;
-        }
-
-        Vc_INTRINSIC Vector<T> &operator=(EntryType x) {
-            vec->assign(Vector<T>(x), mask);
-            return *vec;
-        }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f) const {
-            return vec->call(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f) const {
-            return vec->call(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
-            return vec->apply(f, mask);
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
-            return vec->apply(f, mask);
-        }
-
-    private:
-        Vc_ALWAYS_INLINE WriteMaskedVector(Vector<T> *v, const Mask &k) : vec(v), mask(k) {}
-        Vector<T> *const vec;
-        Mask mask;
-};
-
-template<typename T> class Vector
+#define Vc_CURRENT_CLASS_NAME Vector
+template <typename T> class Vector<T, VectorAbi::Sse>
 {
-    friend class WriteMaskedVector<T>;
+    static_assert(std::is_arithmetic<T>::value,
+                  "Vector<T> only accepts arithmetic builtin types as template parameter T.");
+
     protected:
-#ifdef VC_COMPILE_BENCHMARKS
+#ifdef Vc_COMPILE_BENCHMARKS
     public:
 #endif
-        typedef typename VectorTraits<T>::StorageType StorageType;
+        typedef typename SSE::VectorTraits<T>::StorageType StorageType;
         StorageType d;
-        typedef typename VectorTraits<T>::GatherMaskType GatherMask;
-        typedef VectorHelper<typename VectorTraits<T>::VectorType> HV;
-        typedef VectorHelper<T> HT;
+        typedef typename SSE::VectorTraits<T>::GatherMaskType GatherMask;
+        typedef SSE::VectorHelper<typename SSE::VectorTraits<T>::VectorType> HV;
+        typedef SSE::VectorHelper<T> HT;
     public:
-        FREE_STORE_OPERATORS_ALIGNED(16)
+        Vc_FREE_STORE_OPERATORS_ALIGNED(16);
 
-        enum Constants { Size = VectorTraits<T>::Size };
-        typedef typename VectorTraits<T>::VectorType VectorType;
-        typedef typename VectorTraits<T>::EntryType EntryType;
-        typedef typename VectorTraits<T>::IndexType IndexType;
-        typedef typename VectorTraits<T>::MaskType Mask;
+        typedef typename SSE::VectorTraits<T>::VectorType VectorType;
+        using vector_type = VectorType;
+        static constexpr size_t Size = SSE::VectorTraits<T>::Size;
+        static constexpr size_t MemoryAlignment = alignof(VectorType);
+        typedef typename SSE::VectorTraits<T>::EntryType EntryType;
+        using value_type = EntryType;
+        using VectorEntryType = EntryType;
+        typedef typename std::conditional<(Size >= 4),
+                                          SimdArray<int, Size, SSE::int_v, 4>,
+                                          SimdArray<int, Size, Scalar::int_v, 1>>::type IndexType;
+        typedef typename SSE::VectorTraits<T>::MaskType Mask;
+        using MaskType = Mask;
+        using mask_type = Mask;
         typedef typename Mask::Argument MaskArg;
-        typedef Vc::Memory<Vector<T>, Size> Memory;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-        typedef const Vector<T> &AsArg;
-#else
-        typedef const Vector<T> AsArg;
-#endif
+        typedef typename Mask::Argument MaskArgument;
+        typedef const Vector AsArg;
+        using abi = VectorAbi::Sse;
+        using WriteMaskedVector = Common::WriteMaskedVector<Vector, Mask>;
+        template <typename U> using V = Vector<U, abi>;
 
-        typedef T _T;
+        using reference = Detail::ElementReference<Vector>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // uninitialized
-        Vc_ALWAYS_INLINE Vector() {}
+#include "../common/generalinterface.h"
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // constants
-        explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerZero::ZEnum) Vc_INTRINSIC_R;
-        explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerOne::OEnum) Vc_INTRINSIC_R;
-        explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerIndexesFromZero::IEnum) Vc_INTRINSIC_R;
-        static Vc_INTRINSIC_L Vector Zero() Vc_INTRINSIC_R;
-        static Vc_INTRINSIC_L Vector One() Vc_INTRINSIC_R;
-        static Vc_INTRINSIC_L Vector IndexesFromZero() Vc_INTRINSIC_R;
         static Vc_INTRINSIC_L Vector Random() Vc_INTRINSIC_R;
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // internal: required to enable returning objects of VectorType
-        Vc_ALWAYS_INLINE Vector(const VectorType &x) : d(x) {}
+        Vc_ALWAYS_INLINE Vector(VectorType x) : d(x) {}
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // static_cast / copy ctor
-        template<typename OtherT> explicit Vc_INTRINSIC_L Vector(const Vector<OtherT> &x) Vc_INTRINSIC_R;
-
-        // implicit cast
-        template<typename OtherT> Vc_INTRINSIC_L Vector &operator=(const Vector<OtherT> &x) Vc_INTRINSIC_R;
-
-        // copy assignment
-        Vc_ALWAYS_INLINE Vector &operator=(AsArg v) { d.v() = v.d.v(); return *this; }
+        // implict conversion from compatible Vector<U>
+        template <typename U>
+        Vc_INTRINSIC Vector(
+            V<U> x, typename std::enable_if<Traits::is_implicit_cast_allowed<U, T>::value,
+                                            void *>::type = nullptr)
+            : d(SSE::convert<U, T>(x.data()))
+        {
+        }
+
+#if Vc_IS_VERSION_1
+        // static_cast from the remaining Vector<U>
+        template <typename U>
+        Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
+                      "vector types") Vc_INTRINSIC
+            explicit Vector(
+                V<U> x,
+                typename std::enable_if<!Traits::is_implicit_cast_allowed<U, T>::value,
+                                        void *>::type = nullptr)
+            : d(SSE::convert<U, T>(x.data()))
+        {
+        }
+#endif
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // broadcast
-        explicit Vc_INTRINSIC_L Vector(EntryType a) Vc_INTRINSIC_R;
-        template<typename TT> Vc_INTRINSIC Vector(TT x, VC_EXACT_TYPE(TT, EntryType, void *) = 0) : d(HT::set(x)) {}
-        static Vc_INTRINSIC Vector broadcast4(const EntryType *x) { return Vector<T>(x); }
-        Vc_ALWAYS_INLINE Vector &operator=(EntryType a) { d.v() = HT::set(a); return *this; }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load ctors
-        explicit Vc_INTRINSIC_L
-            Vector(const EntryType *x) Vc_INTRINSIC_R;
-        template<typename Alignment> Vc_INTRINSIC_L
-            Vector(const EntryType *x, Alignment align) Vc_INTRINSIC_R;
-        template<typename OtherT> explicit Vc_INTRINSIC_L
-            Vector(const OtherT    *x) Vc_INTRINSIC_R;
-        template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
-            Vector(const OtherT    *x, Alignment align) Vc_INTRINSIC_R;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // load member functions
-        Vc_INTRINSIC_L
-            void load(const EntryType *mem) Vc_INTRINSIC_R;
-        template<typename Alignment> Vc_INTRINSIC_L
-            void load(const EntryType *mem, Alignment align) Vc_INTRINSIC_R;
-        template<typename OtherT> Vc_INTRINSIC_L
-            void load(const OtherT    *mem) Vc_INTRINSIC_R;
-        template<typename OtherT, typename Alignment> Vc_INTRINSIC_L
-            void load(const OtherT    *mem, Alignment align) Vc_INTRINSIC_R;
+        Vc_INTRINSIC Vector(EntryType a) : d(HT::set(a)) {}
+        template <typename U>
+        Vc_INTRINSIC Vector(U a,
+                            typename std::enable_if<std::is_same<U, int>::value &&
+                                                        !std::is_same<U, EntryType>::value,
+                                                    void *>::type = nullptr)
+            : Vector(static_cast<EntryType>(a))
+        {
+        }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // expand 1 float_v to 2 double_v                 XXX rationale? remove it for release? XXX
-        explicit Vc_INTRINSIC_L Vector(const Vector<typename CtorTypeHelper<T>::Type> *a) Vc_INTRINSIC_R;
-        inline void expand(Vector<typename ExpandTypeHelper<T>::Type> *x) const;
+#include "../common/loadinterface.h"
+#include "../common/storeinterface.h"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // zeroing
         Vc_INTRINSIC_L void setZero() Vc_INTRINSIC_R;
         Vc_INTRINSIC_L void setZero(const Mask &k) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L void setZeroInverted(const Mask &k) Vc_INTRINSIC_R;
 
         Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L void setQnan(typename Mask::Argument k) Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L void setQnan(const Mask &k) Vc_INTRINSIC_R;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // stores
-        Vc_INTRINSIC_L void store(EntryType *mem) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask) const Vc_INTRINSIC_R;
-        template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, A align) const Vc_INTRINSIC_R;
-        template<typename A> Vc_INTRINSIC_L void store(EntryType *mem, const Mask &mask, A align) const Vc_INTRINSIC_R;
+#include "../common/gatherinterface.h"
+#include "../common/scatterinterface.h"
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // swizzles
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T> &abcd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  cdab() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  badc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  aaaa() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bbbb() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  cccc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dddd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bcad() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  bcda() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dabc() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  acbd() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dbca() const Vc_INTRINSIC_R Vc_PURE_R;
-        Vc_INTRINSIC_L Vc_PURE_L const Vector<T>  dcba() const Vc_INTRINSIC_R Vc_PURE_R;
+        //prefix
+        Vc_INTRINSIC Vector &operator++() { data() = HT::add(data(), HT::one()); return *this; }
+        Vc_INTRINSIC Vector &operator--() { data() = HT::sub(data(), HT::one()); return *this; }
+        //postfix
+        Vc_INTRINSIC Vector operator++(int) { const Vector r = *this; data() = HT::add(data(), HT::one()); return r; }
+        Vc_INTRINSIC Vector operator--(int) { const Vector r = *this; data() = HT::sub(data(), HT::one()); return r; }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // gathers
-        template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes);
-        template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes);
-        template<typename IndexT> Vector(const EntryType *mem, const IndexT *indexes, MaskArg mask);
-        template<typename IndexT> Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes, MaskArg mask);
-        template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename IT> Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename S2, typename IT> Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
-        template<typename S1, typename IT1, typename IT2> Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
-        template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes);
-        template<typename Index> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask);
-#ifdef VC_USE_SET_GATHERS
-        template<typename IT> void gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IT>) indexes, MaskArg mask);
-#endif
-        template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename IT> void gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes);
-        template<typename S1, typename S2, typename IT> void gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask);
-        template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes);
-        template<typename S1, typename IT1, typename IT2> void gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask);
+    private:
+        friend reference;
+        Vc_INTRINSIC static value_type get(const Vector &o, int i) noexcept
+        {
+            return o.d.m(i);
+        }
+        template <typename U>
+        Vc_INTRINSIC static void set(Vector &o, int i, U &&v) noexcept(
+            noexcept(std::declval<value_type &>() = v))
+        {
+            o.d.set(i, v);
+        }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // scatters
-        template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const;
-        template<typename Index> void scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask) const;
-        template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes) const;
-        template<typename S1, typename IT> void scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
-        template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes) const;
-        template<typename S1, typename S2, typename IT> void scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const;
-        template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes) const;
-        template<typename S1, typename IT1, typename IT2> void scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask) const;
+    public:
+        Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept
+        {
+            static_assert(noexcept(reference{std::declval<Vector &>(), int()}), "");
+            return {*this, int(index)};
+        }
+        Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept
+        {
+            return d.m(index);
+        }
 
-        //prefix
-        Vc_INTRINSIC Vector &operator++() { data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return *this; }
-        Vc_INTRINSIC Vector &operator--() { data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return *this; }
-        //postfix
-        Vc_INTRINSIC Vector operator++(int) { const Vector<T> r = *this; data() = VectorHelper<T>::add(data(), VectorHelper<T>::one()); return r; }
-        Vc_INTRINSIC Vector operator--(int) { const Vector<T> r = *this; data() = VectorHelper<T>::sub(data(), VectorHelper<T>::one()); return r; }
+        Vc_INTRINSIC_L Vector Vc_VDECL operator[](const SSE::int_v &perm) const Vc_INTRINSIC_R;
 
-        Vc_INTRINSIC Common::AliasingEntryHelper<StorageType> operator[](size_t index) {
-#if defined(VC_GCC) && VC_GCC >= 0x40300 && VC_GCC < 0x40400
-            ::Vc::Warnings::_operator_bracket_warning();
+        Vc_INTRINSIC Vc_PURE Mask operator!() const
+        {
+            return *this == Zero();
+        }
+        Vc_INTRINSIC Vc_PURE Vector operator~() const
+        {
+#ifndef Vc_ENABLE_FLOAT_BIT_OPERATORS
+            static_assert(std::is_integral<T>::value,
+                          "bit-complement can only be used with Vectors of integral type");
 #endif
-            return d.m(index);
+            return Detail::andnot_(data(), HV::allone());
+        }
+        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector operator-() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
+        Vc_INTRINSIC Vc_PURE Vector operator+() const { return *this; }
+
+        Vc_ALWAYS_INLINE Vector  Vc_VDECL operator<< (AsArg shift) const { return generate([&](int i) { return get(*this, i) << get(shift, i); }); }
+        Vc_ALWAYS_INLINE Vector  Vc_VDECL operator>> (AsArg shift) const { return generate([&](int i) { return get(*this, i) >> get(shift, i); }); }
+        Vc_ALWAYS_INLINE Vector &Vc_VDECL operator<<=(AsArg shift) { return *this = *this << shift; }
+        Vc_ALWAYS_INLINE Vector &Vc_VDECL operator>>=(AsArg shift) { return *this = *this >> shift; }
+
+        Vc_INTRINSIC_L Vector &Vc_VDECL operator<<=(  int shift)       Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vector  Vc_VDECL operator<< (  int shift) const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vector &Vc_VDECL operator>>=(  int shift)       Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vector  Vc_VDECL operator>> (  int shift) const Vc_INTRINSIC_R;
+
+        Vc_DEPRECATED("use isnegative(x) instead") Vc_INTRINSIC Vc_PURE Mask
+            isNegative() const
+        {
+            return Vc::isnegative(*this);
+        }
+
+        Vc_ALWAYS_INLINE void assign(const Vector &v, const Mask &mask)
+        {
+            const VectorType k = SSE::sse_cast<VectorType>(mask.data());
+            data() = HV::blend(data(), v.data(), k);
+        }
+
+        template <typename V2>
+        Vc_DEPRECATED("Use simd_cast instead of Vector::staticCast")
+            Vc_ALWAYS_INLINE Vc_PURE V2 staticCast() const
+        {
+            return SSE::convert<T, typename V2::EntryType>(data());
+        }
+        template <typename V2>
+        Vc_DEPRECATED("use reinterpret_components_cast instead")
+            Vc_ALWAYS_INLINE Vc_PURE V2 reinterpretCast() const
+        {
+            return SSE::sse_cast<typename V2::VectorType>(data());
         }
-        Vc_INTRINSIC_L EntryType operator[](size_t index) const Vc_PURE Vc_INTRINSIC_R;
 
-        Vc_INTRINSIC Vector Vc_PURE operator~() const { return VectorHelper<VectorType>::andnot_(data(), VectorHelper<VectorType>::allone()); }
-        Vc_ALWAYS_INLINE_L Vector<typename NegateTypeHelper<T>::Type> operator-() const Vc_ALWAYS_INLINE_R;
-        Vc_INTRINSIC Vector Vc_PURE operator+() const { return *this; }
-
-#define OP(symbol, fun) \
-        Vc_INTRINSIC Vector &operator symbol##=(const Vector<T> &x) { data() = VectorHelper<T>::fun(data(), x.data()); return *this; } \
-        Vc_INTRINSIC Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector<T>(x)); } \
-        Vc_INTRINSIC Vector Vc_PURE operator symbol(const Vector<T> &x) const { return HT::fun(data(), x.data()); } \
-        template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Vector) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
-
-        OP(+, add)
-        OP(-, sub)
-        OP(*, mul)
-#undef OP
-
-        Vc_INTRINSIC_L Vector &operator<<=(AsArg shift)       Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector  operator<< (AsArg shift) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector &operator<<=(  int shift)       Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector  operator<< (  int shift) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector &operator>>=(AsArg shift)       Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector  operator>> (AsArg shift) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector &operator>>=(  int shift)       Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector  operator>> (  int shift) const Vc_INTRINSIC_R;
-
-        Vc_INTRINSIC_L Vector &operator/=(const Vector<T> &x) Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector  operator/ (const Vector<T> &x) const Vc_PURE Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector &operator/=(EntryType x) Vc_INTRINSIC_R;
-        template<typename TT> Vc_INTRINSIC_L VC_EXACT_TYPE(TT, typename DetermineEntryType<T>::Type, Vector<T>) operator/(TT x) const Vc_PURE Vc_INTRINSIC_R;
-
-#define OP(symbol, fun) \
-        Vc_INTRINSIC_L Vector &operator symbol##=(const Vector<T> &x) Vc_INTRINSIC_R; \
-        Vc_INTRINSIC_L Vector operator symbol(const Vector<T> &x) const Vc_PURE Vc_INTRINSIC_R; \
-        Vc_INTRINSIC Vector &operator symbol##=(EntryType x) { return operator symbol##=(Vector(x)); } \
-        template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Vector) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
-        OP(|, or_)
-        OP(&, and_)
-        OP(^, xor_)
-#undef OP
-#define OPcmp(symbol, fun) \
-        Vc_INTRINSIC Mask Vc_PURE operator symbol(const Vector<T> &x) const { return VectorHelper<T>::fun(data(), x.data()); } \
-        template<typename TT> Vc_INTRINSIC VC_EXACT_TYPE(TT, EntryType, Mask) Vc_PURE operator symbol(TT x) const { return operator symbol(Vector(x)); }
-
-        OPcmp(==, cmpeq)
-        OPcmp(!=, cmpneq)
-        OPcmp(>=, cmpnlt)
-        OPcmp(>, cmpnle)
-        OPcmp(<, cmplt)
-        OPcmp(<=, cmple)
-#undef OPcmp
-        Vc_INTRINSIC_L Vc_PURE_L Mask isNegative() const Vc_PURE_R Vc_INTRINSIC_R;
-
-        Vc_ALWAYS_INLINE void fusedMultiplyAdd(const Vector<T> &factor, const Vector<T> &summand) {
-            VectorHelper<T>::fma(data(), factor.data(), summand.data());
-        }
-
-        Vc_ALWAYS_INLINE void assign( const Vector<T> &v, const Mask &mask ) {
-            const VectorType k = mm128_reinterpret_cast<VectorType>(mask.data());
-            data() = VectorHelper<VectorType>::blend(data(), v.data(), k);
-        }
-
-        template<typename V2> Vc_ALWAYS_INLINE Vc_PURE V2 staticCast() const { return StaticCastHelper<T, typename V2::_T>::cast(data()); }
-        template<typename V2> Vc_ALWAYS_INLINE Vc_PURE V2 reinterpretCast() const { return mm128_reinterpret_cast<typename V2::VectorType>(data()); }
-
-        Vc_INTRINSIC WriteMaskedVector<T> operator()(const Mask &k) { return WriteMaskedVector<T>(this, k); }
-
-        /**
-         * \return \p true  This vector was completely filled. m2 might be 0 or != 0. You still have
-         *                  to test this.
-         *         \p false This vector was not completely filled. m2 is all 0.
-         */
-        //inline bool pack(Mask &m1, Vector<T> &v2, Mask &m2) {
-            //return VectorHelper<T>::pack(data(), m1.data, v2.data(), m2.data);
-        //}
+        Vc_INTRINSIC WriteMaskedVector operator()(const Mask &k) { return {*this, k}; }
 
         Vc_ALWAYS_INLINE Vc_PURE VectorType &data() { return d.v(); }
         Vc_ALWAYS_INLINE Vc_PURE const VectorType &data() const { return d.v(); }
 
-        Vc_INTRINSIC EntryType min() const { return VectorHelper<T>::min(data()); }
-        Vc_INTRINSIC EntryType max() const { return VectorHelper<T>::max(data()); }
-        Vc_INTRINSIC EntryType product() const { return VectorHelper<T>::mul(data()); }
-        Vc_INTRINSIC EntryType sum() const { return VectorHelper<T>::add(data()); }
+        template<int Index>
+        Vc_INTRINSIC_L Vector broadcast() const Vc_INTRINSIC_R;
+
+        Vc_INTRINSIC EntryType min() const { return HT::min(data()); }
+        Vc_INTRINSIC EntryType max() const { return HT::max(data()); }
+        Vc_INTRINSIC EntryType product() const { return HT::mul(data()); }
+        Vc_INTRINSIC EntryType sum() const { return HT::add(data()); }
+        Vc_INTRINSIC_L Vector partialSum() const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L EntryType min(MaskArg m) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L EntryType max(MaskArg m) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L EntryType product(MaskArg m) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L EntryType sum(MaskArg m) const Vc_INTRINSIC_R;
 
+        Vc_INTRINSIC_L Vector shifted(int amount, Vector shiftIn) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R;
         Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R;
-        inline Vc_PURE Vector sorted() const { return SortHelper<VectorType, Size>::sort(data()); }
+        Vc_INTRINSIC_L Vc_PURE_L Vector reversed() const Vc_INTRINSIC_R Vc_PURE_R;
+        Vc_ALWAYS_INLINE_L Vc_PURE_L Vector sorted() const Vc_ALWAYS_INLINE_R Vc_PURE_R;
 
-        template<typename F> void callWithValuesSorted(F &f) {
+        template <typename F> void callWithValuesSorted(F &&f)
+        {
             EntryType value = d.m(0);
             f(value);
-            for (int i = 1; i < Size; ++i) {
+            for (std::size_t i = 1; i < Size; ++i) {
                 if (d.m(i) != value) {
                     value = d.m(i);
                     f(value);
@@ -410,141 +270,130 @@
             }
         }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f) const {
-            for_all_vector_entries(i,
-                    f(EntryType(d.m(i)));
-                    );
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f) const {
-            for_all_vector_entries(i,
-                    f(EntryType(d.m(i)));
-                    );
+        template <typename F> Vc_INTRINSIC void call(F &&f) const
+        {
+            Common::for_all_vector_entries<Size>([&](size_t i) { f(EntryType(d.m(i))); });
         }
 
-        template<typename F> Vc_INTRINSIC void call(const F &f, const Mask &mask) const {
-            Vc_foreach_bit(size_t i, mask) {
-                f(EntryType(d.m(i)));
-            }
-        }
-        template<typename F> Vc_INTRINSIC void call(F &f, const Mask &mask) const {
-            Vc_foreach_bit(size_t i, mask) {
+        template <typename F> Vc_INTRINSIC void call(F &&f, const Mask &mask) const
+        {
+            for(size_t i : where(mask)) {
                 f(EntryType(d.m(i)));
             }
         }
 
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f) const {
-            Vector<T> r;
-            for_all_vector_entries(i,
-                    r.d.m(i) = f(EntryType(d.m(i)));
-                    );
-            return r;
-        }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f) const {
-            Vector<T> r;
-            for_all_vector_entries(i,
-                    r.d.m(i) = f(EntryType(d.m(i)));
-                    );
-            return r;
-        }
-
-        template<typename F> Vc_INTRINSIC Vector<T> apply(const F &f, const Mask &mask) const {
-            Vector<T> r(*this);
-            Vc_foreach_bit (size_t i, mask) {
-                r.d.m(i) = f(EntryType(r.d.m(i)));
-            }
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f) const
+        {
+            Vector r;
+            Common::for_all_vector_entries<Size>(
+                [&](size_t i) { r.d.set(i, f(EntryType(d.m(i)))); });
             return r;
         }
-        template<typename F> Vc_INTRINSIC Vector<T> apply(F &f, const Mask &mask) const {
-            Vector<T> r(*this);
-            Vc_foreach_bit (size_t i, mask) {
-                r.d.m(i) = f(EntryType(r.d.m(i)));
+        template <typename F> Vc_INTRINSIC Vector apply(F &&f, const Mask &mask) const
+        {
+            Vector r(*this);
+            for (size_t i : where(mask)) {
+                r.d.set(i, f(EntryType(r.d.m(i))));
             }
             return r;
         }
 
         template<typename IndexT> Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {
-            for_all_vector_entries(i,
-                    d.m(i) = f(i);
-                    );
+            Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f(i)); });
         }
         Vc_INTRINSIC void fill(EntryType (&f)()) {
-            for_all_vector_entries(i,
-                    d.m(i) = f();
-                    );
+            Common::for_all_vector_entries<Size>([&](size_t i) { d.set(i, f()); });
         }
 
-        Vc_INTRINSIC_L Vector copySign(typename Vector::AsArg reference) const Vc_INTRINSIC_R;
-        Vc_INTRINSIC_L Vector exponent() const Vc_INTRINSIC_R;
-};
+        template <typename G> static Vc_INTRINSIC_L Vector generate(G gen) Vc_INTRINSIC_R;
 
-typedef Vector<double>         double_v;
-typedef Vector<float>          float_v;
-typedef Vector<float8>         sfloat_v;
-typedef Vector<int>            int_v;
-typedef Vector<unsigned int>   uint_v;
-typedef Vector<short>          short_v;
-typedef Vector<unsigned short> ushort_v;
-typedef double_v::Mask double_m;
-typedef float_v::Mask float_m;
-typedef sfloat_v::Mask sfloat_m;
-typedef int_v::Mask int_m;
-typedef uint_v::Mask uint_m;
-typedef short_v::Mask short_m;
-typedef ushort_v::Mask ushort_m;
-
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<float8> Vector<float8>::broadcast4(const float *x) {
-    const _M128 &v = VectorHelper<_M128>::load(x, Aligned);
-    return Vector<float8>(M256::create(v, v));
-}
-
-template<typename T> class SwizzledVector : public Vector<T> {};
+        Vc_DEPRECATED("use copysign(x, y) instead") Vc_INTRINSIC Vector
+            copySign(AsArg reference) const
+        {
+            return Vc::copysign(*this, reference);
+        }
 
-static Vc_ALWAYS_INLINE Vc_PURE int_v    min(const int_v    &x, const int_v    &y) { return mm_min_epi32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE uint_v   min(const uint_v   &x, const uint_v   &y) { return mm_min_epu32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE short_v  min(const short_v  &x, const short_v  &y) { return _mm_min_epi16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE ushort_v min(const ushort_v &x, const ushort_v &y) { return mm_min_epu16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE float_v  min(const float_v  &x, const float_v  &y) { return _mm_min_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE double_v min(const double_v &x, const double_v &y) { return _mm_min_pd(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE int_v    max(const int_v    &x, const int_v    &y) { return mm_max_epi32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE uint_v   max(const uint_v   &x, const uint_v   &y) { return mm_max_epu32(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE short_v  max(const short_v  &x, const short_v  &y) { return _mm_max_epi16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE ushort_v max(const ushort_v &x, const ushort_v &y) { return mm_max_epu16(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE float_v  max(const float_v  &x, const float_v  &y) { return _mm_max_ps(x.data(), y.data()); }
-static Vc_ALWAYS_INLINE Vc_PURE double_v max(const double_v &x, const double_v &y) { return _mm_max_pd(x.data(), y.data()); }
+        Vc_DEPRECATED("use exponent(x) instead") Vc_INTRINSIC Vector exponent() const
+        {
+            return Vc::exponent(*this);
+        }
 
-static Vc_ALWAYS_INLINE Vc_PURE sfloat_v min(const sfloat_v &x, const sfloat_v &y) {
-    return M256::create(_mm_min_ps(x.data()[0], y.data()[0]), _mm_min_ps(x.data()[1], y.data()[1]));
-}
-static Vc_ALWAYS_INLINE Vc_PURE sfloat_v max(const sfloat_v &x, const sfloat_v &y) {
-    return M256::create(_mm_max_ps(x.data()[0], y.data()[0]), _mm_max_ps(x.data()[1], y.data()[1]));
+        Vc_INTRINSIC_L Vector interleaveLow(Vector x) const Vc_INTRINSIC_R;
+        Vc_INTRINSIC_L Vector interleaveHigh(Vector x) const Vc_INTRINSIC_R;
+};
+#undef Vc_CURRENT_CLASS_NAME
+template <typename T> constexpr size_t Vector<T, VectorAbi::Sse>::Size;
+template <typename T> constexpr size_t Vector<T, VectorAbi::Sse>::MemoryAlignment;
+
+static Vc_ALWAYS_INLINE Vc_PURE SSE::int_v    min(const SSE::int_v    &x, const SSE::int_v    &y) { return SSE::min_epi32(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::uint_v   min(const SSE::uint_v   &x, const SSE::uint_v   &y) { return SSE::min_epu32(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::short_v  min(const SSE::short_v  &x, const SSE::short_v  &y) { return _mm_min_epi16(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::ushort_v min(const SSE::ushort_v &x, const SSE::ushort_v &y) { return SSE::min_epu16(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::float_v  min(const SSE::float_v  &x, const SSE::float_v  &y) { return _mm_min_ps(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::double_v min(const SSE::double_v &x, const SSE::double_v &y) { return _mm_min_pd(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::int_v    max(const SSE::int_v    &x, const SSE::int_v    &y) { return SSE::max_epi32(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::uint_v   max(const SSE::uint_v   &x, const SSE::uint_v   &y) { return SSE::max_epu32(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::short_v  max(const SSE::short_v  &x, const SSE::short_v  &y) { return _mm_max_epi16(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::ushort_v max(const SSE::ushort_v &x, const SSE::ushort_v &y) { return SSE::max_epu16(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::float_v  max(const SSE::float_v  &x, const SSE::float_v  &y) { return _mm_max_ps(x.data(), y.data()); }
+static Vc_ALWAYS_INLINE Vc_PURE SSE::double_v max(const SSE::double_v &x, const SSE::double_v &y) { return _mm_max_pd(x.data(), y.data()); }
+
+template <typename T,
+          typename = enable_if<std::is_same<T, double>::value || std::is_same<T, float>::value ||
+                               std::is_same<T, short>::value ||
+                               std::is_same<T, int>::value>>
+Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> abs(Vector<T, VectorAbi::Sse> x)
+{
+    return SSE::VectorHelper<T>::abs(x.data());
 }
 
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> sqrt (const Vector<T> &x) { return VectorHelper<T>::sqrt(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> rsqrt(const Vector<T> &x) { return VectorHelper<T>::rsqrt(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> abs  (const Vector<T> &x) { return VectorHelper<T>::abs(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> reciprocal(const Vector<T> &x) { return VectorHelper<T>::reciprocal(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE Vector<T> round(const Vector<T> &x) { return VectorHelper<T>::round(x.data()); }
-
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::Mask isfinite(const Vector<T> &x) { return VectorHelper<T>::isFinite(x.data()); }
-  template<typename T> static Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::Mask isnan(const Vector<T> &x) { return VectorHelper<T>::isNaN(x.data()); }
-
-#include "forceToRegisters.tcc"
-#ifdef VC_GNU_ASM
-template<>
-Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float8> &x1) {
-  __asm__ __volatile__(""::"x"(x1.data()[0]), "x"(x1.data()[1]));
-}
-#elif defined(VC_MSVC)
-#pragma optimize("g", off)
-template<>
-Vc_ALWAYS_INLINE void forceToRegisters(const Vector<float8> &/*x1*/) {
-}
-#endif
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> sqrt (const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::sqrt(x.data()); }
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> rsqrt(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::rsqrt(x.data()); }
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> reciprocal(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::reciprocal(x.data()); }
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> round(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::round(x.data()); }
+
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::Mask isfinite(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::isFinite(x.data()); }
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::Mask isinf(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::isInfinite(x.data()); }
+  template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::Mask isnan(const Vector<T, VectorAbi::Sse> &x) { return SSE::VectorHelper<T>::isNaN(x.data()); }
+
+#define Vc_CONDITIONAL_ASSIGN(name_, op_)                                                \
+    template <Operator O, typename T, typename M, typename U>                            \
+    Vc_INTRINSIC enable_if<O == Operator::name_, void> conditional_assign(               \
+        Vector<T, VectorAbi::Sse> &lhs, M &&mask, U &&rhs)                               \
+    {                                                                                    \
+        lhs(mask) op_ rhs;                                                               \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(          Assign,  =);
+Vc_CONDITIONAL_ASSIGN(      PlusAssign, +=);
+Vc_CONDITIONAL_ASSIGN(     MinusAssign, -=);
+Vc_CONDITIONAL_ASSIGN(  MultiplyAssign, *=);
+Vc_CONDITIONAL_ASSIGN(    DivideAssign, /=);
+Vc_CONDITIONAL_ASSIGN( RemainderAssign, %=);
+Vc_CONDITIONAL_ASSIGN(       XorAssign, ^=);
+Vc_CONDITIONAL_ASSIGN(       AndAssign, &=);
+Vc_CONDITIONAL_ASSIGN(        OrAssign, |=);
+Vc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);
+Vc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);
+#undef Vc_CONDITIONAL_ASSIGN
+
+#define Vc_CONDITIONAL_ASSIGN(name_, expr_)                                              \
+    template <Operator O, typename T, typename M>                                        \
+    Vc_INTRINSIC enable_if<O == Operator::name_, Vector<T, VectorAbi::Sse>>              \
+    conditional_assign(Vector<T, VectorAbi::Sse> &lhs, M &&mask)                         \
+    {                                                                                    \
+        return expr_;                                                                    \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+Vc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++);
+Vc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask));
+Vc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--);
+Vc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask));
+#undef Vc_CONDITIONAL_ASSIGN
+
+}  // namespace Vc
 
-#include "undomacros.h"
 #include "vector.tcc"
-#include "math.h"
-#endif // SSE_VECTOR_H
+#include "simd_cast.h"
+
+#endif // VC_SSE_VECTOR_H_
diff -Nru vc-0.7.4/sse/vectorhelper.h vc-1.3.0/sse/vectorhelper.h
--- vc-0.7.4/sse/vectorhelper.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/vectorhelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,212 +1,146 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef SSE_VECTORHELPER_H
-#define SSE_VECTORHELPER_H
+#ifndef VC_SSE_VECTORHELPER_H_
+#define VC_SSE_VECTORHELPER_H_
 
 #include "types.h"
+#include "../common/loadstoreflags.h"
 #include <limits>
+#include "const_data.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
+namespace Vc_VERSIONED_NAMESPACE
 {
 namespace SSE
 {
-
-namespace Internal
-{
-Vc_INTRINSIC Vc_CONST __m128 exponent(__m128 v)
-{
-    __m128i tmp = _mm_srli_epi32(_mm_castps_si128(v), 23);
-    tmp = _mm_sub_epi32(tmp, _mm_set1_epi32(0x7f));
-    return _mm_cvtepi32_ps(tmp);
-}
-Vc_INTRINSIC Vc_CONST M256 exponent(VC_ALIGNED_PARAMETER(M256) v)
-{
-    __m128i tmp0 = _mm_srli_epi32(_mm_castps_si128(v[0]), 23);
-    __m128i tmp1 = _mm_srli_epi32(_mm_castps_si128(v[1]), 23);
-    tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x7f));
-    tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x7f));
-    return M256::create( _mm_cvtepi32_ps(tmp0), _mm_cvtepi32_ps(tmp1));
-}
-Vc_INTRINSIC Vc_CONST __m128d exponent(__m128d v)
-{
-    __m128i tmp = _mm_srli_epi64(_mm_castpd_si128(v), 52);
-    tmp = _mm_sub_epi32(tmp, _mm_set1_epi32(0x3ff));
-    return _mm_cvtepi32_pd(_mm_shuffle_epi32(tmp, 0x08));
-}
-} // namespace Internal
-
-    template<typename VectorType, unsigned int Size> struct SortHelper
-    {
-        static inline Vc_CONST_L VectorType sort(VectorType) Vc_CONST_R;
-    };
-    template<unsigned int Size> struct SortHelper<M256, Size>
-    {
-        static inline Vc_PURE_L M256 sort(const M256 &) Vc_PURE_R;
-    };
-
-#define OP0(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name() { return code; }
-#define OP2(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(VectorTypeArg a, VectorTypeArg b) { return code; }
-#define OP3(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(VectorTypeArg a, VectorTypeArg b, VectorTypeArg c) { return code; }
-    template<> struct VectorHelper<M256>
-    {
-        typedef M256 VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-        typedef const VectorType &VectorTypeArg;
-#else
-        typedef const VectorType VectorTypeArg;
-#endif
-        template<typename A> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const float *x, A) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, VectorTypeArg m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, VectorTypeArg m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, VectorTypeArg m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-        static Vc_ALWAYS_INLINE_L void store(float *mem, VectorTypeArg x, VectorTypeArg m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-        OP0(allone, VectorType::create(_mm_setallone_ps(), _mm_setallone_ps()))
-        OP0(zero, VectorType::create(_mm_setzero_ps(), _mm_setzero_ps()))
-        OP2(or_, VectorType::create(_mm_or_ps(a[0], b[0]), _mm_or_ps(a[1], b[1])))
-        OP2(xor_, VectorType::create(_mm_xor_ps(a[0], b[0]), _mm_xor_ps(a[1], b[1])))
-        OP2(and_, VectorType::create(_mm_and_ps(a[0], b[0]), _mm_and_ps(a[1], b[1])))
-        OP2(andnot_, VectorType::create(_mm_andnot_ps(a[0], b[0]), _mm_andnot_ps(a[1], b[1])))
-        OP3(blend, VectorType::create(mm_blendv_ps(a[0], b[0], c[0]), mm_blendv_ps(a[1], b[1], c[1])))
-    };
-#undef OP0
-#undef OP2
-#undef OP3
-
-#define OP0(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name() { return code; }
-#define OP1(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a) { return code; }
-#define OP2(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a, const VectorType b) { return code; }
-#define OP3(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a, const VectorType b, const VectorType c) { return code; }
+#define Vc_OP0(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name() { return code; }
+#define Vc_OP1(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a) { return code; }
+#define Vc_OP2(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a, const VectorType b) { return code; }
+#define Vc_OP3(name, code) static Vc_ALWAYS_INLINE Vc_CONST VectorType name(const VectorType a, const VectorType b, const VectorType c) { return code; }
 
         template<> struct VectorHelper<_M128>
         {
             typedef _M128 VectorType;
-            template<typename A> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const float *x, A) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, const VectorType m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, const VectorType m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(float *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-            OP0(allone, _mm_setallone_ps())
-            OP0(zero, _mm_setzero_ps())
-            OP2(or_, _mm_or_ps(a, b))
-            OP2(xor_, _mm_xor_ps(a, b))
-            OP2(and_, _mm_and_ps(a, b))
-            OP2(andnot_, _mm_andnot_ps(a, b))
-            OP3(blend, mm_blendv_ps(a, b, c))
+
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const float *x, typename Flags::EnableIfAligned  = nullptr) { return _mm_load_ps(x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const float *x, typename Flags::EnableIfUnaligned = nullptr) { return _mm_loadu_ps(x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const float *x, typename Flags::EnableIfStreaming = nullptr) { return _mm_stream_load(x); }
+
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VectorType x, typename Flags::EnableIfAligned               = nullptr) { _mm_store_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VectorType x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm_storeu_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VectorType x, typename Flags::EnableIfStreaming             = nullptr) { _mm_stream_ps(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VectorType x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { _mm_maskmoveu_si128(_mm_castps_si128(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem)); }
+
+            // before AVX there was only one maskstore. load -> blend -> store would break the C++ memory model (read/write of memory that is actually not touched by this thread)
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(float *mem, VectorType x, VectorType m) { _mm_maskmoveu_si128(_mm_castps_si128(x), _mm_castps_si128(m), reinterpret_cast<char *>(mem)); }
+
+            Vc_OP0(allone, _mm_setallone_ps())
+            Vc_OP0(zero, _mm_setzero_ps())
+            Vc_OP3(blend, blendv_ps(a, b, c))
         };
 
 
         template<> struct VectorHelper<_M128D>
         {
             typedef _M128D VectorType;
-            template<typename A> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const double *x, A) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, const VectorType m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, const VectorType m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            static Vc_ALWAYS_INLINE_L void store(double *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-            OP0(allone, _mm_setallone_pd())
-            OP0(zero, _mm_setzero_pd())
-            OP2(or_, _mm_or_pd(a, b))
-            OP2(xor_, _mm_xor_pd(a, b))
-            OP2(and_, _mm_and_pd(a, b))
-            OP2(andnot_, _mm_andnot_pd(a, b))
-            OP3(blend, mm_blendv_pd(a, b, c))
+
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const double *x, typename Flags::EnableIfAligned   = nullptr) { return _mm_load_pd(x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const double *x, typename Flags::EnableIfUnaligned = nullptr) { return _mm_loadu_pd(x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const double *x, typename Flags::EnableIfStreaming = nullptr) { return _mm_stream_load(x); }
+
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VectorType x, typename Flags::EnableIfAligned               = nullptr) { _mm_store_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VectorType x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm_storeu_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VectorType x, typename Flags::EnableIfStreaming             = nullptr) { _mm_stream_pd(mem, x); }
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VectorType x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { _mm_maskmoveu_si128(_mm_castpd_si128(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem)); }
+
+            // before AVX there was only one maskstore. load -> blend -> store would break the C++ memory model (read/write of memory that is actually not touched by this thread)
+            template<typename Flags> static Vc_ALWAYS_INLINE void store(double *mem, VectorType x, VectorType m) { _mm_maskmoveu_si128(_mm_castpd_si128(x), _mm_castpd_si128(m), reinterpret_cast<char *>(mem)); }
+
+            Vc_OP0(allone, _mm_setallone_pd())
+            Vc_OP0(zero, _mm_setzero_pd())
+            Vc_OP3(blend, blendv_pd(a, b, c))
         };
 
         template<> struct VectorHelper<_M128I>
         {
             typedef _M128I VectorType;
-            template<typename T> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const T *x, AlignedFlag) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const T *x, UnalignedFlag) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const T *x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L Vc_PURE_L VectorType load(const T *x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R Vc_PURE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, const VectorType m, AlignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, const VectorType m, UnalignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag) Vc_ALWAYS_INLINE_R;
-            template<typename T> static Vc_ALWAYS_INLINE_L void store(T *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag) Vc_ALWAYS_INLINE_R;
-
-            OP0(allone, _mm_setallone_si128())
-            OP0(zero, _mm_setzero_si128())
-            OP2(or_, _mm_or_si128(a, b))
-            OP2(xor_, _mm_xor_si128(a, b))
-            OP2(and_, _mm_and_si128(a, b))
-            OP2(andnot_, _mm_andnot_si128(a, b))
-            OP3(blend, mm_blendv_epi8(a, b, c))
+
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const T *x, typename Flags::EnableIfAligned   = nullptr) { return _mm_load_si128(reinterpret_cast<const VectorType *>(x)); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const T *x, typename Flags::EnableIfUnaligned = nullptr) { return _mm_loadu_si128(reinterpret_cast<const VectorType *>(x)); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE Vc_PURE VectorType load(const T *x, typename Flags::EnableIfStreaming = nullptr) { return _mm_stream_load(x); }
+
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VectorType x, typename Flags::EnableIfAligned               = nullptr) { _mm_store_si128(reinterpret_cast<VectorType *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VectorType x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm_storeu_si128(reinterpret_cast<VectorType *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VectorType x, typename Flags::EnableIfStreaming             = nullptr) { _mm_stream_si128(reinterpret_cast<VectorType *>(mem), x); }
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VectorType x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { _mm_maskmoveu_si128(x, _mm_setallone_si128(), reinterpret_cast<char *>(mem)); }
+
+            // before AVX there was only one maskstore. load -> blend -> store would break the C++ memory model (read/write of memory that is actually not touched by this thread)
+            template<typename Flags, typename T> static Vc_ALWAYS_INLINE void store(T *mem, VectorType x, VectorType m) { _mm_maskmoveu_si128(x, m, reinterpret_cast<char *>(mem)); }
+
+            Vc_OP0(allone, _mm_setallone_si128())
+            Vc_OP0(zero, _mm_setzero_si128())
+            Vc_OP3(blend, blendv_epi8(a, b, c))
         };
 
-#undef OP1
-#undef OP2
-#undef OP3
-
-#define OP1(op) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a) { return CAT(_mm_##op##_, SUFFIX)(a); }
-#define OP(op) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return CAT(_mm_##op##_ , SUFFIX)(a, b); }
-#define OP_(op) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return CAT(_mm_##op    , SUFFIX)(a, b); }
-#define OPx(op, op2) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return CAT(_mm_##op2##_, SUFFIX)(a, b); }
-#define OPcmp(op) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType cmp##op(const VectorType a, const VectorType b) { return CAT(_mm_cmp##op##_, SUFFIX)(a, b); }
-#define OP_CAST_(op) \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return CAT(_mm_castps_, SUFFIX)( \
-            _mm_##op##ps(CAT(CAT(_mm_cast, SUFFIX), _ps)(a), \
-              CAT(CAT(_mm_cast, SUFFIX), _ps)(b))); \
+#undef Vc_OP1
+#undef Vc_OP2
+#undef Vc_OP3
+
+#define Vc_OP1(op) \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a) { return Vc_CAT2(_mm_##op##_, Vc_SUFFIX)(a); }
+#define Vc_OP(op) \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return Vc_CAT2(_mm_##op##_ , Vc_SUFFIX)(a, b); }
+#define Vc_OP_(op) \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return Vc_CAT2(_mm_##op    , Vc_SUFFIX)(a, b); }
+#define Vc_OPx(op, op2) \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return Vc_CAT2(_mm_##op2##_, Vc_SUFFIX)(a, b); }
+#define Vc_OP_CAST_(op) \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType op(const VectorType a, const VectorType b) { return Vc_CAT2(_mm_castps_, Vc_SUFFIX)( \
+            _mm_##op##ps(Vc_CAT2(Vc_CAT2(_mm_cast, Vc_SUFFIX), _ps)(a), \
+              Vc_CAT2(Vc_CAT2(_mm_cast, Vc_SUFFIX), _ps)(b))); \
         }
-#define MINMAX \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType min(VectorType a, VectorType b) { return CAT(_mm_min_, SUFFIX)(a, b); } \
-        static Vc_ALWAYS_INLINE Vc_CONST VectorType max(VectorType a, VectorType b) { return CAT(_mm_max_, SUFFIX)(a, b); }
+#define Vc_MINMAX \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType min(VectorType a, VectorType b) { return Vc_CAT2(_mm_min_, Vc_SUFFIX)(a, b); } \
+        static Vc_ALWAYS_INLINE Vc_CONST VectorType max(VectorType a, VectorType b) { return Vc_CAT2(_mm_max_, Vc_SUFFIX)(a, b); }
 
         template<> struct VectorHelper<double> {
             typedef _M128D VectorType;
             typedef double EntryType;
-#define SUFFIX pd
+#define Vc_SUFFIX pd
 
-            OP_(or_) OP_(and_) OP_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(_mm_castps_pd(mask), a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const double a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const double a, const double b) { return CAT(_mm_set_, SUFFIX)(a, b); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return CAT(_mm_setone_, SUFFIX)(); }// set(1.); }
+            Vc_OP_(or_) Vc_OP_(and_) Vc_OP_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(_mm_castps_pd(mask), a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const double a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const double a, const double b) { return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }// set(1.); }
 
-#ifdef VC_IMPL_FMA4
+#ifdef Vc_IMPL_FMA4
             static Vc_ALWAYS_INLINE void fma(VectorType &v1, VectorType v2, VectorType v3) {
                 v1 = _mm_macc_pd(v1, v2, v3);
             }
@@ -214,7 +148,7 @@
             static inline void fma(VectorType &v1, VectorType v2, VectorType v3) {
                 VectorType h1 = _mm_and_pd(v1, _mm_load_pd(reinterpret_cast<const double *>(&c_general::highMaskDouble)));
                 VectorType h2 = _mm_and_pd(v2, _mm_load_pd(reinterpret_cast<const double *>(&c_general::highMaskDouble)));
-#if defined(VC_GCC) && VC_GCC < 0x40703
+#if defined(Vc_GCC) && Vc_GCC < 0x40703
                 // GCC before 4.7.3 uses an incorrect optimization where it replaces the subtraction with an andnot
                 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54703
                 asm("":"+x"(h1), "+x"(h2));
@@ -225,19 +159,16 @@
                 const VectorType lh = add(mul(l1, h2), mul(h1, l2));
                 const VectorType hh = mul(h1, h2);
                 // ll < lh < hh for all entries is certain
-                const VectorType lh_lt_v3 = cmplt(abs(lh), abs(v3)); // |lh| < |v3|
-                const VectorType b = mm_blendv_pd(v3, lh, lh_lt_v3);
-                const VectorType c = mm_blendv_pd(lh, v3, lh_lt_v3);
+                const VectorType lh_lt_v3 = _mm_cmplt_pd(abs(lh), abs(v3)); // |lh| < |v3|
+                const VectorType b = blendv_pd(v3, lh, lh_lt_v3);
+                const VectorType c = blendv_pd(lh, v3, lh_lt_v3);
                 v1 = add(add(ll, b), add(c, hh));
             }
 #endif
 
-            OP(add) OP(sub) OP(mul)
-            OPcmp(eq) OPcmp(neq)
-            OPcmp(lt) OPcmp(nlt)
-            OPcmp(le) OPcmp(nle)
+            Vc_OP(add) Vc_OP(sub) Vc_OP(mul)
 
-            OP1(sqrt)
+            Vc_OP1(sqrt)
             static Vc_ALWAYS_INLINE Vc_CONST VectorType rsqrt(VectorType x) {
                 return _mm_div_pd(one(), sqrt(x));
             }
@@ -250,11 +181,14 @@
             static Vc_ALWAYS_INLINE Vc_CONST VectorType isFinite(VectorType x) {
                 return _mm_cmpord_pd(x, _mm_mul_pd(zero(), x));
             }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType isInfinite(VectorType x) {
+                return _mm_castsi128_pd(cmpeq_epi64(_mm_castpd_si128(abs(x)), _mm_castpd_si128(_mm_load_pd(c_log<double>::d(1)))));
+            }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(const VectorType a) {
-                return CAT(_mm_and_, SUFFIX)(a, _mm_setabsmask_pd());
+                return Vc_CAT2(_mm_and_, Vc_SUFFIX)(a, _mm_setabsmask_pd());
             }
 
-            MINMAX
+            Vc_MINMAX
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 a = _mm_min_sd(a, _mm_unpackhi_pd(a, a));
                 return _mm_cvtsd_f64(a);
@@ -271,9 +205,9 @@
                 a = _mm_add_sd(a, _mm_shuffle_pd(a, a, _MM_SHUFFLE2(0, 1)));
                 return _mm_cvtsd_f64(a);
             }
-#undef SUFFIX
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) {
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
                 return _mm_round_pd(a, _MM_FROUND_NINT);
 #else
                 //XXX: slow: _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);
@@ -285,17 +219,17 @@
         template<> struct VectorHelper<float> {
             typedef float EntryType;
             typedef _M128 VectorType;
-#define SUFFIX ps
+#define Vc_SUFFIX ps
 
-            OP_(or_) OP_(and_) OP_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(mask, a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d) { return CAT(_mm_set_, SUFFIX)(a, b, c, d); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return CAT(_mm_setone_, SUFFIX)(); }// set(1.f); }
+            Vc_OP_(or_) Vc_OP_(and_) Vc_OP_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(mask, a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d) { return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b, c, d); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }// set(1.f); }
             static Vc_ALWAYS_INLINE Vc_CONST _M128 concat(_M128D a, _M128D b) { return _mm_movelh_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b)); }
 
-#ifdef VC_IMPL_FMA4
+#ifdef Vc_IMPL_FMA4
             static Vc_ALWAYS_INLINE void fma(VectorType &v1, VectorType v2, VectorType v3) {
                 v1 = _mm_macc_ps(v1, v2, v3);
             }
@@ -313,26 +247,26 @@
             }
 #endif
 
-            OP(add) OP(sub) OP(mul)
-            OPcmp(eq) OPcmp(neq)
-            OPcmp(lt) OPcmp(nlt)
-            OPcmp(le) OPcmp(nle)
+            Vc_OP(add) Vc_OP(sub) Vc_OP(mul)
 
-            OP1(sqrt) OP1(rsqrt)
+            Vc_OP1(sqrt) Vc_OP1(rsqrt)
             static Vc_ALWAYS_INLINE Vc_CONST VectorType isNaN(VectorType x) {
                 return _mm_cmpunord_ps(x, x);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType isFinite(VectorType x) {
                 return _mm_cmpord_ps(x, _mm_mul_ps(zero(), x));
             }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType isInfinite(VectorType x) {
+                return _mm_castsi128_ps(_mm_cmpeq_epi32(_mm_castps_si128(abs(x)), _mm_castps_si128(_mm_load_ps(c_log<float>::d(1)))));
+            }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType reciprocal(VectorType x) {
                 return _mm_rcp_ps(x);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(const VectorType a) {
-                return CAT(_mm_and_, SUFFIX)(a, _mm_setabsmask_ps());
+                return Vc_CAT2(_mm_and_, Vc_SUFFIX)(a, _mm_setabsmask_ps());
             }
 
-            MINMAX
+            Vc_MINMAX
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 a = _mm_min_ps(a, _mm_movehl_ps(a, a));   // a = min(a0, a2), min(a1, a3), min(a2, a2), min(a3, a3)
                 a = _mm_min_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1))); // a = min(a0, a1), a1, a2, a3
@@ -353,9 +287,9 @@
                 a = _mm_add_ss(a, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 0, 1)));
                 return _mm_cvtss_f32(a);
             }
-#undef SUFFIX
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) {
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
                 return _mm_round_ps(a, _MM_FROUND_NINT);
 #else
                 //XXX slow: _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);
@@ -364,110 +298,32 @@
             }
         };
 
-        template<> struct VectorHelper<float8> {
-            typedef float EntryType;
-            typedef M256 VectorType;
-#ifdef VC_PASSING_VECTOR_BY_VALUE_IS_BROKEN
-            typedef const VectorType &VectorTypeArg;
-#else
-            typedef const VectorType VectorTypeArg;
-#endif
-
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) {
-                const _M128 x = _mm_set1_ps(a);
-                return VectorType::create(x, x);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d) {
-                const _M128 x = _mm_set_ps(a, b, c, d);
-                return VectorType::create(x, x);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d,
-                    const float e, const float f, const float g, const float h) {
-                return VectorType::create(_mm_set_ps(a, b, c, d), _mm_set_ps(e, f, g, h));
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return VectorType::create(_mm_setzero_ps(), _mm_setzero_ps()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one()  { return set(1.f); }
-
-#define REUSE_FLOAT_IMPL1(fun) \
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType fun(VectorTypeArg x) { \
-                return VectorType::create(VectorHelper<float>::fun(x[0]), VectorHelper<float>::fun(x[1])); \
-            }
-#define REUSE_FLOAT_IMPL2(fun) \
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType fun(VectorTypeArg x, VectorTypeArg y) { \
-                return VectorType::create(VectorHelper<float>::fun(x[0], y[0]), VectorHelper<float>::fun(x[1], y[1])); \
-            }
-            REUSE_FLOAT_IMPL1(reciprocal)
-            REUSE_FLOAT_IMPL1(sqrt)
-            REUSE_FLOAT_IMPL1(rsqrt)
-            REUSE_FLOAT_IMPL1(isNaN)
-            REUSE_FLOAT_IMPL1(isFinite)
-            REUSE_FLOAT_IMPL1(abs)
-            REUSE_FLOAT_IMPL1(round)
-
-            REUSE_FLOAT_IMPL2(and_)
-            REUSE_FLOAT_IMPL2(or_)
-            REUSE_FLOAT_IMPL2(xor_)
-            REUSE_FLOAT_IMPL2(notMaskedToZero)
-            REUSE_FLOAT_IMPL2(add)
-            REUSE_FLOAT_IMPL2(sub)
-            REUSE_FLOAT_IMPL2(mul)
-            REUSE_FLOAT_IMPL2(cmple)
-            REUSE_FLOAT_IMPL2(cmpnle)
-            REUSE_FLOAT_IMPL2(cmplt)
-            REUSE_FLOAT_IMPL2(cmpnlt)
-            REUSE_FLOAT_IMPL2(cmpeq)
-            REUSE_FLOAT_IMPL2(cmpneq)
-            REUSE_FLOAT_IMPL2(min)
-            REUSE_FLOAT_IMPL2(max)
-
-            static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorTypeArg a) {
-                return VectorHelper<float>::min(VectorHelper<float>::min(a[0], a[1]));
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST EntryType max(VectorTypeArg a) {
-                return VectorHelper<float>::max(VectorHelper<float>::max(a[0], a[1]));
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VectorTypeArg a) {
-                return VectorHelper<float>::mul(VectorHelper<float>::mul(a[0], a[1]));
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST EntryType add(VectorTypeArg a) {
-                return VectorHelper<float>::add(VectorHelper<float>::add(a[0], a[1]));
-            }
-
-            static inline void fma(VectorType &a, VectorTypeArg b, VectorTypeArg c) {
-                VectorHelper<float>::fma(a[0], b[0], c[0]);
-                VectorHelper<float>::fma(a[1], b[1], c[1]);
-            }
-#undef REUSE_FLOAT_IMPL2
-#undef REUSE_FLOAT_IMPL1
-        };
-
         template<> struct VectorHelper<int> {
             typedef int EntryType;
             typedef _M128I VectorType;
-#define SUFFIX si128
+#define Vc_SUFFIX si128
 
-            OP_(or_) OP_(and_) OP_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(_mm_castps_si128(mask), a); }
-#undef SUFFIX
-#define SUFFIX epi32
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return CAT(_mm_setone_, SUFFIX)(); }
+            Vc_OP_(or_) Vc_OP_(and_) Vc_OP_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(_mm_castps_si128(mask), a); }
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epi32
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }
 
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const int a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const int a, const int b, const int c, const int d) { return CAT(_mm_set_, SUFFIX)(a, b, c, d); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const int a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const int a, const int b, const int c, const int d) { return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b, c, d); }
 
             static Vc_ALWAYS_INLINE void fma(VectorType &v1, VectorType v2, VectorType v3) { v1 = add(mul(v1, v2), v3); }
 
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VectorType a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_slli_, Vc_SUFFIX)(a, shift);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VectorType a, int shift) {
-                return CAT(_mm_srai_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_srai_, Vc_SUFFIX)(a, shift);
             }
-            static Vc_INTRINSIC Vc_CONST VectorType abs(const VectorType a) { return mm_abs_epi32(a); }
-
-            static Vc_INTRINSIC Vc_CONST VectorType min(const VectorType a, const VectorType b) { return mm_min_epi32(a, b); }
-            static Vc_INTRINSIC Vc_CONST VectorType max(const VectorType a, const VectorType b) { return mm_max_epi32(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(const VectorType a) { return abs_epi32(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType min(VectorType a, VectorType b) { return min_epi32(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType max(VectorType a, VectorType b) { return max_epi32(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)));
                 // using lo_epi16 for speed here
@@ -485,7 +341,7 @@
                 a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 0, 3, 2)));
                 return _mm_cvtsi128_si32(a);
             }
-#ifdef VC_IMPL_SSE4_1
+#ifdef Vc_IMPL_SSE4_1
             static Vc_ALWAYS_INLINE Vc_CONST VectorType mul(VectorType a, VectorType b) { return _mm_mullo_epi32(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VectorType a) {
                 a = mul(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)));
@@ -502,32 +358,25 @@
             }
 #endif
 
-            OP(add) OP(sub)
-            OPcmp(eq)
-            OPcmp(lt)
-            OPcmp(gt)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(const VectorType a, const VectorType b) { _M128I x = cmpeq(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(const VectorType a, const VectorType b) { _M128I x = cmplt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (const VectorType a, const VectorType b) { _M128I x = cmpgt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(const VectorType a, const VectorType b) { return cmpgt(a, b); }
-#undef SUFFIX
+            Vc_OP(add) Vc_OP(sub)
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) { return a; }
         };
 
         template<> struct VectorHelper<unsigned int> {
             typedef unsigned int EntryType;
             typedef _M128I VectorType;
-#define SUFFIX si128
-            OP_CAST_(or_) OP_CAST_(and_) OP_CAST_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(_mm_castps_si128(mask), a); }
-
-#undef SUFFIX
-#define SUFFIX epu32
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return CAT(_mm_setone_, SUFFIX)(); }
+#define Vc_SUFFIX si128
+            Vc_OP_CAST_(or_) Vc_OP_CAST_(and_) Vc_OP_CAST_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(_mm_castps_si128(mask), a); }
+
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epu32
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }
 
-            static Vc_INTRINSIC Vc_CONST VectorType min(const VectorType a, const VectorType b) { return mm_min_epu32(a, b); }
-            static Vc_INTRINSIC Vc_CONST VectorType max(const VectorType a, const VectorType b) { return mm_max_epu32(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType min(VectorType a, VectorType b) { return min_epu32(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType max(VectorType a, VectorType b) { return max_epu32(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)));
                 // using lo_epi16 for speed here
@@ -577,75 +426,57 @@
 //X                 return mul(a, set(b));
 //X             }
 
-#undef SUFFIX
-#define SUFFIX epi32
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epi32
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VectorType a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_slli_, Vc_SUFFIX)(a, shift);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VectorType a, int shift) {
-                return CAT(_mm_srli_, SUFFIX)(a, shift);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const unsigned int a) { return CAT(_mm_set1_, SUFFIX)(a); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const unsigned int a, const unsigned int b, const unsigned int c, const unsigned int d) { return CAT(_mm_set_, SUFFIX)(a, b, c, d); }
-
-            OP(add) OP(sub)
-            OPcmp(eq)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(const VectorType a, const VectorType b) { return _mm_andnot_si128(cmpeq(a, b), _mm_setallone_si128()); }
-
-#ifndef USE_INCORRECT_UNSIGNED_COMPARE
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmplt(const VectorType a, const VectorType b) {
-                return _mm_cmplt_epu32(a, b);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpgt(const VectorType a, const VectorType b) {
-                return _mm_cmpgt_epu32(a, b);
+                return Vc_CAT2(_mm_srli_, Vc_SUFFIX)(a, shift);
             }
-#else
-            OPcmp(lt)
-            OPcmp(gt)
-#endif
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(const VectorType a, const VectorType b) { return _mm_andnot_si128(cmplt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (const VectorType a, const VectorType b) { return _mm_andnot_si128(cmpgt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(const VectorType a, const VectorType b) { return cmpgt(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const unsigned int a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const unsigned int a, const unsigned int b, const unsigned int c, const unsigned int d) { return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b, c, d); }
 
-#undef SUFFIX
+            Vc_OP(add) Vc_OP(sub)
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) { return a; }
         };
 
         template<> struct VectorHelper<signed short> {
             typedef _M128I VectorType;
             typedef signed short EntryType;
-#define SUFFIX si128
+#define Vc_SUFFIX si128
 
-            OP_(or_) OP_(and_) OP_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(_mm_castps_si128(mask), a); }
+            Vc_OP_(or_) Vc_OP_(and_) Vc_OP_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(_mm_castps_si128(mask), a); }
             static Vc_ALWAYS_INLINE Vc_CONST _M128I concat(_M128I a, _M128I b) { return _mm_packs_epi32(a, b); }
             static Vc_ALWAYS_INLINE Vc_CONST _M128I expand0(_M128I x) { return _mm_srai_epi32(_mm_unpacklo_epi16(x, x), 16); }
             static Vc_ALWAYS_INLINE Vc_CONST _M128I expand1(_M128I x) { return _mm_srai_epi32(_mm_unpackhi_epi16(x, x), 16); }
 
-#undef SUFFIX
-#define SUFFIX epi16
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return CAT(_mm_setone_, SUFFIX)(); }
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epi16
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }
 
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VectorType a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_slli_, Vc_SUFFIX)(a, shift);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VectorType a, int shift) {
-                return CAT(_mm_srai_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_srai_, Vc_SUFFIX)(a, shift);
             }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a) { return CAT(_mm_set1_, SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a, const EntryType b, const EntryType c, const EntryType d,
                     const EntryType e, const EntryType f, const EntryType g, const EntryType h) {
-                return CAT(_mm_set_, SUFFIX)(a, b, c, d, e, f, g, h);
+                return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b, c, d, e, f, g, h);
             }
 
             static Vc_ALWAYS_INLINE void fma(VectorType &v1, VectorType v2, VectorType v3) {
                 v1 = add(mul(v1, v2), v3); }
 
-            static Vc_INTRINSIC Vc_CONST VectorType abs(const VectorType a) { return mm_abs_epi16(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(const VectorType a) { return abs_epi16(a); }
 
-            OPx(mul, mullo)
-            OP(min) OP(max)
+            Vc_OPx(mul, mullo)
+            Vc_OP(min) Vc_OP(max)
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
                 a = min(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(1, 0, 3, 2)));
@@ -673,37 +504,36 @@
                 return _mm_cvtsi128_si32(a); // & 0xffff is implicit
             }
 
-            OP(add) OP(sub)
-            OPcmp(eq)
-            OPcmp(lt)
-            OPcmp(gt)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(const VectorType a, const VectorType b) { _M128I x = cmpeq(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(const VectorType a, const VectorType b) { _M128I x = cmplt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (const VectorType a, const VectorType b) { _M128I x = cmpgt(a, b); return _mm_andnot_si128(x, _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(const VectorType a, const VectorType b) { return cmpgt(a, b); }
-#undef SUFFIX
+            Vc_OP(add) Vc_OP(sub)
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) { return a; }
         };
 
         template<> struct VectorHelper<unsigned short> {
             typedef _M128I VectorType;
             typedef unsigned short EntryType;
-#define SUFFIX si128
-            OP_CAST_(or_) OP_CAST_(and_) OP_CAST_(xor_)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return CAT(_mm_setzero_, SUFFIX)(); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return CAT(_mm_and_, SUFFIX)(_mm_castps_si128(mask), a); }
-#ifdef VC_IMPL_SSE4_1
+#define Vc_SUFFIX si128
+            Vc_OP_CAST_(or_) Vc_OP_CAST_(and_) Vc_OP_CAST_(xor_)
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm_setzero_, Vc_SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VectorType a, _M128 mask) { return Vc_CAT2(_mm_and_, Vc_SUFFIX)(_mm_castps_si128(mask), a); }
+#ifdef Vc_IMPL_SSE4_1
             static Vc_ALWAYS_INLINE Vc_CONST _M128I concat(_M128I a, _M128I b) { return _mm_packus_epi32(a, b); }
 #else
-            // XXX too bad, but this is broken without SSE 4.1
-            static Vc_ALWAYS_INLINE Vc_CONST _M128I concat(_M128I a, _M128I b) { return _mm_packs_epi32(a, b); }
+            // FIXME too bad, but this is broken without SSE 4.1
+            static Vc_ALWAYS_INLINE Vc_CONST _M128I concat(_M128I a, _M128I b) {
+                auto tmp0 = _mm_unpacklo_epi16(a, b); // 0 4 X X 1 5 X X
+                auto tmp1 = _mm_unpackhi_epi16(a, b); // 2 6 X X 3 7 X X
+                auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1); // 0 2 4 6 X X X X
+                auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1); // 1 3 5 7 X X X X
+                return _mm_unpacklo_epi16(tmp2, tmp3); // 0 1 2 3 4 5 6 7
+            }
 #endif
-            static Vc_ALWAYS_INLINE Vc_CONST _M128I expand0(_M128I x) { return _mm_srli_epi32(_mm_unpacklo_epi16(x, x), 16); }
-            static Vc_ALWAYS_INLINE Vc_CONST _M128I expand1(_M128I x) { return _mm_srli_epi32(_mm_unpackhi_epi16(x, x), 16); }
-
-#undef SUFFIX
-#define SUFFIX epu16
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return CAT(_mm_setone_, SUFFIX)(); }
+            static Vc_ALWAYS_INLINE Vc_CONST _M128I expand0(_M128I x) { return _mm_unpacklo_epi16(x, _mm_setzero_si128()); }
+            static Vc_ALWAYS_INLINE Vc_CONST _M128I expand1(_M128I x) { return _mm_unpackhi_epi16(x, _mm_setzero_si128()); }
+
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epu16
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return Vc_CAT2(_mm_setone_, Vc_SUFFIX)(); }
 
 //X             template<unsigned int b> static Vc_ALWAYS_INLINE Vc_CONST VectorType mul(const VectorType a) {
 //X                 switch (b) {
@@ -723,24 +553,24 @@
 //X                 }
 //X                 return mul(a, set(b));
 //X             }
-#if !defined(USE_INCORRECT_UNSIGNED_COMPARE) || VC_IMPL_SSE4_1
-            static Vc_INTRINSIC Vc_CONST VectorType min(const VectorType a, const VectorType b) { return CAT(mm_min_, SUFFIX)(a, b); }
-            static Vc_INTRINSIC Vc_CONST VectorType max(const VectorType a, const VectorType b) { return CAT(mm_max_, SUFFIX)(a, b); }
+#if !defined(USE_INCORRECT_UNSIGNED_COMPARE) || Vc_IMPL_SSE4_1
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType min(VectorType a, VectorType b) { return min_epu16(a, b); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType max(VectorType a, VectorType b) { return max_epu16(a, b); }
 #endif
-#undef SUFFIX
-#define SUFFIX epi16
+#undef Vc_SUFFIX
+#define Vc_SUFFIX epi16
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftLeft(VectorType a, int shift) {
-                return CAT(_mm_slli_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_slli_, Vc_SUFFIX)(a, shift);
             }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType shiftRight(VectorType a, int shift) {
-                return CAT(_mm_srli_, SUFFIX)(a, shift);
+                return Vc_CAT2(_mm_srli_, Vc_SUFFIX)(a, shift);
             }
 
             static Vc_ALWAYS_INLINE void fma(VectorType &v1, VectorType v2, VectorType v3) { v1 = add(mul(v1, v2), v3); }
 
-            OPx(mul, mullo) // should work correctly for all values
-#if defined(USE_INCORRECT_UNSIGNED_COMPARE) && !defined(VC_IMPL_SSE4_1)
-            OP(min) OP(max) // XXX breaks for values with MSB set
+            Vc_OPx(mul, mullo) // should work correctly for all values
+#if defined(USE_INCORRECT_UNSIGNED_COMPARE) && !defined(Vc_IMPL_SSE4_1)
+            Vc_OP(min) Vc_OP(max) // XXX breaks for values with MSB set
 #endif
             static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VectorType a) {
                 // reminder: _MM_SHUFFLE(3, 2, 1, 0) means "no change"
@@ -770,45 +600,27 @@
                 a = add(a, _mm_shufflelo_epi16(a, _MM_SHUFFLE(1, 1, 1, 1)));
                 return _mm_cvtsi128_si32(a); // & 0xffff is implicit
             }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a) { return CAT(_mm_set1_, SUFFIX)(a); }
+            static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a) { return Vc_CAT2(_mm_set1_, Vc_SUFFIX)(a); }
             static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const EntryType a, const EntryType b, const EntryType c,
                     const EntryType d, const EntryType e, const EntryType f,
                     const EntryType g, const EntryType h) {
-                return CAT(_mm_set_, SUFFIX)(a, b, c, d, e, f, g, h);
+                return Vc_CAT2(_mm_set_, Vc_SUFFIX)(a, b, c, d, e, f, g, h);
             }
 
-            OP(add) OP(sub)
-            OPcmp(eq)
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpneq(const VectorType a, const VectorType b) { return _mm_andnot_si128(cmpeq(a, b), _mm_setallone_si128()); }
-
-#ifndef USE_INCORRECT_UNSIGNED_COMPARE
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmplt(const VectorType a, const VectorType b) {
-                return _mm_cmplt_epu16(a, b);
-            }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpgt(const VectorType a, const VectorType b) {
-                return _mm_cmpgt_epu16(a, b);
-            }
-#else
-            OPcmp(lt)
-            OPcmp(gt)
-#endif
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnlt(const VectorType a, const VectorType b) { return _mm_andnot_si128(cmplt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmple (const VectorType a, const VectorType b) { return _mm_andnot_si128(cmpgt(a, b), _mm_setallone_si128()); }
-            static Vc_ALWAYS_INLINE Vc_CONST VectorType cmpnle(const VectorType a, const VectorType b) { return cmpgt(a, b); }
-#undef SUFFIX
+            Vc_OP(add) Vc_OP(sub)
+#undef Vc_SUFFIX
             static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VectorType a) { return a; }
         };
-#undef OP1
-#undef OP
-#undef OP_
-#undef OPx
-#undef OPcmp
-
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
+#undef Vc_OP1
+#undef Vc_OP
+#undef Vc_OP_
+#undef Vc_OPx
+#undef Vc_OP_CAST_
+#undef Vc_MINMAX
+
+}  // namespace SSE
+}  // namespace Vc
 
 #include "vectorhelper.tcc"
-#include "undomacros.h"
 
-#endif // SSE_VECTORHELPER_H
+#endif // VC_SSE_VECTORHELPER_H_
diff -Nru vc-0.7.4/sse/vectorhelper.tcc vc-1.3.0/sse/vectorhelper.tcc
--- vc-0.7.4/sse/vectorhelper.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/vectorhelper.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,493 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "casts.h"
-#include <cstdlib>
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-namespace SSE
-{
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// float_v
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128 VectorHelper<_M128>::load(const float *x, AlignedFlag)
-{
-    return _mm_load_ps(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128 VectorHelper<_M128>::load(const float *x, UnalignedFlag)
-{
-    return _mm_loadu_ps(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128 VectorHelper<_M128>::load(const float *x, StreamingAndAlignedFlag)
-{
-    return _mm_stream_load(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128 VectorHelper<_M128>::load(const float *x, StreamingAndUnalignedFlag)
-{
-    return load(x, Unaligned);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// stores
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, AlignedFlag)
-{
-    _mm_store_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, UnalignedFlag)
-{
-    _mm_storeu_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, StreamingAndAlignedFlag)
-{
-    _mm_stream_ps(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, const VectorType m, AlignedFlag)
-{
-    _mm_store_ps(mem, mm_blendv_ps(_mm_load_ps(mem), x, m));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, const VectorType m, UnalignedFlag)
-{
-    _mm_storeu_ps(mem, mm_blendv_ps(_mm_loadu_ps(mem), x, m));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x), _mm_castps_si128(m), reinterpret_cast<char *>(mem));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128>::store(float *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x), _mm_castps_si128(m), reinterpret_cast<char *>(mem));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// sfloat_v
-template<> Vc_ALWAYS_INLINE Vc_PURE M256 VectorHelper<M256>::load(const float *x, AlignedFlag)
-{
-    return VectorType::create(_mm_load_ps(x), _mm_load_ps(x + 4));
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE M256 VectorHelper<M256>::load(const float *x, UnalignedFlag)
-{
-    return VectorType::create(_mm_loadu_ps(x), _mm_loadu_ps(x + 4));
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE M256 VectorHelper<M256>::load(const float *x, StreamingAndAlignedFlag)
-{
-    return VectorType::create(_mm_stream_load(&x[0]), _mm_stream_load(&x[4]));
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE M256 VectorHelper<M256>::load(const float *x, StreamingAndUnalignedFlag)
-{
-    return load(x, Unaligned);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// stores
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, AlignedFlag)
-{
-    _mm_store_ps(mem, x[0]);
-    _mm_store_ps(mem + 4, x[1]);
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, UnalignedFlag)
-{
-    _mm_storeu_ps(mem, x[0]);
-    _mm_storeu_ps(mem + 4, x[1]);
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, StreamingAndAlignedFlag)
-{
-    _mm_stream_ps(mem, x[0]);
-    _mm_stream_ps(mem + 4, x[1]);
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x[0]), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm_castps_si128(x[1]), _mm_setallone_si128(), reinterpret_cast<char *>(mem + 4));
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, VectorTypeArg m, AlignedFlag)
-{
-    _mm_store_ps(mem, mm_blendv_ps(_mm_load_ps(mem), x[0], m[0]));
-    _mm_store_ps(mem + 4, mm_blendv_ps(_mm_load_ps(mem + 4), x[1], m[1]));
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, VectorTypeArg m, UnalignedFlag)
-{
-    _mm_storeu_ps(mem, mm_blendv_ps(_mm_loadu_ps(mem), x[0], m[0]));
-    _mm_storeu_ps(mem + 4, mm_blendv_ps(_mm_loadu_ps(mem + 4), x[1], m[1]));
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, VectorTypeArg m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x[0]), _mm_castps_si128(m[0]), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm_castps_si128(x[1]), _mm_castps_si128(m[1]), reinterpret_cast<char *>(mem + 4));
-}
-Vc_ALWAYS_INLINE void VectorHelper<M256>::store(float *mem, VectorTypeArg x, VectorTypeArg m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castps_si128(x[0]), _mm_castps_si128(m[0]), reinterpret_cast<char *>(mem));
-    _mm_maskmoveu_si128(_mm_castps_si128(x[1]), _mm_castps_si128(m[1]), reinterpret_cast<char *>(mem + 4));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// double_v
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128D VectorHelper<_M128D>::load(const double *x, AlignedFlag)
-{
-    return _mm_load_pd(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128D VectorHelper<_M128D>::load(const double *x, UnalignedFlag)
-{
-    return _mm_loadu_pd(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128D VectorHelper<_M128D>::load(const double *x, StreamingAndAlignedFlag)
-{
-    return _mm_stream_load(x);
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE _M128D VectorHelper<_M128D>::load(const double *x, StreamingAndUnalignedFlag)
-{
-    return load(x, Unaligned);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// stores
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, AlignedFlag)
-{
-    _mm_store_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, UnalignedFlag)
-{
-    _mm_storeu_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, StreamingAndAlignedFlag)
-{
-    _mm_stream_pd(mem, x);
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castpd_si128(x), _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, const VectorType m, AlignedFlag)
-{
-    _mm_store_pd(mem, mm_blendv_pd(_mm_load_pd(mem), x, m));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, const VectorType m, UnalignedFlag)
-{
-    _mm_storeu_pd(mem, mm_blendv_pd(_mm_loadu_pd(mem), x, m));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castpd_si128(x), _mm_castpd_si128(m), reinterpret_cast<char *>(mem));
-}
-Vc_ALWAYS_INLINE void VectorHelper<_M128D>::store(double *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(_mm_castpd_si128(x), _mm_castpd_si128(m), reinterpret_cast<char *>(mem));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// int_v, uint_v, short_v, ushort_v
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE _M128I VectorHelper<_M128I>::load(const T *x, AlignedFlag)
-{
-    return _mm_load_si128(reinterpret_cast<const VectorType *>(x));
-}
-
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE _M128I VectorHelper<_M128I>::load(const T *x, UnalignedFlag)
-{
-    return _mm_loadu_si128(reinterpret_cast<const VectorType *>(x));
-}
-
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE _M128I VectorHelper<_M128I>::load(const T *x, StreamingAndAlignedFlag)
-{
-    return _mm_stream_load(x);
-}
-
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE _M128I VectorHelper<_M128I>::load(const T *x, StreamingAndUnalignedFlag)
-{
-    return load(x, Unaligned);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// stores
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, AlignedFlag)
-{
-    _mm_store_si128(reinterpret_cast<VectorType *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, UnalignedFlag)
-{
-    _mm_storeu_si128(reinterpret_cast<VectorType *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, StreamingAndAlignedFlag)
-{
-    _mm_stream_si128(reinterpret_cast<VectorType *>(mem), x);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(x, _mm_setallone_si128(), reinterpret_cast<char *>(mem));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, const VectorType m, AlignedFlag align)
-{
-    store(mem, mm_blendv_epi8(load(mem, align), x, m), align);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, const VectorType m, UnalignedFlag align)
-{
-    store(mem, mm_blendv_epi8(load(mem, align), x, m), align);
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, const VectorType m, StreamingAndAlignedFlag)
-{
-    _mm_maskmoveu_si128(x, m, reinterpret_cast<char *>(mem));
-}
-template<typename T> Vc_ALWAYS_INLINE void VectorHelper<_M128I>::store(T *mem, const VectorType x, const VectorType m, StreamingAndUnalignedFlag)
-{
-    _mm_maskmoveu_si128(x, m, reinterpret_cast<char *>(mem));
-}
-
-    template<> inline Vc_CONST _M128I SortHelper<_M128I, 8>::sort(_M128I x)
-    {
-        _M128I lo, hi, y;
-        // sort pairs
-        y = Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(x);
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-        x = mm_blend_epi16(lo, hi, 0xaa);
-
-        // merge left and right quads
-        y = Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(x);
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-        x = mm_blend_epi16(lo, hi, 0xcc);
-        y = _mm_srli_si128(x, 2);
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-        x = mm_blend_epi16(lo, _mm_slli_si128(hi, 2), 0xaa);
-
-        // merge quads into octs
-        y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
-        y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-
-        x = _mm_unpacklo_epi16(lo, hi);
-        y = _mm_srli_si128(x, 8);
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-
-        x = _mm_unpacklo_epi16(lo, hi);
-        y = _mm_srli_si128(x, 8);
-        lo = _mm_min_epi16(x, y);
-        hi = _mm_max_epi16(x, y);
-
-        return _mm_unpacklo_epi16(lo, hi);
-    }
-    template<> inline Vc_CONST _M128I SortHelper<_M128I, 4>::sort(_M128I x)
-    {
-        /*
-        // in 16,67% of the cases the merge can be replaced by an append
-
-        // x = [a b c d]
-        // y = [c d a b]
-        _M128I y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
-        _M128I l = mm_min_epi32(x, y); // min[ac bd ac bd]
-        _M128I h = mm_max_epi32(x, y); // max[ac bd ac bd]
-        if (IS_UNLIKELY(_mm_cvtsi128_si32(h) <= l[1])) { // l[0] < h[0] < l[1] < h[1]
-            return _mm_unpacklo_epi32(l, h);
-        }
-        // h[0] > l[1]
-        */
-
-        // sort pairs
-        _M128I y = _mm_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1));
-        _M128I l = mm_min_epi32(x, y);
-        _M128I h = mm_max_epi32(x, y);
-        x = _mm_unpacklo_epi32(l, h);
-        y = _mm_unpackhi_epi32(h, l);
-
-        // sort quads
-        l = mm_min_epi32(x, y);
-        h = mm_max_epi32(x, y);
-        x = _mm_unpacklo_epi32(l, h);
-        y = _mm_unpackhi_epi64(x, x);
-
-        l = mm_min_epi32(x, y);
-        h = mm_max_epi32(x, y);
-        return _mm_unpacklo_epi32(l, h);
-    }
-    template<> inline Vc_CONST _M128 SortHelper<_M128, 4>::sort(_M128 x)
-    {
-        _M128 y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(2, 3, 0, 1));
-        _M128 l = _mm_min_ps(x, y);
-        _M128 h = _mm_max_ps(x, y);
-        x = _mm_unpacklo_ps(l, h);
-        y = _mm_unpackhi_ps(h, l);
-
-        l = _mm_min_ps(x, y);
-        h = _mm_max_ps(x, y);
-        x = _mm_unpacklo_ps(l, h);
-        y = _mm_movehl_ps(x, x);
-
-        l = _mm_min_ps(x, y);
-        h = _mm_max_ps(x, y);
-        return _mm_unpacklo_ps(l, h);
-//X         _M128 k = _mm_cmpgt_ps(x, y);
-//X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(2, 2, 0, 0));
-//X         x = mm_blendv_ps(x, y, k);
-//X         y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(1, 0, 3, 2));
-//X         k = _mm_cmpgt_ps(x, y);
-//X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(1, 0, 1, 0));
-//X         x = mm_blendv_ps(x, y, k);
-//X         y = _mm_shuffle_ps(x, x, _MM_SHUFFLE(3, 1, 2, 0));
-//X         k = _mm_cmpgt_ps(x, y);
-//X         k = _mm_shuffle_ps(k, k, _MM_SHUFFLE(0, 1, 1, 0));
-//X         return mm_blendv_ps(x, y, k);
-    }
-    template<> inline Vc_PURE M256 SortHelper<M256, 8>::sort(const M256 &_x)
-    {
-	    M256 x = _x;
-        typedef SortHelper<_M128, 4> H;
-
-        _M128 a, b, l, h;
-        a = H::sort(x[0]);
-        b = H::sort(x[1]);
-
-        // merge
-        b = _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 1, 2, 3));
-        l = _mm_min_ps(a, b);
-        h = _mm_max_ps(a, b);
-
-        a = _mm_unpacklo_ps(l, h);
-        b = _mm_unpackhi_ps(l, h);
-        l = _mm_min_ps(a, b);
-        h = _mm_max_ps(a, b);
-
-        a = _mm_unpacklo_ps(l, h);
-        b = _mm_unpackhi_ps(l, h);
-        l = _mm_min_ps(a, b);
-        h = _mm_max_ps(a, b);
-
-        x[0] = _mm_unpacklo_ps(l, h);
-        x[1] = _mm_unpackhi_ps(l, h);
-        return x;
-    }
-    template<> inline Vc_CONST _M128D SortHelper<_M128D, 2>::sort(_M128D x)
-    {
-        const _M128D y = _mm_shuffle_pd(x, x, _MM_SHUFFLE2(0, 1));
-        return _mm_unpacklo_pd(_mm_min_sd(x, y), _mm_max_sd(x, y));
-    }
-
-    // can be used to multiply with a constant. For some special constants it doesn't need an extra
-    // vector but can use a shift instead, basically encoding the factor in the instruction.
-    template<typename IndexType, unsigned int constant> Vc_ALWAYS_INLINE Vc_CONST IndexType mulConst(const IndexType x) {
-        typedef VectorHelper<typename IndexType::EntryType> H;
-        switch (constant) {
-            case    0: return H::zero();
-            case    1: return x;
-            case    2: return H::slli(x.data(),  1);
-            case    4: return H::slli(x.data(),  2);
-            case    8: return H::slli(x.data(),  3);
-            case   16: return H::slli(x.data(),  4);
-            case   32: return H::slli(x.data(),  5);
-            case   64: return H::slli(x.data(),  6);
-            case  128: return H::slli(x.data(),  7);
-            case  256: return H::slli(x.data(),  8);
-            case  512: return H::slli(x.data(),  9);
-            case 1024: return H::slli(x.data(), 10);
-            case 2048: return H::slli(x.data(), 11);
-        }
-#ifndef VC_IMPL_SSE4_1
-        // without SSE 4.1 int multiplication is not so nice
-        if (sizeof(typename IndexType::EntryType) == 4) {
-            switch (constant) {
-                case    3: return H::add(        x.data()    , H::slli(x.data(),  1));
-                case    5: return H::add(        x.data()    , H::slli(x.data(),  2));
-                case    9: return H::add(        x.data()    , H::slli(x.data(),  3));
-                case   17: return H::add(        x.data()    , H::slli(x.data(),  4));
-                case   33: return H::add(        x.data()    , H::slli(x.data(),  5));
-                case   65: return H::add(        x.data()    , H::slli(x.data(),  6));
-                case  129: return H::add(        x.data()    , H::slli(x.data(),  7));
-                case  257: return H::add(        x.data()    , H::slli(x.data(),  8));
-                case  513: return H::add(        x.data()    , H::slli(x.data(),  9));
-                case 1025: return H::add(        x.data()    , H::slli(x.data(), 10));
-                case 2049: return H::add(        x.data()    , H::slli(x.data(), 11));
-                case    6: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  2));
-                case   10: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  3));
-                case   18: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  4));
-                case   34: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  5));
-                case   66: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  6));
-                case  130: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  7));
-                case  258: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  8));
-                case  514: return H::add(H::slli(x.data(), 1), H::slli(x.data(),  9));
-                case 1026: return H::add(H::slli(x.data(), 1), H::slli(x.data(), 10));
-                case 2050: return H::add(H::slli(x.data(), 1), H::slli(x.data(), 11));
-                case   12: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  3));
-                case   20: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  4));
-                case   36: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  5));
-                case   68: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  6));
-                case  132: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  7));
-                case  260: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  8));
-                case  516: return H::add(H::slli(x.data(), 2), H::slli(x.data(),  9));
-                case 1028: return H::add(H::slli(x.data(), 2), H::slli(x.data(), 10));
-                case 2052: return H::add(H::slli(x.data(), 2), H::slli(x.data(), 11));
-                case   24: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  4));
-                case   40: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  5));
-                case   72: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  6));
-                case  136: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  7));
-                case  264: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  8));
-                case  520: return H::add(H::slli(x.data(), 3), H::slli(x.data(),  9));
-                case 1032: return H::add(H::slli(x.data(), 3), H::slli(x.data(), 10));
-                case 2056: return H::add(H::slli(x.data(), 3), H::slli(x.data(), 11));
-                case   48: return H::add(H::slli(x.data(), 4), H::slli(x.data(),  5));
-                case   80: return H::add(H::slli(x.data(), 4), H::slli(x.data(),  6));
-                case  144: return H::add(H::slli(x.data(), 4), H::slli(x.data(),  7));
-                case  272: return H::add(H::slli(x.data(), 4), H::slli(x.data(),  8));
-                case  528: return H::add(H::slli(x.data(), 4), H::slli(x.data(),  9));
-                case 1040: return H::add(H::slli(x.data(), 4), H::slli(x.data(), 10));
-                case 2064: return H::add(H::slli(x.data(), 4), H::slli(x.data(), 11));
-                case   96: return H::add(H::slli(x.data(), 5), H::slli(x.data(),  6));
-                case  160: return H::add(H::slli(x.data(), 5), H::slli(x.data(),  7));
-                case  288: return H::add(H::slli(x.data(), 5), H::slli(x.data(),  8));
-                case  544: return H::add(H::slli(x.data(), 5), H::slli(x.data(),  9));
-                case 1056: return H::add(H::slli(x.data(), 5), H::slli(x.data(), 10));
-                case 2080: return H::add(H::slli(x.data(), 5), H::slli(x.data(), 11));
-                case  192: return H::add(H::slli(x.data(), 6), H::slli(x.data(),  7));
-                case  320: return H::add(H::slli(x.data(), 6), H::slli(x.data(),  8));
-                case  576: return H::add(H::slli(x.data(), 6), H::slli(x.data(),  9));
-                case 1088: return H::add(H::slli(x.data(), 6), H::slli(x.data(), 10));
-                case 2112: return H::add(H::slli(x.data(), 6), H::slli(x.data(), 11));
-                case  384: return H::add(H::slli(x.data(), 7), H::slli(x.data(),  8));
-                case  640: return H::add(H::slli(x.data(), 7), H::slli(x.data(),  9));
-                case 1152: return H::add(H::slli(x.data(), 7), H::slli(x.data(), 10));
-                case 2176: return H::add(H::slli(x.data(), 7), H::slli(x.data(), 11));
-                case  768: return H::add(H::slli(x.data(), 8), H::slli(x.data(),  9));
-                case 1280: return H::add(H::slli(x.data(), 8), H::slli(x.data(), 10));
-                case 2304: return H::add(H::slli(x.data(), 8), H::slli(x.data(), 11));
-                case 1536: return H::add(H::slli(x.data(), 9), H::slli(x.data(), 10));
-                case 2560: return H::add(H::slli(x.data(), 9), H::slli(x.data(), 11));
-                case 3072: return H::add(H::slli(x.data(),10), H::slli(x.data(), 11));
-            }
-        }
-#endif
-        return H::mul(x.data(), H::set(constant));
-    }
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
diff -Nru vc-0.7.4/sse/vector.tcc vc-1.3.0/sse/vector.tcc
--- vc-0.7.4/sse/vector.tcc	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/sse/vector.tcc	2016-10-27 02:05:02.000000000 -0500
@@ -1,1545 +1,808 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
+#include "../common/x86_prefetches.h"
 #include "limits.h"
 #include "../common/bitscanintrinsics.h"
+#include "../common/set.h"
+#include "../common/gatherimplementation.h"
+#include "../common/scatterimplementation.h"
+#include "../common/transpose.h"
 #include "macros.h"
 
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-ALIGN(64) extern unsigned int RandomState[16];
-
-namespace SSE
-{
-
-template<typename T, int Size> static Vc_ALWAYS_INLINE Vc_CONST const T *_IndexesFromZero() {
-    if (Size == 4) {
-        return reinterpret_cast<const T *>(_IndexesFromZero4);
-    } else if (Size == 8) {
-        return reinterpret_cast<const T *>(_IndexesFromZero8);
-    } else if (Size == 16) {
-        return reinterpret_cast<const T *>(_IndexesFromZero16);
-    }
-    return 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// constants {{{1
-template<typename T> Vc_INTRINSIC Vector<T>::Vector(VectorSpecialInitializerZero::ZEnum)
-    : d(VectorHelper<VectorType>::zero())
-{
-}
-
-template<typename T> Vc_INTRINSIC Vector<T>::Vector(VectorSpecialInitializerOne::OEnum)
-    : d(VectorHelper<T>::one())
+namespace Vc_VERSIONED_NAMESPACE
 {
-}
-
-template<typename T> Vc_INTRINSIC Vector<T>::Vector(VectorSpecialInitializerIndexesFromZero::IEnum)
-    : d(VectorHelper<VectorType>::load(_IndexesFromZero<EntryType, Size>(), Aligned))
+namespace Detail
 {
-}
+// compare operators {{{1
+Vc_INTRINSIC SSE::double_m operator==(SSE::double_v a, SSE::double_v b) { return _mm_cmpeq_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator==(SSE:: float_v a, SSE:: float_v b) { return _mm_cmpeq_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator==(SSE::   int_v a, SSE::   int_v b) { return _mm_cmpeq_epi32(a.data(), b.data()); }
+Vc_INTRINSIC SSE::  uint_m operator==(SSE::  uint_v a, SSE::  uint_v b) { return _mm_cmpeq_epi32(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: short_m operator==(SSE:: short_v a, SSE:: short_v b) { return _mm_cmpeq_epi16(a.data(), b.data()); }
+Vc_INTRINSIC SSE::ushort_m operator==(SSE::ushort_v a, SSE::ushort_v b) { return _mm_cmpeq_epi16(a.data(), b.data()); }
 
-template<typename T> Vc_INTRINSIC Vc_CONST Vector<T> Vector<T>::Zero()
-{
-    return VectorHelper<VectorType>::zero();
-}
+Vc_INTRINSIC SSE::double_m operator!=(SSE::double_v a, SSE::double_v b) { return _mm_cmpneq_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator!=(SSE:: float_v a, SSE:: float_v b) { return _mm_cmpneq_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator!=(SSE::   int_v a, SSE::   int_v b) { return not_(_mm_cmpeq_epi32(a.data(), b.data())); }
+Vc_INTRINSIC SSE::  uint_m operator!=(SSE::  uint_v a, SSE::  uint_v b) { return not_(_mm_cmpeq_epi32(a.data(), b.data())); }
+Vc_INTRINSIC SSE:: short_m operator!=(SSE:: short_v a, SSE:: short_v b) { return not_(_mm_cmpeq_epi16(a.data(), b.data())); }
+Vc_INTRINSIC SSE::ushort_m operator!=(SSE::ushort_v a, SSE::ushort_v b) { return not_(_mm_cmpeq_epi16(a.data(), b.data())); }
 
-template<typename T> Vc_INTRINSIC Vc_CONST Vector<T> Vector<T>::One()
-{
-    return VectorHelper<T>::one();
-}
-
-template<typename T> Vc_INTRINSIC Vc_CONST Vector<T> Vector<T>::IndexesFromZero()
-{
-    return VectorHelper<VectorType>::load(_IndexesFromZero<EntryType, Size>(), Aligned);
-}
-
-// conversion/casts {{{1
-template<typename T> template<typename OtherT> Vc_INTRINSIC Vector<T>::Vector(const Vector<OtherT> &x)
-    : d(StaticCastHelper<OtherT, T>::cast(x.data()))
-{
-}
-
-template<> template<> Vc_INTRINSIC short_v &Vector<short>::operator=(const ushort_v &x) {
-    data() = StaticCastHelper<unsigned short, short>::cast(x.data()); return *this;
-}
-template<> template<> Vc_INTRINSIC ushort_v &Vector<unsigned short>::operator=(const short_v &x) {
-    data() = StaticCastHelper<short, unsigned short>::cast(x.data()); return *this;
-}
-template<> template<> Vc_INTRINSIC int_v &Vector<int>::operator=(const uint_v &x) {
-    data() = StaticCastHelper<unsigned int, int>::cast(x.data()); return *this;
+Vc_INTRINSIC SSE::double_m operator> (SSE::double_v a, SSE::double_v b) { return _mm_cmpgt_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator> (SSE:: float_v a, SSE:: float_v b) { return _mm_cmpgt_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator> (SSE::   int_v a, SSE::   int_v b) { return _mm_cmpgt_epi32(a.data(), b.data()); }
+Vc_INTRINSIC SSE::  uint_m operator> (SSE::  uint_v a, SSE::  uint_v b) {
+#ifndef USE_INCORRECT_UNSIGNED_COMPARE
+    return SSE::cmpgt_epu32(a.data(), b.data());
+#else
+    return _mm_cmpgt_epi32(a.data(), b.data());
+#endif
 }
-template<> template<> Vc_INTRINSIC uint_v &Vector<unsigned int>::operator=(const int_v &x) {
-    data() = StaticCastHelper<int, unsigned int>::cast(x.data()); return *this;
+Vc_INTRINSIC SSE:: short_m operator> (SSE:: short_v a, SSE:: short_v b) { return _mm_cmpgt_epi16(a.data(), b.data()); }
+Vc_INTRINSIC SSE::ushort_m operator> (SSE::ushort_v a, SSE::ushort_v b) {
+#ifndef USE_INCORRECT_UNSIGNED_COMPARE
+    return SSE::cmpgt_epu16(a.data(), b.data());
+#else
+    return _mm_cmpgt_epi16(a.data(), b.data());
+#endif
 }
 
-// broadcasts {{{1
-template<typename T> Vc_INTRINSIC Vector<T>::Vector(EntryType a)
-    : d(VectorHelper<T>::set(a))
-{
+Vc_INTRINSIC SSE::double_m operator< (SSE::double_v a, SSE::double_v b) { return _mm_cmplt_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator< (SSE:: float_v a, SSE:: float_v b) { return _mm_cmplt_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator< (SSE::   int_v a, SSE::   int_v b) { return _mm_cmplt_epi32(a.data(), b.data()); }
+Vc_INTRINSIC SSE::  uint_m operator< (SSE::  uint_v a, SSE::  uint_v b) {
+#ifndef USE_INCORRECT_UNSIGNED_COMPARE
+    return SSE::cmplt_epu32(a.data(), b.data());
+#else
+    return _mm_cmplt_epi32(a.data(), b.data());
+#endif
 }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// load ctors {{{1
-template<typename T> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *x) { load(x); }
-template<typename T> template<typename A> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *x, A a) { load(x, a); }
-template<typename T> template<typename OtherT> Vc_ALWAYS_INLINE Vector<T>::Vector(const OtherT *x) { load(x); }
-template<typename T> template<typename OtherT, typename A> Vc_ALWAYS_INLINE Vector<T>::Vector(const OtherT *x, A a) { load(x, a); }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// load member functions {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::load(const EntryType *mem)
-{
-    load(mem, Aligned);
+Vc_INTRINSIC SSE:: short_m operator< (SSE:: short_v a, SSE:: short_v b) { return _mm_cmplt_epi16(a.data(), b.data()); }
+Vc_INTRINSIC SSE::ushort_m operator< (SSE::ushort_v a, SSE::ushort_v b) {
+#ifndef USE_INCORRECT_UNSIGNED_COMPARE
+    return SSE::cmplt_epu16(a.data(), b.data());
+#else
+    return _mm_cmplt_epi16(a.data(), b.data());
+#endif
 }
 
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::load(const EntryType *mem, A align)
-{
-    d.v() = VectorHelper<VectorType>::load(mem, align);
-}
+Vc_INTRINSIC SSE::double_m operator>=(SSE::double_v a, SSE::double_v b) { return _mm_cmpnlt_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator>=(SSE:: float_v a, SSE:: float_v b) { return _mm_cmpnlt_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator>=(SSE::   int_v a, SSE::   int_v b) { return !(a < b); }
+Vc_INTRINSIC SSE::  uint_m operator>=(SSE::  uint_v a, SSE::  uint_v b) { return !(a < b); }
+Vc_INTRINSIC SSE:: short_m operator>=(SSE:: short_v a, SSE:: short_v b) { return !(a < b); }
+Vc_INTRINSIC SSE::ushort_m operator>=(SSE::ushort_v a, SSE::ushort_v b) { return !(a < b); }
 
-template<typename T> template<typename OtherT> Vc_INTRINSIC void Vector<T>::load(const OtherT *mem)
-{
-    load(mem, Aligned);
-}
+Vc_INTRINSIC SSE::double_m operator<=(SSE::double_v a, SSE::double_v b) { return _mm_cmple_pd(a.data(), b.data()); }
+Vc_INTRINSIC SSE:: float_m operator<=(SSE:: float_v a, SSE:: float_v b) { return _mm_cmple_ps(a.data(), b.data()); }
+Vc_INTRINSIC SSE::   int_m operator<=(SSE::   int_v a, SSE::   int_v b) { return !(a > b); }
+Vc_INTRINSIC SSE::  uint_m operator<=(SSE::  uint_v a, SSE::  uint_v b) { return !(a > b); }
+Vc_INTRINSIC SSE:: short_m operator<=(SSE:: short_v a, SSE:: short_v b) { return !(a > b); }
+Vc_INTRINSIC SSE::ushort_m operator<=(SSE::ushort_v a, SSE::ushort_v b) { return !(a > b); }
 
-// float8: simply use the float implementation twice {{{2
-template<> template<typename OtherT, typename A> Vc_INTRINSIC void Vector<float8>::load(const OtherT *x, A a)
+// bitwise operators {{{1
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator^(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    d.v() = M256::create(
-            Vector<float>(&x[0], a).data(),
-            Vector<float>(&x[4], a).data()
-            );
+    return xor_(a.data(), b.data());
 }
-
-// LoadHelper {{{2
-template<typename DstT, typename SrcT, typename Flags> struct LoadHelper;
-
-// float {{{2
-template<typename Flags> struct LoadHelper<float, double, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const double *mem, Flags f)
-    {
-        return _mm_movelh_ps(_mm_cvtpd_ps(VectorHelper<__m128d>::load(&mem[0], f)),
-                             _mm_cvtpd_ps(VectorHelper<__m128d>::load(&mem[2], f)));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned int, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const unsigned int *mem, Flags f)
-    {
-        return StaticCastHelper<unsigned int, float>::cast(VectorHelper<__m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, int, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const int *mem, Flags f)
-    {
-        return StaticCastHelper<int, float>::cast(VectorHelper<__m128i>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const unsigned short *mem, Flags f)
-    {
-        return _mm_cvtepi32_ps(LoadHelper<int, unsigned short, Flags>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const short *mem, Flags f)
-    {
-        return _mm_cvtepi32_ps(LoadHelper<int, short, Flags>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, unsigned char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const unsigned char *mem, Flags f)
-    {
-        return _mm_cvtepi32_ps(LoadHelper<int, unsigned char, Flags>::load(mem, f));
-    }
-};
-template<typename Flags> struct LoadHelper<float, signed char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128 load(const signed char *mem, Flags f)
-    {
-        return _mm_cvtepi32_ps(LoadHelper<int, signed char, Flags>::load(mem, f));
-    }
-};
-
-// int {{{2
-template<typename Flags> struct LoadHelper<int, unsigned int, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned int *mem, Flags f)
-    {
-        return VectorHelper<__m128i>::load(mem, f);
-    }
-};
-// no difference between streaming and alignment, because the
-// 32/64 bit loads are not available as streaming loads, and can always be unaligned
-template<typename Flags> struct LoadHelper<int, unsigned short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned short *mem, Flags)
-    {
-        return mm_cvtepu16_epi32( _mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-template<typename Flags> struct LoadHelper<int, short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const short *mem, Flags)
-    {
-        return mm_cvtepi16_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-template<typename Flags> struct LoadHelper<int, unsigned char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned char *mem, Flags)
-    {
-        return mm_cvtepu8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const int *>(mem)));
-    }
-};
-template<typename Flags> struct LoadHelper<int, signed char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const signed char *mem, Flags)
-    {
-        return mm_cvtepi8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const int *>(mem)));
-    }
-};
-
-// unsigned int {{{2
-template<typename Flags> struct LoadHelper<unsigned int, unsigned short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned short *mem, Flags)
-    {
-        return mm_cvtepu16_epi32(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-template<typename Flags> struct LoadHelper<unsigned int, unsigned char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned char *mem, Flags)
-    {
-        return mm_cvtepu8_epi32(_mm_cvtsi32_si128(*reinterpret_cast<const int *>(mem)));
-    }
-};
-
-// short {{{2
-template<typename Flags> struct LoadHelper<short, unsigned short, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned short *mem, Flags f)
-    {
-        return VectorHelper<__m128i>::load(mem, f);
-    }
-};
-template<typename Flags> struct LoadHelper<short, unsigned char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned char *mem, Flags)
-    {
-        return mm_cvtepu8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-template<typename Flags> struct LoadHelper<short, signed char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const signed char *mem, Flags)
-    {
-        return mm_cvtepi8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-
-// unsigned short {{{2
-template<typename Flags> struct LoadHelper<unsigned short, unsigned char, Flags> {
-    static Vc_ALWAYS_INLINE Vc_PURE __m128i load(const unsigned char *mem, Flags)
-    {
-        return mm_cvtepu8_epi16(_mm_loadl_epi64(reinterpret_cast<const __m128i *>(mem)));
-    }
-};
-
-// general load, implemented via LoadHelper {{{2
-template<typename DstT> template<typename SrcT, typename Flags> Vc_INTRINSIC void Vector<DstT>::load(const SrcT *x, Flags f)
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator&(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    d.v() = LoadHelper<DstT, SrcT, Flags>::load(x, f);
+    return and_(a.data(), b.data());
 }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// expand/combine {{{1
-template<typename T> Vc_INTRINSIC Vector<T>::Vector(const Vector<typename CtorTypeHelper<T>::Type> *a)
-    : d(VectorHelper<T>::concat(a[0].data(), a[1].data()))
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator|(SSE::Vector<T> a, SSE::Vector<T> b)
 {
+    return or_(a.data(), b.data());
 }
-
-template<typename T> inline void Vector<T>::expand(Vector<typename ExpandTypeHelper<T>::Type> *x) const
+// arithmetic operators {{{1
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator+(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    if (Size == 8u) {
-        x[0].data() = VectorHelper<T>::expand0(data());
-        x[1].data() = VectorHelper<T>::expand1(data());
-    }
+    return add(a.data(), b.data(), T());
 }
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// zeroing {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::setZero()
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator-(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = VectorHelper<VectorType>::zero();
+    return sub(a.data(), b.data(), T());
 }
-
-template<typename T> Vc_INTRINSIC void Vector<T>::setZero(const Mask &k)
+template <typename T>
+Vc_INTRINSIC SSE::Vector<T> operator*(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = VectorHelper<VectorType>::andnot_(mm128_reinterpret_cast<VectorType>(k.data()), data());
+    return mul(a.data(), b.data(), T());
 }
-
-template<> Vc_INTRINSIC void Vector<double>::setQnan()
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_floating_point<T>::value, SSE::Vector<T>> operator/(
+    SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = _mm_setallone_pd();
+    return div(a.data(), b.data(), T());
 }
-template<> Vc_INTRINSIC void Vector<double>::setQnan(Mask::Argument k)
+template <typename T>
+Vc_INTRINSIC
+    enable_if<std::is_same<int, T>::value || std::is_same<uint, T>::value, SSE::Vector<T>>
+    operator/(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = _mm_or_pd(data(), k.dataD());
+    return SSE::Vector<T>::generate([&](int i) { return a[i] / b[i]; });
 }
-template<> Vc_INTRINSIC void Vector<float>::setQnan()
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_same<short, T>::value || std::is_same<ushort, T>::value,
+                       SSE::Vector<T>>
+operator/(SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = _mm_setallone_ps();
+    using HT = SSE::VectorHelper<T>;
+    __m128 lo = _mm_cvtepi32_ps(HT::expand0(a.data()));
+    __m128 hi = _mm_cvtepi32_ps(HT::expand1(a.data()));
+    lo = _mm_div_ps(lo, _mm_cvtepi32_ps(HT::expand0(b.data())));
+    hi = _mm_div_ps(hi, _mm_cvtepi32_ps(HT::expand1(b.data())));
+    return HT::concat(_mm_cvttps_epi32(lo), _mm_cvttps_epi32(hi));
 }
-template<> Vc_INTRINSIC void Vector<float>::setQnan(Mask::Argument k)
+template <typename T>
+Vc_INTRINSIC enable_if<std::is_integral<T>::value, SSE::Vector<T>> operator%(
+    SSE::Vector<T> a, SSE::Vector<T> b)
 {
-    data() = _mm_or_ps(data(), k.data());
+    return a - a / b * b;
 }
-template<> Vc_INTRINSIC void Vector<float8>::setQnan()
-{
-    d.v()[0] = _mm_setallone_ps();
-    d.v()[1] = _mm_setallone_ps();
-}
-template<> Vc_INTRINSIC void Vector<float8>::setQnan(Mask::Argument k)
+// }}}1
+}  // namespace Detail
+// constants {{{1
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Sse>::Vector(VectorSpecialInitializerZero)
+    : d(HV::zero())
 {
-    d.v()[0] = _mm_or_ps(d.v()[0], k.data()[0]);
-    d.v()[1] = _mm_or_ps(d.v()[1], k.data()[1]);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// stores {{{1
-template<typename T> Vc_INTRINSIC void Vector<T>::store(EntryType *mem) const
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Sse>::Vector(VectorSpecialInitializerOne)
+    : d(HT::one())
 {
-    VectorHelper<VectorType>::store(mem, data(), Aligned);
 }
 
-template<typename T> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, const Mask &mask) const
+template <typename T>
+Vc_INTRINSIC Vector<T, VectorAbi::Sse>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : d(Detail::load16(Detail::IndexesFromZero<EntryType, Size>(), Aligned))
 {
-    VectorHelper<VectorType>::store(mem, data(), mm128_reinterpret_cast<VectorType>(mask.data()), Aligned);
+#if defined Vc_GCC && Vc_GCC < 0x40903 && defined Vc_IMPL_AVX2
+    // GCC 4.9.2 (at least) miscompiles SSE::short_v::IndexesFromZero() if used implicitly
+    // from SimdArray<short, 9> compiling for AVX2 to vpmovsxwd (sign extending load from
+    // a 8x 16-bit constant to 8x 32-bit register)
+    if (std::is_same<T, short>::value) {
+        asm("" ::"x"(d.v()));
+    }
+#endif
 }
 
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, A align) const
+template <>
+Vc_INTRINSIC Vector<float, VectorAbi::Sse>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : d(SSE::convert<int, float>(SSE::int_v::IndexesFromZero().data()))
 {
-    VectorHelper<VectorType>::store(mem, data(), align);
 }
 
-template<typename T> template<typename A> Vc_INTRINSIC void Vector<T>::store(EntryType *mem, const Mask &mask, A align) const
+template <>
+Vc_INTRINSIC Vector<double, VectorAbi::Sse>::Vector(VectorSpecialInitializerIndexesFromZero)
+    : d(SSE::convert<int, double>(SSE::int_v::IndexesFromZero().data()))
 {
-    HV::store(mem, data(), mm128_reinterpret_cast<VectorType>(mask.data()), align);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// division {{{1
-template<typename T> Vc_INTRINSIC Vector<T> &WriteMaskedVector<T>::operator/=(const Vector<T> &x)
-{
-    return operator=(*vec / x);
-}
-template<> Vc_INTRINSIC int_v &WriteMaskedVector<int>::operator/=(const int_v &x)
-{
-    Vc_foreach_bit (int i, mask) {
-        vec->d.m(i) /= x.d.m(i);
-    }
-    return *vec;
-}
-template<> Vc_INTRINSIC uint_v &WriteMaskedVector<unsigned int>::operator/=(const uint_v &x)
-{
-    Vc_foreach_bit (int i, mask) {
-        vec->d.m(i) /= x.d.m(i);
-    }
-    return *vec;
-}
-template<> Vc_INTRINSIC short_v &WriteMaskedVector<short>::operator/=(const short_v &x)
-{
-    Vc_foreach_bit (int i, mask) {
-        vec->d.m(i) /= x.d.m(i);
-    }
-    return *vec;
-}
-template<> Vc_INTRINSIC ushort_v &WriteMaskedVector<unsigned short>::operator/=(const ushort_v &x)
-{
-    Vc_foreach_bit (int i, mask) {
-        vec->d.m(i) /= x.d.m(i);
-    }
-    return *vec;
-}
-
-template<typename T> inline Vector<T> &Vector<T>::operator/=(EntryType x)
+// load member functions {{{1
+template <typename DstT>
+template <typename SrcT, typename Flags>
+Vc_INTRINSIC typename Vector<DstT, VectorAbi::Sse>::
+#ifndef Vc_MSVC
+template
+#endif
+load_concept<SrcT, Flags>::type Vector<DstT, VectorAbi::Sse>::load(const SrcT *mem, Flags flags)
 {
-    if (VectorTraits<T>::HasVectorDivision) {
-        return operator/=(Vector<T>(x));
-    }
-    for_all_vector_entries(i,
-            d.m(i) /= x;
-            );
-    return *this;
+    Common::handleLoadPrefetches(mem, flags);
+    d.v() = Detail::load<VectorType, DstT>(mem, flags);
 }
 
-template<typename T> template<typename TT> Vc_INTRINSIC Vc_PURE VC_EXACT_TYPE(TT, typename DetermineEntryType<T>::Type, Vector<T>) Vector<T>::operator/(TT x) const
+// zeroing {{{1
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Sse>::setZero()
 {
-    if (VectorTraits<T>::HasVectorDivision) {
-        return operator/(Vector<T>(x));
-    }
-    Vector<T> r;
-    for_all_vector_entries(i,
-            r.d.m(i) = d.m(i) / x;
-            );
-    return r;
-}
-
-template<typename T> inline Vector<T> &Vector<T>::operator/=(const Vector<T> &x)
-{
-    for_all_vector_entries(i,
-            d.m(i) /= x.d.m(i);
-            );
-    return *this;
+    data() = HV::zero();
 }
 
-template<typename T> inline Vc_PURE Vector<T> Vector<T>::operator/(const Vector<T> &x) const
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Sse>::setZero(const Mask &k)
 {
-    Vector<T> r;
-    for_all_vector_entries(i,
-            r.d.m(i) = d.m(i) / x.d.m(i);
-            );
-    return r;
-}
-
-template<> inline Vector<short> &Vector<short>::operator/=(const Vector<short> &x)
-{
-    __m128 lo = _mm_cvtepi32_ps(VectorHelper<short>::expand0(d.v()));
-    __m128 hi = _mm_cvtepi32_ps(VectorHelper<short>::expand1(d.v()));
-    lo = _mm_div_ps(lo, _mm_cvtepi32_ps(VectorHelper<short>::expand0(x.d.v())));
-    hi = _mm_div_ps(hi, _mm_cvtepi32_ps(VectorHelper<short>::expand1(x.d.v())));
-    d.v() = _mm_packs_epi32(_mm_cvtps_epi32(lo), _mm_cvtps_epi32(hi));
-    return *this;
+    data() = Detail::andnot_(SSE::sse_cast<VectorType>(k.data()), data());
 }
 
-template<> inline Vc_PURE Vector<short> Vector<short>::operator/(const Vector<short> &x) const
+template<typename T> Vc_INTRINSIC void Vector<T, VectorAbi::Sse>::setZeroInverted(const Mask &k)
 {
-    __m128 lo = _mm_cvtepi32_ps(VectorHelper<short>::expand0(d.v()));
-    __m128 hi = _mm_cvtepi32_ps(VectorHelper<short>::expand1(d.v()));
-    lo = _mm_div_ps(lo, _mm_cvtepi32_ps(VectorHelper<short>::expand0(x.d.v())));
-    hi = _mm_div_ps(hi, _mm_cvtepi32_ps(VectorHelper<short>::expand1(x.d.v())));
-    return _mm_packs_epi32(_mm_cvtps_epi32(lo), _mm_cvtps_epi32(hi));
-}
-
-template<> inline Vector<unsigned short> &Vector<unsigned short>::operator/=(const Vector<unsigned short> &x)
-{
-    __m128 lo = _mm_cvtepi32_ps(VectorHelper<short>::expand0(d.v()));
-    __m128 hi = _mm_cvtepi32_ps(VectorHelper<short>::expand1(d.v()));
-    lo = _mm_div_ps(lo, _mm_cvtepi32_ps(VectorHelper<short>::expand0(x.d.v())));
-    hi = _mm_div_ps(hi, _mm_cvtepi32_ps(VectorHelper<short>::expand1(x.d.v())));
-    d.v() = _mm_packs_epi32(_mm_cvtps_epi32(lo), _mm_cvtps_epi32(hi));
-    return *this;
+    data() = Detail::and_(SSE::sse_cast<VectorType>(k.data()), data());
 }
 
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<unsigned short> Vector<unsigned short>::operator/(const Vector<unsigned short> &x) const
+template<> Vc_INTRINSIC void SSE::double_v::setQnan()
 {
-    __m128 lo = _mm_cvtepi32_ps(VectorHelper<short>::expand0(d.v()));
-    __m128 hi = _mm_cvtepi32_ps(VectorHelper<short>::expand1(d.v()));
-    lo = _mm_div_ps(lo, _mm_cvtepi32_ps(VectorHelper<short>::expand0(x.d.v())));
-    hi = _mm_div_ps(hi, _mm_cvtepi32_ps(VectorHelper<short>::expand1(x.d.v())));
-    return _mm_packs_epi32(_mm_cvtps_epi32(lo), _mm_cvtps_epi32(hi));
+    data() = SSE::_mm_setallone_pd();
 }
-
-template<> Vc_ALWAYS_INLINE Vector<float> &Vector<float>::operator/=(const Vector<float> &x)
+template<> Vc_INTRINSIC void Vector<double, VectorAbi::Sse>::setQnan(const Mask &k)
 {
-    d.v() = _mm_div_ps(d.v(), x.d.v());
-    return *this;
+    data() = _mm_or_pd(data(), k.dataD());
 }
-
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<float> Vector<float>::operator/(const Vector<float> &x) const
+template<> Vc_INTRINSIC void SSE::float_v::setQnan()
 {
-    return _mm_div_ps(d.v(), x.d.v());
+    data() = SSE::_mm_setallone_ps();
 }
-
-template<> Vc_ALWAYS_INLINE Vector<float8> &Vector<float8>::operator/=(const Vector<float8> &x)
+template<> Vc_INTRINSIC void Vector<float, VectorAbi::Sse>::setQnan(const Mask &k)
 {
-    d.v()[0] = _mm_div_ps(d.v()[0], x.d.v()[0]);
-    d.v()[1] = _mm_div_ps(d.v()[1], x.d.v()[1]);
-    return *this;
-}
-
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<float8> Vector<float8>::operator/(const Vector<float8> &x) const
-{
-    Vector<float8> r;
-    r.d.v()[0] = _mm_div_ps(d.v()[0], x.d.v()[0]);
-    r.d.v()[1] = _mm_div_ps(d.v()[1], x.d.v()[1]);
-    return r;
+    data() = _mm_or_ps(data(), k.data());
 }
 
-template<> Vc_ALWAYS_INLINE Vector<double> &Vector<double>::operator/=(const Vector<double> &x)
+///////////////////////////////////////////////////////////////////////////////////////////
+// stores {{{1
+template <typename T>
+template <typename U, typename Flags, typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Sse>::store(U *mem, Flags flags) const
 {
-    d.v() = _mm_div_pd(d.v(), x.d.v());
-    return *this;
+    Common::handleStorePrefetches(mem, flags);
+    HV::template store<Flags>(mem, data());
 }
 
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<double> Vector<double>::operator/(const Vector<double> &x) const
+template <typename T>
+template <typename U, typename Flags, typename>
+Vc_INTRINSIC void Vector<T, VectorAbi::Sse>::store(U *mem, Mask mask, Flags flags) const
 {
-    return _mm_div_pd(d.v(), x.d.v());
+    Common::handleStorePrefetches(mem, flags);
+    HV::template store<Flags>(mem, data(), sse_cast<VectorType>(mask.data()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 // operator- {{{1
-template<> Vc_ALWAYS_INLINE Vector<double> Vc_PURE Vc_FLATTEN Vector<double>::operator-() const
-{
-    return _mm_xor_pd(d.v(), _mm_setsignmask_pd());
-}
-template<> Vc_ALWAYS_INLINE Vector<float> Vc_PURE Vc_FLATTEN Vector<float>::operator-() const
-{
-    return _mm_xor_ps(d.v(), _mm_setsignmask_ps());
-}
-template<> Vc_ALWAYS_INLINE Vector<float8> Vc_PURE Vc_FLATTEN Vector<float8>::operator-() const
-{
-    return M256::create(
-            _mm_xor_ps(d.v()[0], _mm_setsignmask_ps()),
-            _mm_xor_ps(d.v()[1], _mm_setsignmask_ps()));
-}
-template<> Vc_ALWAYS_INLINE Vector<int> Vc_PURE Vc_FLATTEN Vector<int>::operator-() const
-{
-#ifdef VC_IMPL_SSSE3
-    return _mm_sign_epi32(d.v(), _mm_setallone_si128());
-#else
-    return _mm_add_epi32(_mm_xor_si128(d.v(), _mm_setallone_si128()), _mm_setone_epi32());
-#endif
-}
-template<> Vc_ALWAYS_INLINE Vector<int> Vc_PURE Vc_FLATTEN Vector<unsigned int>::operator-() const
-{
-#ifdef VC_IMPL_SSSE3
-    return _mm_sign_epi32(d.v(), _mm_setallone_si128());
-#else
-    return _mm_add_epi32(_mm_xor_si128(d.v(), _mm_setallone_si128()), _mm_setone_epi32());
-#endif
-}
-template<> Vc_ALWAYS_INLINE Vector<short> Vc_PURE Vc_FLATTEN Vector<short>::operator-() const
-{
-#ifdef VC_IMPL_SSSE3
-    return _mm_sign_epi16(d.v(), _mm_setallone_si128());
-#else
-    return _mm_mullo_epi16(d.v(), _mm_setallone_si128());
-#endif
-}
-template<> Vc_ALWAYS_INLINE Vector<short> Vc_PURE Vc_FLATTEN Vector<unsigned short>::operator-() const
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::operator-() const
 {
-#ifdef VC_IMPL_SSSE3
-    return _mm_sign_epi16(d.v(), _mm_setallone_si128());
-#else
-    return _mm_mullo_epi16(d.v(), _mm_setallone_si128());
-#endif
+    return Detail::negate(d.v(), std::integral_constant<std::size_t, sizeof(T)>());
 }
-
 ///////////////////////////////////////////////////////////////////////////////////////////
 // integer ops {{{1
-#define OP_IMPL(T, symbol, fun) \
-template<> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator symbol##=(const Vector<T> &x) \
-{ \
-    d.v() = VectorHelper<T>::fun(d.v(), x.d.v()); \
-    return *this; \
-} \
-template<> Vc_ALWAYS_INLINE Vc_PURE Vector<T>  Vector<T>::operator symbol(const Vector<T> &x) const \
-{ \
-    return VectorHelper<T>::fun(d.v(), x.d.v()); \
-}
-OP_IMPL(int, &, and_)
-OP_IMPL(int, |, or_)
-OP_IMPL(int, ^, xor_)
-OP_IMPL(unsigned int, &, and_)
-OP_IMPL(unsigned int, |, or_)
-OP_IMPL(unsigned int, ^, xor_)
-OP_IMPL(short, &, and_)
-OP_IMPL(short, |, or_)
-OP_IMPL(short, ^, xor_)
-OP_IMPL(unsigned short, &, and_)
-OP_IMPL(unsigned short, |, or_)
-OP_IMPL(unsigned short, ^, xor_)
-OP_IMPL(float, &, and_)
-OP_IMPL(float, |, or_)
-OP_IMPL(float, ^, xor_)
-OP_IMPL(float8, &, and_)
-OP_IMPL(float8, |, or_)
-OP_IMPL(float8, ^, xor_)
-OP_IMPL(double, &, and_)
-OP_IMPL(double, |, or_)
-OP_IMPL(double, ^, xor_)
-#undef OP_IMPL
-
-#ifdef VC_IMPL_XOP
-static Vc_INTRINSIC Vc_CONST __m128i shiftLeft (const    int_v &value, const    int_v &count) { return _mm_sha_epi32(value.data(), count.data()); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftLeft (const   uint_v &value, const   uint_v &count) { return _mm_shl_epi32(value.data(), count.data()); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftLeft (const  short_v &value, const  short_v &count) { return _mm_sha_epi16(value.data(), count.data()); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftLeft (const ushort_v &value, const ushort_v &count) { return _mm_shl_epi16(value.data(), count.data()); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftRight(const    int_v &value, const    int_v &count) { return shiftLeft(value,          -count ); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftRight(const   uint_v &value, const   uint_v &count) { return shiftLeft(value,   uint_v(-count)); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftRight(const  short_v &value, const  short_v &count) { return shiftLeft(value,          -count ); }
-static Vc_INTRINSIC Vc_CONST __m128i shiftRight(const ushort_v &value, const ushort_v &count) { return shiftLeft(value, ushort_v(-count)); }
-
-#define _VC_OP(T, symbol, impl) \
-template<> Vc_INTRINSIC T &T::operator symbol##=(T::AsArg shift) \
-{ \
-    d.v() = impl(*this, shift); \
-    return *this; \
-} \
-template<> Vc_INTRINSIC Vc_PURE T  T::operator symbol   (T::AsArg shift) const \
-{ \
-    return impl(*this, shift); \
-}
-VC_APPLY_2(VC_LIST_INT_VECTOR_TYPES, _VC_OP, <<, shiftLeft)
-VC_APPLY_2(VC_LIST_INT_VECTOR_TYPES, _VC_OP, >>, shiftRight)
-#undef _VC_OP
-#else
-#if defined(VC_GCC) && VC_GCC == 0x40600 && defined(VC_IMPL_XOP)
-#define VC_WORKAROUND __attribute__((optimize("no-tree-vectorize"),weak))
-#else
-#define VC_WORKAROUND Vc_INTRINSIC
-#endif
-
-#define OP_IMPL(T, symbol) \
-template<> VC_WORKAROUND Vector<T> &Vector<T>::operator symbol##=(Vector<T>::AsArg x) \
-{ \
-    for_all_vector_entries(i, \
-            d.m(i) symbol##= x.d.m(i); \
-            ); \
-    return *this; \
-} \
-template<> inline Vc_PURE Vector<T>  Vector<T>::operator symbol(Vector<T>::AsArg x) const \
-{ \
-    Vector<T> r; \
-    for_all_vector_entries(i, \
-            r.d.m(i) = d.m(i) symbol x.d.m(i); \
-            ); \
-    return r; \
-}
-OP_IMPL(int, <<)
-OP_IMPL(int, >>)
-OP_IMPL(unsigned int, <<)
-OP_IMPL(unsigned int, >>)
-OP_IMPL(short, <<)
-OP_IMPL(short, >>)
-OP_IMPL(unsigned short, <<)
-OP_IMPL(unsigned short, >>)
-#undef OP_IMPL
-#undef VC_WORKAROUND
+#ifdef Vc_IMPL_XOP
+template <> Vc_ALWAYS_INLINE    SSE::int_v    SSE::int_v::operator<<(const    SSE::int_v shift) const { return _mm_sha_epi32(d.v(), shift.d.v()); }
+template <> Vc_ALWAYS_INLINE   SSE::uint_v   SSE::uint_v::operator<<(const   SSE::uint_v shift) const { return _mm_shl_epi32(d.v(), shift.d.v()); }
+template <> Vc_ALWAYS_INLINE  SSE::short_v  SSE::short_v::operator<<(const  SSE::short_v shift) const { return _mm_sha_epi16(d.v(), shift.d.v()); }
+template <> Vc_ALWAYS_INLINE SSE::ushort_v SSE::ushort_v::operator<<(const SSE::ushort_v shift) const { return _mm_shl_epi16(d.v(), shift.d.v()); }
+template <> Vc_ALWAYS_INLINE    SSE::int_v    SSE::int_v::operator>>(const    SSE::int_v shift) const { return operator<<(-shift); }
+template <> Vc_ALWAYS_INLINE   SSE::uint_v   SSE::uint_v::operator>>(const   SSE::uint_v shift) const { return operator<<(-shift); }
+template <> Vc_ALWAYS_INLINE  SSE::short_v  SSE::short_v::operator>>(const  SSE::short_v shift) const { return operator<<(-shift); }
+template <> Vc_ALWAYS_INLINE SSE::ushort_v SSE::ushort_v::operator>>(const SSE::ushort_v shift) const { return operator<<(-shift); }
+#elif defined Vc_IMPL_AVX2
+template <> Vc_ALWAYS_INLINE SSE::Vector<   int> Vector<   int, VectorAbi::Sse>::operator<<(const SSE::Vector<   int> x) const { return _mm_sllv_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE SSE::Vector<  uint> Vector<  uint, VectorAbi::Sse>::operator<<(const SSE::Vector<  uint> x) const { return _mm_sllv_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE SSE::Vector<   int> Vector<   int, VectorAbi::Sse>::operator>>(const SSE::Vector<   int> x) const { return _mm_srav_epi32(d.v(), x.d.v()); }
+template <> Vc_ALWAYS_INLINE SSE::Vector<  uint> Vector<  uint, VectorAbi::Sse>::operator>>(const SSE::Vector<  uint> x) const { return _mm_srlv_epi32(d.v(), x.d.v()); }
 #endif
 
-template<typename T> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator>>=(int shift) {
-    d.v() = VectorHelper<T>::shiftRight(d.v(), shift);
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Sse> &Vector<T, VectorAbi::Sse>::operator>>=(int shift) {
+    d.v() = HT::shiftRight(d.v(), shift);
     return *this;
 }
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T> Vector<T>::operator>>(int shift) const {
-    return VectorHelper<T>::shiftRight(d.v(), shift);
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::operator>>(int shift) const {
+    return HT::shiftRight(d.v(), shift);
 }
-template<typename T> Vc_ALWAYS_INLINE Vector<T> &Vector<T>::operator<<=(int shift) {
-    d.v() = VectorHelper<T>::shiftLeft(d.v(), shift);
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Sse> &Vector<T, VectorAbi::Sse>::operator<<=(int shift) {
+    d.v() = HT::shiftLeft(d.v(), shift);
     return *this;
 }
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T> Vector<T>::operator<<(int shift) const {
-    return VectorHelper<T>::shiftLeft(d.v(), shift);
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::operator<<(int shift) const {
+    return HT::shiftLeft(d.v(), shift);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// swizzles {{{1
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T> &Vector<T>::abcd() const { return *this; }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::cdab() const { return Mem::permute<X2, X3, X0, X1>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::badc() const { return Mem::permute<X1, X0, X3, X2>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::aaaa() const { return Mem::permute<X0, X0, X0, X0>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::bbbb() const { return Mem::permute<X1, X1, X1, X1>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::cccc() const { return Mem::permute<X2, X2, X2, X2>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::dddd() const { return Mem::permute<X3, X3, X3, X3>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::bcad() const { return Mem::permute<X1, X2, X0, X3>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::bcda() const { return Mem::permute<X1, X2, X3, X0>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::dabc() const { return Mem::permute<X3, X0, X1, X2>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::acbd() const { return Mem::permute<X0, X2, X1, X3>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::dbca() const { return Mem::permute<X3, X1, X2, X0>(data()); }
-template<typename T> Vc_INTRINSIC Vc_PURE const Vector<T>  Vector<T>::dcba() const { return Mem::permute<X3, X2, X1, X0>(data()); }
-
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::cdab() const { return M256::create(Mem::permute<X2, X3, X0, X1>(d.v()[0]), Mem::permute<X2, X3, X0, X1>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::badc() const { return M256::create(Mem::permute<X1, X0, X3, X2>(d.v()[0]), Mem::permute<X1, X0, X3, X2>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::aaaa() const { return M256::create(Mem::permute<X0, X0, X0, X0>(d.v()[0]), Mem::permute<X0, X0, X0, X0>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::bbbb() const { return M256::create(Mem::permute<X1, X1, X1, X1>(d.v()[0]), Mem::permute<X1, X1, X1, X1>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::cccc() const { return M256::create(Mem::permute<X2, X2, X2, X2>(d.v()[0]), Mem::permute<X2, X2, X2, X2>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::dddd() const { return M256::create(Mem::permute<X3, X3, X3, X3>(d.v()[0]), Mem::permute<X3, X3, X3, X3>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::bcad() const { return M256::create(Mem::permute<X1, X2, X0, X3>(d.v()[0]), Mem::permute<X1, X2, X0, X3>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::bcda() const { return M256::create(Mem::permute<X1, X2, X3, X0>(d.v()[0]), Mem::permute<X1, X2, X3, X0>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::dabc() const { return M256::create(Mem::permute<X3, X0, X1, X2>(d.v()[0]), Mem::permute<X3, X0, X1, X2>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::acbd() const { return M256::create(Mem::permute<X0, X2, X1, X3>(d.v()[0]), Mem::permute<X0, X2, X1, X3>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::dbca() const { return M256::create(Mem::permute<X3, X1, X2, X0>(d.v()[0]), Mem::permute<X3, X1, X2, X0>(d.v()[1])); }
-template<> Vc_INTRINSIC Vc_PURE const sfloat_v Vector<sfloat>::dcba() const { return M256::create(Mem::permute<X3, X2, X1, X0>(d.v()[0]), Mem::permute<X3, X2, X1, X0>(d.v()[1])); }
-
-#define VC_SWIZZLES_16BIT_IMPL(T) \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::cdab() const { return Mem::permute<X2, X3, X0, X1, X6, X7, X4, X5>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::badc() const { return Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::aaaa() const { return Mem::permute<X0, X0, X0, X0, X4, X4, X4, X4>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::bbbb() const { return Mem::permute<X1, X1, X1, X1, X5, X5, X5, X5>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::cccc() const { return Mem::permute<X2, X2, X2, X2, X6, X6, X6, X6>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::dddd() const { return Mem::permute<X3, X3, X3, X3, X7, X7, X7, X7>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::bcad() const { return Mem::permute<X1, X2, X0, X3, X5, X6, X4, X7>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::bcda() const { return Mem::permute<X1, X2, X3, X0, X5, X6, X7, X4>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::dabc() const { return Mem::permute<X3, X0, X1, X2, X7, X4, X5, X6>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::acbd() const { return Mem::permute<X0, X2, X1, X3, X4, X6, X5, X7>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::dbca() const { return Mem::permute<X3, X1, X2, X0, X7, X5, X6, X4>(data()); } \
-template<> Vc_INTRINSIC Vc_PURE const Vector<T> Vector<T>::dcba() const { return Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(data()); }
-VC_SWIZZLES_16BIT_IMPL(short)
-VC_SWIZZLES_16BIT_IMPL(unsigned short)
-#undef VC_SWIZZLES_16BIT_IMPL
-
-// operators {{{1
-#include "../common/operators.h"
-// isNegative {{{1
-template<> Vc_INTRINSIC Vc_PURE float_m float_v::isNegative() const
-{
-    return sse_cast<__m128>(_mm_srai_epi32(sse_cast<__m128i>(_mm_and_ps(_mm_setsignmask_ps(), d.v())), 31));
-}
-template<> Vc_INTRINSIC Vc_PURE sfloat_m sfloat_v::isNegative() const
-{
-    return M256::create(
-            sse_cast<__m128>(_mm_srai_epi32(sse_cast<__m128i>(_mm_and_ps(_mm_setsignmask_ps(), d.v()[0])), 31)),
-            sse_cast<__m128>(_mm_srai_epi32(sse_cast<__m128i>(_mm_and_ps(_mm_setsignmask_ps(), d.v()[1])), 31))
-            );
-}
-template<> Vc_INTRINSIC Vc_PURE double_m double_v::isNegative() const
-{
-    return Mem::permute<X1, X1, X3, X3>(sse_cast<__m128>(
-                _mm_srai_epi32(sse_cast<__m128i>(_mm_and_pd(_mm_setsignmask_pd(), d.v())), 31)
-                ));
-}
-// gathers {{{1
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, const IndexT *indexes)
+// isnegative {{{1
+Vc_INTRINSIC Vc_CONST SSE::float_m isnegative(SSE::float_v x)
 {
-    gather(mem, indexes);
+    return sse_cast<__m128>(_mm_srai_epi32(
+        sse_cast<__m128i>(_mm_and_ps(SSE::_mm_setsignmask_ps(), x.data())), 31));
 }
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes)
+Vc_INTRINSIC Vc_CONST SSE::double_m isnegative(SSE::double_v x)
 {
-    gather(mem, indexes);
+    return Mem::permute<X1, X1, X3, X3>(sse_cast<__m128>(_mm_srai_epi32(
+        sse_cast<__m128i>(_mm_and_pd(SSE::_mm_setsignmask_pd(), x.data())), 31)));
 }
 
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, const IndexT *indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(mem, indexes, mask);
-}
-
-template<typename T> template<typename IndexT> Vc_ALWAYS_INLINE Vector<T>::Vector(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IndexT>) indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(mem, indexes, mask);
-}
-
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    gather(array, member1, indexes);
-}
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(array, member1, indexes, mask);
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    gather(array, member1, member2, indexes);
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(array, member1, member2, indexes, mask);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    gather(array, ptrMember1, outerIndexes, innerIndexes);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE Vector<T>::Vector(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask)
-    : d(HT::zero())
-{
-    gather(array, ptrMember1, outerIndexes, innerIndexes, mask);
-}
-
-template<typename T, size_t Size> struct IndexSizeChecker { static void check() {} };
-template<typename T, size_t Size> struct IndexSizeChecker<Vector<T>, Size>
-{
-    static void check() {
-        VC_STATIC_ASSERT(Vector<T>::Size >= Size, IndexVector_must_have_greater_or_equal_number_of_entries);
-    }
-};
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+// gathers {{{1
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::double_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
     d.v() = _mm_setr_pd(mem[indexes[0]], mem[indexes[1]]);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::float_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
     d.v() = _mm_setr_ps(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float8>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
-{
-    IndexSizeChecker<Index, Size>::check();
-    d.v()[0] = _mm_setr_ps(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
-    d.v()[1] = _mm_setr_ps(mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
-}
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::int_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
     d.v() = _mm_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::uint_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
     d.v() = _mm_setr_epi32(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]]);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::short_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-            mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
+    d.v() = Vc::set(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
+                    mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
 }
-template<> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes)
+
+template <>
+template <typename MT, typename IT>
+Vc_ALWAYS_INLINE void SSE::ushort_v::gatherImplementation(const MT *mem, IT &&indexes)
 {
-    IndexSizeChecker<Index, Size>::check();
-    d.v() = _mm_setr_epi16(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
-                mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
+    d.v() = Vc::set(mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], mem[indexes[3]],
+                    mem[indexes[4]], mem[indexes[5]], mem[indexes[6]], mem[indexes[7]]);
 }
 
-#ifdef VC_USE_SET_GATHERS
-template<typename T> template<typename IT> Vc_ALWAYS_INLINE void Vector<T>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Vector<IT>) indexes, MaskArg mask)
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Sse>::gatherImplementation(const MT *mem, IT &&indexes, MaskArgument mask)
 {
-    IndexSizeChecker<Vector<IT>, Size>::check();
-    Vector<IT> indexesTmp = indexes;
-    indexesTmp.setZero(!static_cast<typename Vector<IT>::Mask>(mask));
-    (*this)(mask) = Vector<T>(mem, indexesTmp);
-}
+    using Selector = std::integral_constant < Common::GatherScatterImplementation,
+#ifdef Vc_USE_SET_GATHERS
+          Traits::is_simd_vector<IT>::value ? Common::GatherScatterImplementation::SetIndexZero :
 #endif
-
-#ifdef VC_USE_BSF_GATHERS
-#define VC_MASKED_GATHER                        \
-    int bits = mask.toInt();                    \
-    while (bits) {                              \
-        const int i = _bit_scan_forward(bits);  \
-        bits &= ~(1 << i); /* btr? */           \
-        d.m(i) = ith_value(i);                  \
-    }
-#elif defined(VC_USE_POPCNT_BSF_GATHERS)
-#define VC_MASKED_GATHER                        \
-    unsigned int bits = mask.toInt();           \
-    unsigned int low, high = 0;                 \
-    switch (mask.count()) {             \
-    case 8:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 7:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 6:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 5:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 4:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-        high = (1 << high);                     \
-    case 3:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        d.m(low) = ith_value(low);              \
-    case 2:                                     \
-        high = _bit_scan_reverse(bits);         \
-        d.m(high) = ith_value(high);            \
-    case 1:                                     \
-        low = _bit_scan_forward(bits);          \
-        d.m(low) = ith_value(low);              \
-    case 0:                                     \
-        break;                                  \
-    }
+#ifdef Vc_USE_BSF_GATHERS
+                                            Common::GatherScatterImplementation::BitScanLoop
+#elif defined Vc_USE_POPCNT_BSF_GATHERS
+              Common::GatherScatterImplementation::PopcntSwitch
 #else
-#define VC_MASKED_GATHER                        \
-    if (mask.isEmpty()) {                       \
-        return;                                 \
-    }                                           \
-    for_all_vector_entries(i,                   \
-            if (mask[i]) d.m(i) = ith_value(i); \
-            );
+              Common::GatherScatterImplementation::SimpleLoop
 #endif
-
-template<typename T> template<typename Index>
-Vc_INTRINSIC void Vector<T>::gather(const EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask)
-{
-    IndexSizeChecker<Index, Size>::check();
-#define ith_value(_i_) (mem[indexes[_i_]])
-    VC_MASKED_GATHER
-#undef ith_value
+                                                > ;
+    Common::executeGather(Selector(), *this, mem, indexes, mask);
 }
 
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_pd(array[indexes[0]].*(member1), array[indexes[1]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_ps(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float8>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v()[0] = _mm_setr_ps(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1));
-    d.v()[1] = _mm_setr_ps(array[indexes[4]].*(member1), array[indexes[5]].*(member1), array[indexes[6]].*(member1),
-            array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi32(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi32(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1), array[indexes[1]].*(member1), array[indexes[2]].*(member1),
-            array[indexes[3]].*(member1), array[indexes[4]].*(member1), array[indexes[5]].*(member1),
-            array[indexes[6]].*(member1), array[indexes[7]].*(member1));
-}
-template<typename T> template<typename S1, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-{
-    IndexSizeChecker<IT, Size>::check();
-#define ith_value(_i_) (array[indexes[_i_]].*(member1))
-    VC_MASKED_GATHER
-#undef ith_value
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_pd(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_ps(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float8>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v()[0] = _mm_setr_ps(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2),
-            array[indexes[2]].*(member1).*(member2), array[indexes[3]].*(member1).*(member2));
-    d.v()[1] = _mm_setr_ps(array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi32(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2),
-            array[indexes[2]].*(member1).*(member2), array[indexes[3]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi32(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2),
-            array[indexes[2]].*(member1).*(member2), array[indexes[3]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes)
-{
-    IndexSizeChecker<IT, Size>::check();
-    d.v() = _mm_setr_epi16(array[indexes[0]].*(member1).*(member2), array[indexes[1]].*(member1).*(member2), array[indexes[2]].*(member1).*(member2),
-            array[indexes[3]].*(member1).*(member2), array[indexes[4]].*(member1).*(member2), array[indexes[5]].*(member1).*(member2),
-            array[indexes[6]].*(member1).*(member2), array[indexes[7]].*(member1).*(member2));
-}
-template<typename T> template<typename S1, typename S2, typename IT>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const S2 S1::* member1, const EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask)
-{
-    IndexSizeChecker<IT, Size>::check();
-#define ith_value(_i_) (array[indexes[_i_]].*(member1).*(member2))
-    VC_MASKED_GATHER
-#undef ith_value
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<double>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_pd((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]],
-            (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_ps((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<float8>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v()[0] = _mm_setr_ps((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]]);
-    d.v()[1] = _mm_setr_ps((array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<int>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi32((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned int>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi32((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<short>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi16((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<unsigned short>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-    d.v() = _mm_setr_epi16((array[outerIndexes[0]].*(ptrMember1))[innerIndexes[0]], (array[outerIndexes[1]].*(ptrMember1))[innerIndexes[1]],
-            (array[outerIndexes[2]].*(ptrMember1))[innerIndexes[2]], (array[outerIndexes[3]].*(ptrMember1))[innerIndexes[3]],
-            (array[outerIndexes[4]].*(ptrMember1))[innerIndexes[4]], (array[outerIndexes[5]].*(ptrMember1))[innerIndexes[5]],
-            (array[outerIndexes[6]].*(ptrMember1))[innerIndexes[6]], (array[outerIndexes[7]].*(ptrMember1))[innerIndexes[7]]);
-}
-template<typename T> template<typename S1, typename IT1, typename IT2>
-Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::gather(const S1 *array, const EntryType *const S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask)
-{
-    IndexSizeChecker<IT1, Size>::check();
-    IndexSizeChecker<IT2, Size>::check();
-#define ith_value(_i_) (array[outerIndexes[_i_]].*(ptrMember1))[innerIndexes[_i_]]
-    VC_MASKED_GATHER
-#undef ith_value
-}
 // scatters {{{1
-#undef VC_MASKED_GATHER
-#ifdef VC_USE_BSF_SCATTERS
-#define VC_MASKED_SCATTER                       \
-    int bits = mask.toInt();                    \
-    while (bits) {                              \
-        const int i = _bit_scan_forward(bits);  \
-        bits ^= (1 << i); /* btr? */            \
-        ith_value(i) = d.m(i);                  \
-    }
-#elif defined(VC_USE_POPCNT_BSF_SCATTERS)
-#define VC_MASKED_SCATTER                       \
-    unsigned int bits = mask.toInt();           \
-    unsigned int low, high = 0;                 \
-    switch (mask.count()) {             \
-    case 8:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 7:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 6:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 5:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 4:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-        high = (1 << high);                     \
-    case 3:                                     \
-        low = _bit_scan_forward(bits);          \
-        bits ^= high | (1 << low);              \
-        ith_value(low) = d.m(low);              \
-    case 2:                                     \
-        high = _bit_scan_reverse(bits);         \
-        ith_value(high) = d.m(high);            \
-    case 1:                                     \
-        low = _bit_scan_forward(bits);          \
-        ith_value(low) = d.m(low);              \
-    case 0:                                     \
-        break;                                  \
-    }
-#else
-#define VC_MASKED_SCATTER                       \
-    if (mask.isEmpty()) {                       \
-        return;                                 \
-    }                                           \
-    for_all_vector_entries(i,                   \
-            if (mask[i]) ith_value(i) = d.m(i); \
-            );
-#endif
-
-template<typename T> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes) const
-{
-    for_all_vector_entries(i,
-            mem[indexes[i]] = d.m(i);
-            );
-}
-template<typename T> template<typename Index> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(EntryType *mem, VC_ALIGNED_PARAMETER(Index) indexes, MaskArg mask) const
-{
-#define ith_value(_i_) mem[indexes[_i_]]
-    VC_MASKED_SCATTER
-#undef ith_value
-}
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes) const
-{
-    for_all_vector_entries(i,
-            array[indexes[i]].*(member1) = d.m(i);
-            );
-}
-template<typename T> template<typename S1, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType S1::* member1, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const
-{
-#define ith_value(_i_) array[indexes[_i_]].*(member1)
-    VC_MASKED_SCATTER
-#undef ith_value
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes) const
-{
-    for_all_vector_entries(i,
-            array[indexes[i]].*(member1).*(member2) = d.m(i);
-            );
-}
-template<typename T> template<typename S1, typename S2, typename IT> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, S2 S1::* member1, EntryType S2::* member2, VC_ALIGNED_PARAMETER(IT) indexes, MaskArg mask) const
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Sse>::scatterImplementation(MT *mem, IT &&indexes) const
 {
-#define ith_value(_i_) array[indexes[_i_]].*(member1).*(member2)
-    VC_MASKED_SCATTER
-#undef ith_value
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes) const
-{
-    for_all_vector_entries(i,
-            (array[innerIndexes[i]].*(ptrMember1))[outerIndexes[i]] = d.m(i);
-            );
-}
-template<typename T> template<typename S1, typename IT1, typename IT2> Vc_ALWAYS_INLINE void Vc_FLATTEN Vector<T>::scatter(S1 *array, EntryType *S1::* ptrMember1, VC_ALIGNED_PARAMETER(IT1) outerIndexes, VC_ALIGNED_PARAMETER(IT2) innerIndexes, MaskArg mask) const
-{
-#define ith_value(_i_) (array[outerIndexes[_i_]].*(ptrMember1))[innerIndexes[_i_]]
-    VC_MASKED_SCATTER
-#undef ith_value
+    Common::unrolled_loop<std::size_t, 0, Size>([&](std::size_t i) { mem[indexes[i]] = d.m(i); });
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
-// operator[] {{{1
-template<typename T> Vc_INTRINSIC typename Vector<T>::EntryType Vc_PURE Vector<T>::operator[](size_t index) const
-{
-    return d.m(index);
-}
-#ifdef VC_GCC
-template<> Vc_INTRINSIC double Vc_PURE Vector<double>::operator[](size_t index) const
-{
-    if (__builtin_constant_p(index)) {
-        return extract_double_imm(d.v(), index);
-    }
-    return d.m(index);
-}
-template<> Vc_INTRINSIC float Vc_PURE Vector<float>::operator[](size_t index) const
-{
-    return extract_float(d.v(), index);
-}
-template<> Vc_INTRINSIC float Vc_PURE Vector<float8>::operator[](size_t index) const
+template <typename T>
+template <typename MT, typename IT>
+inline void Vector<T, VectorAbi::Sse>::scatterImplementation(MT *mem, IT &&indexes, MaskArgument mask) const
 {
-    if (__builtin_constant_p(index)) {
-        if (index < 4) {
-            return extract_float_imm(d.v()[0], index);
-        }
-        return extract_float_imm(d.v()[1], index - 4);
-    }
-    return d.m(index);
-}
-template<> Vc_INTRINSIC int Vc_PURE Vector<int>::operator[](size_t index) const
-{
-    if (__builtin_constant_p(index)) {
-#if VC_GCC >= 0x40601 || !defined(VC_USE_VEX_CODING) // GCC < 4.6.1 incorrectly uses vmovq instead of movq for the following
-#ifdef __x86_64__
-        if (index == 0) return _mm_cvtsi128_si64(d.v()) & 0xFFFFFFFFull;
-        if (index == 1) return _mm_cvtsi128_si64(d.v()) >> 32;
-#else
-        if (index == 0) return _mm_cvtsi128_si32(d.v());
+    using Selector = std::integral_constant < Common::GatherScatterImplementation,
+#ifdef Vc_USE_SET_GATHERS
+          Traits::is_simd_vector<IT>::value ? Common::GatherScatterImplementation::SetIndexZero :
 #endif
-#endif
-#ifdef VC_IMPL_SSE4_1
-        return _mm_extract_epi32(d.v(), index);
+#ifdef Vc_USE_BSF_GATHERS
+                                            Common::GatherScatterImplementation::BitScanLoop
+#elif defined Vc_USE_POPCNT_BSF_GATHERS
+              Common::GatherScatterImplementation::PopcntSwitch
 #else
-        return _mm_cvtsi128_si32(_mm_srli_si128(d.v(), index * 4));
+              Common::GatherScatterImplementation::SimpleLoop
 #endif
-    }
-    return d.m(index);
+                                                > ;
+    Common::executeScatter(Selector(), *this, mem, indexes, mask);
 }
-template<> Vc_INTRINSIC unsigned int Vc_PURE Vector<unsigned int>::operator[](size_t index) const
-{
-    if (__builtin_constant_p(index)) {
-#if VC_GCC >= 0x40601 || !defined(VC_USE_VEX_CODING) // GCC < 4.6.1 incorrectly uses vmovq instead of movq for the following
-#ifdef __x86_64__
-        if (index == 0) return _mm_cvtsi128_si64(d.v()) & 0xFFFFFFFFull;
-        if (index == 1) return _mm_cvtsi128_si64(d.v()) >> 32;
-#else
-        if (index == 0) return _mm_cvtsi128_si32(d.v());
-#endif
-#endif
-#ifdef VC_IMPL_SSE4_1
-        return _mm_extract_epi32(d.v(), index);
-#else
-        return _mm_cvtsi128_si32(_mm_srli_si128(d.v(), index * 4));
-#endif
-    }
-    return d.m(index);
-}
-template<> Vc_INTRINSIC short Vc_PURE Vector<short>::operator[](size_t index) const
-{
-    if (__builtin_constant_p(index)) {
-        return _mm_extract_epi16(d.v(), index);
-    }
-    return d.m(index);
-}
-template<> Vc_INTRINSIC unsigned short Vc_PURE Vector<unsigned short>::operator[](size_t index) const
-{
-    if (__builtin_constant_p(index)) {
-        return _mm_extract_epi16(d.v(), index);
-    }
-    return d.m(index);
-}
-#endif // GCC
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 // horizontal ops {{{1
-#ifndef VC_IMPL_SSE4_1
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::partialSum() const
+{
+    //   a    b    c    d    e    f    g    h
+    // +      a    b    c    d    e    f    g    -> a ab bc  cd   de    ef     fg      gh
+    // +           a    ab   bc   cd   de   ef   -> a ab abc abcd bcde  cdef   defg    efgh
+    // +                     a    ab   abc  abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh
+    Vector<T, VectorAbi::Sse> tmp = *this;
+    if (Size >  1) tmp += tmp.shifted(-1);
+    if (Size >  2) tmp += tmp.shifted(-2);
+    if (Size >  4) tmp += tmp.shifted(-4);
+    if (Size >  8) tmp += tmp.shifted(-8);
+    if (Size > 16) tmp += tmp.shifted(-16);
+    return tmp;
+}
+#ifndef Vc_IMPL_SSE4_1
 // without SSE4.1 integer multiplication is slow and we rather multiply the scalars
-template<> Vc_INTRINSIC Vc_PURE int Vector<int>::product() const
+template<> Vc_INTRINSIC Vc_PURE int SSE::int_v::product() const
 {
     return (d.m(0) * d.m(1)) * (d.m(2) * d.m(3));
 }
-template<> Vc_INTRINSIC Vc_PURE unsigned int Vector<unsigned int>::product() const
+template<> Vc_INTRINSIC Vc_PURE unsigned int SSE::uint_v::product() const
 {
     return (d.m(0) * d.m(1)) * (d.m(2) * d.m(3));
 }
 #endif
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::EntryType Vector<T>::min(MaskArg m) const
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::EntryType Vector<T, VectorAbi::Sse>::min(MaskArg m) const
 {
-    Vector<T> tmp = std::numeric_limits<Vector<T> >::max();
+    Vector<T, VectorAbi::Sse> tmp = std::numeric_limits<Vector<T, VectorAbi::Sse> >::max();
     tmp(m) = *this;
     return tmp.min();
 }
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::EntryType Vector<T>::max(MaskArg m) const
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::EntryType Vector<T, VectorAbi::Sse>::max(MaskArg m) const
 {
-    Vector<T> tmp = std::numeric_limits<Vector<T> >::min();
+    Vector<T, VectorAbi::Sse> tmp = std::numeric_limits<Vector<T, VectorAbi::Sse> >::min();
     tmp(m) = *this;
     return tmp.max();
 }
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::EntryType Vector<T>::product(MaskArg m) const
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::EntryType Vector<T, VectorAbi::Sse>::product(MaskArg m) const
 {
-    Vector<T> tmp(VectorSpecialInitializerOne::One);
+    Vector<T, VectorAbi::Sse> tmp(Vc::One);
     tmp(m) = *this;
     return tmp.product();
 }
-template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T>::EntryType Vector<T>::sum(MaskArg m) const
+template<typename T> Vc_ALWAYS_INLINE Vc_PURE typename Vector<T, VectorAbi::Sse>::EntryType Vector<T, VectorAbi::Sse>::sum(MaskArg m) const
 {
-    Vector<T> tmp(VectorSpecialInitializerZero::Zero);
+    Vector<T, VectorAbi::Sse> tmp(Vc::Zero);
     tmp(m) = *this;
     return tmp.sum();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// copySign {{{1
-template<> Vc_INTRINSIC Vc_PURE Vector<float> Vector<float>::copySign(Vector<float>::AsArg reference) const
-{
-    return _mm_or_ps(
-            _mm_and_ps(reference.d.v(), _mm_setsignmask_ps()),
-            _mm_and_ps(d.v(), _mm_setabsmask_ps())
-            );
-}
-template<> Vc_INTRINSIC Vc_PURE Vector<float8> Vector<float8>::copySign(Vector<float8>::AsArg reference) const
-{
-    return M256::create( _mm_or_ps(
-                _mm_and_ps(reference.d.v()[0], _mm_setsignmask_ps()),
-                _mm_and_ps(d.v()[0], _mm_setabsmask_ps())
-                ), _mm_or_ps(
-                _mm_and_ps(reference.d.v()[1], _mm_setsignmask_ps()),
-                _mm_and_ps(d.v()[1], _mm_setabsmask_ps())
-                )
-            );
-}
-template<> Vc_INTRINSIC Vc_PURE Vector<double> Vector<double>::copySign(Vector<double>::AsArg reference) const
-{
-    return _mm_or_pd(
-            _mm_and_pd(reference.d.v(), _mm_setsignmask_pd()),
-            _mm_and_pd(d.v(), _mm_setabsmask_pd())
-            );
-}//}}}1
 // exponent {{{1
-template<> Vc_INTRINSIC Vc_PURE Vector<float> Vector<float>::exponent() const
+namespace Detail
+{
+Vc_INTRINSIC Vc_CONST __m128 exponent(__m128 v)
 {
-    VC_ASSERT((*this >= 0.f).isFull());
-    return Internal::exponent(d.v());
+    __m128i tmp = _mm_srli_epi32(_mm_castps_si128(v), 23);
+    tmp = _mm_sub_epi32(tmp, _mm_set1_epi32(0x7f));
+    return _mm_cvtepi32_ps(tmp);
 }
-template<> Vc_INTRINSIC Vc_PURE Vector<float8> Vector<float8>::exponent() const
+Vc_INTRINSIC Vc_CONST __m128d exponent(__m128d v)
 {
-    VC_ASSERT((*this >= 0.f).isFull());
-    return Internal::exponent(d.v());
+    __m128i tmp = _mm_srli_epi64(_mm_castpd_si128(v), 52);
+    tmp = _mm_sub_epi32(tmp, _mm_set1_epi32(0x3ff));
+    return _mm_cvtepi32_pd(_mm_shuffle_epi32(tmp, 0x08));
 }
-template<> Vc_INTRINSIC Vc_PURE Vector<double> Vector<double>::exponent() const
+} // namespace Detail
+
+Vc_INTRINSIC Vc_CONST SSE::float_v exponent(SSE::float_v x)
 {
-    VC_ASSERT((*this >= 0.).isFull());
-    return Internal::exponent(d.v());
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return Detail::exponent(x.data());
+}
+Vc_INTRINSIC Vc_CONST SSE::double_v exponent(SSE::double_v x)
+{
+    using Detail::operator>=;
+    Vc_ASSERT((x >= x.Zero()).isFull());
+    return Detail::exponent(x.data());
 }
 // }}}1
 // Random {{{1
-static void _doRandomStep(Vector<unsigned int> &state0,
-        Vector<unsigned int> &state1)
+static void _doRandomStep(SSE::uint_v &state0,
+        SSE::uint_v &state1)
 {
-    state0.load(&Vc::RandomState[0]);
-    state1.load(&Vc::RandomState[uint_v::Size]);
-    (state1 * 0xdeece66du + 11).store(&Vc::RandomState[uint_v::Size]);
-    uint_v(_mm_xor_si128((state0 * 0xdeece66du + 11).data(), _mm_srli_epi32(state1.data(), 16))).store(&Vc::RandomState[0]);
+    using SSE::uint_v;
+    using Detail::operator+;
+    using Detail::operator*;
+    state0.load(&Common::RandomState[0]);
+    state1.load(&Common::RandomState[uint_v::Size]);
+    (state1 * uint_v(0xdeece66du) + uint_v(11)).store(&Common::RandomState[uint_v::Size]);
+    uint_v(_mm_xor_si128((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),
+                         _mm_srli_epi32(state1.data(), 16)))
+        .store(&Common::RandomState[0]);
 }
 
-template<typename T> Vc_ALWAYS_INLINE Vector<T> Vector<T>::Random()
+template<typename T> Vc_ALWAYS_INLINE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::Random()
 {
-    Vector<unsigned int> state0, state1;
+    SSE::uint_v state0, state1;
     _doRandomStep(state0, state1);
-    return state0.reinterpretCast<Vector<T> >();
+    return state0.data();
 }
 
-template<> Vc_ALWAYS_INLINE Vector<float> Vector<float>::Random()
+template<> Vc_ALWAYS_INLINE SSE::float_v SSE::float_v::Random()
 {
-    Vector<unsigned int> state0, state1;
+    SSE::uint_v state0, state1;
     _doRandomStep(state0, state1);
     return _mm_sub_ps(_mm_or_ps(_mm_castsi128_ps(_mm_srli_epi32(state0.data(), 2)), HT::one()), HT::one());
 }
 
-template<> Vc_ALWAYS_INLINE Vector<float8> Vector<float8>::Random()
-{
-    Vector<unsigned int> state0, state1;
-    _doRandomStep(state0, state1);
-    state1 ^= state0 >> 16;
-    return M256::create(
-            _mm_sub_ps(_mm_or_ps(_mm_castsi128_ps(_mm_srli_epi32(state0.data(), 2)), VectorHelper<float>::one()), VectorHelper<float>::one()),
-            _mm_sub_ps(_mm_or_ps(_mm_castsi128_ps(_mm_srli_epi32(state1.data(), 2)), VectorHelper<float>::one()), VectorHelper<float>::one())
-            );
-}
-
-template<> Vc_ALWAYS_INLINE Vector<double> Vector<double>::Random()
+template<> Vc_ALWAYS_INLINE SSE::double_v SSE::double_v::Random()
 {
     typedef unsigned long long uint64 Vc_MAY_ALIAS;
-    uint64 state0 = *reinterpret_cast<const uint64 *>(&Vc::RandomState[8]);
-    uint64 state1 = *reinterpret_cast<const uint64 *>(&Vc::RandomState[10]);
-    const __m128i state = _mm_load_si128(reinterpret_cast<const __m128i *>(&Vc::RandomState[8]));
-    *reinterpret_cast<uint64 *>(&Vc::RandomState[ 8]) = (state0 * 0x5deece66dull + 11);
-    *reinterpret_cast<uint64 *>(&Vc::RandomState[10]) = (state1 * 0x5deece66dull + 11);
-    return (Vector<double>(_mm_castsi128_pd(_mm_srli_epi64(state, 12))) | One()) - One();
+    uint64 state0 = *reinterpret_cast<const uint64 *>(&Common::RandomState[8]);
+    uint64 state1 = *reinterpret_cast<const uint64 *>(&Common::RandomState[10]);
+    const __m128i state = _mm_load_si128(reinterpret_cast<const __m128i *>(&Common::RandomState[8]));
+    *reinterpret_cast<uint64 *>(&Common::RandomState[ 8]) = (state0 * 0x5deece66dull + 11);
+    *reinterpret_cast<uint64 *>(&Common::RandomState[10]) = (state1 * 0x5deece66dull + 11);
+    return _mm_sub_pd(_mm_or_pd(_mm_castsi128_pd(_mm_srli_epi64(state, 12)), HT::one()), HT::one());
 }
 // shifted / rotated {{{1
-template<typename T> Vc_INTRINSIC Vc_PURE Vector<T> Vector<T>::shifted(int amount) const
+template<typename T> Vc_INTRINSIC Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::shifted(int amount) const
 {
     enum {
         EntryTypeSizeof = sizeof(EntryType)
     };
     switch (amount) {
     case  0: return *this;
-    case  1: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 1 * EntryTypeSizeof));
-    case  2: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 2 * EntryTypeSizeof));
-    case  3: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 3 * EntryTypeSizeof));
-    case  4: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 4 * EntryTypeSizeof));
-    case  5: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 5 * EntryTypeSizeof));
-    case  6: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 6 * EntryTypeSizeof));
-    case  7: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 7 * EntryTypeSizeof));
-    case  8: return mm128_reinterpret_cast<VectorType>(_mm_srli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 8 * EntryTypeSizeof));
-    case -1: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 1 * EntryTypeSizeof));
-    case -2: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 2 * EntryTypeSizeof));
-    case -3: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 3 * EntryTypeSizeof));
-    case -4: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 4 * EntryTypeSizeof));
-    case -5: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 5 * EntryTypeSizeof));
-    case -6: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 6 * EntryTypeSizeof));
-    case -7: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 7 * EntryTypeSizeof));
-    case -8: return mm128_reinterpret_cast<VectorType>(_mm_slli_si128(mm128_reinterpret_cast<__m128i>(d.v()), 8 * EntryTypeSizeof));
+    case  1: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 1 * EntryTypeSizeof));
+    case  2: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 2 * EntryTypeSizeof));
+    case  3: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 3 * EntryTypeSizeof));
+    case  4: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 4 * EntryTypeSizeof));
+    case  5: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 5 * EntryTypeSizeof));
+    case  6: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 6 * EntryTypeSizeof));
+    case  7: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 7 * EntryTypeSizeof));
+    case  8: return SSE::sse_cast<VectorType>(_mm_srli_si128(SSE::sse_cast<__m128i>(d.v()), 8 * EntryTypeSizeof));
+    case -1: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 1 * EntryTypeSizeof));
+    case -2: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 2 * EntryTypeSizeof));
+    case -3: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 3 * EntryTypeSizeof));
+    case -4: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 4 * EntryTypeSizeof));
+    case -5: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 5 * EntryTypeSizeof));
+    case -6: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 6 * EntryTypeSizeof));
+    case -7: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 7 * EntryTypeSizeof));
+    case -8: return SSE::sse_cast<VectorType>(_mm_slli_si128(SSE::sse_cast<__m128i>(d.v()), 8 * EntryTypeSizeof));
     }
     return Zero();
 }
-template<> Vc_INTRINSIC Vc_PURE sfloat_v sfloat_v::shifted(int amount) const
+template<typename T> Vc_INTRINSIC Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::shifted(int amount, Vector shiftIn) const
 {
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    switch (amount) {
-    case -7: return M256::create(_mm_setzero_ps(), _mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 3 * EntryTypeSizeof)));
-    case -6: return M256::create(_mm_setzero_ps(), _mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 2 * EntryTypeSizeof)));
-    case -5: return M256::create(_mm_setzero_ps(), _mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 1 * EntryTypeSizeof)));
-    case -4: return M256::create(_mm_setzero_ps(), d.v()[0]);
-    case -3: return M256::create(_mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 3 * EntryTypeSizeof)), _mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 1 * EntryTypeSizeof)));
-    case -2: return M256::create(_mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 2 * EntryTypeSizeof)), _mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 2 * EntryTypeSizeof)));
-    case -1: return M256::create(_mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(d.v()[0]), 1 * EntryTypeSizeof)), _mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 3 * EntryTypeSizeof)));
-    case  0: return *this;
-    case  1: return M256::create(_mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 1 * EntryTypeSizeof)), _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 1 * EntryTypeSizeof)));
-    case  2: return M256::create(_mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 2 * EntryTypeSizeof)), _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 2 * EntryTypeSizeof)));
-    case  3: return M256::create(_mm_castsi128_ps(mm_alignr_epi8(_mm_castps_si128(d.v()[1]), _mm_castps_si128(d.v()[0]), 3 * EntryTypeSizeof)), _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 3 * EntryTypeSizeof)));
-    case  4: return M256::create(d.v()[1], _mm_setzero_ps());
-    case  5: return M256::create(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 1 * EntryTypeSizeof)), _mm_setzero_ps());
-    case  6: return M256::create(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 2 * EntryTypeSizeof)), _mm_setzero_ps());
-    case  7: return M256::create(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(d.v()[1]), 3 * EntryTypeSizeof)), _mm_setzero_ps());
+    if (amount >= -int(size())) {
+        constexpr int VectorWidth = int(size());
+        constexpr int EntryTypeSizeof = sizeof(EntryType);
+        const __m128i v0 = sse_cast<__m128i>(d.v());
+        const __m128i v1 = sse_cast<__m128i>(shiftIn.d.v());
+        auto &&fixup = sse_cast<VectorType, __m128i>;
+        switch (amount) {
+        case  0: return *this;
+                 // alignr_epi8: [arg1 arg0] << n
+        case -1: return fixup(SSE::alignr_epi8<(VectorWidth - 1) * EntryTypeSizeof>(v0, v1));
+        case -2: return fixup(SSE::alignr_epi8<(VectorWidth - 2) * EntryTypeSizeof>(v0, v1));
+        case -3: return fixup(SSE::alignr_epi8<(VectorWidth - 3) * EntryTypeSizeof>(v0, v1));
+        case -4: return fixup(SSE::alignr_epi8<(VectorWidth - 4) * EntryTypeSizeof>(v0, v1));
+        case -5: return fixup(SSE::alignr_epi8<(VectorWidth - 5) * EntryTypeSizeof>(v0, v1));
+        case -6: return fixup(SSE::alignr_epi8<(VectorWidth - 6) * EntryTypeSizeof>(v0, v1));
+        case -7: return fixup(SSE::alignr_epi8<(VectorWidth - 7) * EntryTypeSizeof>(v0, v1));
+        case -8: return fixup(SSE::alignr_epi8<(VectorWidth - 8) * EntryTypeSizeof>(v0, v1));
+        case -9: return fixup(SSE::alignr_epi8<(VectorWidth - 9) * EntryTypeSizeof>(v0, v1));
+        case-10: return fixup(SSE::alignr_epi8<(VectorWidth -10) * EntryTypeSizeof>(v0, v1));
+        case-11: return fixup(SSE::alignr_epi8<(VectorWidth -11) * EntryTypeSizeof>(v0, v1));
+        case-12: return fixup(SSE::alignr_epi8<(VectorWidth -12) * EntryTypeSizeof>(v0, v1));
+        case-13: return fixup(SSE::alignr_epi8<(VectorWidth -13) * EntryTypeSizeof>(v0, v1));
+        case-14: return fixup(SSE::alignr_epi8<(VectorWidth -14) * EntryTypeSizeof>(v0, v1));
+        case-15: return fixup(SSE::alignr_epi8<(VectorWidth -15) * EntryTypeSizeof>(v0, v1));
+        case  1: return fixup(SSE::alignr_epi8< 1 * EntryTypeSizeof>(v1, v0));
+        case  2: return fixup(SSE::alignr_epi8< 2 * EntryTypeSizeof>(v1, v0));
+        case  3: return fixup(SSE::alignr_epi8< 3 * EntryTypeSizeof>(v1, v0));
+        case  4: return fixup(SSE::alignr_epi8< 4 * EntryTypeSizeof>(v1, v0));
+        case  5: return fixup(SSE::alignr_epi8< 5 * EntryTypeSizeof>(v1, v0));
+        case  6: return fixup(SSE::alignr_epi8< 6 * EntryTypeSizeof>(v1, v0));
+        case  7: return fixup(SSE::alignr_epi8< 7 * EntryTypeSizeof>(v1, v0));
+        case  8: return fixup(SSE::alignr_epi8< 8 * EntryTypeSizeof>(v1, v0));
+        case  9: return fixup(SSE::alignr_epi8< 9 * EntryTypeSizeof>(v1, v0));
+        case 10: return fixup(SSE::alignr_epi8<10 * EntryTypeSizeof>(v1, v0));
+        case 11: return fixup(SSE::alignr_epi8<11 * EntryTypeSizeof>(v1, v0));
+        case 12: return fixup(SSE::alignr_epi8<12 * EntryTypeSizeof>(v1, v0));
+        case 13: return fixup(SSE::alignr_epi8<13 * EntryTypeSizeof>(v1, v0));
+        case 14: return fixup(SSE::alignr_epi8<14 * EntryTypeSizeof>(v1, v0));
+        case 15: return fixup(SSE::alignr_epi8<15 * EntryTypeSizeof>(v1, v0));
+        }
     }
-    return Zero();
+    return shiftIn.shifted(int(size()) + amount);
 }
-template<typename T> Vc_INTRINSIC Vc_PURE Vector<T> Vector<T>::rotated(int amount) const
+template<typename T> Vc_INTRINSIC Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::rotated(int amount) const
 {
     enum {
         EntryTypeSizeof = sizeof(EntryType)
     };
-    const __m128i v = mm128_reinterpret_cast<__m128i>(d.v());
+    const __m128i v = SSE::sse_cast<__m128i>(d.v());
     switch (static_cast<unsigned int>(amount) % Size) {
     case  0: return *this;
-    case  1: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 1 * EntryTypeSizeof));
-    case  2: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 2 * EntryTypeSizeof));
-    case  3: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 3 * EntryTypeSizeof));
+    case  1: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<1 * EntryTypeSizeof>(v, v));
+    case  2: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<2 * EntryTypeSizeof>(v, v));
+    case  3: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<3 * EntryTypeSizeof>(v, v));
              // warning "Immediate parameter to intrinsic call too large" disabled in VcMacros.cmake.
              // ICC fails to see that the modulo operation (Size == sizeof(VectorType) / sizeof(EntryType))
              // disables the following four calls unless sizeof(EntryType) == 2.
-    case  4: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 4 * EntryTypeSizeof));
-    case  5: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 5 * EntryTypeSizeof));
-    case  6: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 6 * EntryTypeSizeof));
-    case  7: return mm128_reinterpret_cast<VectorType>(mm_alignr_epi8(v, v, 7 * EntryTypeSizeof));
+    case  4: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<4 * EntryTypeSizeof>(v, v));
+    case  5: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<5 * EntryTypeSizeof>(v, v));
+    case  6: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<6 * EntryTypeSizeof>(v, v));
+    case  7: return SSE::sse_cast<VectorType>(SSE::alignr_epi8<7 * EntryTypeSizeof>(v, v));
     }
     return Zero();
 }
-template<> Vc_INTRINSIC Vc_PURE sfloat_v sfloat_v::rotated(int amount) const
+// sorted {{{1
+namespace Detail
 {
-    enum {
-        EntryTypeSizeof = sizeof(EntryType)
-    };
-    const __m128i v0 = sse_cast<__m128i>(d.v()[0]);
-    const __m128i v1 = sse_cast<__m128i>(d.v()[1]);
-    switch (static_cast<unsigned int>(amount) % Size) {
-    case  0: return *this;
-    case  1: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v1, v0, 1 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v0, v1, 1 * EntryTypeSizeof)));
-    case  2: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v1, v0, 2 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v0, v1, 2 * EntryTypeSizeof)));
-    case  3: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v1, v0, 3 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v0, v1, 3 * EntryTypeSizeof)));
-    case  4: return M256::create(d.v()[1], d.v()[0]);
-    case  5: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v0, v1, 1 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v1, v0, 1 * EntryTypeSizeof)));
-    case  6: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v0, v1, 2 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v1, v0, 2 * EntryTypeSizeof)));
-    case  7: return M256::create(sse_cast<__m128>(mm_alignr_epi8(v0, v1, 3 * EntryTypeSizeof)), sse_cast<__m128>(mm_alignr_epi8(v1, v0, 3 * EntryTypeSizeof)));
-    }
-    return Zero();
+inline Vc_CONST SSE::double_v sorted(SSE::double_v x_)
+{
+    const __m128d x = x_.data();
+    const __m128d y = _mm_shuffle_pd(x, x, _MM_SHUFFLE2(0, 1));
+    return _mm_unpacklo_pd(_mm_min_sd(x, y), _mm_max_sd(x, y));
+}
+}  // namespace Detail
+template <typename T>
+Vc_ALWAYS_INLINE Vc_PURE Vector<T, VectorAbi::Sse> Vector<T, VectorAbi::Sse>::sorted()
+    const
+{
+    return Detail::sorted(*this);
+}
+// interleaveLow/-High {{{1
+template <> Vc_INTRINSIC SSE::double_v SSE::double_v::interleaveLow (SSE::double_v x) const { return _mm_unpacklo_pd(data(), x.data()); }
+template <> Vc_INTRINSIC SSE::double_v SSE::double_v::interleaveHigh(SSE::double_v x) const { return _mm_unpackhi_pd(data(), x.data()); }
+template <> Vc_INTRINSIC  SSE::float_v  SSE::float_v::interleaveLow ( SSE::float_v x) const { return _mm_unpacklo_ps(data(), x.data()); }
+template <> Vc_INTRINSIC  SSE::float_v  SSE::float_v::interleaveHigh( SSE::float_v x) const { return _mm_unpackhi_ps(data(), x.data()); }
+template <> Vc_INTRINSIC    SSE::int_v    SSE::int_v::interleaveLow (   SSE::int_v x) const { return _mm_unpacklo_epi32(data(), x.data()); }
+template <> Vc_INTRINSIC    SSE::int_v    SSE::int_v::interleaveHigh(   SSE::int_v x) const { return _mm_unpackhi_epi32(data(), x.data()); }
+template <> Vc_INTRINSIC   SSE::uint_v   SSE::uint_v::interleaveLow (  SSE::uint_v x) const { return _mm_unpacklo_epi32(data(), x.data()); }
+template <> Vc_INTRINSIC   SSE::uint_v   SSE::uint_v::interleaveHigh(  SSE::uint_v x) const { return _mm_unpackhi_epi32(data(), x.data()); }
+template <> Vc_INTRINSIC  SSE::short_v  SSE::short_v::interleaveLow ( SSE::short_v x) const { return _mm_unpacklo_epi16(data(), x.data()); }
+template <> Vc_INTRINSIC  SSE::short_v  SSE::short_v::interleaveHigh( SSE::short_v x) const { return _mm_unpackhi_epi16(data(), x.data()); }
+template <> Vc_INTRINSIC SSE::ushort_v SSE::ushort_v::interleaveLow (SSE::ushort_v x) const { return _mm_unpacklo_epi16(data(), x.data()); }
+template <> Vc_INTRINSIC SSE::ushort_v SSE::ushort_v::interleaveHigh(SSE::ushort_v x) const { return _mm_unpackhi_epi16(data(), x.data()); }
+// }}}1
+// generate {{{1
+template <> template <typename G> Vc_INTRINSIC SSE::double_v SSE::double_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    return _mm_setr_pd(tmp0, tmp1);
+}
+template <> template <typename G> Vc_INTRINSIC SSE::float_v SSE::float_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    return _mm_setr_ps(tmp0, tmp1, tmp2, tmp3);
+}
+template <> template <typename G> Vc_INTRINSIC SSE::int_v SSE::int_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    return _mm_setr_epi32(tmp0, tmp1, tmp2, tmp3);
+}
+template <> template <typename G> Vc_INTRINSIC SSE::uint_v SSE::uint_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    return _mm_setr_epi32(tmp0, tmp1, tmp2, tmp3);
+}
+template <> template <typename G> Vc_INTRINSIC SSE::short_v SSE::short_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    return _mm_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
+}
+template <> template <typename G> Vc_INTRINSIC SSE::ushort_v SSE::ushort_v::generate(G gen)
+{
+    const auto tmp0 = gen(0);
+    const auto tmp1 = gen(1);
+    const auto tmp2 = gen(2);
+    const auto tmp3 = gen(3);
+    const auto tmp4 = gen(4);
+    const auto tmp5 = gen(5);
+    const auto tmp6 = gen(6);
+    const auto tmp7 = gen(7);
+    return _mm_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
 }
 // }}}1
-// sorted specializations {{{1
-template<> inline Vc_PURE uint_v uint_v::sorted() const
+// reversed {{{1
+template <> Vc_INTRINSIC Vc_PURE SSE::double_v SSE::double_v::reversed() const
 {
-    __m128i x = data();
-    __m128i y = _mm_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1));
-    __m128i l = mm_min_epu32(x, y);
-    __m128i h = mm_max_epu32(x, y);
-    x = _mm_unpacklo_epi32(l, h);
-    y = _mm_unpackhi_epi32(h, l);
-
-    // sort quads
-    l = mm_min_epu32(x, y);
-    h = mm_max_epu32(x, y);
-    x = _mm_unpacklo_epi32(l, h);
-    y = _mm_unpackhi_epi64(x, x);
-
-    l = mm_min_epu32(x, y);
-    h = mm_max_epu32(x, y);
-    return _mm_unpacklo_epi32(l, h);
-}
-template<> inline Vc_PURE ushort_v ushort_v::sorted() const
-{
-    __m128i lo, hi, y, x = data();
-    // sort pairs
-    y = Mem::permute<X1, X0, X3, X2, X5, X4, X7, X6>(x);
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-    x = mm_blend_epi16(lo, hi, 0xaa);
-
-    // merge left and right quads
-    y = Mem::permute<X3, X2, X1, X0, X7, X6, X5, X4>(x);
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-    x = mm_blend_epi16(lo, hi, 0xcc);
-    y = _mm_srli_si128(x, 2);
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-    x = mm_blend_epi16(lo, _mm_slli_si128(hi, 2), 0xaa);
-
-    // merge quads into octs
-    y = _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2));
-    y = _mm_shufflelo_epi16(y, _MM_SHUFFLE(0, 1, 2, 3));
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-
-    x = _mm_unpacklo_epi16(lo, hi);
-    y = _mm_srli_si128(x, 8);
-    lo = mm_min_epu16(x, y);
-    hi = mm_max_epu16(x, y);
-
-    return _mm_unpacklo_epi16(lo, hi);
+    return Mem::permute<X1, X0>(d.v());
+}
+template <> Vc_INTRINSIC Vc_PURE SSE::float_v SSE::float_v::reversed() const
+{
+    return Mem::permute<X3, X2, X1, X0>(d.v());
+}
+template <> Vc_INTRINSIC Vc_PURE SSE::int_v SSE::int_v::reversed() const
+{
+    return Mem::permute<X3, X2, X1, X0>(d.v());
+}
+template <> Vc_INTRINSIC Vc_PURE SSE::uint_v SSE::uint_v::reversed() const
+{
+    return Mem::permute<X3, X2, X1, X0>(d.v());
+}
+template <> Vc_INTRINSIC Vc_PURE SSE::short_v SSE::short_v::reversed() const
+{
+    return sse_cast<__m128i>(
+        Mem::shuffle<X1, Y0>(sse_cast<__m128d>(Mem::permuteHi<X7, X6, X5, X4>(d.v())),
+                             sse_cast<__m128d>(Mem::permuteLo<X3, X2, X1, X0>(d.v()))));
+}
+template <> Vc_INTRINSIC Vc_PURE SSE::ushort_v SSE::ushort_v::reversed() const
+{
+    return sse_cast<__m128i>(
+        Mem::shuffle<X1, Y0>(sse_cast<__m128d>(Mem::permuteHi<X7, X6, X5, X4>(d.v())),
+                             sse_cast<__m128d>(Mem::permuteLo<X3, X2, X1, X0>(d.v()))));
+}
+// }}}1
+// permutation via operator[] {{{1
+template <>
+Vc_INTRINSIC SSE::float_v SSE::float_v::operator[](const SSE::int_v &
+#ifdef Vc_IMPL_AVX
+                                             perm
+#endif
+                                         ) const
+{
+    /*
+    const int_m cross128 = concat(_mm_cmpgt_epi32(lo128(perm.data()), _mm_set1_epi32(3)),
+                                  _mm_cmplt_epi32(hi128(perm.data()), _mm_set1_epi32(4)));
+    if (cross128.isNotEmpty()) {
+    SSE::float_v x = _mm256_permutevar_ps(d.v(), perm.data());
+        x(cross128) = _mm256_permutevar_ps(Mem::permute128<X1, X0>(d.v()), perm.data());
+        return x;
+    } else {
+    */
+#ifdef Vc_IMPL_AVX
+    return _mm_permutevar_ps(d.v(), perm.data());
+#else
+    return *this;//TODO
+#endif
+}
+// broadcast from constexpr index {{{1
+template <> template <int Index> Vc_INTRINSIC SSE::float_v SSE::float_v::broadcast() const
+{
+    constexpr VecPos Inner = static_cast<VecPos>(Index & 0x3);
+    return Mem::permute<Inner, Inner, Inner, Inner>(d.v());
+}
+template <> template <int Index> Vc_INTRINSIC SSE::double_v SSE::double_v::broadcast() const
+{
+    constexpr VecPos Inner = static_cast<VecPos>(Index & 0x1);
+    return Mem::permute<Inner, Inner>(d.v());
 }
 // }}}1
-} // namespace SSE
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
 
-#include "undomacros.h"
+namespace Common
+{
+// transpose_impl {{{1
+Vc_ALWAYS_INLINE void transpose_impl(
+    TransposeTag<4, 4>, SSE::float_v *Vc_RESTRICT r[],
+    const TransposeProxy<SSE::float_v, SSE::float_v, SSE::float_v, SSE::float_v> &proxy)
+{
+    const auto in0 = std::get<0>(proxy.in).data();
+    const auto in1 = std::get<1>(proxy.in).data();
+    const auto in2 = std::get<2>(proxy.in).data();
+    const auto in3 = std::get<3>(proxy.in).data();
+    const auto tmp0 = _mm_unpacklo_ps(in0, in2);
+    const auto tmp1 = _mm_unpacklo_ps(in1, in3);
+    const auto tmp2 = _mm_unpackhi_ps(in0, in2);
+    const auto tmp3 = _mm_unpackhi_ps(in1, in3);
+    *r[0] = _mm_unpacklo_ps(tmp0, tmp1);
+    *r[1] = _mm_unpackhi_ps(tmp0, tmp1);
+    *r[2] = _mm_unpacklo_ps(tmp2, tmp3);
+    *r[3] = _mm_unpackhi_ps(tmp2, tmp3);
+}
+// }}}1
+}  // namespace Common
+}
 
 // vim: foldmethod=marker
diff -Nru vc-0.7.4/Test_all_compilers.sh vc-1.3.0/Test_all_compilers.sh
--- vc-0.7.4/Test_all_compilers.sh	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/Test_all_compilers.sh	2016-10-27 02:05:02.000000000 -0500
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/sh -e
 export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
 export LANG="en_US.UTF-8"
 export LANGUAGE="en_US.UTF-8"
@@ -9,16 +9,38 @@
 unset CFLAGS CXXFLAGS
 
 cd "`dirname "$0"`"
+test -z "dashboard_model" && export dashboard_model=Experimental
 
 runTest() {
-  CFLAGS="$1" CXXFLAGS="$1" ./Test_vc.sh Experimental
+  CFLAGS="$1" CXXFLAGS="$1" ctest -S test.cmake
+}
+
+tested_compilers="lsakdfjwowleqirjodfisj"
+
+runAllTests() {
+  # first make sure we don't test a compiler a second time
+  id="`which $CXX`"
+  id="`readlink -f $id`"
+  echo "$id"|grep -qF "$tested_compilers" && return
+  tested_compilers="$tested_compilers
+$id"
+
+  # alright run the ctest script
+  runTest &
+  supports32Bit && runTest -m32 &
+  supportsx32 && runTest -mx32 &
+  wait
 }
 
 supports32Bit() {
   test `uname -m` = "x86_64" || return 1
   CXX=${CXX:-c++}
   cat > /tmp/m32test.cpp <<END
+#include <algorithm>
+#include <string>
 #include <iostream>
+#include <cerrno>
+void foo(int x) { switch (x) { case 0x0A: break; case 0x0B: break; case 0x0C: break; case 0x0D: break; case 0x0E: break; } }
 int main() { std::cout << "Hello World!\n"; return 0; }
 END
   $CXX -m32 -o /tmp/m32test /tmp/m32test.cpp >/dev/null 2>&1 || return 1
@@ -26,25 +48,52 @@
   return 0
 }
 
-cxxlist="`find /usr/bin/ /usr/local/bin/ -name 'g++-*'`"
+supportsx32() {
+  test `uname -m` = "x86_64" || return 1
+  CXX=${CXX:-c++}
+  cat > /tmp/mx32test.cpp <<END
+#include <algorithm>
+#include <string>
+#include <iostream>
+#include <cerrno>
+void foo(int x) { switch (x) { case 0x0A: break; case 0x0B: break; case 0x0C: break; case 0x0D: break; case 0x0E: break; } }
+int main() { std::cout << "Hello World!\n"; return 0; }
+END
+  $CXX -mx32 -o /tmp/mx32test /tmp/mx32test.cpp >/dev/null 2>&1 || return 1
+  rm /tmp/mx32test*
+  return 0
+}
+
+cxxlist="`find /usr/bin/ /usr/local/bin/ -name '*++-[0-9]*'|grep -v -- -linux-gnu`"
 if test -z "$cxxlist"; then
-  cxxlist="`find /usr/bin/ /usr/local/bin/ -name 'g++'`"
+  cxxlist="`find /usr/bin/ /usr/local/bin/ -name '*++'|grep -v -- -linux-gnu`"
 fi
 if test -z "$cxxlist"; then
   # default compiler
-  runTest &
-  supports32Bit && runTest -m32 &
-  wait
+  runAllTests
 else
   for CXX in $cxxlist; do
-    CC=`echo "$CXX"|sed 's/g++/gcc/'`
-    if test -x "$CC" -a -x "$CXX"; then (
+    CC=`echo "$CXX"|sed 's/clang++/clang/;s/g++/gcc/'`
+    if test -x "$CC" -a -x "$CXX"; then
       export CC
       export CXX
-      runTest &
-      supports32Bit && runTest -m32 &
-      wait
-    ) fi
+      runAllTests
+    fi
+  done
+fi
+
+if test -r /etc/profile.d/modules.sh; then
+  source /etc/profile.d/modules.sh
+  for mod in `module avail -t 2>&1`; do
+    case `echo $mod|tr '[:upper:]' '[:lower:]'` in
+      *intel*|*icc*) export CC=icc CXX=icpc;;
+      *gnu*|*gcc*) export CC=gcc CXX=g++;;
+      *llvm*|*clang*) export CC=clang CXX=clang++;;
+      *) continue;;
+    esac
+    module load $mod
+    runAllTests
+    module unload $mod
   done
 fi
 
@@ -55,9 +104,7 @@
       ( cd $HOME/src/gcc-build && ./update.sh "`dirname "$VcEnv"`" )
       ;;
   esac
-  runTest &
-  supports32Bit && runTest -m32 &
-  wait
+  runAllTests
 ) done
 
 export CC=icc
@@ -73,7 +120,5 @@
 esac
 test -n "$icclist" && for IccEnv in $icclist; do (
   . $IccEnv $arch
-  runTest &
-  supports32Bit && runTest -m32 &
-  wait
+  runAllTests
 ) done
diff -Nru vc-0.7.4/test.cmake vc-1.3.0/test.cmake
--- vc-0.7.4/test.cmake	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/test.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -2,27 +2,72 @@
    get_filename_component(CTEST_SOURCE_DIRECTORY "${CMAKE_CURRENT_LIST_FILE}" PATH)
 endif()
 
+# Dashboard Model
+################################################################################
 set(dashboard_model "$ENV{dashboard_model}")
 if(NOT dashboard_model)
    set(dashboard_model "Experimental")
 endif()
+
+# Set build variables from environment variables
+################################################################################
 set(target_architecture "$ENV{target_architecture}")
 set(skip_tests "$ENV{skip_tests}")
 
-set(build_type "$ENV{build_type}")
+# Set CMAKE_BUILD_TYPE from environment variable
+################################################################################
+set(appveyor $ENV{APPVEYOR})
+if(appveyor)
+   set(build_type "$ENV{CONFIGURATION}")
+else()
+   set(build_type "$ENV{build_type}")
+endif()
 if(NOT build_type)
    set(build_type "Release")
 endif()
 
 # better make sure we get english output (this is vital for the implicit_type_conversion_failures tests)
+################################################################################
 set(ENV{LANG} "en_US")
 
+# determine the git branch we're testing
+################################################################################
+file(READ "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" git_branch)
+string(STRIP "${git_branch}" git_branch)
+# -> ref: refs/heads/foobar
+string(REGEX REPLACE "^.*/" "" git_branch "${git_branch}")
+# -> foobar
+if(git_branch MATCHES "^[0-9a-f]+$")
+   # it's a hash -> make it short
+   string(SUBSTRING "${git_branch}" 0 7 git_branch)
+elseif(git_branch MATCHES "^gh-[0-9]+")
+   # it's a feature branch referencing a GitHub issue number -> make it short
+   string(REGEX MATCH "^gh-[0-9]+" git_branch "${git_branch}")
+endif()
+
+# determine the (short) hostname of the build machine
+################################################################################
+set(travis_os $ENV{TRAVIS_OS_NAME})
+if(travis_os)
+   set(CTEST_SITE "Travis CI")
+elseif(appveyor)
+   set(CTEST_SITE "AppVeyor CI")
+else()
+   execute_process(COMMAND hostname -s RESULT_VARIABLE ok OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+   if(NOT ok EQUAL 0)
+      execute_process(COMMAND hostname OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+   endif()
+endif()
+
+# collect system information for the "Build Name" (and build setup, e.g. -j)
+################################################################################
 find_program(UNAME uname)
 if(UNAME)
    execute_process(COMMAND ${UNAME} -s OUTPUT_VARIABLE arch OUTPUT_STRIP_TRAILING_WHITESPACE)
    string(TOLOWER "${arch}" arch)
    execute_process(COMMAND ${UNAME} -m OUTPUT_VARIABLE chip OUTPUT_STRIP_TRAILING_WHITESPACE)
    string(TOLOWER "${chip}" chip)
+   string(REPLACE "x86_64" "amd64" chip "${chip}")
 else()
    find_program(CMD cmd)
    if(CMD)
@@ -42,7 +87,7 @@
       reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0" /v Identifier
       OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE processorId)
    if("${processorId}" MATCHES "AMD64")
-      set(chip "x86_64")
+      set(chip "amd64")
    elseif("${processorId}" MATCHES "x86")
       set(chip "x86")
    else()
@@ -50,131 +95,193 @@
    endif()
 endif()
 
-if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7")
-   find_program(CL cl)
-   execute_process(COMMAND ${CL} /nologo -EP "${CTEST_SOURCE_DIRECTORY}/cmake/msvc_version.c" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE COMPILER_VERSION)
-   string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION)
-   if("${CL}" MATCHES "amd64")
-      set(COMPILER_VERSION "${COMPILER_VERSION} x86 64bit")
-   elseif("${CL}" MATCHES "ia64")
-      set(COMPILER_VERSION "${COMPILER_VERSION} Itanium")
-   else()
-      set(COMPILER_VERSION "${COMPILER_VERSION} x86 32bit")
-   endif()
-   set(number_of_processors "$ENV{NUMBER_OF_PROCESSORS}")
-   if(NOT number_of_processors)
+# determine a short description of the OS we're running on
+################################################################################
+if(arch STREQUAL "linux")
+   execute_process(COMMAND lsb_release -d COMMAND cut -f2 OUTPUT_VARIABLE os_ident)
+   string(REGEX REPLACE "\\(.*\\)" "" os_ident "${os_ident}") # shorten the Distribution string, stripping everything in parens
+   string(REPLACE "Scientific Linux SL" "SL" os_ident "${os_ident}")
+   string(REPLACE " release" "" os_ident "${os_ident}")
+   string(REPLACE " GNU/Linux" "" os_ident "${os_ident}")
+   string(REPLACE "openSUSE" "Suse" os_ident "${os_ident}")
+   string(REPLACE " User Edition" "" os_ident "${os_ident}")
+   string(STRIP "${os_ident}" os_ident)
+elseif(arch STREQUAL "darwin")
+   set(os_ident "OSX")
+else()
+   set(os_ident "${arch}")
+   string(REPLACE "Windows" "Win" os_ident "${os_ident}")
+endif()
+
+# Determine the processor count (number_of_processors)
+################################################################################
+set(number_of_processors "$ENV{NUMBER_OF_PROCESSORS}")
+if(NOT number_of_processors)
+   if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7" OR "${arch}" MATCHES "mingw" OR "${arch}" MATCHES "msys")
       execute_process(COMMAND
          reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor"
          OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
       string(REGEX REPLACE "[^0-9]+" "," number_of_processors "${number_of_processors}")
       string(REGEX REPLACE "^.*," "" number_of_processors "${number_of_processors}")
       math(EXPR number_of_processors "1 + ${number_of_processors}")
+   elseif("${arch}" STREQUAL "darwin")
+      execute_process(COMMAND sysctl -n hw.ncpu OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
+   else()
+      execute_process(COMMAND grep -c processor /proc/cpuinfo OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
    endif()
-elseif(arch MATCHES "mingw")
-   find_program(CL cl)
-   find_program(GXX "g++")
-   if("$ENV{CXX}" MATCHES "g\\+\\+")
-      set(GXX "$ENV{CXX}")
-   endif()
-   if(GXX)
-      execute_process(COMMAND "${GXX}" --version OUTPUT_VARIABLE COMPILER_VERSION ERROR_VARIABLE COMPILER_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
-      string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION}")
-      list(GET COMPILER_VERSION 0 COMPILER_VERSION)
-   elseif(CL)
+endif()
+
+# Determine the compiler version string
+################################################################################
+set(compiler)
+macro(extract_msvc_compiler_info CL)
+   if(CL)
       execute_process(COMMAND ${CL} /nologo -EP "${CTEST_SOURCE_DIRECTORY}/cmake/msvc_version.c" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE COMPILER_VERSION)
       string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION)
+      if("${CL}" MATCHES "amd64")
+         set(COMPILER_VERSION "${COMPILER_VERSION} amd64")
+      elseif("${CL}" MATCHES "ia64")
+         set(COMPILER_VERSION "${COMPILER_VERSION} ia64")
+      else()
+         set(COMPILER_VERSION "${COMPILER_VERSION} x86")
+      endif()
+      set(compiler "MSVC")
    else()
       message(FATAL_ERROR "unknown compiler")
    endif()
-   execute_process(COMMAND reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor" COMMAND grep -c CentralProcessor OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
-else()
-   set(_cxx "$ENV{CXX}")
-   if(NOT _cxx)
-      set(_cxx "c++")
-   endif()
-   execute_process(COMMAND ${_cxx} --version OUTPUT_VARIABLE COMPILER_VERSION ERROR_VARIABLE COMPILER_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
-   string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION}")
+endmacro()
+macro(extract_gnuc_compiler_info CXX)
+   execute_process(COMMAND "${CXX}" --version OUTPUT_VARIABLE COMPILER_VERSION_COMPLETE ERROR_VARIABLE COMPILER_VERSION_COMPLETE OUTPUT_STRIP_TRAILING_WHITESPACE)
+   string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION_COMPLETE}")
    list(GET COMPILER_VERSION 0 COMPILER_VERSION)
    string(REPLACE "Open64 Compiler Suite: Version" "Open64" COMPILER_VERSION "${COMPILER_VERSION}")
-   if(arch STREQUAL "darwin")
-      execute_process(COMMAND sysctl -n hw.ncpu OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
+   string(REPLACE "icpc" "ICC" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REPLACE "gxx" "GCC" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REPLACE "g++" "GCC" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REPLACE ".exe" "" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REPLACE " version" "" COMPILER_VERSION "${COMPILER_VERSION}")
+   if(COMPILER_VERSION MATCHES "based on LLVM ")
+      # e.g. "Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)"
+      string(REGEX REPLACE ".*based on LLVM" "clang" COMPILER_VERSION "${COMPILER_VERSION}")
+      string(REPLACE ")" "" COMPILER_VERSION "${COMPILER_VERSION}")
+   endif()
+   string(REGEX REPLACE " \\([^()]*\\)" "" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REGEX REPLACE " \\[.*\\]" "" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(REGEX REPLACE "GCC-[0-9](\\.[0-9])?" "GCC" COMPILER_VERSION "${COMPILER_VERSION}")
+   string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION)
+   if(COMPILER_VERSION_COMPLETE MATCHES "Free Software Foundation, Inc." AND NOT COMPILER_VERSION MATCHES "GCC")
+      # it's GCC but without "GCC" in the COMPILER_VERSION string - fix it up
+      string(REPLACE "cxx" "GCC" COMPILER_VERSION "${COMPILER_VERSION}")
+      string(REPLACE "c++" "GCC" COMPILER_VERSION "${COMPILER_VERSION}")
+      if(NOT COMPILER_VERSION MATCHES "GCC")
+         set(COMPILER_VERSION "GCC (${COMPILER_VERSION})")
+      endif()
+   endif()
+   if(COMPILER_VERSION MATCHES "clang")
+      set(compiler "clang")
+   elseif(COMPILER_VERSION MATCHES "ICC")
+      set(compiler "ICC")
+   elseif(COMPILER_VERSION MATCHES "Open64")
+      set(compiler "Open64")
+   elseif(COMPILER_VERSION MATCHES "GCC")
+      if(WIN32)
+         set(compiler "MinGW")
+      else()
+         set(compiler "GCC")
+      endif()
+   endif()
+endmacro()
+if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7" OR "${arch}" MATCHES "msys")
+   find_program(CL cl)
+   extract_msvc_compiler_info(${CL})
+elseif(arch MATCHES "mingw")
+   if("$ENV{CXX}" MATCHES "g\\+\\+" OR "$ENV{CXX}" MATCHES "gxx")
+      set(GXX "$ENV{CXX}")
    else()
-      execute_process(COMMAND grep -c processor /proc/cpuinfo OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors)
+      find_program(GXX NAMES "g++" "gxx")
+   endif()
+   if(GXX)
+      extract_gnuc_compiler_info("${GXX}")
+   else()
+      find_program(CL cl)
+      extract_msvc_compiler_info(${CL})
    endif()
+else()
+   set(CXX "$ENV{CXX}")
+   if(NOT CXX)
+      unset(CXX)
+      find_program(CXX NAMES c++ g++ clang++ icpc)
+      if(NOT CXX)
+         message(FATAL_ERROR "No C++ compiler found (arch: ${arch})")
+      endif()
+   endif()
+   extract_gnuc_compiler_info("${CXX}")
 endif()
 
-file(READ "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" git_branch)
-string(STRIP "${git_branch}" git_branch)
-# -> ref: refs/heads/master
-string(REGEX REPLACE "^.*/" "" git_branch "${git_branch}")
-# -> master
-
-if(arch STREQUAL "linux")
-   execute_process(COMMAND lsb_release -d COMMAND cut -f2 OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE lsbRelease)
-   set(CTEST_BUILD_NAME "${lsbRelease}")
+# Build the CTEST_BUILD_NAME string
+################################################################################
+if(target_architecture)
+   set(tmp ${target_architecture})
 else()
-   set(CTEST_BUILD_NAME "${arch}")
+   execute_process(COMMAND cmake -Darch=${arch} -P ${CTEST_SOURCE_DIRECTORY}/print_target_architecture.cmake OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE tmp)
 endif()
-string(STRIP "${CTEST_BUILD_NAME} ${chip} ${COMPILER_VERSION} $ENV{CXXFLAGS}" CTEST_BUILD_NAME)
-set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${build_type}")
-if(target_architecture)
-   set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${target_architecture}")
+if(build_type STREQUAL "Release")
+   set(build_type_short "Rel")
+elseif(build_type STREQUAL "Debug")
+   set(build_type_short "Deb")
+elseif(build_type STREQUAL "RelWithDebInfo")
+   set(build_type_short "RDI")
+elseif(build_type STREQUAL "RelWithDebug")
+   set(build_type_short "RWD")
+elseif(build_type STREQUAL "None")
+   set(build_type_short "Non")
 else()
-   execute_process(COMMAND cmake -Darch=${arch} -P ${CTEST_SOURCE_DIRECTORY}/print_target_architecture.cmake OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE auto_target_arch ERROR_VARIABLE auto_target_arch)
-   set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${auto_target_arch}")
+   set(build_type_short "${build_type}")
 endif()
-string(REPLACE "/" "_" CTEST_BUILD_NAME "${git_branch}: ${CTEST_BUILD_NAME}")
-string(REPLACE "+" "x" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}") # CDash fails to escape '+' correctly in URIs
-string(REGEX REPLACE "[][ ():]" "_" CTEST_BINARY_DIRECTORY "${CTEST_BUILD_NAME}")
-set(CTEST_BINARY_DIRECTORY "${CTEST_SOURCE_DIRECTORY}/build-${dashboard_model}-${CTEST_BINARY_DIRECTORY}")
-file(MAKE_DIRECTORY "${CTEST_BINARY_DIRECTORY}")
-
-execute_process(COMMAND hostname -s RESULT_VARIABLE ok OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-if(NOT ok EQUAL 0)
-   execute_process(COMMAND hostname OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+string(STRIP "${git_branch} ${COMPILER_VERSION} $ENV{CXXFLAGS} ${build_type_short} ${tmp} ${chip} ${os_ident}" CTEST_BUILD_NAME)
+if("$ENV{subset}" STREQUAL "sse")
+   set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} sse")
+elseif("$ENV{subset}" STREQUAL "avx")
+   set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} avx")
 endif()
 
-Set(CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE TRUE)
+string(REPLACE "  " " " CTEST_BUILD_NAME "${CTEST_BUILD_NAME}")
 
-set(CTEST_NOTES_FILES "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" "${CTEST_SOURCE_DIRECTORY}/.git/refs/heads/${git_branch}")
+# work around CDash limitations:
+string(REPLACE "/" "_" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}")
+string(REPLACE "+" "x" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}")
 
-set(compiler)
-if(COMPILER_VERSION MATCHES "clang")
-   set(compiler "clang")
-elseif(COMPILER_VERSION MATCHES "g\\+\\+")
-   if(WIN32)
-      set(compiler "MinGW")
-   else()
-      set(compiler "GCC")
-   endif()
-elseif(COMPILER_VERSION MATCHES "MSVC")
-   set(compiler "MSVC")
-elseif(COMPILER_VERSION MATCHES "ICC")
-   set(compiler "ICC")
-elseif(COMPILER_VERSION MATCHES "Open64")
-   set(compiler "Open64")
-endif()
-if(COMPILER_VERSION MATCHES "\\((experimental|prerelease)\\)" OR COMPILER_VERSION MATCHES "clang version 3.5")
-   set(compiler "experimental")
+# Determine build directory
+################################################################################
+string(REGEX REPLACE "[][ ():, ]" "" CTEST_BINARY_DIRECTORY "${CTEST_BUILD_NAME}")
+set(CTEST_BINARY_DIRECTORY "${CTEST_SOURCE_DIRECTORY}/build-${dashboard_model}/${CTEST_BINARY_DIRECTORY}")
+
+# Give user feedback
+################################################################################
+#message("src:        ${CTEST_SOURCE_DIRECTORY}")
+#message("obj:        ${CTEST_BINARY_DIRECTORY}")
+message("build name: ${CTEST_BUILD_NAME}")
+message("site:       ${CTEST_SITE}")
+message("model:      ${dashboard_model}")
+
+Set(CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE TRUE)
+
+list(APPEND CTEST_NOTES_FILES "${CTEST_SOURCE_DIRECTORY}/.git/HEAD")
+if(EXISTS "${CTEST_SOURCE_DIRECTORY}/.git/refs/heads/${git_branch}")
+   list(APPEND CTEST_NOTES_FILES "${CTEST_SOURCE_DIRECTORY}/.git/refs/heads/${git_branch}")
 endif()
 
-include(${CTEST_SOURCE_DIRECTORY}/CTestCustom.cmake)
 include(${CTEST_SOURCE_DIRECTORY}/CTestConfig.cmake)
-set(CTEST_USE_LAUNCHERS 1) # much improved error/warning message logging
+ctest_read_custom_files(${CTEST_SOURCE_DIRECTORY})
+set(CTEST_USE_LAUNCHERS 0) # launchers once lead to much improved error/warning
+                           # message logging. Nowadays they lead to no warning/
+                           # error messages on the dashboard at all.
 if(WIN32)
    set(MAKE_ARGS "-k")
 else()
-   set(MAKE_ARGS "-j${number_of_processors} -k")
+   set(MAKE_ARGS "-j${number_of_processors} -l${number_of_processors} -k")
 endif()
 
-message("********************************")
-#message("src:        ${CTEST_SOURCE_DIRECTORY}")
-#message("obj:        ${CTEST_BINARY_DIRECTORY}")
-message("build name: ${CTEST_BUILD_NAME}")
-message("site:       ${CTEST_SITE}")
-message("model:      ${dashboard_model}")
-message("********************************")
-
 if(WIN32)
    if("${compiler}" STREQUAL "MSVC")
       find_program(JOM jom)
@@ -197,13 +304,27 @@
    set(CMAKE_MAKE_PROGRAM "make")
 endif()
 
-set(configure_options "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS};-DCMAKE_BUILD_TYPE=${build_type};-DBUILD_EXAMPLES=TRUE;-DTEST_OPERATOR_FAILURES=TRUE")
+set(configure_options "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}")
+list(APPEND configure_options "-DCMAKE_BUILD_TYPE=${build_type}")
+list(APPEND configure_options "-DBUILD_TESTING=TRUE")
+list(APPEND configure_options "-DBUILD_EXAMPLES=TRUE")
+if(NOT travis_os) # Make it a bit faster on Travis CI
+   list(APPEND configure_options "-DTEST_OPERATOR_FAILURES=TRUE")
+endif()
+list(APPEND configure_options "-DUSE_CCACHE=ON")
 if(target_architecture)
-   set(configure_options "${configure_options};-DTARGET_ARCHITECTURE=${target_architecture}")
+   list(APPEND configure_options "-DTARGET_ARCHITECTURE=${target_architecture}")
+endif()
+
+if("${COMPILER_VERSION}" MATCHES "(GCC|Open64).*4\\.[01234567]\\."
+      OR "${COMPILER_VERSION}" MATCHES "GCC 4.8.0"
+      OR "${COMPILER_VERSION}" MATCHES "clang 3\\.[0123](\\.[0-9])?$")
+   message(FATAL_ERROR "Compiler too old for C++11 (${COMPILER_VERSION})")
 endif()
 
 macro(go)
-   set_property(GLOBAL PROPERTY SubProject ${compiler})
+   # SubProjects currently don't improve the overview but rather make the dashboard more cumbersume to navigate
+   #set_property(GLOBAL PROPERTY SubProject "master: ${compiler}")
    set_property(GLOBAL PROPERTY Label other)
    CTEST_START (${dashboard_model})
    set(res 0)
@@ -213,32 +334,68 @@
          ctest_submit(PARTS Update)
       endif()
    endif()
+
+   # enter the following section for Continuous builds only if the CTEST_UPDATE above found changes
    if(NOT ${dashboard_model} STREQUAL "Continuous" OR res GREATER 0)
       CTEST_CONFIGURE (BUILD "${CTEST_BINARY_DIRECTORY}"
          OPTIONS "${configure_options}"
          APPEND
          RETURN_VALUE res)
+      list(APPEND CTEST_NOTES_FILES
+         #"${CTEST_BINARY_DIRECTORY}/CMakeFiles/CMakeOutput.log"
+         "${CTEST_BINARY_DIRECTORY}/CMakeFiles/CMakeError.log"
+         )
       ctest_submit(PARTS Notes Configure)
+      unset(CTEST_NOTES_FILES) # less clutter in ctest -V output
       if(res EQUAL 0)
-         foreach(label other Scalar SSE AVX)
-            set_property(GLOBAL PROPERTY Label ${label})
-            set(CTEST_BUILD_TARGET "${label}")
-            set(CTEST_BUILD_COMMAND "${CMAKE_MAKE_PROGRAM} ${MAKE_ARGS} ${CTEST_BUILD_TARGET}")
+         set(test_results 0)
+         if(travis_os)
+            set(CTEST_BUILD_COMMAND "${CMAKE_MAKE_PROGRAM} ${MAKE_ARGS}")
             ctest_build(
                BUILD "${CTEST_BINARY_DIRECTORY}"
                APPEND
                RETURN_VALUE res)
             ctest_submit(PARTS Build)
-            if(res EQUAL 0 AND NOT skip_tests)
-               ctest_test(
+            ctest_test(
+               BUILD "${CTEST_BINARY_DIRECTORY}"
+               APPEND
+               RETURN_VALUE test_results
+               PARALLEL_LEVEL ${number_of_processors})
+            ctest_submit(PARTS Test)
+         else()
+            if("$ENV{subset}" STREQUAL "sse")
+               set(label_list other Scalar SSE)
+            elseif("$ENV{subset}" STREQUAL "avx")
+               set(label_list AVX AVX2 MIC)
+            else()
+               set(label_list other Scalar SSE AVX AVX2 MIC)
+            endif()
+            foreach(label ${label_list})
+               set_property(GLOBAL PROPERTY Label ${label})
+               set(CTEST_BUILD_TARGET "${label}")
+               set(CTEST_BUILD_COMMAND "${CMAKE_MAKE_PROGRAM} ${MAKE_ARGS} ${CTEST_BUILD_TARGET}")
+               ctest_build(
                   BUILD "${CTEST_BINARY_DIRECTORY}"
                   APPEND
-                  RETURN_VALUE res
-                  PARALLEL_LEVEL ${number_of_processors}
-                  INCLUDE_LABEL "${label}")
-               ctest_submit(PARTS Test)
-            endif()
-         endforeach()
+                  RETURN_VALUE res)
+               ctest_submit(PARTS Build)
+               if(res EQUAL 0 AND NOT skip_tests)
+                  ctest_test(
+                     BUILD "${CTEST_BINARY_DIRECTORY}"
+                     APPEND
+                     RETURN_VALUE res
+                     PARALLEL_LEVEL ${number_of_processors}
+                     INCLUDE_LABEL "^${label}$")
+                  ctest_submit(PARTS Test)
+                  if(NOT res EQUAL 0)
+                     set(test_results ${res})
+                  endif()
+               endif()
+            endforeach()
+         endif()
+         if(NOT test_results EQUAL 0)
+            message(FATAL_ERROR "One or more tests failed.")
+         endif()
       endif()
    endif()
 endmacro()
@@ -250,6 +407,8 @@
       ctest_sleep(${START_TIME} 1200 ${CTEST_ELAPSED_TIME})
    endwhile()
 else()
-   CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
+   if(EXISTS "${CTEST_BINARY_DIRECTORY}")
+      CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
+   endif()
    go()
 endif()
diff -Nru vc-0.7.4/tests/abi.cmake vc-1.3.0/tests/abi.cmake
--- vc-0.7.4/tests/abi.cmake	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/abi.cmake	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,77 @@
+#######################################################################
+# test Vector<T> ABI
+#######################################################################
+
+execute_process(
+   COMMAND ${OBJDUMP} --no-show-raw-insn -dC -j .text ${BINARY}
+   COMMAND grep -A3 " <test"
+   COMMAND sed 1d
+   COMMAND cut -d: -f2
+   COMMAND xargs echo
+   OUTPUT_VARIABLE asm)
+string(STRIP "${asm}" asm)
+
+if("${asm}" MATCHES "%esp")
+   set(x86_32 TRUE)
+else()
+   set(x86_32 FALSE)
+endif()
+set(expect_failure FALSE)
+
+# Note the regex parts looking for %esp can only match on ia32. (Not sure about x32, though)
+# 'retq' on the other hand, can only match on x64
+if("${IMPL}" STREQUAL SSE)
+   set(reference "(^addps %xmm(0,%xmm1 movaps %xmm1,%xmm0 retq|1,%xmm0 retq)|vaddps %xmm(0,%xmm1|1,%xmm0),%xmm0 retq|.*v?movaps 0x[12]4\\(%esp\\),%xmm[01]( | .+ )v?(add|mova)ps 0x[12]4\\(%esp\\),%xmm[01])")
+   if(x86_32 AND COMPILER_IS_CLANG AND "${SYSTEM_NAME}" STREQUAL "Linux")
+      set(expect_failure TRUE)
+   endif()
+elseif("${IMPL}" STREQUAL AVX OR "${IMPL}" STREQUAL AVX2)
+   set(reference "(^vaddps %ymm(0,%ymm1|1,%ymm0),%ymm0 retq|vmovaps 0x[24]4\\(%esp\\),%ymm[01]( | .+ )v(add|mova)ps 0x[24]4\\(%esp\\),%ymm[01],%ymm)")
+   if(x86_32 AND COMPILER_IS_CLANG AND "${SYSTEM_NAME}" STREQUAL "Linux")
+      set(expect_failure TRUE)
+   endif()
+elseif("${IMPL}" STREQUAL MIC)
+   set(reference "^vaddps %zmm(0,%zmm1|1,%zmm0),%zmm0 retq")
+else()
+   message(FATAL_ERROR "Unknown IMPL '${IMPL}'")
+endif()
+
+if("${asm}" MATCHES "${reference}")
+   if(expect_failure)
+      message(FATAL_ERROR "Warning: unexpected pass. The test was flagged as EXPECT_FAILURE but passed instead.")
+   else()
+      message("PASS: Vector<T> ABI")
+   endif()
+elseif(expect_failure)
+   message("Expected Failure.\n'${asm}'\n  does not match\n'${reference}'")
+else()
+   message(FATAL_ERROR "Failed.\n'${asm}'\n  does not match\n'${reference}'")
+endif()
+
+#######################################################################
+# test Mask<T> ABI
+#######################################################################
+if("${IMPL}" STREQUAL MIC)
+   set(reference "%di,.*%si,") # needs to read from %di and %si
+endif()
+
+execute_process(
+   COMMAND ${OBJDUMP} --no-show-raw-insn -dC -j .text ${BINARY}
+   COMMAND grep -A3 " <mask_test"
+   COMMAND sed 1d
+   COMMAND cut -d: -f2
+   COMMAND xargs echo
+   OUTPUT_VARIABLE asm)
+string(STRIP "${asm}" asm)
+string(REPLACE "add" "and" reference "${reference}")
+if("${asm}" MATCHES "${reference}")
+   if(expect_failure)
+      message(FATAL_ERROR "Warning: unexpected pass. The test was flagged as EXPECT_FAILURE but passed instead.")
+   else()
+      message("PASS: Mask<T> ABI")
+   endif()
+elseif(expect_failure)
+   message("Expected Failure.\n'${asm}'\n  does not match\n'${reference}'")
+else()
+   message(FATAL_ERROR "Failed.\n'${asm}'\n  does not match\n'${reference}'")
+endif()
diff -Nru vc-0.7.4/tests/abi.cpp vc-1.3.0/tests/abi.cpp
--- vc-0.7.4/tests/abi.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/abi.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,13 @@
+#include <Vc/Vc>
+
+Vc::float_v test(Vc::float_v a, Vc::float_v b)
+{
+    return a + b;
+}
+
+Vc::float_m mask_test(Vc::float_m a, Vc::float_m b)
+{
+    return a & b;
+}
+
+int Vc_CDECL main() { return 0; }
diff -Nru vc-0.7.4/tests/alignedbase.cpp vc-1.3.0/tests/alignedbase.cpp
--- vc-0.7.4/tests/alignedbase.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/alignedbase.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,117 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+template <std::size_t N> using Int = std::integral_constant<std::size_t, N>;
+
+template <std::size_t A> struct Foo : public Vc::AlignedBase<A>
+{
+    static constexpr std::size_t alignment() { return A; }
+    int x;
+};
+
+std::uintptr_t addressOf(void *ptr)
+{
+    return reinterpret_cast<std::uintptr_t>(ptr);
+}
+
+void *blackhole = nullptr;
+
+TEST_TYPES(A, alignedbase, (Int<4>, Int<8>, Int<16>, Int<32>, Int<64>, Int<128>))
+{
+    using T = Foo<A::value>;
+    COMPARE(alignof(T), A::value);
+    char padding = 1;
+    blackhole = &padding;
+    T onStack;
+    COMPARE(addressOf(&onStack) & (A::value - 1), 0u);
+
+    std::unique_ptr<T[]> onHeap{new T[3]};
+    COMPARE(addressOf(&onHeap[0]) & (A::value - 1), 0u);
+    COMPARE(addressOf(&onHeap[1]) & (A::value - 1), 0u);
+    COMPARE(addressOf(&onHeap[2]) & (A::value - 1), 0u);
+}
+
+template <typename T> struct VectorAligned : public Vc::VectorAlignedBaseT<T>
+{
+    int x;
+};
+
+TEST_TYPES(N, vectoralignedbase,
+           (Int<4>, Int<8>, Int<16>, Int<32>, Int<64>, Int<128>, Int<256>))
+{
+    using V = Vc::SimdMaskArray<int, N::value>;
+    using T = VectorAligned<V>;
+    constexpr auto A = alignof(V);
+    COMPARE(alignof(T), A);
+    char padding = 1;
+    blackhole = &padding;
+    T onStack;
+    COMPARE(addressOf(&onStack) & (A - 1), 0u);
+
+    std::unique_ptr<T[]> onHeap{new T[3]};
+    COMPARE(addressOf(&onHeap[0]) & (A - 1), 0u);
+    COMPARE(addressOf(&onHeap[1]) & (A - 1), 0u);
+    COMPARE(addressOf(&onHeap[2]) & (A - 1), 0u);
+}
+
+template <typename T> struct MemoryAligned : public Vc::MemoryAlignedBaseT<T>
+{
+    int x;
+};
+
+TEST_TYPES(N, memoryalignedbase,
+           (Int<4>, Int<8>, Int<16>, Int<32>, Int<64>, Int<128>, Int<256>))
+{
+    using V = Vc::SimdMaskArray<int, N::value>;
+    using T = MemoryAligned<V>;
+    constexpr auto A = V::MemoryAlignment;
+    COMPARE(alignof(T), A);
+    char padding = 1;
+    blackhole = &padding;
+    T onStack;
+    COMPARE(addressOf(&onStack) & (A - 1), 0u);
+
+    std::unique_ptr<T[]> onHeap{new T[3]};
+    COMPARE(addressOf(&onHeap[0]) & (A - 1), 0u);
+    COMPARE(addressOf(&onHeap[1]) & (A - 1), 0u);
+    COMPARE(addressOf(&onHeap[2]) & (A - 1), 0u);
+}
+
+TEST_TYPES(T, alignedbasealiases,
+           (float, double, unsigned long long, long long, unsigned long, long,
+            unsigned int, int, unsigned short, short, unsigned char, signed char))
+{
+    using V = Vc::Vector<T>;
+    VERIFY(alignof(Vc::VectorAlignedBase) >= alignof(V));
+    VERIFY(alignof(Vc::MemoryAlignedBase) >= V::MemoryAlignment);
+    VERIFY(Vc::VectorAlignment >= alignof(V));
+    VERIFY(Vc::MemoryAlignment >= V::MemoryAlignment);
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/alignmentinheritance.cpp vc-1.3.0/tests/alignmentinheritance.cpp
--- vc-0.7.4/tests/alignmentinheritance.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/alignmentinheritance.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,45 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest-old.h"
+
+#if defined(Vc_ICC) || (defined(Vc_GCC) && Vc_GCC < 0x40800)
+class A {} __attribute__((aligned(64)));
+#else
+class alignas(64) A {};
+#endif
+class B : public A {};
+
+void alignmentOfSubclass()
+{
+    COMPARE(alignof(B), alignof(A));
+}
+
+void testmain()
+{
+    runTest(alignmentOfSubclass);
+}
diff -Nru vc-0.7.4/tests/arithmetics.cpp vc-1.3.0/tests/arithmetics.cpp
--- vc-0.7.4/tests/arithmetics.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/arithmetics.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,31 +1,56 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 #include <iostream>
 #include <limits>
 #include <Vc/limits>
+#include <common/const.h>
 #include <common/macros.h>
 
 using namespace Vc;
 
-template<typename Vec> void testZero()
+#define ALL_TYPES (ALL_VECTORS)
+#if 0
+#define ALL_TYPES                                                                                  \
+    (SIMD_ARRAYS(32),                                                                              \
+     SIMD_ARRAYS(31),                                                                              \
+     SIMD_ARRAYS(16),                                                                              \
+     SIMD_ARRAYS(8),                                                                               \
+     SIMD_ARRAYS(4),                                                                               \
+     SIMD_ARRAYS(2),                                                                               \
+     SIMD_ARRAYS(1),                                                                               \
+     ALL_VECTORS)
+#endif
+
+std::default_random_engine randomEngine;
+
+// testZero{{{1
+TEST_TYPES(Vec, testZero, ALL_TYPES)
 {
     Vec a(Zero), b(Zero);
     COMPARE(a, b);
@@ -43,7 +68,8 @@
     COMPARE(d, Vec(zero));
 }
 
-template<typename Vec> void testCmp()
+// testCmp{{{1
+TEST_TYPES(Vec, testCmp, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     Vec a(Zero), b(Zero);
@@ -66,21 +92,19 @@
         const T min = 0;
         const T step = max / 200;
         T j = min;
-        VERIFY(Vec(Zero) == Vec(j));
-        VERIFY(!(Vec(Zero) < Vec(j)));
-        VERIFY(!(Vec(Zero) > Vec(j)));
-        VERIFY(!(Vec(Zero) != Vec(j)));
+        VERIFY(all_of(Vec(Zero) == Vec(j)));
+        VERIFY(none_of(Vec(Zero) < Vec(j)));
+        VERIFY(none_of(Vec(Zero) > Vec(j)));
+        VERIFY(none_of(Vec(Zero) != Vec(j)));
         j += step;
         for (int i = 0; i < 200; ++i, j += step) {
-            if(Vec(Zero) >= Vec(j)) {
+            if(all_of(Vec(Zero) >= Vec(j))) {
                 std::cout << j << " " << Vec(j) << " " << (Vec(Zero) >= Vec(j)) << std::endl;
             }
-            VERIFY(Vec(Zero) < Vec(j));
-            VERIFY(Vec(j) > Vec(Zero));
-            VERIFY(!(Vec(Zero) >= Vec(j)));
-            VERIFY(!(Vec(j) <= Vec(Zero)));
-            VERIFY(!static_cast<bool>(Vec(Zero) >= Vec(j)));
-            VERIFY(!static_cast<bool>(Vec(j) <= Vec(Zero)));
+            VERIFY(all_of(Vec(Zero) < Vec(j))) << (Vec(Zero) < Vec(j)) << ", j = " << j << ", step = " << step;
+            VERIFY(all_of(Vec(j) > Vec(Zero)));
+            VERIFY(none_of(Vec(Zero) >= Vec(j)));
+            VERIFY(none_of(Vec(j) <= Vec(Zero))) << (Vec(j) <= Vec::Zero()) << ", j = " << j << ", Vec(j) = " << Vec(j);
         }
     }
     if (std::numeric_limits<T>::min() <= 0) {
@@ -91,21 +115,22 @@
         const T step = min / T(-201);
         T j = min;
         for (int i = 0; i < 200; ++i, j += step) {
-            VERIFY(Vec(j) < Vec(Zero));
-            VERIFY(Vec(Zero) > Vec(j));
-            VERIFY(!(Vec(Zero) <= Vec(j)));
-            VERIFY(!(Vec(j) >= Vec(Zero)));
+            VERIFY(all_of(Vec(j) < Vec(Zero)));
+            VERIFY(all_of(Vec(Zero) > Vec(j)));
+            VERIFY(none_of(Vec(Zero) <= Vec(j)));
+            VERIFY(none_of(Vec(j) >= Vec(Zero)));
         }
     }
 }
 
-template<typename Vec> void testIsMix()
+// testIsMix{{{1
+TEST_TYPES(Vec, testIsMix, ALL_TYPES)
 {
-    Vec a(IndexesFromZero);
+    Vec a = Vec::IndexesFromZero();
     Vec b(Zero);
     Vec c(One);
     if (Vec::Size > 1) {
-        VERIFY((a == b).isMix());
+        VERIFY((a == b).isMix()) << "a == b: " << (a == b);
         VERIFY((a != b).isMix());
         VERIFY((a == c).isMix());
         VERIFY((a != c).isMix());
@@ -121,7 +146,8 @@
     }
 }
 
-template<typename Vec> void testAdd()
+// testAdd{{{1
+TEST_TYPES(Vec, testAdd, ALL_TYPES)
 {
     Vec a(Zero), b(Zero);
     COMPARE(a, b);
@@ -132,10 +158,20 @@
 
     COMPARE(a, b + 1);
     COMPARE(a, b + c);
-    Vec x(Zero);
+
+    for (int repetition = 0; repetition < 10000; ++repetition) {
+        const Vec x = Vec::Random();
+        const Vec y = Vec::Random();
+        Vec reference;
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            reference[i] = x[i] + y[i];
+        }
+        COMPARE(x + y, reference) << '\n' << x << " + " << y;
+    }
 }
 
-template<typename Vec> void testSub()
+// testSub{{{1
+TEST_TYPES(Vec, testSub, ALL_TYPES)
 {
     Vec a(2), b(2);
     COMPARE(a, b);
@@ -146,15 +182,26 @@
 
     COMPARE(a, b - 1);
     COMPARE(a, b - c);
+
+    for (int repetition = 0; repetition < 10000; ++repetition) {
+        const Vec x = Vec::Random();
+        const Vec y = Vec::Random();
+        Vec reference;
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            reference[i] = x[i] - y[i];
+        }
+        COMPARE(x - y, reference) << '\n' << x << " - " << y;
+    }
 }
 
-template<typename V> void testMul()
+// testMul{{{1
+TEST_TYPES(V, testMul, ALL_TYPES)
 {
     for (int i = 0; i < 10000; ++i) {
         V a = V::Random();
         V b = V::Random();
         V reference = a;
-        for (int j = 0; j < V::Size; ++j) {
+        for (size_t j = 0; j < V::Size; ++j) {
             // this could overflow - but at least the compiler can't know about it so it doesn't
             // matter that it's undefined behavior in C++. The only thing that matters is what the
             // hardware does...
@@ -164,20 +211,32 @@
     }
 }
 
-template<typename Vec> void testMulAdd()
+// testMulAdd{{{1
+TEST_TYPES(Vec, testMulAdd, ALL_TYPES)
 {
-    for (unsigned int i = 0; i < 0xffff; ++i) {
-        const Vec i2(i * i + 1);
-        Vec a(i);
-
-        FUZZY_COMPARE(a * a + 1, i2);
+    typedef typename Vec::EntryType T;
+    static_assert(std::is_arithmetic<T>::value, "The EntryType is not a builtin arithmetic type");
+    for (std::size_t rep = 0; rep < 10000 / Vec::Size; ++rep) {
+        Vec a = Vec::Random();
+        if (std::is_floating_point<T>::value) {
+            a *= static_cast<int>(std::sqrt(std::numeric_limits<T>::max()));
+        } else if (std::is_signed<T>::value) {
+            a /= static_cast<int>(std::sqrt(std::numeric_limits<T>::max()));
+        }
+        using ReferenceVector = decltype(a * a);
+        ReferenceVector reference = a;
+        reference = reference.apply([](T x) { return x * x + 1; });
+        FUZZY_COMPARE(a * a + T(1), reference) << "a: " << a;
     }
 }
 
-template<typename Vec> void testMulSub()
+// testMulSub{{{1
+TEST_TYPES(Vec, testMulSub, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
-    for (unsigned int i = 0; i < 0xffff; ++i) {
+    const unsigned int minI = sizeof(T) < 4 ? -0xb4 : 0;
+    const unsigned int maxI = sizeof(T) < 4 ? 0xb4 : 0xffff;
+    for (unsigned int i = minI; i < maxI; ++i) {
         const T j = static_cast<T>(i);
         const Vec test(j);
 
@@ -185,11 +244,27 @@
     }
 }
 
-template<typename Vec> void testDiv()
+// testDiv{{{1
+TEST_TYPES(Vec, testDiv, ALL_TYPES)
 {
+    for (int repetition = 0; repetition < 10000; ++repetition) {
+        const Vec a = Vec::Random();
+        const Vec b = Vec::Random();
+        if (none_of(b == Vec::Zero())) {
+            Vec reference;
+            for (size_t i = 0; i < Vec::Size; ++i) {
+                reference[i] = a[i] / b[i];
+            }
+            COMPARE(a / b, reference) << '\n' << a << " / " << b;
+        }
+    }
     typedef typename Vec::EntryType T;
-    // If this test fails for ICC see here:
+#if defined(Vc_ICC) && !defined(__x86_64__) && Vc_ICC <= 20131008
     // http://software.intel.com/en-us/forums/topic/488995
+    if (isEqualType<short, T>()) {
+        EXPECT_FAILURE();
+    }
+#endif
 
     const T stepsize = std::max(T(1), T(std::numeric_limits<T>::max() / 1024));
     for (T divisor = 1; divisor < 5; ++divisor) {
@@ -205,7 +280,36 @@
     }
 }
 
-template<typename Vec> void testAnd()
+// testModulo{{{1
+TEST_TYPES(V, testModulo, (SIMD_INT_ARRAYS(32), SIMD_INT_ODD_ARRAYS(31), INT_VECTORS))
+{
+    using T = typename V::EntryType;
+    alignas(static_cast<size_t>(V::MemoryAlignment)) T x_mem[V::size()];
+    alignas(static_cast<size_t>(V::MemoryAlignment)) T y_mem[V::size()];
+    for (int repetition = 0; repetition < 1000; ++repetition) {
+        const V x = V::Random();
+        x.store(x_mem, Vc::Aligned);
+        V y = (V::Random() & 2047) - 1023;
+        y(y == 0) = -1024;
+        y.store(y_mem, Vc::Aligned);
+        {
+            const V z = x % y;
+            const V reference =
+                V::generate([&](size_t i) { return x_mem[i] % y_mem[i]; });
+            COMPARE(z, reference) << ", x: " << x << ", y: " << y;
+            COMPARE(V::Zero() % y, V::Zero());
+            COMPARE(y % y, V::Zero());
+        }
+        {
+            const V z = x % 256;
+            const V reference = V::generate([&](size_t i) { return x_mem[i] % 256; });
+            COMPARE(z, reference) << ", x: " << x;
+        }
+    }
+}
+
+// testAnd{{{1
+TEST_TYPES(Vec, testAnd, (int_v, ushort_v, uint_v, short_v))
 {
     Vec a(0x7fff);
     Vec b(0xf);
@@ -216,7 +320,8 @@
     COMPARE((c & 0x7ff0), Vec(zero));
 }
 
-template<typename Vec> void testShift()
+// testShift{{{1
+TEST_TYPES(Vec, testShift, (int_v, ushort_v, uint_v, short_v))
 {
     typedef typename Vec::EntryType T;
     const T step = std::max<T>(1, std::numeric_limits<T>::max() / 1000);
@@ -224,8 +329,8 @@
         NShifts = sizeof(T) * 8
     };
     for (Vec x = std::numeric_limits<Vec>::min() + Vec::IndexesFromZero();
-            x <  std::numeric_limits<Vec>::max() - step;
-            x += step) {
+         all_of(x < std::numeric_limits<Vec>::max() - step);
+         x += step) {
         for (size_t shift = 0; shift < NShifts; ++shift) {
             const Vec rightShift = x >> shift;
             const Vec leftShift  = x << shift;
@@ -235,6 +340,12 @@
             }
         }
     }
+#if defined Vc_CLANG && Vc_CLANG < 0x30500
+    // clang 3.4 ICEs on the following code with AVX2. just skip it.
+    if (std::is_same<Vc::VectorAbi::Avx, typename Vec::abi>::value) {
+        return;
+    }
+#endif
 
     Vec a(1);
     Vec b(2);
@@ -246,7 +357,7 @@
 
     Vec shifts(IndexesFromZero);
     a <<= shifts;
-    for (typename Vec::EntryType i = 0, x = 1; i < Vec::Size; ++i, x <<= 1) {
+    for (T i = 0, x = 1; i < T(Vc::is_signed<Vec>::value ? Vec::Size - 1 : Vec::Size); ++i, x <<= 1) {
         COMPARE(a[i], x);
     }
 
@@ -258,12 +369,13 @@
 
     a = Vec(16);
     a >>= shifts;
-    for (typename Vec::EntryType i = 0, x = 16; i < Vec::Size; ++i, x >>= 1) {
+    for (T i = 0, x = 16; i < T(Vec::Size); ++i, x >>= 1) {
         COMPARE(a[i], x);
     }
 }
 
-template<typename Vec> void testOnesComplement()
+// testOnesComplement{{{1
+TEST_TYPES(Vec, testOnesComplement, (INT_VECTORS, SIMD_INT_ODD_ARRAYS(17)))
 {
     Vec a(One);
     Vec b = ~a;
@@ -272,6 +384,15 @@
     COMPARE(~(a + b), Vec(Zero));
 }
 
+// logicalNegation{{{1
+TEST_TYPES(V, logicalNegation, ALL_TYPES)
+{
+    V a = V::Random();
+    COMPARE(!a, a == 0) << "a = " << a;
+    COMPARE(!V::Zero(), V() == V()) << "a = " << a;
+}
+
+// testNegate{{{1
 template<typename T> struct NegateRangeHelper
 {
     typedef int Iterator;
@@ -296,64 +417,75 @@
 template<> const int NegateRangeHelper<unsigned short>::Start = 0;
 template<> const int NegateRangeHelper<unsigned short>::End = 0xffff - 0xee;
 
-template<typename Vec> void testNegate()
+TEST_TYPES(Vec, testNegate, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
+
+    for (int i = 0; i < 1000; ++i) {
+        const Vec x = Vec::Random();
+        const auto negX = -x;
+        for (size_t j = 0; j < x.Size; ++j) {
+            const T reference = -x[j];
+            COMPARE(negX[j], reference) << "x = " << x;
+        }
+    }
+
     typedef NegateRangeHelper<T> Range;
     for (typename Range::Iterator i = Range::Start; i < Range::End; i += 0xef) {
         T i2 = static_cast<T>(i);
         Vec a(i2);
 
-        COMPARE(static_cast<Vec>(-a), Vec(-i2)) << " i2: " << i2;
+        COMPARE(-a, Vec(-i2)) << " i2: " << i2;
     }
 }
 
-template<typename Vec> void testMin()
+// testMin{{{1
+TEST_TYPES(Vec, testMin, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
-    typedef typename Vec::IndexType I;
 
-    Vec v(I::IndexesFromZero());
+    Vec v = Vec::IndexesFromZero();
 
     COMPARE(v.min(), static_cast<T>(0));
     COMPARE((T(Vec::Size) - v).min(), static_cast<T>(1));
 
-    int j = 0;
-    Mask m;
-    do {
-        m = allMasks<Vec>(j++);
-        if (m.isEmpty()) {
-            break;
+    const size_t max = (size_t(1) << Vec::Size) - 1;
+    std::uniform_int_distribution<size_t> dist(0, max);
+    for (int rep = 0; rep < 100000; ++rep) {
+        const size_t j = dist(randomEngine);
+        Mask m = UnitTest::allMasks<Vec>(j);
+        if (any_of(m)) {
+            COMPARE(v.min(m), static_cast<T>(m.firstOne())) << m << v;
         }
-        COMPARE(v.min(m), static_cast<T>(m.firstOne())) << m << v;
-    } while (true);
+    }
 }
 
-template<typename Vec> void testMax()
+// testMax{{{1
+TEST_TYPES(Vec, testMax, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
-    typedef typename Vec::IndexType I;
 
-    Vec v(I::IndexesFromZero());
+    Vec v = Vec::IndexesFromZero();
 
     COMPARE(v.max(), static_cast<T>(Vec::Size - 1));
     v = T(Vec::Size) - v;
     COMPARE(v.max(), static_cast<T>(Vec::Size));
 
-    int j = 0;
-    Mask m;
-    do {
-        m = allMasks<Vec>(j++);
-        if (m.isEmpty()) {
-            break;
+    const size_t max = (size_t(1) << Vec::Size) - 1;
+    std::uniform_int_distribution<size_t> dist(0, max);
+    for (int rep = 0; rep < 100000; ++rep) {
+        const size_t j = dist(randomEngine);
+        Mask m = UnitTest::allMasks<Vec>(j);
+        if (any_of(m)) {
+            COMPARE(v.max(m), static_cast<T>(Vec::Size - m.firstOne())) << m << v;
         }
-        COMPARE(v.max(m), static_cast<T>(Vec::Size - m.firstOne())) << m << v;
-    } while (true);
+    }
 }
 
-template<typename Vec> void testProduct()
+// testProduct{{{1
+TEST_TYPES(Vec, testProduct, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
@@ -362,32 +494,41 @@
         T x = static_cast<T>(i);
         Vec v(x);
         T x2 = x;
-        for (int k = Vec::Size; k > 1; k /= 2) {
-            x2 *= x2;
+        if (std::numeric_limits<T>::is_exact) {
+            for (int k = Vec::Size; k > 1; --k) {
+                x2 *= x;
+            }
+            COMPARE(v.product(), x2) << v;
+        } else {
+            x2 = std::round(std::pow(x, static_cast<int>(Vec::Size)));
+            FUZZY_COMPARE(v.product(), x2) << v;
         }
-        COMPARE(v.product(), x2);
 
-        int j = 0;
-        Mask m;
-        do {
-            m = allMasks<Vec>(j++);
-            if (m.isEmpty()) {
-                break;
-            }
-            if (std::numeric_limits<T>::is_exact) {
-                x2 = x;
-                for (int k = m.count(); k > 1; --k) {
-                    x2 *= x;
+        const size_t max = (size_t(1) << Vec::Size) - 1;
+        std::uniform_int_distribution<size_t> dist(0, max);
+        for (int rep = 0; rep < 10000; ++rep) {
+            const size_t j = dist(randomEngine);
+            Mask m = UnitTest::allMasks<Vec>(j);
+            if (any_of(m)) {
+                if (std::numeric_limits<T>::is_exact) {
+                    x2 = x;
+                    for (int k = m.count(); k > 1; --k) {
+                        x2 *= x;
+                    }
+                    COMPARE(v.product(m), x2) << v << ".product(" << m << ')';
+                } else {
+                    x2 = std::round(std::pow(x, static_cast<int>(m.count())));
+                    FUZZY_COMPARE(v.product(m), x2) << v << ".product(" << m << ')';
                 }
             } else {
-                x2 = static_cast<T>(pow(static_cast<double>(x), m.count()));
+                COMPARE(v.product(m), T(1)) << v << ".product(" << m << ')';
             }
-            COMPARE(v.product(m), x2) << m << v;
-        } while (true);
+        }
     }
 }
 
-template<typename Vec> void testSum()
+// testSum{{{1
+TEST_TYPES(Vec, testSum, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
@@ -395,189 +536,113 @@
     for (int i = 0; i < 10; ++i) {
         T x = static_cast<T>(i);
         Vec v(x);
-        COMPARE(v.sum(), x * Vec::Size);
+        COMPARE(v.sum(), T(x * Vec::Size)) << v;
 
-        int j = 0;
-        Mask m;
-        do {
-            m = allMasks<Vec>(j++);
-            COMPARE(v.sum(m), x * m.count()) << m << v;
-        } while (!m.isEmpty());
+        const size_t max = (size_t(1) << Vec::Size) - 1;
+        std::uniform_int_distribution<size_t> dist(0, max);
+        for (int rep = 0; rep < 10000; ++rep) {
+            const size_t j = dist(randomEngine);
+            Mask m = UnitTest::allMasks<Vec>(j);
+            if (any_of(m)) {
+                COMPARE(v.sum(m), static_cast<T>(x * m.count())) << m << v;
+            } else {
+                COMPARE(v.sum(m), T(0)) << m << v;
+            }
+        }
     }
 }
 
-template<typename V> void fma()
+// testPartialSum{{{1
+TEST_TYPES(V, testPartialSum, ALL_TYPES)
+{
+    V reference = V::IndexesFromZero() + 1;
+    COMPARE(V(1).partialSum(), reference);
+    /* disabled until correct masking is implemented
+
+    typedef typename V::IndexType I;
+    reference = simd_cast<V>(I(2) << I::IndexesFromZero());
+    COMPARE(V(2).partialSum([](const V &a, const V &b) { return a * b; }), reference);
+    */
+}
+
+// testFma{{{1
+template <typename V, typename T> void testFmaDispatch(T)
 {
     for (int i = 0; i < 1000; ++i) {
         V a = V::Random();
         const V b = V::Random();
         const V c = V::Random();
         const V reference = a * b + c;
-        a.fusedMultiplyAdd(b, c);
-        COMPARE(a, reference) << ", a = " << a << ", b = " << b << ", c = " << c;
+        COMPARE(Vc::fma(a, b, c), reference) << ", a = " << a << ", b = " << b
+                                             << ", c = " << c;
     }
 }
 
-template<> void fma<float_v>()
+template <typename V> void testFmaDispatch(float)
 {
-    float_v b = Vc_buildFloat(1, 0x000001, 0);
-    float_v c = Vc_buildFloat(1, 0x000000, -24);
-    float_v a = b;
+    using Vc::Detail::floatConstant;
+    V b = floatConstant<1, 0x000001, 0>();
+    V c = floatConstant<1, 0x000000, -24>();
+    V a = b;
     /*a *= b;
     a += c;
-    COMPARE(a, float_v(Vc_buildFloat(1, 0x000002, 0)));
+    COMPARE(a, V(floatConstant<1, 0x000002, 0>()));
     a = b;*/
-    a.fusedMultiplyAdd(b, c);
-    COMPARE(a, float_v(Vc_buildFloat(1, 0x000003, 0)));
+    COMPARE(Vc::fma(a, b, c), V(floatConstant<1, 0x000003, 0>()));
 
-    a = Vc_buildFloat(1, 0x000002, 0);
-    b = Vc_buildFloat(1, 0x000002, 0);
-    c = Vc_buildFloat(-1, 0x000000, 0);
+    a = floatConstant<1, 0x000002, 0>();
+    b = floatConstant<1, 0x000002, 0>();
+    c = floatConstant<-1, 0x000000, 0>();
     /*a *= b;
     a += c;
-    COMPARE(a, float_v(Vc_buildFloat(1, 0x000000, -21)));
+    COMPARE(a, V(floatConstant<1, 0x000000, -21>()));
     a = b;*/
-    a.fusedMultiplyAdd(b, c); // 1 + 2^-21 + 2^-44 - 1 == (1 + 2^-20)*2^-18
-    COMPARE(a, float_v(Vc_buildFloat(1, 0x000001, -21)));
+    COMPARE(Vc::fma(a, b, c),  // 1 + 2^-21 + 2^-44 - 1 == (1 + 2^-20)*2^-18
+            V(floatConstant<1, 0x000001, -21>()));
 }
 
-template<> void fma<sfloat_v>()
+template <typename V> void testFmaDispatch(double)
 {
-    sfloat_v b = Vc_buildFloat(1, 0x000001, 0);
-    sfloat_v c = Vc_buildFloat(1, 0x000000, -24);
-    sfloat_v a = b;
-    /*a *= b;
-    a += c;
-    COMPARE(a, sfloat_v(Vc_buildFloat(1, 0x000002, 0)));
-    a = b;*/
-    a.fusedMultiplyAdd(b, c);
-    COMPARE(a, sfloat_v(Vc_buildFloat(1, 0x000003, 0)));
-
-    a = Vc_buildFloat(1, 0x000002, 0);
-    b = Vc_buildFloat(1, 0x000002, 0);
-    c = Vc_buildFloat(-1, 0x000000, 0);
-    /*a *= b;
-    a += c;
-    COMPARE(a, sfloat_v(Vc_buildFloat(1, 0x000000, -21)));
-    a = b;*/
-    a.fusedMultiplyAdd(b, c); // 1 + 2^-21 + 2^-44 - 1 == (1 + 2^-20)*2^-18
-    COMPARE(a, sfloat_v(Vc_buildFloat(1, 0x000001, -21)));
+    using Vc::Detail::doubleConstant;
+    V b = doubleConstant<1, 0x0000000000001, 0>();
+    V c = doubleConstant<1, 0x0000000000000, -53>();
+    V a = b;
+    COMPARE(fma(a, b, c), V(doubleConstant<1, 0x0000000000003, 0>()));
+
+    a = doubleConstant<1, 0x0000000000002, 0>();
+    b = doubleConstant<1, 0x0000000000002, 0>();
+    c = doubleConstant<-1, 0x0000000000000, 0>();
+    COMPARE(fma(a, b, c),  // 1 + 2^-50 + 2^-102 - 1
+            V(doubleConstant<1, 0x0000000000001, -50>()));
+}
+
+TEST_TYPES(V, testFma, ALL_TYPES)
+{
+    using T = typename V::EntryType;
+// https://github.com/VcDevel/Vc/issues/61
+// std::fma (the implementation of the Scalar fma function) produces incorrect results on
+// RHEL6 (which uses glibc 2.12) in debug builds. On 64-bit float and double both fail. On
+// 32-bit on double fails.
+#if (defined Vc_GCC || defined Vc_CLANG) && !defined __OPTIMIZE__ &&                     \
+    defined __GLIBC__ && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 12
+    if (std::is_same<typename V::abi, VectorAbi::Scalar>::value) {
+        if (std::is_same<T, double>::value) {
+            UnitTest::EXPECT_FAILURE();
+        }
+#if defined Vc_GCC || (defined Vc_CLANG && Vc_CLANG >= 0x30500)
+        if (std::is_same<T, float>::value && sizeof(void*) == 8) {
+            UnitTest::EXPECT_FAILURE();
+        }
+#endif
+    }
+#elif defined Vc_MSVC
+    if (std::is_same<typename V::abi, VectorAbi::Scalar>::value) {
+        if (std::is_floating_point<T>::value) {
+            UnitTest::EXPECT_FAILURE();
+        }
+    }
+#endif
+    testFmaDispatch<V>(T());
 }
 
-template<> void fma<double_v>()
-{
-    double_v b = Vc_buildDouble(1, 0x0000000000001, 0);
-    double_v c = Vc_buildDouble(1, 0x0000000000000, -53);
-    double_v a = b;
-    a.fusedMultiplyAdd(b, c);
-    COMPARE(a, double_v(Vc_buildDouble(1, 0x0000000000003, 0)));
-
-    a = Vc_buildDouble(1, 0x0000000000002, 0);
-    b = Vc_buildDouble(1, 0x0000000000002, 0);
-    c = Vc_buildDouble(-1, 0x0000000000000, 0);
-    a.fusedMultiplyAdd(b, c); // 1 + 2^-50 + 2^-102 - 1
-    COMPARE(a, double_v(Vc_buildDouble(1, 0x0000000000001, -50)));
-}
-
-int main(int argc, char **argv)
-{
-    initTest(argc, argv);
-
-    testAllTypes(fma);
-
-    runTest(testZero<int_v>);
-    runTest(testZero<uint_v>);
-    runTest(testZero<float_v>);
-    runTest(testZero<double_v>);
-    runTest(testZero<short_v>);
-    runTest(testZero<ushort_v>);
-    runTest(testZero<sfloat_v>);
-
-    runTest(testCmp<int_v>);
-    runTest(testCmp<uint_v>);
-    runTest(testCmp<float_v>);
-    runTest(testCmp<double_v>);
-    runTest(testCmp<short_v>);
-    runTest(testCmp<ushort_v>);
-    runTest(testCmp<sfloat_v>);
-
-    runTest(testIsMix<int_v>);
-    runTest(testIsMix<uint_v>);
-    //runTest(testIsMix<float_v>);
-    //runTest(testIsMix<double_v>);
-    runTest(testIsMix<short_v>);
-    runTest(testIsMix<ushort_v>);
-    //runTest(testIsMix<sfloat_v>);
-
-    runTest(testAdd<int_v>);
-    runTest(testAdd<uint_v>);
-    runTest(testAdd<float_v>);
-    runTest(testAdd<double_v>);
-    runTest(testAdd<short_v>);
-    runTest(testAdd<ushort_v>);
-    runTest(testAdd<sfloat_v>);
-
-    runTest(testSub<int_v>);
-    runTest(testSub<uint_v>);
-    runTest(testSub<float_v>);
-    runTest(testSub<double_v>);
-    runTest(testSub<short_v>);
-    runTest(testSub<ushort_v>);
-    runTest(testSub<sfloat_v>);
-
-    runTest(testMul<int_v>);
-    runTest(testMul<uint_v>);
-    runTest(testMul<float_v>);
-    runTest(testMul<double_v>);
-    runTest(testMul<short_v>);
-    runTest(testMul<ushort_v>);
-    runTest(testMul<sfloat_v>);
-
-    runTest(testDiv<int_v>);
-    runTest(testDiv<uint_v>);
-    runTest(testDiv<float_v>);
-    runTest(testDiv<double_v>);
-    runTest(testDiv<short_v>);
-    runTest(testDiv<ushort_v>);
-    runTest(testDiv<sfloat_v>);
-
-    runTest(testAnd<int_v>);
-    runTest(testAnd<uint_v>);
-    runTest(testAnd<short_v>);
-    runTest(testAnd<ushort_v>);
-    // no operator& for float/double
-
-    runTest(testShift<int_v>);
-    runTest(testShift<uint_v>);
-    runTest(testShift<short_v>);
-    runTest(testShift<ushort_v>);
-
-    runTest(testMulAdd<int_v>);
-    runTest(testMulAdd<uint_v>);
-    runTest(testMulAdd<float_v>);
-    runTest(testMulAdd<double_v>);
-    runTest(testMulAdd<short_v>);
-    runTest(testMulAdd<ushort_v>);
-    runTest(testMulAdd<sfloat_v>);
-
-    runTest(testMulSub<int_v>);
-    runTest(testMulSub<uint_v>);
-    runTest(testMulSub<float_v>);
-    runTest(testMulSub<double_v>);
-    runTest(testMulSub<short_v>);
-    runTest(testMulSub<ushort_v>);
-    runTest(testMulSub<sfloat_v>);
-
-    runTest(testOnesComplement<int_v>);
-    runTest(testOnesComplement<uint_v>);
-    runTest(testOnesComplement<short_v>);
-    runTest(testOnesComplement<ushort_v>);
-
-    testAllTypes(testNegate);
-    testAllTypes(testMin);
-    testAllTypes(testMax);
-    testAllTypes(testProduct);
-    testAllTypes(testSum);
-
-    return 0;
-}
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/casts.cpp vc-1.3.0/tests/casts.cpp
--- vc-0.7.4/tests/casts.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/casts.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,21 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 #include <limits>
@@ -23,16 +31,434 @@
 
 using namespace Vc;
 
+// EXTRA_IMPL_VECTORS {{{1
+#ifdef Vc_IMPL_Scalar
+#define EXTRA_IMPL_VECTORS
+#elif defined Vc_IMPL_AVX2
+#define EXTRA_IMPL_VECTORS                                                               \
+    Vc::Scalar::int_v, Vc::Scalar::ushort_v, Vc::Scalar::double_v, Vc::Scalar::uint_v,   \
+        Vc::Scalar::short_v, Vc::Scalar::float_v, Vc::SSE::int_v, Vc::SSE::ushort_v,     \
+        Vc::SSE::double_v, Vc::SSE::uint_v, Vc::SSE::short_v, Vc::SSE::float_v,          \
+        Vc::AVX::int_v, Vc::AVX::ushort_v, Vc::AVX::double_v, Vc::AVX::uint_v,           \
+        Vc::AVX::short_v, Vc::AVX::float_v
+#elif defined Vc_IMPL_AVX
+#define EXTRA_IMPL_VECTORS                                                               \
+    Vc::Scalar::int_v, Vc::Scalar::ushort_v, Vc::Scalar::double_v, Vc::Scalar::uint_v,   \
+        Vc::Scalar::short_v, Vc::Scalar::float_v, Vc::SSE::int_v, Vc::SSE::ushort_v,     \
+        Vc::SSE::double_v, Vc::SSE::uint_v, Vc::SSE::short_v, Vc::SSE::float_v
+#else
+#define EXTRA_IMPL_VECTORS                                                               \
+    Vc::Scalar::int_v, Vc::Scalar::ushort_v, Vc::Scalar::double_v, Vc::Scalar::uint_v,   \
+        Vc::Scalar::short_v, Vc::Scalar::float_v
+#endif
+
+// AllTestTypes {{{1
+#ifdef Vc_DEFAULT_TYPES
+using AllTestTypes = outer_product<Typelist<ALL_VECTORS>, Typelist<ALL_VECTORS>>;
+#elif defined Vc_EXTRA_TYPES
+using AllTestTypes =
+    concat<outer_product<Typelist<ALL_VECTORS>, Typelist<EXTRA_IMPL_VECTORS>>,
+           outer_product<Typelist<EXTRA_IMPL_VECTORS>, Typelist<ALL_VECTORS>>>;
+#elif defined Vc_FROM_N
+#ifdef Vc_TO_N
+using AllTestTypes =
+    outer_product<Typelist<SIMD_ARRAYS(Vc_FROM_N)>, Typelist<SIMD_ARRAYS(Vc_TO_N)>>;
+#else
+using AllTestTypes =
+    outer_product<Typelist<SIMD_ARRAYS(Vc_FROM_N)>, Typelist<ALL_VECTORS>>;
+#endif
+#elif defined Vc_TO_N
+using AllTestTypes =
+    outer_product<Typelist<ALL_VECTORS>, Typelist<SIMD_ARRAYS(Vc_TO_N)>>;
+#endif
+
+// is_conversion_undefined {{{1
+/* implementation-defined
+ * ======================
+ * §4.7 p3 (integral conversions)
+ *  If the destination type is signed, the value is unchanged if it can be represented in the
+ *  destination type (and bit-field width); otherwise, the value is implementation-defined.
+ *
+ * undefined
+ * =========
+ * §4.9 p1 (floating-integral conversions)
+ *  floating point type can be converted to integer type.
+ *  The behavior is undefined if the truncated value cannot be
+ *  represented in the destination type.
+ *      p2
+ *  integer can be converted to floating point type.
+ *  If the value being converted is outside the range of values that can be represented, the
+ *  behavior is undefined.
+ */
+template <typename To, typename From>
+typename std::enable_if<
+    (std::is_arithmetic<From>::value && std::is_floating_point<From>::value &&
+     std::is_integral<To>::value),
+    bool>::type
+is_conversion_undefined(From x)
+{
+    if (x > static_cast<From>(std::numeric_limits<To>::max()) ||
+        x < static_cast<From>(std::numeric_limits<To>::min())) {
+        return true;
+    }
+    return false;
+}
+template <typename To, typename From>
+typename std::enable_if<
+    (std::is_arithmetic<From>::value &&
+     !(std::is_floating_point<From>::value && std::is_integral<To>::value)),
+    bool>::type
+is_conversion_undefined(From)
+{
+    return false;
+}
+
+template <typename To, typename From>
+typename std::enable_if<Vc::is_simd_vector<From>::value, typename From::Mask>::type
+    is_conversion_undefined(const From x)
+{
+    typename From::Mask k = false;
+    for (std::size_t i = 0; i < From::Size; ++i) {
+        k[i] = is_conversion_undefined(x[i]);
+    }
+}
+
+// ith_scalar {{{1
+template <typename V> inline typename V::EntryType ith_scalar(std::size_t i, const V &x)
+{
+    return x[i];
+}
+template <typename V, typename... Vs, typename = Vc::enable_if<(sizeof...(Vs) > 0)>>
+inline typename V::EntryType ith_scalar(std::size_t i, const V &x, const Vs &... xs)
+{
+    return i < V::Size ? x[i] : ith_scalar(i - V::Size, xs...);
+}
+// extraInformation {{{1
+static void doNothing(const std::initializer_list<void *> &) {}
+template <typename To, typename V0, typename... Vs>
+std::string extraInformation(const V0 &arg0, const Vs &... args)
+{
+    std::stringstream s;
+    s << "\nsimd_cast<" << UnitTest::typeToString<To>() << ">(" << std::setprecision(20) << arg0;
+    doNothing({&(s << ", " << args)...});
+    s << ')';
+    return s.str();
+}
+// rnd {{{1
+template <typename To, typename From>
+static Vc::enable_if<(Vc::Traits::is_floating_point<From>::value), From> rnd()
+{
+    using T = typename From::value_type;
+    auto r = (From::Random() - T(0.5)) *
+             T(std::numeric_limits<typename To::value_type>::max());
+    r.setZero(isnan(r));
+    return r;
+}
+template <typename To, typename From>
+static Vc::enable_if<(!Vc::Traits::is_floating_point<From>::value), From> rnd()
+{
+    return From::Random();
+}
+// cast_vector_impl {{{1
+template <typename To, typename From, typename... Froms>
+Vc::enable_if<(To::Size <= sizeof...(Froms) * From::Size), void> cast_vector_impl(
+    const From &, const Froms &...)
+{
+}
+
+template <typename To, typename From, typename... Froms>
+Vc::enable_if<(To::Size > sizeof...(Froms) * From::Size), void> cast_vector_impl(
+    const From &x0, const Froms &... xs)
+{
+    using T = typename To::EntryType;
+    auto result = simd_cast<To>(x0, xs...);
+#ifdef Vc_GCC
+    // workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47226
+    // parameter pack expansion does not work inside lambda
+    typename From::EntryType input[(1 + sizeof...(Froms)) * From::Size];
+    for (std::size_t i = 0; i < (1 + sizeof...(Froms)) * From::Size; ++i) {
+        input[i] = ith_scalar(i, x0, xs...);
+    }
+#endif
+    const To reference = To::generate([&](std::size_t i) {
+        if (i >= (1 + sizeof...(Froms)) * From::Size) {
+            return T(0);
+        }
+#ifdef Vc_GCC
+        if (is_conversion_undefined<T>(input[i])) {
+            result[i] = 0;
+            return T(0);
+        }
+        return static_cast<T>(input[i]);
+#else
+        const auto input = ith_scalar(i, x0, xs...);
+        if (is_conversion_undefined<T>(input)) {
+            result[i] = 0;
+            return T(0);
+        }
+        return static_cast<T>(input);
+#endif
+    });
+
+    COMPARE(result, reference) << extraInformation<To>(x0, xs...);
+    cast_vector_impl<To>(x0, rnd<To, From>(), xs...);
+}
+// cast_vector_split {{{1
+template <typename To, typename From, std::size_t Index = 0>
+Vc::enable_if<!(Index * To::Size < From::Size && To::Size < From::Size), void>
+    cast_vector_split(const From &)
+{
+}
+template <typename To, typename From, std::size_t Index = 0>
+Vc::enable_if<(Index * To::Size < From::Size && To::Size < From::Size), void>
+    cast_vector_split(const From &x)
+{
+    using T = typename To::EntryType;
+    const auto result = simd_cast<To, Index>(x);
+    const To reference = To::generate([&](std::size_t i) {
+        if (i + Index * To::Size >= From::Size) {
+            return T(0);
+        }
+        const auto input = x[i + Index * To::Size];
+        return is_conversion_undefined<T>(input) ? result[i] : static_cast<T>(input);
+    });
+
+    COMPARE(result, reference) << "simd_cast<" << UnitTest::typeToString<To>() << ", "
+                               << Index << ">(" << x << ')';
+
+    cast_vector_split<To, From, Index + 1>(x);
+}
+TEST_TYPES(TList, cast_vector, (AllTestTypes))  // {{{1
+{
+    using From = typename TList::template at<0>;
+    using To = typename TList::template at<1>;
+    using T = typename From::EntryType;
+
+    alignas(From) T testData[21 + 2 * From::Size] = {
+        T(0xc0000080u),
+        T(0xc0000081u),
+        T(0xc000017fu),
+        T(0xc0000180u),
+        std::numeric_limits<T>::min(),
+        T(0),
+        T(-1),
+        T(1),
+        std::numeric_limits<T>::max(),
+        T(std::numeric_limits<T>::max() - 1),
+        T(std::numeric_limits<T>::max() - 0xff),
+        T(std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 6 - 1)),
+        T(-std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 6 - 1)),
+        T(std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 4 - 1)),
+        T(-std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 4 - 1)),
+        T(std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 2 - 1)),
+        T(-std::numeric_limits<T>::max() / std::pow(2., sizeof(T) * 2 - 1)),
+        T(std::numeric_limits<T>::max() - 0xff),
+        T(std::numeric_limits<T>::max() - 0x55),
+        T(-std::numeric_limits<T>::min()),
+        T(-std::numeric_limits<T>::max())};
+    rnd<To, From>().store(&testData[21], Vc::Unaligned);
+    for (std::size_t i = 0; i < 21 + From::Size; i += From::Size) {
+        const From v(&testData[i],
+                     Vc::Unaligned);  // Unaligned because From can be SimdArray<T, Odd>
+        cast_vector_impl<To>(v);
+        cast_vector_split<To>(v);
+    }
+    cast_vector_split<To>(rnd<To, From>());
+}
+// mask_cast_1 {{{1
+template <typename To, typename From> void mask_cast_1(const From &mask)
+{
+    To casted = simd_cast<To>(mask);
+    std::size_t i = 0;
+    for (; i < std::min(To::Size, From::Size); ++i) {
+        COMPARE(casted[i], mask[i]) << "i: " << i << ", " << mask << " got converted to "
+                                    << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < To::Size; ++i) {
+        COMPARE(casted[i], false) << "i: " << i << ", " << mask << " got converted to "
+                                  << UnitTest::typeToString<To>() << ": " << casted;
+    }
+}
+// mask_cast_2 {{{1
+template <typename To, typename From>
+void mask_cast_2(const From &mask0, const From &mask1,
+                 Vc::enable_if<(To::Size > From::Size)> = Vc::nullarg)
+{
+    To casted = simd_cast<To>(mask0, mask1);
+    std::size_t i = 0;
+    for (; i < From::Size; ++i) {
+        COMPARE(casted[i], mask0[i]) << "i: " << i << mask0 << mask1
+                                     << " were converted to "
+                                     << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < std::min(To::Size, 2 * From::Size); ++i) {
+        COMPARE(casted[i], mask1[i - From::Size])
+            << "i: " << i << mask0 << mask1 << " were converted to "
+            << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < To::Size; ++i) {
+        COMPARE(casted[i], false) << "i: " << i << mask0 << mask1 << " were converted to "
+                                  << UnitTest::typeToString<To>() << ": " << casted;
+    }
+}
+template <typename To, typename From>
+void mask_cast_2(const From &, const From &,
+                 Vc::enable_if<!(To::Size > From::Size)> = Vc::nullarg)
+{
+}
+// mask_cast_4 {{{1
+template <typename To, typename From>
+void mask_cast_4(const From &mask0, const From &mask1, const From &mask2,
+                 const From &mask3,
+                 Vc::enable_if<(To::Size > 2 * From::Size)> = Vc::nullarg)
+{
+    To casted = simd_cast<To>(mask0, mask1, mask2, mask3);
+    std::size_t i = 0;
+    for (; i < From::Size; ++i) {
+        COMPARE(casted[i], mask0[i]) << "i: " << i << mask0 << mask1 << mask2 << mask3
+                                     << " were converted to "
+                                     << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < std::min(To::Size, 2 * From::Size); ++i) {
+        COMPARE(casted[i], mask1[i - From::Size])
+            << "i: " << i << mask0 << mask1 << mask2 << mask3 << " were converted to "
+            << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < std::min(To::Size, 3 * From::Size); ++i) {
+        COMPARE(casted[i], mask2[i - 2 * From::Size])
+            << "i: " << i << mask0 << mask1 << mask2 << mask3 << " were converted to "
+            << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < std::min(To::Size, 4 * From::Size); ++i) {
+        COMPARE(casted[i], mask3[i - 3 * From::Size])
+            << "i: " << i << mask0 << mask1 << mask2 << mask3 << " were converted to "
+            << UnitTest::typeToString<To>() << ": " << casted;
+    }
+    for (; i < To::Size; ++i) {
+        COMPARE(casted[i], false) << "i: " << i << mask0 << mask1 << mask2 << mask3
+                                  << " were converted to " << UnitTest::typeToString<To>()
+                                  << ": " << casted;
+    }
+}
+template <typename To, typename From>
+void mask_cast_4(const From &, const From &, const From &, const From &,
+                 Vc::enable_if<!(To::Size > 2 * From::Size)> = Vc::nullarg)
+{
+}
+// cast_mask_split {{{1
+template <typename To, typename From, std::size_t Index = 0>
+Vc::enable_if<!(Index * To::Size < From::Size && To::Size < From::Size), void>
+    cast_mask_split(const From &)
+{
+}
+template <typename To, typename From, std::size_t Index = 0>
+Vc::enable_if<(Index * To::Size < From::Size && To::Size < From::Size), void>
+    cast_mask_split(const From &x)
+{
+    const auto result = simd_cast<To, Index>(x);
+    const To reference = To::generate([&](std::size_t i) {
+        return i + Index * To::Size >= From::Size ? false : x[i + Index * To::Size];
+    });
+
+    COMPARE(result, reference) << "simd_cast<" << UnitTest::typeToString<To>() << ", "
+                               << Index << ">(" << x << ')';
+
+    cast_mask_split<To, From, Index + 1>(x);
+}
+TEST_TYPES(TList, cast_mask, (AllTestTypes)) // {{{1
+{
+    using FromV = typename TList::template at<0>;
+    using ToV = typename TList::template at<1>;
+    using From = typename FromV::Mask;
+    using To = typename ToV::Mask;
+    std::vector<From> randomMasks(4, From{false});
+
+    UnitTest::withRandomMask<FromV>([&](const From &mask) {
+        std::rotate(randomMasks.begin(), randomMasks.begin() + 1, randomMasks.end());
+        randomMasks[0] = mask;
+        mask_cast_1<To>(randomMasks[0]);
+        mask_cast_2<To>(randomMasks[0], randomMasks[1]);
+        mask_cast_4<To>(randomMasks[0], randomMasks[1], randomMasks[2], randomMasks[3]);
+        cast_mask_split<To>(randomMasks[0]);
+    });
+}
+// }}}1
+#ifdef Vc_DEFAULT_TYPES
+TEST(fullConversion)/*{{{*/
+{
+    float_v x = float_v::Random();
+    float_v r;
+    for (size_t i = 0; i < float_v::Size; i += double_v::Size) {
+        float_v tmp = simd_cast<float_v>(0.1 * simd_cast<double_v>(x.shifted(i)));
+        r = r.shifted(double_v::Size, tmp);
+    }
+    for (size_t i = 0; i < float_v::Size; ++i) {
+        COMPARE(r[i], static_cast<float>(x[i] * 0.1)) << "i = " << i;
+    }
+}/*}}}*/
+#endif // Vc_DEFAULT_TYPES
+
+#if 0
+/*{{{*/
+template<typename T> constexpr bool may_overflow() { return std::is_integral<T>::value && std::is_unsigned<T>::value; }
+
+template<typename T1, typename T2> struct is_conversion_exact
+{
+    static constexpr bool is_T2_integer = std::is_integral<T2>::value;
+    static constexpr bool is_T2_signed = is_T2_integer && std::is_signed<T2>::value;
+    static constexpr bool is_float_int_conversion = std::is_floating_point<T1>::value && is_T2_integer;
+
+    template <typename U, typename V> static constexpr bool can_represent(V x) {
+        return x <= std::numeric_limits<U>::max() && x >= std::numeric_limits<U>::min();
+    }
+
+    template<typename U> static constexpr U max() { return std::numeric_limits<U>::max() - U(1); }
+    template<typename U> static constexpr U min() { return std::numeric_limits<U>::min() + U(1); }
+
+    static constexpr bool for_value(T1 v) {
+        return (!is_float_int_conversion && !is_T2_signed) || can_represent<T2>(v);
+    }
+    static constexpr bool for_plus_one(T1 v) {
+        return (v <= max<T1>() || may_overflow<T1>()) && (v <= max<T2>() || may_overflow<T2>()) &&
+               for_value(v + 1);
+    }
+    static constexpr bool for_minus_one(T1 v) {
+        return (v >= min<T1>() || may_overflow<T1>()) && (v >= min<T2>() || may_overflow<T2>()) &&
+               for_value(v - 1);
+    }
+};
+
+template<typename V1, typename V2> V2 makeReference(V2 reference)
+{
+    reference.setZero(V2::IndexesFromZero() >= V1::Size);
+    return reference;
+}
+
 template<typename V1, typename V2> void testNumber(double n)
 {
     typedef typename V1::EntryType T1;
     typedef typename V2::EntryType T2;
 
+    constexpr T1 One = T1(1);
+
     // compare casts from T1 -> T2 with casts from V1 -> V2
 
     const T1 n1 = static_cast<T1>(n);
     //std::cerr << "n1 = " << n1 << ", static_cast<T2>(n1) = " << static_cast<T2>(n1) << std::endl;
-    COMPARE(static_cast<V2>(V1(n1)), V2(static_cast<T2>(n1))) << "\n       n1: " << n1;
+
+    if (is_conversion_exact<T1, T2>::for_value(n1)) {
+        COMPARE(static_cast<V2>(V1(n1)), makeReference<V1>(V2(static_cast<T1>(n1))))
+            << "\n       n1: " << n1
+            << "\n   V1(n1): " << V1(n1)
+            << "\n   T2(n1): " << T2(n1)
+            ;
+    }
+    if (is_conversion_exact<T1, T2>::for_plus_one(n1)) {
+        COMPARE(static_cast<V2>(V1(n1) + One), makeReference<V1>(V2(static_cast<T2>(n1 + One)))) << "\n       n1: " << n1;
+    }
+    if (is_conversion_exact<T1, T2>::for_minus_one(n1)) {
+        COMPARE(static_cast<V2>(V1(n1) - One), makeReference<V1>(V2(static_cast<T2>(n1 - One)))) << "\n       n1: " << n1;
+    }
 }
 
 template<typename T> double maxHelper()
@@ -69,7 +495,9 @@
                 static_cast<double>(-std::numeric_limits<T2>::max())
                 );
 
+    testNumber<V1, V2>(-1.);
     testNumber<V1, V2>(0.);
+    testNumber<V1, V2>(0.5);
     testNumber<V1, V2>(1.);
     testNumber<V1, V2>(2.);
     testNumber<V1, V2>(max);
@@ -77,68 +505,11 @@
     testNumber<V1, V2>(max / 2);
     testNumber<V1, V2>(max / 4);
     testNumber<V1, V2>(min);
-}
 
-template<typename T> void testCast()
-{
-    testCast2<typename T::V1, typename T::V2>();
+    V1 test(IndexesFromZero);
+    COMPARE(static_cast<V2>(test), makeReference<V1>(V2::IndexesFromZero()));
 }
+/*}}}*/
+#endif
 
-#define _CONCAT(A, B) A ## _ ## B
-#define CONCAT(A, B) _CONCAT(A, B)
-template<typename T1, typename T2>
-struct T2Helper
-{
-    typedef T1 V1;
-    typedef T2 V2;
-};
-
-void testFloatIndexesFromZero()
-{
-    Vc::float_v test(Vc::int_v::IndexesFromZero());
-    for (int i = 0; i < float_v::Size; ++i) {
-        COMPARE(test[i], float(i));
-    }
-}
-
-int main(int argc, char **argv)
-{
-    initTest(argc, argv);
-
-#define TEST(v1, v2) \
-    typedef T2Helper<v1, v2> CONCAT(v1, v2); \
-    runTest(testCast<CONCAT(v1, v2)>)
-
-    TEST(float_v, float_v);
-    TEST(float_v, int_v);
-    TEST(float_v, uint_v);
-    // needs special handling for different Size:
-    //TEST(float_v, double_v);
-    //TEST(float_v, short_v);
-    //TEST(float_v, ushort_v);
-
-    TEST(int_v, float_v);
-    TEST(int_v, int_v);
-    TEST(int_v, uint_v);
-
-    TEST(uint_v, float_v);
-    TEST(uint_v, int_v);
-    TEST(uint_v, uint_v);
-
-    TEST(ushort_v, sfloat_v);
-    TEST(ushort_v, short_v);
-    TEST(ushort_v, ushort_v);
-
-    TEST(short_v, sfloat_v);
-    TEST(short_v, short_v);
-    TEST(short_v, ushort_v);
-
-    TEST(sfloat_v, sfloat_v);
-    TEST(sfloat_v, short_v);
-    TEST(sfloat_v, ushort_v);
-#undef TEST
-
-    runTest(testFloatIndexesFromZero);
-
-    return 0;
-}
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/CMakeLists.txt vc-1.3.0/tests/CMakeLists.txt
--- vc-0.7.4/tests/CMakeLists.txt	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/CMakeLists.txt	2016-10-27 02:05:02.000000000 -0500
@@ -4,6 +4,32 @@
 if(Vc_COMPILER_IS_MSVC)
    AddCompilerFlag("/wd4267") # Disable warning "conversion from 'size_t' to 'int', possible loss of data"
    AddCompilerFlag("/wd4723") # Disable warning "potential divide by 0" (suppress doesn't work)
+   AddCompilerFlag("/wd4503") # Disable warning "decorated name length exceeded, name was truncated"
+endif()
+
+# 32-bit x86 requires SSE for fp math to produce comparable results.
+AddCompilerFlag("-mfpmath=sse" CXX_FLAGS Vc_ARCHITECTURE_FLAGS CXX_RESULT _fpmath_ok)
+
+set(Vc_SCALAR_FLAGS "${Vc_ARCHITECTURE_FLAGS};-DVc_IMPL=Scalar")
+set(Vc_SSE_FLAGS    "${Vc_ARCHITECTURE_FLAGS};-DVc_IMPL=SSE")
+set(Vc_AVX_FLAGS    "${Vc_ARCHITECTURE_FLAGS};-DVc_IMPL=AVX")
+set(Vc_AVX2_FLAGS   "${Vc_ARCHITECTURE_FLAGS};-DVc_IMPL=AVX2")
+set(Vc_MIC_FLAGS    "-DVc_IMPL=MIC")
+
+if(USE_XOP)
+   set(Vc_SSE_FLAGS  "${Vc_SSE_FLAGS}+XOP")
+   set(Vc_AVX_FLAGS  "${Vc_AVX_FLAGS}+XOP")
+endif()
+if(USE_FMA)
+   set(Vc_SSE_FLAGS  "${Vc_SSE_FLAGS}+FMA")
+   set(Vc_AVX_FLAGS  "${Vc_AVX_FLAGS}+FMA")
+   set(Vc_AVX2_FLAGS "${Vc_AVX2_FLAGS}+FMA")
+elseif(USE_FMA4)
+   set(Vc_SSE_FLAGS  "${Vc_SSE_FLAGS}+FMA4")
+   set(Vc_AVX_FLAGS  "${Vc_AVX_FLAGS}+FMA4")
+endif()
+if(USE_BMI2)
+   set(Vc_AVX2_FLAGS "${Vc_AVX2_FLAGS}+BMI2")
 endif()
 
 if(DEFINED Vc_INSIDE_ROOT)
@@ -13,160 +39,339 @@
    set(Vc_TEST_TARGET_PREFIX "")
 endif()
 
-set(CXX11_FLAG)
-if(NOT DEFINED Vc_INSIDE_ROOT)
-   set(_cxx11_flags "-std=c++11" "-std=c++0x")
-   if(Vc_COMPILER_IS_GCC AND WIN32)
-      # MinGW fails to compile POSIX code unless gnu++11 is used
-      set(_cxx11_flags "-std=gnu++11" "-std=gnu++0x")
-   endif()
-   foreach(_flag ${_cxx11_flags})
-      string(REGEX REPLACE "[-+/:= ]" "_" _flag_esc "${_flag}")
-      check_cxx_compiler_flag("${_flag}" check_cxx_compiler_flag_${_flag_esc})
-      if(check_cxx_compiler_flag_${_flag_esc})
-         set(CXX11_FLAG ${_flag})
+# don't warn about sanity checks:
+if(Vc_COMPILER_IS_CLANG)
+   # GCC does not complain about the following flags until much later. Therefore
+   # the AddCompilerFlag logic doesn't work as intended.
+   AddCompilerFlag(-Wno-tautological-constant-out-of-range-compare)
+   AddCompilerFlag(-Wno-tautological-compare)
+endif()
+
+CHECK_CXX_SOURCE_COMPILES("#include <cxxabi.h>
+int main() { return 0; }" cxx_abi_header_works)
+if(cxx_abi_header_works)
+   add_definitions(-DHAVE_CXX_ABI_H)
+endif()
+
+macro(vc_set_first_flag_of _result)
+   set(${_result})
+   foreach(_flag ${ARGN})
+      AddCompilerFlag("${_flag}" CXX_FLAGS ${_result} CXX_RESULT _ok)
+      if(_ok)
          break()
       endif()
    endforeach()
-endif()
+endmacro()
 
+vc_set_first_flag_of(_sse2_flag "-xSSE2" "-msse2" "/arch:SSE2")
+vc_set_first_flag_of(_sse4_1_flag "-xSSE4.1" "-msse4.1" "/arch:SSE2")
+vc_set_first_flag_of(_avx_flag "-xAVX" "-mavx" "/arch:AVX")
+vc_set_first_flag_of(_avx2_flag "-xCORE-AVX2" "-mavx2" "/arch:AVX2")
 macro(vc_add_run_target _target)
-   add_custom_target(run_${_target}
-      ${_target}
-      DEPENDS ${_target}
-      COMMENT "Execute ${_target} test"
-      VERBATIM
-      )
+   if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
+      # do nothing. This just clutters the solution explorer
+   elseif("${_target}" MATCHES "_mic$")
+      if(MIC_NATIVELOAD)
+         get_target_property(_exe "${_target}" OUTPUT_NAME)
+         add_custom_target(run_${_target}
+            ${MIC_NATIVELOAD} "${_exe}" -a "-v"
+            DEPENDS ${_target}
+            COMMENT "Execute ${_target} test"
+            VERBATIM
+            )
+         list(APPEND _run_targets "run_${_target}")
+      endif()
+   else()
+      add_custom_target(run_${_target}
+         ${_target} -v
+         DEPENDS ${_target}
+         COMMENT "Execute ${_target} test"
+         VERBATIM
+         )
+      list(APPEND _run_targets "run_${_target}")
+   endif()
+endmacro()
+
+macro(vc_set_test_target_properties _target _impl _compile_flags)
+   target_link_libraries(${_target} Vc)
+   set_target_properties(${_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x")
+   set_target_properties(${_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+   add_target_property(${_target} COMPILE_FLAGS "${_extra_flags}")
+   set_property(TARGET ${_target} APPEND PROPERTY COMPILE_OPTIONS ${_compile_flags})
+   add_target_property(${_target} LABELS "${_impl}")
+   add_dependencies(build_tests ${_target})
+   add_dependencies(${_impl} ${_target})
+   add_test(${Vc_TEST_TARGET_PREFIX}${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
+   set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_target} PROPERTY LABELS "${_impl}")
+   vc_add_run_target(${_target})
 endmacro()
 
 macro(vc_add_test _name)
-   foreach(_std cxx98 cxx11)
-      set(_extra_flags)
-      set(name ${_name})
-      foreach(_arg ${ARGN})
+   set(_extra_flags)
+   set(name ${_name})
+   set(_state 0)
+   set(_targets "Scalar;SSE;AVX1;AVX2;MIC")
+   foreach(_arg ${ARGN})
+      if("${_arg}" STREQUAL "FLAGS")
+         set(_state 0)
+      elseif("${_arg}" STREQUAL "TARGETS")
+         set(_targets)
+         set(_state 1)
+      elseif(_state EQUAL 0)
          set(_extra_flags "${_extra_flags} -D${_arg}")
          set(name "${name}_${_arg}")
-      endforeach()
-
-      if("${_std}" STREQUAL "cxx11")
-         if(NOT CXX11_FLAG)
-            break()
-         endif()
-         set(SAVE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-         if(CMAKE_CXX_FLAGS MATCHES " -ansi ")
-            string(REPLACE " -ansi " " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+      elseif(_state EQUAL 1)
+         if("${_arg}" STREQUAL "AVX")
+            list(APPEND _targets "AVX1")
+         else()
+            list(APPEND _targets "${_arg}")
          endif()
-         set(_extra_flags "${_extra_flags} ${CXX11_FLAG}")
-         set(name "c++11_${name}")
       endif()
+   endforeach()
+   string(REPLACE "=" "_" name "${name}")
+
+   set(_run_targets)
+
+   set(_target "${name}_scalar")
+   list(FIND disabled_targets ${_target} _disabled)
+   if(_disabled EQUAL -1 AND "${_targets}" MATCHES "Scalar")
+      file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/scalar/*.tcc" "${CMAKE_SOURCE_DIR}/scalar/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
+      add_file_dependencies(${_name}.cpp "${_extra_deps}")
+      add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
+      vc_set_test_target_properties(${_target} Scalar "${Vc_SCALAR_FLAGS}")
+   endif()
 
-      set(_target "${name}_scalar")
+   if(USE_SSE2 AND NOT Vc_SSE_INTRINSICS_BROKEN AND "${_targets}" MATCHES "SSE")
+      set(_target "${name}_sse")
       list(FIND disabled_targets ${_target} _disabled)
       if(_disabled EQUAL -1)
-         file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/scalar/*.tcc" "${CMAKE_SOURCE_DIR}/scalar/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
+         file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/sse/*.tcc" "${CMAKE_SOURCE_DIR}/sse/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
          add_file_dependencies(${_name}.cpp "${_extra_deps}")
          add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
-         target_link_libraries(${_target} Vc)
-         add_target_property(${_target} COMPILE_FLAGS "-DVC_IMPL=Scalar ${_extra_flags}")
-         add_target_property(${_target} LABELS "Scalar")
-         add_dependencies(build_tests ${_target})
-         add_dependencies(Scalar ${_target})
-         add_test(${Vc_TEST_TARGET_PREFIX}${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
-         set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_target} PROPERTY LABELS "Scalar")
-         vc_add_run_target(${_target})
+         vc_set_test_target_properties(${_target} SSE "${Vc_SSE_FLAGS}")
       endif()
+   endif()
 
-      if(USE_SSE2 AND NOT Vc_SSE_INTRINSICS_BROKEN)
-         set(DVC_IMPL "-DVC_IMPL=SSE")
-         if(USE_XOP)
-            set(DVC_IMPL "${DVC_IMPL}+XOP")
-         endif()
-         if(USE_FMA)
-            set(DVC_IMPL "${DVC_IMPL}+FMA")
-         elseif(USE_FMA4)
-            set(DVC_IMPL "${DVC_IMPL}+FMA4")
-         endif()
-         set(_target "${name}_sse")
-         list(FIND disabled_targets ${_target} _disabled)
-         if(_disabled EQUAL -1)
-            file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/sse/*.tcc" "${CMAKE_SOURCE_DIR}/sse/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
-            add_file_dependencies(${_name}.cpp "${_extra_deps}")
-            add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
-            target_link_libraries(${_target} Vc)
-            add_target_property(${_target} COMPILE_FLAGS "${DVC_IMPL} ${_extra_flags}")
-            add_target_property(${_target} LABELS "SSE")
-            add_dependencies(build_tests ${_target})
-            add_dependencies(SSE ${_target})
-            add_test(${Vc_TEST_TARGET_PREFIX}${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
-            set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_target} PROPERTY LABELS "SSE")
-            vc_add_run_target(${_target})
-         endif()
+   if(USE_AVX AND "${_targets}" MATCHES "AVX1")
+      set(_target "${name}_avx")
+      list(FIND disabled_targets ${_target} _disabled)
+      if(_disabled EQUAL -1)
+         file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/avx/*.tcc" "${CMAKE_SOURCE_DIR}/avx/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
+         add_file_dependencies(${_name}.cpp "${_extra_deps}")
+         add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
+         vc_set_test_target_properties(${_target} AVX "${Vc_AVX_FLAGS}")
       endif()
+   endif()
 
-      if(USE_AVX)
-         set(DVC_IMPL "-DVC_IMPL=AVX")
-         if(USE_XOP)
-            set(DVC_IMPL "${DVC_IMPL}+XOP")
-         endif()
-         if(USE_FMA)
-            set(DVC_IMPL "${DVC_IMPL}+FMA")
-         elseif(USE_FMA4)
-            set(DVC_IMPL "${DVC_IMPL}+FMA4")
-         endif()
-         set(_target "${name}_avx")
-         list(FIND disabled_targets ${_target} _disabled)
-         if(_disabled EQUAL -1)
-            file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/avx/*.tcc" "${CMAKE_SOURCE_DIR}/avx/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
-            add_file_dependencies(${_name}.cpp "${_extra_deps}")
-            add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
-            target_link_libraries(${_target} Vc)
-            add_target_property(${_target} COMPILE_FLAGS "${DVC_IMPL} ${_extra_flags}")
-            add_target_property(${_target} LABELS "AVX")
-            add_dependencies(build_tests ${_target})
-            add_dependencies(AVX ${_target})
-            add_test(${Vc_TEST_TARGET_PREFIX}${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
-            set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_target} PROPERTY LABELS "AVX")
+   if(USE_AVX2 AND "${_targets}" MATCHES "AVX2")
+      set(_target "${name}_avx2")
+      list(FIND disabled_targets ${_target} _disabled)
+      if(_disabled EQUAL -1)
+         file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/avx/*.tcc" "${CMAKE_SOURCE_DIR}/avx/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
+         add_file_dependencies(${_name}.cpp "${_extra_deps}")
+         add_executable(${_target} EXCLUDE_FROM_ALL ${_name}.cpp)
+         vc_set_test_target_properties(${_target} AVX2 "${Vc_AVX2_FLAGS}")
+      endif()
+   endif()
+
+   if(MIC_NATIVE_FOUND AND "${_targets}" MATCHES "MIC")
+      set(_target "${name}_mic")
+      list(FIND disabled_targets ${_target} _disabled)
+      file(GLOB _extra_deps "${CMAKE_SOURCE_DIR}/mic/*.tcc" "${CMAKE_SOURCE_DIR}/mic/*.h" "${CMAKE_SOURCE_DIR}/common/*.h")
+      add_file_dependencies(${_name}.cpp "${_extra_deps}")
+      set(_objs)
+      if("${_name}" STREQUAL "trigonometric")
+         foreach(fun sincos asin acos atan)
+            foreach(filename reference-${fun}-sp.dat reference-${fun}-dp.dat)
+               set(_objs ${_objs} ${CMAKE_CURRENT_BINARY_DIR}/${filename}.k1om.o)
+            endforeach()
+         endforeach()
+      elseif("${_name}" STREQUAL "logarithm")
+         foreach(fun ln log2 log10)
+            foreach(filename reference-${fun}-sp.dat reference-${fun}-dp.dat)
+               set(_objs ${_objs} ${CMAKE_CURRENT_BINARY_DIR}/${filename}.k1om.o)
+            endforeach()
+         endforeach()
+      endif()
+      mic_add_executable(${_target}
+         LINK_LIBRARIES Vc_MIC
+         COMPILE_FLAGS "${Vc_MIC_FLAGS} ${_extra_flags}"
+         SOURCES ${_name}.cpp
+         OBJECTS ${_objs}
+         EXCLUDE_FROM_ALL
+         )
+      add_target_property(${_target} LABELS "MIC")
+      if(_disabled EQUAL -1)
+         add_dependencies(build_tests ${_target})
+         add_dependencies(MIC ${_target})
+         if(MIC_NATIVELOAD)
+            get_target_property(_exe "${_target}" OUTPUT_NAME)
+            add_test(NAME ${Vc_TEST_TARGET_PREFIX}${_target}
+               COMMAND "${MIC_NATIVELOAD}" "${_exe}"
+               )
+            set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_target} PROPERTY LABELS "MIC")
             vc_add_run_target(${_target})
          endif()
-      endif(USE_AVX)
-      if("${_std}" STREQUAL "cxx11")
-         set(CMAKE_CXX_FLAGS "${SAVE_CXX_FLAGS}")
       endif()
-   endforeach()
+   endif()
+
+   if(_run_targets)
+      add_custom_target(run_${name}_all
+         COMMENT "Execute all ${name} tests"
+         VERBATIM
+         )
+      add_dependencies(run_${name}_all ${_run_targets})
+   endif()
+
 endmacro(vc_add_test)
 
+set(_deps)
+foreach(fun sincos asin acos atan ln log2 log10)
+   foreach(filename reference-${fun}-sp.dat reference-${fun}-dp.dat)
+      add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${filename}"
+         COMMAND ${CMAKE_COMMAND} -Dfilename=${filename} -P ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
+         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
+         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+         COMMENT "Downloading Test Data: ${filename}"
+         VERBATIM
+         )
+      if(MIC_OBJCOPY)
+         add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${filename}.k1om.o"
+            COMMAND ${MIC_OBJCOPY} -I binary -O elf64-k1om -B k1om ${filename} ${filename}.k1om.o
+            DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${filename}"
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+            COMMENT "Converting Test Data: ${filename}.k1om.o"
+            VERBATIM
+            )
+         list(APPEND _deps "${CMAKE_CURRENT_BINARY_DIR}/${filename}.k1om.o")
+      endif()
+      list(APPEND _deps "${CMAKE_CURRENT_BINARY_DIR}/${filename}")
+   endforeach()
+endforeach()
+add_custom_target(download-testdata ALL
+   DEPENDS ${_deps}
+   )
+add_dependencies(Scalar download-testdata)
+add_dependencies(SSE download-testdata)
+add_dependencies(AVX download-testdata)
+add_dependencies(AVX2 download-testdata)
+add_dependencies(MIC download-testdata)
+
+vc_add_test(types)
+vc_add_test(subscript)
+vc_add_test(type_traits)
 vc_add_test(stlcontainer)
 vc_add_test(scalaraccess)
 vc_add_test(memory)
 vc_add_test(arithmetics)
+vc_add_test(simdize)
 vc_add_test(implicit_type_conversion)
-vc_add_test(expandandmerge)
+vc_add_test(iterators)
 vc_add_test(load)
 vc_add_test(store)
 vc_add_test(gather)
-vc_add_test(gather VC_USE_BSF_GATHERS)
-vc_add_test(gather VC_USE_POPCNT_BSF_GATHERS)
-vc_add_test(gather VC_USE_SET_GATHERS)
+vc_add_test(gather Vc_USE_BSF_GATHERS TARGETS SSE AVX AVX2)
+vc_add_test(gather Vc_USE_POPCNT_BSF_GATHERS TARGETS SSE AVX AVX2)
+vc_add_test(gather Vc_USE_SET_GATHERS TARGETS SSE AVX AVX2)
 vc_add_test(scatter)
-vc_add_test(scatter VC_USE_BSF_SCATTERS)
-vc_add_test(scatter VC_USE_POPCNT_BSF_SCATTERS)
+vc_add_test(scatter Vc_USE_BSF_SCATTERS TARGETS SSE AVX AVX2)
+vc_add_test(scatter Vc_USE_POPCNT_BSF_SCATTERS TARGETS SSE AVX AVX2)
+vc_add_test(ulp)
+vc_add_test(logarithm)
+vc_add_test(logarithm Vc_LOG_ILP TARGETS SSE AVX AVX2)
+vc_add_test(logarithm Vc_LOG_ILP2 TARGETS SSE AVX AVX2)
+vc_add_test(trigonometric)
 vc_add_test(math)
-vc_add_test(math VC_LOG_ILP)
-vc_add_test(math VC_LOG_ILP2)
+vc_add_test(reductions)
 vc_add_test(mask)
 vc_add_test(utils)
+vc_add_test(sorted)
+vc_add_test(random)
 vc_add_test(deinterleave)
-vc_add_test(deinterleave VC_USE_MASKMOV_SCATTER)
-vc_add_test(casts)
-vc_add_test(swizzles)
+vc_add_test(gatherinterleavedmemory)
+vc_add_test(scatterinterleavedmemory)
+vc_add_test(scatterinterleavedmemory Vc_USE_MASKMOV_SCATTER TARGETS SSE AVX AVX2)
+vc_add_test(casts Vc_DEFAULT_TYPES)
+option(BUILD_EXTRA_CAST_TESTS "build all possible combinations of simd_cast tests (compiles for a very long time)" FALSE)
+if(BUILD_EXTRA_CAST_TESTS)
+   vc_add_test(casts Vc_EXTRA_TYPES)
+   foreach(n 1 2 3 4 5 8 16 17 31)
+      vc_add_test(casts Vc_FROM_N=${n})
+      vc_add_test(casts Vc_TO_N=${n})
+      foreach(m 1 2 3 4 5 8 16 17 31)
+         vc_add_test(casts Vc_FROM_N=${m} Vc_TO_N=${n})
+      endforeach()
+   endforeach()
+endif()
+vc_add_test(simdarray)
+
+find_program(OBJDUMP objdump)
+mark_as_advanced(OBJDUMP)
+
+if(OBJDUMP)
+   macro(test_abi _target _impl)
+      set(_test test_${_target})
+      if("${_impl}" STREQUAL "MIC")
+         mic_add_executable(${_target} SOURCES abi.cpp LINK_LIBRARIES Vc_MIC COMPILE_FLAGS "-DVc_IMPL=${_impl};${ARGN};-O2")
+      else()
+         add_executable(${_target} EXCLUDE_FROM_ALL abi.cpp)
+         target_link_libraries(${_target} Vc)
+         set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS "Vc_IMPL=${_impl}")
+         set_property(TARGET ${_target} APPEND PROPERTY COMPILE_OPTIONS "${ARGN};-O2")
+      endif()
+      add_target_property(${_target} LABELS "${_impl}")
+      add_dependencies(${_impl} ${_target})
+      add_dependencies(build_tests ${_target})
+
+      get_target_property(_exe ${_target} OUTPUT_NAME)
+      if(NOT _exe)
+         set(_exe ${_target})
+      endif()
+
+      add_test(NAME ${_test}
+         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+         COMMAND ${CMAKE_COMMAND} -DOBJDUMP=${OBJDUMP} -DBINARY=${_exe} -DIMPL=${_impl}
+         -DCOMPILER_IS_CLANG=${Vc_COMPILER_IS_CLANG} -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME}
+         -P ${CMAKE_CURRENT_SOURCE_DIR}/abi.cmake
+         )
+      set_property(TEST ${_test} PROPERTY LABELS "${_impl}")
+      add_custom_target(run_${_target}
+         ${CMAKE_COMMAND} -DOBJDUMP=${OBJDUMP} -DBINARY=${_exe} -DIMPL=${_impl}
+         -DCOMPILER_IS_CLANG=${Vc_COMPILER_IS_CLANG} -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME}
+         -P ${CMAKE_CURRENT_SOURCE_DIR}/abi.cmake
+         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+         DEPENDS ${_target}
+         COMMENT "Execute ${_target} test"
+         VERBATIM
+         )
+   endmacro()
+
+   if("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "[x3-7]86")
+      test_abi(abi_SSE     SSE  ${_sse2_flag})
+      test_abi(abi_SSE_AVX SSE  ${_avx_flag})
+      if(NOT Vc_AVX_INTRINSICS_BROKEN)
+         test_abi(abi_AVX     AVX  ${_avx_flag})
+         test_abi(abi_AVX2    AVX2 ${_avx2_flag})
+      endif()
+   endif()
+   if(MIC_NATIVE_FOUND)
+      find_program(MIC_OBJDUMP x86_64-k1om-linux-objdump PATHS ENV PATH "${MIC_TARGET_TOOLS_DIR}/bin")
+      mark_as_advanced(MIC_OBJDUMP)
+      if(MIC_OBJDUMP)
+         set(OBJDUMP "${MIC_OBJDUMP}")
+         test_abi(abi_MIC MIC)
+      endif()
+   endif()
+endif()
 
 if(USE_SSE2 AND NOT Vc_SSE_INTRINSICS_BROKEN)
    list(FIND disabled_targets sse_blend _disabled)
    if(_disabled EQUAL -1)
       add_executable(sse2_blend EXCLUDE_FROM_ALL sse_blend.cpp)
-      add_target_property(sse2_blend COMPILE_FLAGS "-DVC_IMPL=SSE2")
+      add_target_property(sse2_blend COMPILE_DEFINITIONS "Vc_IMPL=SSE2")
+      set_property(TARGET sse2_blend APPEND PROPERTY COMPILE_OPTIONS "${_sse2_flag}")
       add_target_property(sse2_blend LABELS "SSE")
-      add_dependencies(build_tests ${_target})
+      add_dependencies(build_tests sse2_blend)
       add_dependencies(SSE sse2_blend)
       add_test(${Vc_TEST_TARGET_PREFIX}sse2_blend "${CMAKE_CURRENT_BINARY_DIR}/sse2_blend")
       set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse2_blend PROPERTY LABELS "SSE")
@@ -174,9 +379,10 @@
 
       if(USE_SSE4_1)
          add_executable(sse4_blend EXCLUDE_FROM_ALL sse_blend.cpp)
-         add_target_property(sse4_blend COMPILE_FLAGS "-DVC_IMPL=SSE4_1")
+         add_target_property(sse4_blend COMPILE_DEFINITIONS "Vc_IMPL=SSE4_1")
+         set_property(TARGET sse4_blend APPEND PROPERTY COMPILE_OPTIONS ${Vc_ARCHITECTURE_FLAGS})
          add_target_property(sse4_blend LABELS "SSE")
-         add_dependencies(build_tests ${_target})
+         add_dependencies(build_tests sse4_blend)
          add_dependencies(SSE sse4_blend)
          add_test(${Vc_TEST_TARGET_PREFIX}sse4_blend "${CMAKE_CURRENT_BINARY_DIR}/sse4_blend")
          set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse4_blend PROPERTY LABELS "SSE")
@@ -185,14 +391,23 @@
    endif()
 endif()
 
-add_executable(supportfunctions EXCLUDE_FROM_ALL supportfunctions.cpp)
-target_link_libraries(supportfunctions Vc)
-add_target_property(supportfunctions LABELS "other")
-add_dependencies(build_tests ${_target})
-add_dependencies(other supportfunctions)
-add_test(${Vc_TEST_TARGET_PREFIX}supportfunctions "${CMAKE_CURRENT_BINARY_DIR}/supportfunctions")
-set_property(TEST ${Vc_TEST_TARGET_PREFIX}supportfunctions PROPERTY LABELS "other")
-vc_add_run_target(supportfunctions)
+macro(vc_add_general_test _name)
+   add_executable(${_name} EXCLUDE_FROM_ALL ${_name}.cpp )
+   target_link_libraries(${_name} Vc)
+   add_target_property(${_name} LABELS "other")
+   set_property(TARGET ${_name} APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
+   add_dependencies(build_tests ${_name})
+   add_dependencies(other ${_name})
+   add_test(${Vc_TEST_TARGET_PREFIX}${_name} "${CMAKE_CURRENT_BINARY_DIR}/${_name}")
+   set_property(TEST ${Vc_TEST_TARGET_PREFIX}${_name} PROPERTY LABELS "other")
+   vc_add_run_target(${_name})
+endmacro()
+
+if(_last_target_arch STREQUAL "auto" AND NOT Vc_AVX_INTRINSICS_BROKEN)
+   vc_add_general_test(supportfunctions)
+endif()
+vc_add_general_test(alignmentinheritance)
+vc_add_general_test(alignedbase)
 
 get_property(_incdirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
 set(incdirs)
@@ -200,58 +415,76 @@
    list(APPEND incdirs "-I${_d}")
 endforeach()
 
-separate_arguments(_flags UNIX_COMMAND ${CMAKE_CXX_FLAGS})
+separate_arguments(_flags UNIX_COMMAND "${CMAKE_CXX_FLAGS} ${Vc_DEFINITIONS}")
+list(APPEND _flags ${Vc_COMPILE_FLAGS})
+set(_tmp)
 foreach(_f ${_flags})
    if(_f MATCHES "^-m" OR _f MATCHES "^/arch:" OR _f MATCHES "^-x")
-      list(REMOVE_ITEM _flags "${_f}")
+      # nothing
+   elseif(_f MATCHES "^/[A-Za-z]")
+      string(SUBSTRING "${_f}" 1 -1 _f)
+      list(APPEND _tmp "-${_f}")
+   else()
+      list(APPEND _tmp "${_f}")
    endif()
 endforeach()
+set(_flags "${_tmp}")
 
 set(TEST_OPERATOR_FAILURES FALSE CACHE BOOL "Run implicit type conversion operator tests.")
 if(TEST_OPERATOR_FAILURES)
+   find_program(BIN_ENV env)
+   if(NOT BIN_ENV)
+      set(CENV "")
+   else()
+      set(CENV "env;LANG=C")
+   endif()
    macro(vc_test_implicit_type_conversion_failures A B)
-      foreach(impl Scalar SSE AVX)
+      foreach(impl Scalar SSE AVX AVX2)
          if("${impl}" STREQUAL "Scalar")
             set(_implFlags)
          elseif("${impl}" STREQUAL "SSE")
-            if(Vc_COMPILER_IS_MSVC)
-               AddCompilerFlag("/arch:SSE2" CXX_FLAGS _implFlags)
-               string(STRIP "${_implFlags}" _implFlags)
-            elseif(Vc_COMPILER_IS_INTEL)
-               set(_implFlags "-xSSE2")
-            else()
-               set(_implFlags "-msse2")
-            endif()
+            string(REPLACE " " ";" _implFlags "${_sse2_flag}")
          elseif("${impl}" STREQUAL "AVX")
             if(Vc_AVX_INTRINSICS_BROKEN)
                break()
             endif()
-            if(Vc_COMPILER_IS_MSVC)
-               set(_implFlags "/arch:AVX")
-            elseif(Vc_COMPILER_IS_INTEL)
-               set(_implFlags "-xAVX")
-            else()
-               set(_implFlags "-mavx")
+            string(REPLACE " " ";" _implFlags "${_avx_flag}")
+         elseif("${impl}" STREQUAL "AVX2")
+            if(Vc_AVX2_INTRINSICS_BROKEN)
+               break()
             endif()
+            string(REPLACE " " ";" _implFlags "${_avx2_flag}")
          endif()
-         set(type_b ${B})
-         foreach(type_a ${A} ${B})
+         set(type_b "${B}")
+         foreach(type_a "${A}" "${B}")
             foreach(op "^" "==" "*") # "/" "+" "-" "&" "|" "!=" "<=" ">=" "<" ">")
                set(name "implicit_type_conversion_failures_${type_a}_${op}_${type_b}_${impl}")
+               string(REGEX REPLACE "[<>, ():;?]" "_" name "${name}")
+               if(Vc_COMPILER_IS_MSVC)
+                  set(_output)
+               else()
+                  set(_output "-o;${name}.tmp")
+               endif()
                add_test(NAME "${Vc_TEST_TARGET_PREFIX}${name}" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   COMMAND
+                  ${CENV}
                   ${CMAKE_CXX_COMPILER} ${_flags} ${_implFlags}
-                  ${incdirs} -o "${name}.tmp"
-                  "-DTYPE_A=${type_a}" "-DTEST_OP=${op}" "-DTYPE_B=${type_b}" "-DVC_IMPL=${impl}"
+                  "-DTYPE_A=${type_a}" "-DTEST_OP=${op}" "-DTYPE_B=${type_b}" "-DVc_IMPL=${impl}"
+                  ${incdirs} ${_output} -c
                   ${CMAKE_CURRENT_SOURCE_DIR}/implicit_type_conversion_failures.cpp
                   )
-               set_property(TEST "${name}" PROPERTY LABELS "${impl}")
-               set_tests_properties("${name}" PROPERTIES
-                  PASS_REGULAR_EXPRESSION "invalid operands to binary expression;error: no match for .*operator\\${op};error C267[789]: binary .*\\${op}.* no (global )?operator found;error: no operator \"\\${op}\" matches these operands"
-                  FAIL_REGULAR_EXPRESSION "no such file or directory;undefined reference to"
+               set_property(TEST "${Vc_TEST_TARGET_PREFIX}${name}" PROPERTY LABELS "${impl}")
+               set_property(TEST "${Vc_TEST_TARGET_PREFIX}${name}" PROPERTY PASS_REGULAR_EXPRESSION
+                  "error: no operator .* matches these operands" # ICC
+                  "error: invalid operands to binary expression" # Clang
+                  "error: no match for 'operator..?' "           # GCC
+                  "error: no match for ‘operator..?’ "           # GCC
+                  "error C2676: binary "                         # MSVC
+                  "error C2677: binary "                         # MSVC
+                  "error C2679: binary "                         # MSVC
                   )
             endforeach()
-            set(type_b ${A})
+            set(type_b "${A}")
          endforeach()
       endforeach()
    endmacro()
@@ -263,22 +496,17 @@
    vc_test_implicit_type_conversion_failures( "float_v"     "double")
    vc_test_implicit_type_conversion_failures( "float_v"    "short_v")
    vc_test_implicit_type_conversion_failures( "float_v"   "ushort_v")
-   vc_test_implicit_type_conversion_failures("sfloat_v"   "double_v")
-   vc_test_implicit_type_conversion_failures("sfloat_v"     "double")
-   vc_test_implicit_type_conversion_failures("sfloat_v"    "float_v")
-   vc_test_implicit_type_conversion_failures("sfloat_v"      "int_v")
-   vc_test_implicit_type_conversion_failures("sfloat_v"     "uint_v")
+   vc_test_implicit_type_conversion_failures(   "int_v"    "float_v")
+   vc_test_implicit_type_conversion_failures(   "int_v"      "float")
+   vc_test_implicit_type_conversion_failures(   "int_v"     "double")
+   vc_test_implicit_type_conversion_failures(   "int_v"       "long")
+   vc_test_implicit_type_conversion_failures(   "int_v"      "llong")
    vc_test_implicit_type_conversion_failures( "short_v"      "int_v")
    vc_test_implicit_type_conversion_failures( "short_v"     "uint_v")
+   vc_test_implicit_type_conversion_failures( "short_v"      "float")
    vc_test_implicit_type_conversion_failures("ushort_v"      "int_v")
    vc_test_implicit_type_conversion_failures("ushort_v"     "uint_v")
-   vc_test_implicit_type_conversion_failures("double_v"       "bool")
-   vc_test_implicit_type_conversion_failures("sfloat_v"       "bool")
-   vc_test_implicit_type_conversion_failures( "float_v"       "bool")
-   vc_test_implicit_type_conversion_failures(   "int_v"       "bool")
-   vc_test_implicit_type_conversion_failures(  "uint_v"       "bool")
-   vc_test_implicit_type_conversion_failures( "short_v"       "bool")
-   vc_test_implicit_type_conversion_failures("ushort_v"       "bool")
+   vc_test_implicit_type_conversion_failures("SimdArray<int, 3>" "int_v")
 endif()
 
 # compile and link test for targets that need to link lots of stuff together
@@ -292,26 +520,13 @@
 target_link_libraries(linkTestLibDynamic2 Vc)
 add_target_property(linkTestLibDynamic1 COMPILE_FLAGS "-DPOSTFIX=A")
 add_target_property(linkTestLibDynamic2 COMPILE_FLAGS "-DPOSTFIX=B")
+set_property(TARGET linkTestLibDynamic1 APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
+set_property(TARGET linkTestLibDynamic2 APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
+set_property(TARGET linkTestLibStatic APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
+set_property(TARGET linkTest APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
 target_link_libraries(linkTestLibStatic Vc)
 target_link_libraries(linkTest Vc linkTestLibDynamic1 linkTestLibDynamic2 linkTestLibStatic)
 
 # Use the following program to generate the sincos-reference-*.dat files
 #add_executable(convert-sincos-reference EXCLUDE_FROM_ALL convert-sincos-reference.cpp)
 
-set(_deps)
-foreach(fun sincos asin acos atan ln log2 log10)
-   foreach(filename reference-${fun}-sp.dat reference-${fun}-dp.dat)
-      add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${filename}"
-         COMMAND ${CMAKE_COMMAND} -Dfilename=${filename} -P ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
-         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/download.cmake
-         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-         COMMENT "Downloading Test Data: ${filename}"
-         VERBATIM
-         )
-      list(APPEND _deps "${CMAKE_CURRENT_BINARY_DIR}/${filename}")
-   endforeach()
-endforeach()
-add_custom_target(download-testdata ALL
-   DEPENDS ${_deps}
-   )
-add_dependencies(other download-testdata)
diff -Nru vc-0.7.4/tests/const.h vc-1.3.0/tests/const.h
--- vc-0.7.4/tests/const.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/const.h	1969-12-31 18:00:00.000000000 -0600
@@ -1,66 +0,0 @@
-/*  This file is part of the Vc library. {{{
-
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-}}}*/
-
-#ifndef VC_TESTS_CONST_H_
-#define VC_TESTS_CONST_H_
-
-#include <common/macros.h>
-
-/*OUTER_NAMESPACE_BEGIN*/
-namespace Vc
-{
-    template<typename T> struct Math;
-    template<> struct Math<float>
-    {
-        static _VC_CONSTEXPR float e()         { return 2.7182818284590452353602874713526625f; }
-        static _VC_CONSTEXPR float log2e()     { return 1.4426950408889634073599246810018921f; }
-        static _VC_CONSTEXPR float log10e()    { return 0.4342944819032518276511289189166051f; }
-        static _VC_CONSTEXPR float ln2()       { return Vc_buildFloat(1, 0x317218, -1); } // .693147182464599609375
-        static _VC_CONSTEXPR float ln10()      { return 2.3025850929940456840179914546843642f; }
-        static _VC_CONSTEXPR float pi()        { return 3.1415926535897932384626433832795029f; }
-        static _VC_CONSTEXPR float pi_2()      { return 1.5707963267948966192313216916397514f; }
-        static _VC_CONSTEXPR float pi_4()      { return 0.7853981633974483096156608458198757f; }
-        static _VC_CONSTEXPR float _1_pi()     { return 0.3183098861837906715377675267450287f; }
-        static _VC_CONSTEXPR float _2_pi()     { return 0.6366197723675813430755350534900574f; }
-        static _VC_CONSTEXPR float _2_sqrtpi() { return 1.1283791670955125738961589031215452f; }
-        static _VC_CONSTEXPR float sqrt2()     { return 1.4142135623730950488016887242096981f; }
-        static _VC_CONSTEXPR float sqrt1_2()   { return 0.7071067811865475244008443621048490f; }
-    };
-    template<> struct Math<double>
-    {
-        static _VC_CONSTEXPR double e()         { return 2.7182818284590452353602874713526625; }
-        static _VC_CONSTEXPR double log2e()     { return 1.4426950408889634073599246810018921; }
-        static _VC_CONSTEXPR double log10e()    { return 0.4342944819032518276511289189166051; }
-        static _VC_CONSTEXPR double ln2()       { return Vc_buildDouble(1, 0x62E42FEFA39EFull, -1); } // .69314718055994528622676398299518041312694549560546875
-        static _VC_CONSTEXPR double ln10()      { return 2.3025850929940456840179914546843642; }
-        static _VC_CONSTEXPR double pi()        { return 3.1415926535897932384626433832795029; }
-        static _VC_CONSTEXPR double pi_2()      { return 1.5707963267948966192313216916397514; }
-        static _VC_CONSTEXPR double pi_4()      { return 0.7853981633974483096156608458198757; }
-        static _VC_CONSTEXPR double _1_pi()     { return 0.3183098861837906715377675267450287; }
-        static _VC_CONSTEXPR double _2_pi()     { return 0.6366197723675813430755350534900574; }
-        static _VC_CONSTEXPR double _2_sqrtpi() { return 1.1283791670955125738961589031215452; }
-        static _VC_CONSTEXPR double sqrt2()     { return 1.4142135623730950488016887242096981; }
-        static _VC_CONSTEXPR double sqrt1_2()   { return 0.7071067811865475244008443621048490; }
-    };
-} // namespace Vc
-/*OUTER_NAMESPACE_END*/
-
-#include <common/undomacros.h>
-
-#endif  // VC_TESTS_CONST_H_
diff -Nru vc-0.7.4/tests/deinterleave.cpp vc-1.3.0/tests/deinterleave.cpp
--- vc-0.7.4/tests/deinterleave.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/deinterleave.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,70 +1,77 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 #include <iostream>
 #include <limits>
 
-using namespace Vc;
-
+using Vc::float_v;
+using Vc::double_v;
+using Vc::int_v;
+using Vc::uint_v;
+using Vc::short_v;
+using Vc::ushort_v;
 
 /*
  *   V \  M | float | double | ushort | short | uint | int
  * ---------+----------------------------------------------
  *  float_v |   X   |        |    X   |   X   |      |
- * sfloat_v |   X   |        |    X   |   X   |      |
  * double_v |       |    X   |        |       |      |
  *    int_v |       |        |        |   X   |      |  X
  *   uint_v |       |        |    X   |       |   X  |
  *  short_v |       |        |        |   X   |      |
  * ushort_v |       |        |    X   |       |      |
  */
-template<typename A, typename B> struct TPair { typedef A V; typedef B M; };
-
-typedef TPair<float_v, float> float_float;
-typedef TPair<float_v, unsigned short> float_ushort;
-typedef TPair<float_v, short> float_short;
-
-typedef TPair<sfloat_v, float> sfloat_float;
-typedef TPair<sfloat_v, unsigned short> sfloat_ushort;
-typedef TPair<sfloat_v, short> sfloat_short;
-
-typedef TPair<double_v, double> double_double;
-typedef TPair<short_v, short> short_short;
-typedef TPair<ushort_v, unsigned short> ushort_ushort;
-
-typedef TPair<int_v, int> int_int;
-typedef TPair<int_v, short> int_short;
-
-typedef TPair<uint_v, unsigned int> uint_uint;
-typedef TPair<uint_v, unsigned short> uint_ushort;
-
-template<typename Pair> void testDeinterleave()
+typedef Typelist<float_v, float> float_float;
+typedef Typelist<float_v, unsigned short> float_ushort;
+typedef Typelist<float_v, short> float_short;
+
+typedef Typelist<double_v, double> double_double;
+typedef Typelist<short_v, short> short_short;
+typedef Typelist<ushort_v, unsigned short> ushort_ushort;
+
+typedef Typelist<int_v, int> int_int;
+typedef Typelist<int_v, short> int_short;
+
+typedef Typelist<uint_v, unsigned int> uint_uint;
+typedef Typelist<uint_v, unsigned short> uint_ushort;
+
+TEST_TYPES(Pair, testDeinterleave,
+           (float_float, float_ushort, float_short, double_double, int_int, int_short,
+            uint_uint, uint_ushort, short_short, ushort_ushort))
 {
-    typedef typename Pair::V V;
-    typedef typename Pair::M M;
+    typedef typename Pair::template at<0> V;
+    typedef typename Pair::template at<1> M;
     typedef typename V::IndexType I;
 
     const bool isSigned = std::numeric_limits<M>::is_signed;
 
     const typename V::EntryType offset = isSigned ? -512 : 0;
-    const V _0246 = static_cast<V>(I::IndexesFromZero()) * 2 + offset;
+    const V _0246 = Vc::simd_cast<V>(I::IndexesFromZero()) * 2 + offset;
 
     M memory[1024];
     for (int i = 0; i < 1024; ++i) {
@@ -73,349 +80,14 @@
 
     V a, b;
 
-    for (int i = 0; i < 1024 - 2 * V::Size; ++i) {
-        // note that a 32 bit integer is certainly enough to decide on alignment...
-        // ... but uintptr_t is C99 but not C++ yet
-        // ... and GCC refuses to do the cast, even if I know what I'm doing
-        if (reinterpret_cast<unsigned long>(&memory[i]) & (VectorAlignment - 1)) {
-            Vc::deinterleave(&a, &b, &memory[i], Unaligned);
+    static_assert(2 * V::Size < 1024, "fix the test, please");
+    for (int i = 0; i < 1024 - 2 * int(V::Size); ++i) {
+        if (reinterpret_cast<std::uintptr_t>(&memory[i]) & (Vc::VectorAlignment - 1)) {
+            Vc::deinterleave(&a, &b, &memory[i], Vc::Unaligned);
         } else {
             Vc::deinterleave(&a, &b, &memory[i]);
         }
-        COMPARE(_0246 + i,     a);
-        COMPARE(_0246 + i + 1, b);
-    }
-}
-
-template<typename T, size_t N> struct SomeStruct
-{
-    T d[N];
-};
-
-template<typename V, size_t StructSize> struct Types
-{
-    typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
-    typedef typename V::AsArg VArg;
-    typedef typename I::AsArg IArg;
-    typedef SomeStruct<T, StructSize> S;
-    typedef const Vc::InterleavedMemoryWrapper<S, V> &Wrapper;
-};
-template<typename V, size_t StructSize, size_t N = StructSize> struct TestDeinterleaveGatherCompare;
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 8> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V v0, v1, v2, v3, v4, v5, v6, v7;
-        (v0, v1, v2, v3, v4, v5, v6, v7) = data_v[indexes];
-        COMPARE(v0, reference + 0) << "N = 8";
-        COMPARE(v1, reference + 1) << "N = 8";
-        COMPARE(v2, reference + 2) << "N = 8";
-        COMPARE(v3, reference + 3) << "N = 8";
-        COMPARE(v4, reference + 4) << "N = 8";
-        COMPARE(v5, reference + 5) << "N = 8";
-        COMPARE(v6, reference + 6) << "N = 8";
-        COMPARE(v7, reference + 7) << "N = 8";
-        TestDeinterleaveGatherCompare<V, StructSize, 7>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 7> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V v0, v1, v2, v3, v4, v5, v6;
-        (v0, v1, v2, v3, v4, v5, v6) = data_v[indexes];
-        COMPARE(v0, reference + 0) << "N = 7";
-        COMPARE(v1, reference + 1) << "N = 7";
-        COMPARE(v2, reference + 2) << "N = 7";
-        COMPARE(v3, reference + 3) << "N = 7";
-        COMPARE(v4, reference + 4) << "N = 7";
-        COMPARE(v5, reference + 5) << "N = 7";
-        COMPARE(v6, reference + 6) << "N = 7";
-        TestDeinterleaveGatherCompare<V, StructSize, 6>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 6> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V v0, v1, v2, v3, v4, v5;
-        (v0, v1, v2, v3, v4, v5) = data_v[indexes];
-        COMPARE(v0, reference + 0) << "N = 6";
-        COMPARE(v1, reference + 1) << "N = 6";
-        COMPARE(v2, reference + 2) << "N = 6";
-        COMPARE(v3, reference + 3) << "N = 6";
-        COMPARE(v4, reference + 4) << "N = 6";
-        COMPARE(v5, reference + 5) << "N = 6";
-        TestDeinterleaveGatherCompare<V, StructSize, 5>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 5> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V v0, v1, v2, v3, v4;
-        (v0, v1, v2, v3, v4) = data_v[indexes];
-        COMPARE(v0, reference + 0) << "N = 5";
-        COMPARE(v1, reference + 1) << "N = 5";
-        COMPARE(v2, reference + 2) << "N = 5";
-        COMPARE(v3, reference + 3) << "N = 5";
-        COMPARE(v4, reference + 4) << "N = 5";
-        TestDeinterleaveGatherCompare<V, StructSize, 4>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 4> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V a, b, c, d;
-        (a, b, c, d) = data_v[indexes];
-        COMPARE(a, reference + 0) << "N = 4";
-        COMPARE(b, reference + 1) << "N = 4";
-        COMPARE(c, reference + 2) << "N = 4";
-        COMPARE(d, reference + 3) << "N = 4";
-        TestDeinterleaveGatherCompare<V, StructSize, 3>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 3> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V a, b, c;
-        (a, b, c) = data_v[indexes];
-        COMPARE(a, reference + 0) << "N = 3";
-        COMPARE(b, reference + 1) << "N = 3";
-        COMPARE(c, reference + 2) << "N = 3";
-        TestDeinterleaveGatherCompare<V, StructSize, 2>::test(data_v, indexes, reference);
-    }
-};
-template<typename V, size_t StructSize> struct TestDeinterleaveGatherCompare<V, StructSize, 2> {
-    static void test(typename Types<V, StructSize>::Wrapper data_v, typename Types<V, StructSize>::IArg indexes, const typename V::AsArg reference)
-    {
-        V a, b;
-        (a, b) = data_v[indexes];
-        COMPARE(a, reference + 0) << "N = 2";
-        COMPARE(b, reference + 1) << "N = 2";
-    }
-};
-
-size_t createNMask(size_t N)
-{
-    size_t NMask = (N >> 1) | (N >> 2);
-    for (size_t shift = 2; shift < sizeof(size_t) * 8; shift *= 2) {
-        NMask |= NMask >> shift;
-    }
-    return NMask;
-}
-
-template<typename V, size_t StructSize> void testDeinterleaveGatherImpl()
-{
-    typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
-    typedef SomeStruct<T, StructSize> S;
-    typedef Vc::InterleavedMemoryWrapper<S, V> Wrapper;
-    const size_t N = std::min<size_t>(std::numeric_limits<typename I::EntryType>::max(), 1024 * 1024 / sizeof(S));
-    const size_t NMask = createNMask(N);
-
-    S *data = Vc::malloc<S, Vc::AlignOnVector>(N);
-    for (size_t i = 0; i < N; ++i) {
-        for (size_t j = 0; j < StructSize; ++j) {
-            data[i].d[j] = i * StructSize + j;
-        }
-    }
-    const Wrapper data_v(data);
-
-    for (int retest = 0; retest < 10000; ++retest) {
-        I indexes = (I::Random() >> 10) & I(NMask);
-        VERIFY(indexes >= 0);
-        VERIFY(indexes < N);
-        const V reference = static_cast<V>(indexes) * V(StructSize);
-
-        TestDeinterleaveGatherCompare<V, StructSize>::test(data_v, indexes, reference);
+        COMPARE(a, _0246 + i);
+        COMPARE(b, _0246 + i + 1);
     }
 }
-
-template<typename V> void testDeinterleaveGather()
-{
-    testDeinterleaveGatherImpl<V, 2>();
-    testDeinterleaveGatherImpl<V, 3>();
-    testDeinterleaveGatherImpl<V, 4>();
-    testDeinterleaveGatherImpl<V, 5>();
-    testDeinterleaveGatherImpl<V, 6>();
-    testDeinterleaveGatherImpl<V, 7>();
-    testDeinterleaveGatherImpl<V, 8>();
-}
-
-template<typename V, size_t StructSize> struct TestInterleavingScatterCompare;
-#define _IMPL(STRUCTSIZE, _code_) \
-template<typename V> struct TestInterleavingScatterCompare<V, STRUCTSIZE> { \
-    typedef TestInterleavingScatterCompare<V, STRUCTSIZE - 1> NextTest; \
-    template<typename Wrapper> static void test(Wrapper &data, const typename V::IndexType &i) { \
-        _code_ \
-    } \
-}
-_IMPL(2,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        V t0;
-        V t1;
-        data[i] = (v0, v1);
-        (t0, t1) = data[i];
-        COMPARE(t0, v0) << 2;
-        COMPARE(t1, v1) << 2;
-     );
-_IMPL(3,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        V t0; V t1; V t2;
-        data[i] = (v0, v1, v2);
-        (t0, t1, t2) = data[i];
-        COMPARE(t0, v0) << 3;
-        COMPARE(t1, v1) << 3;
-        COMPARE(t2, v2) << 3;
-        NextTest::test(data, i);
-     );
-_IMPL(4,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        const V v3 = V::Random();
-        V t0; V t1; V t2; V t3;
-        data[i] = (v0, v1, v2, v3);
-        (t0, t1, t2, t3) = data[i];
-        COMPARE(t0, v0) << 4;
-        COMPARE(t1, v1) << 4;
-        COMPARE(t2, v2) << 4;
-        COMPARE(t3, v3) << 4;
-        NextTest::test(data, i);
-     );
-_IMPL(5,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        const V v3 = V::Random();
-        const V v4 = V::Random();
-        V t0; V t1; V t2; V t3; V t4;
-        data[i] = (v0, v1, v2, v3, v4);
-        (t0, t1, t2, t3, t4) = data[i];
-        COMPARE(t0, v0) << 5;
-        COMPARE(t1, v1) << 5;
-        COMPARE(t2, v2) << 5;
-        COMPARE(t3, v3) << 5;
-        COMPARE(t4, v4) << 5;
-        NextTest::test(data, i);
-     );
-_IMPL(6,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        const V v3 = V::Random();
-        const V v4 = V::Random();
-        const V v5 = V::Random();
-        V t0; V t1; V t2; V t3; V t4; V t5;
-        data[i] = (v0, v1, v2, v3, v4, v5);
-        (t0, t1, t2, t3, t4, t5) = data[i];
-        COMPARE(t0, v0) << 6;
-        COMPARE(t1, v1) << 6;
-        COMPARE(t2, v2) << 6;
-        COMPARE(t3, v3) << 6;
-        COMPARE(t4, v4) << 6;
-        COMPARE(t5, v5) << 6;
-        NextTest::test(data, i);
-     );
-_IMPL(7,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        const V v3 = V::Random();
-        const V v4 = V::Random();
-        const V v5 = V::Random();
-        const V v6 = V::Random();
-        V t0; V t1; V t2; V t3; V t4; V t5; V t6;
-        data[i] = (v0, v1, v2, v3, v4, v5, v6);
-        (t0, t1, t2, t3, t4, t5, t6) = data[i];
-        COMPARE(t0, v0) << 7;
-        COMPARE(t1, v1) << 7;
-        COMPARE(t2, v2) << 7;
-        COMPARE(t3, v3) << 7;
-        COMPARE(t4, v4) << 7;
-        COMPARE(t5, v5) << 7;
-        COMPARE(t6, v6) << 7;
-        NextTest::test(data, i);
-     );
-_IMPL(8,
-        const V v0 = V::Random();
-        const V v1 = V::Random();
-        const V v2 = V::Random();
-        const V v3 = V::Random();
-        const V v4 = V::Random();
-        const V v5 = V::Random();
-        const V v6 = V::Random();
-        const V v7 = V::Random();
-        V t0; V t1; V t2; V t3; V t4; V t5; V t6; V t7;
-        data[i] = (v0, v1, v2, v3, v4, v5, v6, v7);
-        (t0, t1, t2, t3, t4, t5, t6, t7) = data[i];
-        COMPARE(t0, v0) << 8;
-        COMPARE(t1, v1) << 8;
-        COMPARE(t2, v2) << 8;
-        COMPARE(t3, v3) << 8;
-        COMPARE(t4, v4) << 8;
-        COMPARE(t5, v5) << 8;
-        COMPARE(t6, v6) << 8;
-        COMPARE(t7, v7) << 8;
-        NextTest::test(data, i);
-     );
-
-template<typename V, size_t StructSize> void testInterleavingScatterImpl()
-{
-    typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
-    typedef SomeStruct<T, StructSize> S;
-    typedef Vc::InterleavedMemoryWrapper<S, V> Wrapper;
-    const size_t N = std::min<size_t>(std::numeric_limits<typename I::EntryType>::max(), 1024 * 1024 / sizeof(S));
-    const size_t NMask = createNMask(N);
-
-    S *data = Vc::malloc<S, Vc::AlignOnVector>(N);
-    std::memset(data, 0, sizeof(S) * N);
-    Wrapper data_v(data);
-
-    for (int retest = 0; retest < 10000; ++retest) {
-        I indexes = (I::Random() >> 10) & I(NMask);
-        if (I::Size != 1) {
-            // ensure the indexes are unique
-            while(!(indexes.sorted() == indexes.sorted().rotated(1)).isEmpty()) {
-                indexes = (I::Random() >> 10) & I(NMask);
-            }
-        }
-        VERIFY(indexes >= 0);
-        VERIFY(indexes < N);
-
-        TestInterleavingScatterCompare<V, StructSize>::test(data_v, indexes);
-    }
-}
-
-template<typename V> void testInterleavingScatter()
-{
-    testInterleavingScatterImpl<V, 2>();
-    testInterleavingScatterImpl<V, 3>();
-    testInterleavingScatterImpl<V, 4>();
-    testInterleavingScatterImpl<V, 5>();
-    testInterleavingScatterImpl<V, 6>();
-    testInterleavingScatterImpl<V, 7>();
-    testInterleavingScatterImpl<V, 8>();
-}
-
-int main()
-{
-    runTest(testDeinterleave<float_float>);
-    runTest(testDeinterleave<float_ushort>);
-    runTest(testDeinterleave<float_short>);
-    runTest(testDeinterleave<sfloat_float>);
-    runTest(testDeinterleave<sfloat_ushort>);
-    runTest(testDeinterleave<sfloat_short>);
-    runTest(testDeinterleave<double_double>);
-    runTest(testDeinterleave<int_int>);
-    runTest(testDeinterleave<int_short>);
-    runTest(testDeinterleave<uint_uint>);
-    runTest(testDeinterleave<uint_ushort>);
-    runTest(testDeinterleave<short_short>);
-    runTest(testDeinterleave<ushort_ushort>);
-
-    testAllTypes(testDeinterleaveGather);
-    testAllTypes(testInterleavingScatter);
-}
diff -Nru vc-0.7.4/tests/expandandmerge.cpp vc-1.3.0/tests/expandandmerge.cpp
--- vc-0.7.4/tests/expandandmerge.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/expandandmerge.cpp	1969-12-31 18:00:00.000000000 -0600
@@ -1,88 +0,0 @@
-/*  This file is part of the Vc library.
-
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "unittest.h"
-#include <iostream>
-
-using namespace Vc;
-
-enum {
-    VectorSizeFactor = short_v::Size / int_v::Size
-};
-
-void testSigned()
-{
-    for (int start = -32000; start < 32000; start += 5) {
-        int_v a[VectorSizeFactor];
-        for (int i = 0; i < VectorSizeFactor; ++i) {
-            a[i] = int_v(IndexesFromZero) + int_v::Size * i + start;
-        }
-        short_v b(a);
-        COMPARE(b, short_v(IndexesFromZero) + start);
-
-        // false positive: warning: ‘c’ is used uninitialized in this function
-        int_v c[VectorSizeFactor];
-        b.expand(c);
-        for (int i = 0; i < VectorSizeFactor; ++i) {
-            COMPARE(c[i], int_v(IndexesFromZero) + int_v::Size * i + start);
-        }
-    }
-}
-
-void testUnsigned()
-{
-#if defined(VC_IMPL_SSE4_1) || defined(VC_IMPL_AVX)
-    for (unsigned int start = 0; start < 64000; start += 5) {
-#else
-    for (unsigned int start = 0; start < 32000; start += 5) {
-#endif
-        uint_v a[VectorSizeFactor];
-        for (unsigned int i = 0; i < VectorSizeFactor; ++i) {
-            a[i] = uint_v(IndexesFromZero) + uint_v::Size * i + start;
-        }
-        ushort_v b(a);
-        COMPARE(b, ushort_v(IndexesFromZero) + start);
-
-        // false positive: warning: ‘c’ is used uninitialized in this function
-        uint_v c[VectorSizeFactor];
-        b.expand(c);
-        for (unsigned int i = 0; i < VectorSizeFactor; ++i) {
-            COMPARE(c[i], uint_v(IndexesFromZero) + uint_v::Size * i + start);
-        }
-    }
-    for (unsigned int start = 32000; start < 64000; start += 5) {
-        ushort_v b(IndexesFromZero);
-        b += start;
-        COMPARE(b, ushort_v(IndexesFromZero) + start);
-
-        // false positive: warning: ‘c’ may be used uninitialized in this function
-        uint_v c[VectorSizeFactor];
-        b.expand(c);
-        for (unsigned int i = 0; i < VectorSizeFactor; ++i) {
-            COMPARE(c[i], uint_v(IndexesFromZero) + uint_v::Size * i + start);
-        }
-    }
-}
-
-int main()
-{
-    runTest(testSigned);
-    runTest(testUnsigned);
-    return 0;
-}
diff -Nru vc-0.7.4/tests/gather.cpp vc-1.3.0/tests/gather.cpp
--- vc-0.7.4/tests/gather.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/gather.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,54 +1,105 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 #include <iostream>
+#include <Vc/array>
+
+#define ALL_TYPES (ALL_VECTORS, SimdArray<int, 7>)
 
 using namespace Vc;
 
-template<typename Vec> void maskedGatherArray()
+TEST_TYPES(Vec, maskedGatherArray, ALL_TYPES)
 {
     typedef typename Vec::IndexType It;
     typedef typename Vec::EntryType T;
 
     T mem[Vec::Size];
-    for (int i = 0; i < Vec::Size; ++i) {
+    for (size_t i = 0; i < Vec::Size; ++i) {
         mem[i] = i + 1;
     }
 
     It indexes = It::IndexesFromZero();
+    alignas(static_cast<std::size_t>(It::MemoryAlignment))
+        std::array<typename It::EntryType, It::size()> indexArray;
+    indexes.store(&indexArray[0], Vc::Aligned);
     for_all_masks(Vec, m) {
         const Vec a(mem, indexes, m);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             COMPARE(a[i], m[i] ? mem[i] : 0) << " i = " << i << ", m = " << m;
         }
 
         T x = Vec::Size + 1;
         Vec b = x;
         b.gather(mem, indexes, m);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            COMPARE(b[i], m[i] ? mem[i] : x) << " i = " << i << ", m = " << m;
+        }
+
+        // test with array of indexes instead of index-vector:
+        const Vec c(mem, indexArray, m);
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            COMPARE(a[i], m[i] ? mem[i] : 0) << " i = " << i << ", m = " << m;
+        }
+
+        b = x;
+        b.gather(mem, indexArray, m);
+        for (size_t i = 0; i < Vec::Size; ++i) {
             COMPARE(b[i], m[i] ? mem[i] : x) << " i = " << i << ", m = " << m;
         }
     }
 }
 
-template<typename Vec> void gatherArray()
+template <typename Vec>
+Vec incrementIndex(
+    const typename Vec::IndexType &i,
+    typename std::enable_if<!(Vc::is_integral<Vec>::value &&Vc::is_signed<Vec>::value),
+                            void *>::type = nullptr)
+{
+    return Vc::simd_cast<Vec>(i + i.One());
+}
+
+template <typename Vec>
+Vec incrementIndex(const typename Vec::IndexType &i,
+                   typename std::enable_if<Vc::is_integral<Vec>::value &&Vc::is_signed<Vec>::value,
+                                           void *>::type = nullptr)
+{
+    using IT = typename Vec::IndexType;
+    using T = typename Vec::EntryType;
+    // if (i + 1) > std::numeric_limits<Vec>::max() it will overflow, which results in
+    // undefined behavior for signed integers
+    const auto overflowing =
+        Vc::simd_cast<typename Vec::Mask>(i >= IT(std::numeric_limits<T>::max()));
+    Vec r = Vc::simd_cast<Vec>(i + IT::One());
+    where(overflowing) | r = Vc::simd_cast<Vec>(i - std::numeric_limits<T>::max() + std::numeric_limits<T>::min());
+    return r;
+}
+
+TEST_TYPES(Vec, gatherArray, ALL_TYPES)
 {
     typedef typename Vec::IndexType It;
     typedef typename Vec::EntryType T;
@@ -61,9 +112,9 @@
     }
     M mask;
     for (It i = It(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
-        const Vec ii(i + 1);
-        const typename Vec::Mask castedMask = static_cast<typename Vec::Mask>(mask);
-        if (castedMask.isFull()) {
+        const Vec ii = incrementIndex<Vec>(i);
+        const typename Vec::Mask castedMask = simd_cast<typename Vec::Mask>(mask);
+        if (all_of(castedMask)) {
             Vec a(array, i);
             COMPARE(a, ii) << "\n       i: " << i;
             Vec b(Zero);
@@ -74,8 +125,8 @@
         Vec b(Zero);
         b.gather(array, i, castedMask);
         COMPARE(castedMask, (b == ii)) << ", b = " << b << ", ii = " << ii << ", i = " << i;
-        if (!castedMask.isFull()) {
-            COMPARE(!castedMask, b == Vec(Zero));
+        if (!all_of(castedMask)) {
+            COMPARE(!castedMask, b == Vec(Zero)) << "\nb: " << b << "\ncastedMask: " << castedMask << !castedMask;
         }
     }
 
@@ -85,23 +136,23 @@
     COMPARE(a, Vec(One));
 }
 
-template<typename T> struct Struct
+template<typename T, std::size_t Align> struct Struct
 {
-    T a;
+    alignas(Align) T a;
     char x;
-    T b;
+    alignas(Align) T b;
     short y;
-    T c;
+    alignas(Align) T c;
     char z;
 };
 
-template<typename Vec> void gatherStruct()
+TEST_TYPES(Vec, gatherStruct, ALL_TYPES)
 {
     typedef typename Vec::IndexType It;
     typedef typename Vec::EntryType T;
-    typedef Struct<T> S;
-    const int count = 3999;
-    S array[count];
+    typedef Struct<T, alignof(T)> S;
+    constexpr int count = 3999;
+    Vc::array<S, count> array;
     for (int i = 0; i < count; ++i) {
         array[i].a = i;
         array[i].b = i + 1;
@@ -111,32 +162,32 @@
     for (It i = It(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
         // if Vec is double_v the cast keeps only the lower two values, which is why the ==
         // comparison works
-        const Vec i0(i);
-        const Vec i1(i + 1);
-        const Vec i2(i + 2);
-        const typename Vec::Mask castedMask(mask);
+        const Vec i0 = Vc::simd_cast<Vec>(i);
+        const Vec i1 = Vc::simd_cast<Vec>(i + 1);
+        const Vec i2 = Vc::simd_cast<Vec>(i + 2);
+        const auto castedMask = simd_cast<typename Vec::Mask>(mask);
 
         if (castedMask.isFull()) {
-            Vec a(array, &S::a, i);
+            Vec a = array[i][&S::a];
             COMPARE(a, i0) << "\ni: " << i;
-            a.gather(array, &S::b, i);
+            a = array[i][&S::b];
             COMPARE(a, i1);
-            a.gather(array, &S::c, i);
+            a = array[i][&S::c];
             COMPARE(a, i2);
         }
 
         Vec b(Zero);
-        b.gather(array, &S::a, i, castedMask);
+        where(castedMask) | b = array[i][&S::a];
         COMPARE(castedMask, (b == i0));
         if (!castedMask.isFull()) {
             COMPARE(!castedMask, b == Vec(Zero));
         }
-        b.gather(array, &S::b, i, castedMask);
+        where(castedMask) | b = array[i][&S::b];
         COMPARE(castedMask, (b == i1));
         if (!castedMask.isFull()) {
             COMPARE(!castedMask, b == Vec(Zero));
         }
-        b.gather(array, &S::c, i, castedMask);
+        where(castedMask) | b = array[i][&S::c];
         COMPARE(castedMask, (b == i2));
         if (!castedMask.isFull()) {
             COMPARE(!castedMask, b == Vec(Zero));
@@ -144,69 +195,60 @@
     }
 }
 
-template<typename T> struct Row
+template<typename T, int N> struct Row
 {
-    T *data;
+    T data[N];
 };
 
-template<typename Vec> void gather2dim()
+TEST_TYPES(Vec, gather2dim, ALL_TYPES)
 {
     typedef typename Vec::IndexType It;
     typedef typename Vec::EntryType T;
-    const int count = 399;
-    typedef Row<T> S;
-    S array[count];
+    constexpr int count = 19;
+    typedef Row<T, count> S;
+    Vc::array<S, count> array;
     for (int i = 0; i < count; ++i) {
-        array[i].data = new T[count];
         for (int j = 0; j < count; ++j) {
+#ifdef Vc_GCC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
             array[i].data[j] = 2 * i + j + 1;
+#ifdef Vc_GCC
+#pragma GCC diagnostic pop
+#endif
         }
     }
 
     typename It::Mask mask;
     for (It i = It(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
         for (It j = It(IndexesFromZero); !(mask &= (j < count)).isEmpty(); j += Vec::Size) {
-            const Vec i0(i * 2 + j + 1);
-            const typename Vec::Mask castedMask(mask);
+            const Vec i0 = Vc::simd_cast<Vec>(i * 2 + j + 1);
+            const auto castedMask = simd_cast<typename Vec::Mask>(mask);
 
-            Vec a(array, &S::data, i, j, castedMask);
+            Vec a;
+            where(castedMask) | a = array[i][&S::data][j];
             COMPARE(castedMask, castedMask && (a == i0)) << ", a = " << a << ", i0 = " << i0 << ", i = " << i << ", j = " << j;
 
             Vec b(Zero);
-            b.gather(array, &S::data, i, j, castedMask);
+            where(castedMask) | b = array[i][&S::data][j];
+            COMPARE(castedMask, (b == i0));
+
+            b.setZero();
+            b(castedMask) = array[i][&S::data][j];
             COMPARE(castedMask, (b == i0));
             if (!castedMask.isFull()) {
                 COMPARE(!castedMask, b == Vec(Zero));
             } else {
-                Vec c(array, &S::data, i, j);
+                Vec c;
+                c = array[i][&S::data][j];
+                COMPARE(c, i0) << "i: " << i << ", j: " << j;
                 VERIFY((c == i0).isFull());
 
                 Vec d(Zero);
-                d.gather(array, &S::data, i, j);
+                d = array[i][&S::data][j];
                 VERIFY((d == i0).isFull());
             }
         }
     }
-    for (int i = 0; i < count; ++i) {
-        delete[] array[i].data;
-    }
-}
-
-int main(int argc, char **argv)
-{
-    initTest(argc, argv);
-
-    testAllTypes(gatherArray);
-    testAllTypes(maskedGatherArray);
-#if defined(VC_CLANG) && VC_CLANG <= 0x030000
-    // clang fails with:
-    //  candidate template ignored: failed template argument deduction
-    //  template<typename S1, typename IT> inline Vector(const S1 *array, const T S1::* member1, IT indexes, Mask mask = true)
-#warning "Skipping compilation of tests gatherStruct and gather2dim because of clang bug"
-#else
-    testAllTypes(gatherStruct);
-    testAllTypes(gather2dim);
-#endif
-
-    return 0;
 }
diff -Nru vc-0.7.4/tests/gatherinterleavedmemory.cpp vc-1.3.0/tests/gatherinterleavedmemory.cpp
--- vc-0.7.4/tests/gatherinterleavedmemory.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/gatherinterleavedmemory.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,212 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+
+#include "unittest.h"
+
+using namespace Vc;
+
+template<typename T, size_t N> struct SomeStruct
+{
+    T d[N];
+};
+
+template<typename V, size_t StructSize, bool Random = true> struct Types
+{
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType I;
+    typedef typename V::AsArg VArg;
+    typedef const I &IArg;
+    typedef SomeStruct<T, StructSize> S;
+    typedef const Vc::InterleavedMemoryWrapper<S, V> &Wrapper;
+};
+template<typename V, size_t StructSize> struct Types<V, StructSize, false>
+{
+    typedef typename V::EntryType T;
+    typedef int I;
+    typedef typename V::AsArg VArg;
+    typedef I IArg;
+    typedef SomeStruct<T, StructSize> S;
+    typedef const Vc::InterleavedMemoryWrapper<S, V> &Wrapper;
+};
+template<typename V, size_t StructSize, bool Random, size_t N = StructSize> struct TestDeinterleaveGatherCompare;
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 8> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V v0, v1, v2, v3, v4, v5, v6, v7;
+        tie(v0, v1, v2, v3, v4, v5, v6, v7) = data_v[indexes];
+        COMPARE(v0, reference + 0) << "N = 8";
+        COMPARE(v1, reference + 1) << "N = 8";
+        COMPARE(v2, reference + 2) << "N = 8";
+        COMPARE(v3, reference + 3) << "N = 8";
+        COMPARE(v4, reference + 4) << "N = 8";
+        COMPARE(v5, reference + 5) << "N = 8";
+        COMPARE(v6, reference + 6) << "N = 8";
+        COMPARE(v7, reference + 7) << "N = 8";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 7>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 7> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V v0, v1, v2, v3, v4, v5, v6;
+        tie(v0, v1, v2, v3, v4, v5, v6) = data_v[indexes];
+        COMPARE(v0, reference + 0) << "N = 7";
+        COMPARE(v1, reference + 1) << "N = 7";
+        COMPARE(v2, reference + 2) << "N = 7";
+        COMPARE(v3, reference + 3) << "N = 7";
+        COMPARE(v4, reference + 4) << "N = 7";
+        COMPARE(v5, reference + 5) << "N = 7";
+        COMPARE(v6, reference + 6) << "N = 7";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 6>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 6> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V v0, v1, v2, v3, v4, v5;
+        tie(v0, v1, v2, v3, v4, v5) = data_v[indexes];
+        COMPARE(v0, reference + 0) << "N = 6";
+        COMPARE(v1, reference + 1) << "N = 6";
+        COMPARE(v2, reference + 2) << "N = 6";
+        COMPARE(v3, reference + 3) << "N = 6";
+        COMPARE(v4, reference + 4) << "N = 6";
+        COMPARE(v5, reference + 5) << "N = 6";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 5>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 5> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V v0, v1, v2, v3, v4;
+        tie(v0, v1, v2, v3, v4) = data_v[indexes];
+        COMPARE(v0, reference + 0) << "N = 5";
+        COMPARE(v1, reference + 1) << "N = 5";
+        COMPARE(v2, reference + 2) << "N = 5";
+        COMPARE(v3, reference + 3) << "N = 5";
+        COMPARE(v4, reference + 4) << "N = 5";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 4>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 4> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V a, b, c, d;
+        tie(a, b, c, d) = data_v[indexes];
+        COMPARE(a, reference + 0) << "N = 4";
+        COMPARE(b, reference + 1) << "N = 4";
+        COMPARE(c, reference + 2) << "N = 4";
+        COMPARE(d, reference + 3) << "N = 4";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 3>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 3> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V a, b, c;
+        tie(a, b, c) = data_v[indexes];
+        COMPARE(a, reference + 0) << "N = 3";
+        COMPARE(b, reference + 1) << "N = 3";
+        COMPARE(c, reference + 2) << "N = 3";
+        TestDeinterleaveGatherCompare<V, StructSize, Random, 2>::test(data_v, indexes, reference);
+    }
+};
+template<typename V, size_t StructSize, bool Random> struct TestDeinterleaveGatherCompare<V, StructSize, Random, 2> {
+    static void test(typename Types<V, StructSize, Random>::Wrapper data_v, typename Types<V, StructSize, Random>::IArg indexes, const typename V::AsArg reference)
+    {
+        V a, b;
+        tie(a, b) = data_v[indexes];
+        COMPARE(a, reference + 0) << "N = 2, indexes: " << indexes;
+        COMPARE(b, reference + 1) << "N = 2, indexes: " << indexes;
+    }
+};
+
+size_t createNMask(size_t N)
+{
+    size_t NMask = (N >> 1) | (N >> 2);
+    for (size_t shift = 2; shift < sizeof(size_t) * 8; shift *= 2) {
+        NMask |= NMask >> shift;
+    }
+    return NMask;
+}
+
+#if !defined __GNUC__ || defined __OPTIMIZE__
+static constexpr int TotalRetests = 10000;
+#else
+static constexpr int TotalRetests = 1000;
+#endif
+
+TEST_TYPES(Param, testDeinterleaveGather,
+           (outer_product<Typelist<ALL_VECTORS>,
+                          Typelist<std::integral_constant<std::size_t, 2>,
+                                   std::integral_constant<std::size_t, 3>,
+                                   std::integral_constant<std::size_t, 4>,
+                                   std::integral_constant<std::size_t, 5>,
+                                   std::integral_constant<std::size_t, 6>,
+                                   std::integral_constant<std::size_t, 7>,
+                                   std::integral_constant<std::size_t, 8>>>))
+{
+    typedef typename Param::template at<0> V;
+    constexpr auto StructSize = Param::template at<1>::value;
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType I;
+    typedef SomeStruct<T, StructSize> S;
+    typedef Vc::InterleavedMemoryWrapper<S, V> Wrapper;
+    const size_t N = std::min(
+        // indexes * StructSize may not overflow for signed integral types. That would be
+        // UB and MIC::short_v will happily use it for more performance.
+        std::is_integral<T>::value && std::is_signed<T>::value
+            ? static_cast<size_t>(std::numeric_limits<T>::max()) / StructSize
+            : std::numeric_limits<size_t>::max(),
+        std::min(static_cast<size_t>(std::numeric_limits<typename I::EntryType>::max()),
+                 1024u * 1024u / sizeof(S)));
+    const size_t NMask = createNMask(N);
+
+    S *data = Vc::malloc<S, Vc::AlignOnVector>(N);
+    for (size_t i = 0; i < N; ++i) {
+        for (size_t j = 0; j < StructSize; ++j) {
+            data[i].d[j] = i * StructSize + j;
+        }
+    }
+    const Wrapper data_v(data);
+
+    for (int retest = 0; retest < TotalRetests; ++retest) {
+        I indexes = (I::Random() >> 10) & I(NMask);
+        VERIFY(all_of(indexes >= 0));
+        VERIFY(all_of(indexes < N));
+        const V reference = Vc::simd_cast<V>(indexes) * V(StructSize);
+
+        TestDeinterleaveGatherCompare<V, StructSize, true>::test(data_v, indexes, reference);
+    }
+
+    for (int i = 0; i < int(N - V::Size); ++i) {
+        const V reference = Vc::simd_cast<V>(i + I::IndexesFromZero()) * T(StructSize);
+        TestDeinterleaveGatherCompare<V, StructSize, false>::test(data_v, i, reference);
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/generators.h vc-1.3.0/tests/generators.h
--- vc-0.7.4/tests/generators.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/generators.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,73 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <limits>
+#include <type_traits>
+
+template <typename T, typename F>
+inline typename std::enable_if<std::is_floating_point<T>::value>::type
+iterateNumericRange(F &&f)
+{
+    using L = std::numeric_limits<T>;
+    constexpr int nsteps = 17;
+    const T step = L::max() / nsteps;
+    for (int i = 0; i < nsteps; ++i) {
+        f(T(L::lowest() + i * step));
+    }
+    for (int i = 0; i < nsteps; ++i) {
+        f(T(L::max() - i * step));
+    }
+    f(T(-1));
+    f(-L::min());
+    f(-L::denorm_min());
+    f(T(0));
+    f(L::denorm_min());
+    f(L::min());
+    f(T(1));
+}
+
+template <typename T, typename F>
+inline typename std::enable_if<std::is_integral<T>::value>::type iterateNumericRange(
+    F &&f)
+{
+    using L = std::numeric_limits<T>;
+    constexpr int nsteps = 17;
+    const T step = L::max() / nsteps;
+    for (int i = 0; i < nsteps; ++i) {
+        f(T(L::max() - i * step));
+    }
+    f(T(1));
+    f(T(0));
+    if (std::is_signed<T>::value) {
+        f(T(-1));
+        for (int i = 0; i < nsteps; ++i) {
+            f(T(L::min() + i * step));
+        }
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/implicit_type_conversion.cpp vc-1.3.0/tests/implicit_type_conversion.cpp
--- vc-0.7.4/tests/implicit_type_conversion.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/implicit_type_conversion.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,80 +1,120 @@
-/*{{{
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
+/*  This file is part of the Vc library. {{{
+Copyright © 2012-2015 Matthias Kretz <kretz@kde.org>
 
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#include "unittest.h"
-
-//#define QUICK 1
+#include "unittest-old.h"
 
 using namespace Vc;
 
-typedef unsigned short ushort;
-typedef unsigned int uint;
-typedef unsigned long ulong;
-typedef long long longlong;
-typedef unsigned long long ulonglong;
-
-#ifdef QUICK
-#define _TYPE_TEST(a, b, c)
-#define _TYPE_TEST_ERR(a, b)
-#else
-#if defined(VC_GCC) && VC_GCC == 0x40801
-// Skipping tests involving operator& because of a bug in GCC 4.8.1 (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57532)
-#define _TYPE_TEST(a, b, c) \
-    COMPARE(typeid(a() * b()), typeid(c)); \
-    COMPARE(typeid(a() / b()), typeid(c)); \
-    COMPARE(typeid(a() + b()), typeid(c)); \
-    COMPARE(typeid(a() - b()), typeid(c)); \
-    COMPARE(typeid(a() | b()), typeid(c)); \
-    COMPARE(typeid(a() ^ b()), typeid(c)); \
-    COMPARE(typeid(a() == b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() != b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() <= b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() >= b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() <  b()), typeid(c::Mask));
-#else
-#define _TYPE_TEST(a, b, c) \
-    COMPARE(typeid(a() * b()), typeid(c)); \
-    COMPARE(typeid(a() / b()), typeid(c)); \
-    COMPARE(typeid(a() + b()), typeid(c)); \
-    COMPARE(typeid(a() - b()), typeid(c)); \
-    COMPARE(typeid(a() & b()), typeid(c)); \
-    COMPARE(typeid(a() | b()), typeid(c)); \
-    COMPARE(typeid(a() ^ b()), typeid(c)); \
-    COMPARE(typeid(a() == b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() != b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() <= b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() >= b()), typeid(c::Mask)); \
-    COMPARE(typeid(a() <  b()), typeid(c::Mask));
-#endif
-#define _TYPE_TEST_ERR(a, b) \
-    COMPARE(typeid(a() *  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() /  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() +  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() -  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() &  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() |  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() ^  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() == b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() != b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() <= b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() >= b()), typeid(Vc::Error::invalid_operands_of_types<a, b>)); \
-    COMPARE(typeid(a() <  b()), typeid(Vc::Error::invalid_operands_of_types<a, b>));
+static_assert(!std::is_convertible< float_v, double_v>::value, "!std::is_convertible< float_v, double_v>");
+static_assert(!std::is_convertible<   int_v, double_v>::value, "!std::is_convertible<   int_v, double_v>");
+static_assert(!std::is_convertible<  uint_v, double_v>::value, "!std::is_convertible<  uint_v, double_v>");
+static_assert(!std::is_convertible< short_v, double_v>::value, "!std::is_convertible< short_v, double_v>");
+static_assert(!std::is_convertible<ushort_v, double_v>::value, "!std::is_convertible<ushort_v, double_v>");
+
+static_assert(!std::is_convertible<double_v,  float_v>::value, "!std::is_convertible<double_v,  float_v>");
+static_assert(!std::is_convertible<   int_v,  float_v>::value, "!std::is_convertible<   int_v,  float_v>");
+static_assert(!std::is_convertible<  uint_v,  float_v>::value, "!std::is_convertible<  uint_v,  float_v>");
+static_assert(!std::is_convertible< short_v,  float_v>::value, "!std::is_convertible< short_v,  float_v>");
+static_assert(!std::is_convertible<ushort_v,  float_v>::value, "!std::is_convertible<ushort_v,  float_v>");
+
+static_assert(!std::is_convertible<double_v,    int_v>::value, "!std::is_convertible<double_v,    int_v>");
+static_assert(!std::is_convertible< float_v,    int_v>::value, "!std::is_convertible< float_v,    int_v>");
+static_assert( std::is_convertible<  uint_v,    int_v>::value, " std::is_convertible<  uint_v,    int_v>");
+static_assert(!std::is_convertible< short_v,    int_v>::value, "!std::is_convertible< short_v,    int_v>");
+static_assert(!std::is_convertible<ushort_v,    int_v>::value, "!std::is_convertible<ushort_v,    int_v>");
+
+static_assert(!std::is_convertible<double_v,   uint_v>::value, "!std::is_convertible<double_v,   uint_v>");
+static_assert(!std::is_convertible< float_v,   uint_v>::value, "!std::is_convertible< float_v,   uint_v>");
+static_assert( std::is_convertible<   int_v,   uint_v>::value, " std::is_convertible<   int_v,   uint_v>");
+static_assert(!std::is_convertible< short_v,   uint_v>::value, "!std::is_convertible< short_v,   uint_v>");
+static_assert(!std::is_convertible<ushort_v,   uint_v>::value, "!std::is_convertible<ushort_v,   uint_v>");
+
+static_assert(!std::is_convertible<double_v,  short_v>::value, "!std::is_convertible<double_v,  short_v>");
+static_assert(!std::is_convertible< float_v,  short_v>::value, "!std::is_convertible< float_v,  short_v>");
+static_assert(!std::is_convertible<   int_v,  short_v>::value, "!std::is_convertible<   int_v,  short_v>");
+static_assert(!std::is_convertible<  uint_v,  short_v>::value, "!std::is_convertible<  uint_v,  short_v>");
+static_assert( std::is_convertible<ushort_v,  short_v>::value, " std::is_convertible<ushort_v,  short_v>");
+
+static_assert(!std::is_convertible<double_v, ushort_v>::value, "!std::is_convertible<double_v, ushort_v>");
+static_assert(!std::is_convertible< float_v, ushort_v>::value, "!std::is_convertible< float_v, ushort_v>");
+static_assert(!std::is_convertible<   int_v, ushort_v>::value, "!std::is_convertible<   int_v, ushort_v>");
+static_assert(!std::is_convertible<  uint_v, ushort_v>::value, "!std::is_convertible<  uint_v, ushort_v>");
+static_assert( std::is_convertible< short_v, ushort_v>::value, " std::is_convertible< short_v, ushort_v>");
+
+template <typename A, typename B, typename C>
+Vc::enable_if<std::is_integral<A>::value && std::is_integral<B>::value, void>
+integral_tests(A a, B b, C c)
+{
+#if !defined(Vc_GCC) || Vc_GCC != 0x40801
+    // Skipping tests involving operator& because of a bug in GCC 4.8.1
+    // (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57532)
+    static_assert(std::is_same<decltype(a & b), C>::value, "incorrect return type deduction");
+    COMPARE(typeid(a & b), typeid(C));
 #endif
+    static_assert(std::is_same<decltype(a | b), C>::value, "incorrect return type deduction");
+    static_assert(std::is_same<decltype(a ^ b), C>::value, "incorrect return type deduction");
+    COMPARE(typeid(a | b), typeid(C));
+    COMPARE(typeid(a ^ b), typeid(C));
+}
+template <typename A, typename B, typename C>
+Vc::enable_if<!(std::is_integral<A>::value && std::is_integral<B>::value), void>
+integral_tests(A, B, C)
+{
+}
+#define _TYPE_TEST(a, b, c)                                                              \
+    {                                                                                    \
+        integral_tests(a(), b(), c());                                                   \
+        using logical_return = typename std::conditional<                                \
+            std::is_fundamental<decltype(b())>::value, decltype(!a()),                   \
+            typename std::conditional<std::is_fundamental<decltype(a())>::value,         \
+                                      decltype(!b()), c::Mask>::type>::type;             \
+        COMPARE(typeid(a() && b()), typeid(logical_return));                             \
+        COMPARE(typeid(a() || b()), typeid(logical_return));                             \
+        COMPARE(typeid(a() *  b()), typeid(c));                                          \
+        COMPARE(typeid(a() /  b()), typeid(c));                                          \
+        COMPARE(typeid(a() +  b()), typeid(c));                                          \
+        COMPARE(typeid(a() -  b()), typeid(c));                                          \
+        COMPARE(typeid(a() == b()), typeid(c::Mask));                                    \
+        COMPARE(typeid(a() != b()), typeid(c::Mask));                                    \
+        COMPARE(typeid(a() <= b()), typeid(c::Mask));                                    \
+        COMPARE(typeid(a() >= b()), typeid(c::Mask));                                    \
+        COMPARE(typeid(a() <  b()), typeid(c::Mask));                                    \
+        static_assert(std::is_same<decltype(a() && b()), logical_return>::value, #a " && " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() || b()), logical_return>::value, #a " || " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() *  b()), c>::value, #a " *  " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() /  b()), c>::value, #a " /  " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() +  b()), c>::value, #a " +  " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() -  b()), c>::value, #a " -  " #b " => " #c); \
+        static_assert(std::is_same<decltype(a() == b()), c::Mask>::value, #a " == " #b " => " #c "::Mask"); \
+        static_assert(std::is_same<decltype(a() != b()), c::Mask>::value, #a " != " #b " => " #c "::Mask"); \
+        static_assert(std::is_same<decltype(a() <= b()), c::Mask>::value, #a " <= " #b " => " #c "::Mask"); \
+        static_assert(std::is_same<decltype(a() >= b()), c::Mask>::value, #a " >= " #b " => " #c "::Mask"); \
+        static_assert(std::is_same<decltype(a() <  b()), c::Mask>::value, #a " <  " #b " => " #c "::Mask"); \
+    }
 
 #define TYPE_TEST(a, b, c) \
     _TYPE_TEST(a, b, c) \
@@ -102,14 +142,19 @@
     VERIFY( TestImplicitCast<     int>::test( ulong()));
     VERIFY( TestImplicitCast<     int>::test(  bool()));
     VERIFY( TestImplicitCast<double_v>::test(double()));
-    VERIFY(!TestImplicitCast<double_v>::test( float()));
-    VERIFY(!TestImplicitCast<double_v>::test(   int()));
+    VERIFY( TestImplicitCast<double_v>::test( float()));
+    VERIFY( TestImplicitCast<double_v>::test(   int()));
     VERIFY( TestImplicitCast< float_v>::test( float()));
-    VERIFY( TestImplicitCast<sfloat_v>::test( float()));
     VERIFY( TestImplicitCast<   int_v>::test(   int()));
     VERIFY( TestImplicitCast<  uint_v>::test(  uint()));
     VERIFY( TestImplicitCast< short_v>::test( short()));
     VERIFY( TestImplicitCast<ushort_v>::test(ushort()));
+    VERIFY(!TestImplicitCast<double_v>::test(nullptr));
+    VERIFY(!TestImplicitCast< float_v>::test(nullptr));
+    VERIFY(!TestImplicitCast<   int_v>::test(nullptr));
+    VERIFY(!TestImplicitCast<  uint_v>::test(nullptr));
+    VERIFY(!TestImplicitCast< short_v>::test(nullptr));
+    VERIFY(!TestImplicitCast<ushort_v>::test(nullptr));
 
     TYPE_TEST( double_v,    double_v, double_v);
     TYPE_TEST( double_v,      double, double_v);
@@ -120,9 +165,10 @@
     TYPE_TEST( double_v,        uint, double_v);
     TYPE_TEST( double_v,        long, double_v);
     TYPE_TEST( double_v,       ulong, double_v);
-    TYPE_TEST( double_v,    longlong, double_v);
-    TYPE_TEST( double_v,   ulonglong, double_v);
+    TYPE_TEST( double_v,       llong, double_v);
+    TYPE_TEST( double_v,      ullong, double_v);
     TYPE_TEST( double_v,        Enum, double_v);
+    TYPE_TEST( double_v,        bool, double_v);
     TYPE_TEST(   double,    double_v, double_v);
     TYPE_TEST(    float,    double_v, double_v);
     TYPE_TEST(    short,    double_v, double_v);
@@ -131,120 +177,82 @@
     TYPE_TEST(     uint,    double_v, double_v);
     TYPE_TEST(     long,    double_v, double_v);
     TYPE_TEST(    ulong,    double_v, double_v);
-    TYPE_TEST( longlong,    double_v, double_v);
-    TYPE_TEST(ulonglong,    double_v, double_v);
+    TYPE_TEST(    llong,    double_v, double_v);
+    TYPE_TEST(   ullong,    double_v, double_v);
+    TYPE_TEST(     Enum,    double_v, double_v);
+    TYPE_TEST(     bool,    double_v, double_v);
     // double_v done
 
     TYPE_TEST(  float_v,     float_v,  float_v);
     TYPE_TEST(  float_v,       float,  float_v);
     TYPE_TEST(  float_v,       short,  float_v);
     TYPE_TEST(  float_v,      ushort,  float_v);
-    TYPE_TEST(  float_v,       int_v,  float_v);
     TYPE_TEST(  float_v,         int,  float_v);
-    TYPE_TEST(  float_v,      uint_v,  float_v);
     TYPE_TEST(  float_v,        uint,  float_v);
     TYPE_TEST(  float_v,        long,  float_v);
     TYPE_TEST(  float_v,       ulong,  float_v);
-    TYPE_TEST(  float_v,    longlong,  float_v);
-    TYPE_TEST(  float_v,   ulonglong,  float_v);
+    TYPE_TEST(  float_v,       llong,  float_v);
+    TYPE_TEST(  float_v,      ullong,  float_v);
+    TYPE_TEST(  float_v,        Enum,  float_v);
+    TYPE_TEST(  float_v,        bool,  float_v);
     TYPE_TEST(    float,     float_v,  float_v);
     TYPE_TEST(    short,     float_v,  float_v);
     TYPE_TEST(   ushort,     float_v,  float_v);
-    TYPE_TEST(    int_v,     float_v,  float_v);
     TYPE_TEST(      int,     float_v,  float_v);
-    TYPE_TEST(   uint_v,     float_v,  float_v);
     TYPE_TEST(     uint,     float_v,  float_v);
     TYPE_TEST(     long,     float_v,  float_v);
     TYPE_TEST(    ulong,     float_v,  float_v);
-    TYPE_TEST( longlong,     float_v,  float_v);
-    TYPE_TEST(ulonglong,     float_v,  float_v);
+    TYPE_TEST(    llong,     float_v,  float_v);
+    TYPE_TEST(   ullong,     float_v,  float_v);
+    TYPE_TEST(     Enum,     float_v,  float_v);
+    TYPE_TEST(     bool,     float_v,  float_v);
     // double_v + float_v done
 
-    TYPE_TEST( sfloat_v,    sfloat_v, sfloat_v);
-    TYPE_TEST( sfloat_v,       float, sfloat_v);
-    TYPE_TEST( sfloat_v,     short_v, sfloat_v);
-    TYPE_TEST( sfloat_v,       short, sfloat_v);
-    TYPE_TEST( sfloat_v,    ushort_v, sfloat_v);
-    TYPE_TEST( sfloat_v,      ushort, sfloat_v);
-    TYPE_TEST( sfloat_v,         int, sfloat_v);
-    TYPE_TEST( sfloat_v,        uint, sfloat_v);
-    TYPE_TEST( sfloat_v,        long, sfloat_v);
-    TYPE_TEST( sfloat_v,       ulong, sfloat_v);
-    TYPE_TEST( sfloat_v,    longlong, sfloat_v);
-    TYPE_TEST( sfloat_v,   ulonglong, sfloat_v);
-    TYPE_TEST( sfloat_v,    sfloat_v, sfloat_v);
-    TYPE_TEST(    float,    sfloat_v, sfloat_v);
-    TYPE_TEST(  short_v,    sfloat_v, sfloat_v);
-    TYPE_TEST(    short,    sfloat_v, sfloat_v);
-    TYPE_TEST( ushort_v,    sfloat_v, sfloat_v);
-    TYPE_TEST(   ushort,    sfloat_v, sfloat_v);
-    TYPE_TEST(      int,    sfloat_v, sfloat_v);
-    TYPE_TEST(     uint,    sfloat_v, sfloat_v);
-    TYPE_TEST(     long,    sfloat_v, sfloat_v);
-    TYPE_TEST(    ulong,    sfloat_v, sfloat_v);
-    TYPE_TEST( longlong,    sfloat_v, sfloat_v);
-    TYPE_TEST(ulonglong,    sfloat_v, sfloat_v);
-    // double_v + float_v + sfloat_v done
-
     TYPE_TEST(  short_v,     short_v,  short_v);
     TYPE_TEST(  short_v,       short,  short_v);
     TYPE_TEST(  short_v,    ushort_v, ushort_v);
     TYPE_TEST(  short_v,      ushort, ushort_v);
     TYPE_TEST(  short_v,         int,  short_v);
     TYPE_TEST(  short_v,        uint, ushort_v);
-    TYPE_TEST(  short_v,        long,  short_v);
-    TYPE_TEST(  short_v,       ulong, ushort_v);
-    TYPE_TEST(  short_v,    longlong,  short_v);
-    TYPE_TEST(  short_v,   ulonglong, ushort_v);
+    TYPE_TEST(  short_v,        Enum,  short_v);
+    TYPE_TEST(  short_v,        bool,  short_v);
     TYPE_TEST(    short,     short_v,  short_v);
     TYPE_TEST( ushort_v,     short_v, ushort_v);
     TYPE_TEST(   ushort,     short_v, ushort_v);
     TYPE_TEST(      int,     short_v,  short_v);
     TYPE_TEST(     uint,     short_v, ushort_v);
-    TYPE_TEST(     long,     short_v,  short_v);
-    TYPE_TEST(    ulong,     short_v, ushort_v);
-    TYPE_TEST( longlong,     short_v,  short_v);
-    TYPE_TEST(ulonglong,     short_v, ushort_v);
-    // double_v + float_v + sfloat_v + short_v done
+    TYPE_TEST(     Enum,     short_v,  short_v);
+    TYPE_TEST(     bool,     short_v,  short_v);
 
     TYPE_TEST( ushort_v,       short, ushort_v);
     TYPE_TEST( ushort_v,    ushort_v, ushort_v);
     TYPE_TEST( ushort_v,      ushort, ushort_v);
     TYPE_TEST( ushort_v,         int, ushort_v);
     TYPE_TEST( ushort_v,        uint, ushort_v);
-    TYPE_TEST( ushort_v,        long, ushort_v);
-    TYPE_TEST( ushort_v,       ulong, ushort_v);
-    TYPE_TEST( ushort_v,    longlong, ushort_v);
-    TYPE_TEST( ushort_v,   ulonglong, ushort_v);
+    TYPE_TEST( ushort_v,        Enum, ushort_v);
+    TYPE_TEST( ushort_v,        bool, ushort_v);
     TYPE_TEST(    short,    ushort_v, ushort_v);
     TYPE_TEST(   ushort,    ushort_v, ushort_v);
     TYPE_TEST(      int,    ushort_v, ushort_v);
     TYPE_TEST(     uint,    ushort_v, ushort_v);
-    TYPE_TEST(     long,    ushort_v, ushort_v);
-    TYPE_TEST(    ulong,    ushort_v, ushort_v);
-    TYPE_TEST( longlong,    ushort_v, ushort_v);
-    TYPE_TEST(ulonglong,    ushort_v, ushort_v);
-    // double_v + float_v + sfloat_v + short_v + ushort_v done
+    TYPE_TEST(     Enum,    ushort_v, ushort_v);
+    TYPE_TEST(     bool,    ushort_v, ushort_v);
 
-    TYPE_TEST(    int_v,      ushort,   uint_v);
+    TYPE_TEST(    int_v,      ushort,    int_v);
     TYPE_TEST(    int_v,       short,    int_v);
     TYPE_TEST(    int_v,       int_v,    int_v);
     TYPE_TEST(    int_v,         int,    int_v);
     TYPE_TEST(    int_v,      uint_v,   uint_v);
     TYPE_TEST(    int_v,        uint,   uint_v);
-    TYPE_TEST(    int_v,        long,    int_v);
-    TYPE_TEST(    int_v,       ulong,   uint_v);
-    TYPE_TEST(    int_v,    longlong,    int_v);
-    TYPE_TEST(    int_v,   ulonglong,   uint_v);
-    TYPE_TEST(   ushort,       int_v,   uint_v);
+    TYPE_TEST(    int_v,        Enum,    int_v);
+    TYPE_TEST(    int_v,        bool,    int_v);
+    TYPE_TEST(   ushort,       int_v,    int_v);
     TYPE_TEST(    short,       int_v,    int_v);
     TYPE_TEST(      int,       int_v,    int_v);
     TYPE_TEST(   uint_v,       int_v,   uint_v);
     TYPE_TEST(     uint,       int_v,   uint_v);
-    TYPE_TEST(     long,       int_v,    int_v);
-    TYPE_TEST(    ulong,       int_v,   uint_v);
-    TYPE_TEST( longlong,       int_v,    int_v);
-    TYPE_TEST(ulonglong,       int_v,   uint_v);
+    TYPE_TEST(     Enum,       int_v,    int_v);
+    TYPE_TEST(     bool,       int_v,    int_v);
 
     TYPE_TEST(   uint_v,       short,   uint_v);
     TYPE_TEST(   uint_v,      ushort,   uint_v);
@@ -252,24 +260,20 @@
     TYPE_TEST(   uint_v,         int,   uint_v);
     TYPE_TEST(   uint_v,      uint_v,   uint_v);
     TYPE_TEST(   uint_v,        uint,   uint_v);
-    TYPE_TEST(   uint_v,        long,   uint_v);
-    TYPE_TEST(   uint_v,       ulong,   uint_v);
-    TYPE_TEST(   uint_v,    longlong,   uint_v);
-    TYPE_TEST(   uint_v,   ulonglong,   uint_v);
+    TYPE_TEST(   uint_v,        Enum,   uint_v);
+    TYPE_TEST(   uint_v,        bool,   uint_v);
     TYPE_TEST(    short,      uint_v,   uint_v);
     TYPE_TEST(   ushort,      uint_v,   uint_v);
     TYPE_TEST(    int_v,      uint_v,   uint_v);
     TYPE_TEST(      int,      uint_v,   uint_v);
     TYPE_TEST(     uint,      uint_v,   uint_v);
-    TYPE_TEST(     long,      uint_v,   uint_v);
-    TYPE_TEST(    ulong,      uint_v,   uint_v);
-    TYPE_TEST( longlong,      uint_v,   uint_v);
-    TYPE_TEST(ulonglong,      uint_v,   uint_v);
+    TYPE_TEST(     Enum,      uint_v,   uint_v);
+    TYPE_TEST(     bool,      uint_v,   uint_v);
 }
 
-int main(int argc, char **argv)
+void testmain()
 {
-    initTest(argc, argv);
     runTest(testImplicitTypeConversions);
-    return 0;
 }
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/implicit_type_conversion_failures.cpp vc-1.3.0/tests/implicit_type_conversion_failures.cpp
--- vc-0.7.4/tests/implicit_type_conversion_failures.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/implicit_type_conversion_failures.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -6,7 +6,7 @@
 
 using namespace Vc;
 
-int main()
+int Vc_CDECL main()
 {
     TYPE_A() TEST_OP TYPE_B();
     return 0;
diff -Nru vc-0.7.4/tests/iterators.cpp vc-1.3.0/tests/iterators.cpp
--- vc-0.7.4/tests/iterators.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/iterators.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,210 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+TEST_TYPES(V, check_return_types, (ALL_VECTORS, SIMD_ARRAY_LIST, ALL_MASKS))
+{
+    V a{};
+    auto &&it = begin(a);
+    using It = typename std::decay<decltype(it)>::type;
+
+    // InputIterator:
+    VERIFY((std::is_convertible<decltype(it == it), bool>::value));
+    VERIFY((std::is_convertible<decltype(it != it), bool>::value));
+    COMPARE(typeid(*it), typeid(typename It::reference));
+    VERIFY((std::is_convertible<decltype(*it), typename It::value_type>::value));
+    // can't test it->m because it points to fundamental types, which have no members
+    // COMPARE(typeid(it->m), typeid());
+    COMPARE(typeid(++it), typeid(It &));
+    VERIFY((std::is_convertible<decltype(*it++), typename It::value_type>::value));
+
+    // OutputIterator has no additional return type requirements
+
+    // ForwardIterator:
+    VERIFY(std::is_default_constructible<It>::value);
+    // the lvalue-ref guarantee for reference does not (i.e. cannot) hold
+    COMPARE(typeid(it++), typeid(It));
+    COMPARE(typeid(*it++), typeid(typename It::reference));
+
+    // BidirectionalIterator:
+    COMPARE(typeid(--it), typeid(It &));
+    VERIFY((std::is_convertible<decltype(it--), const It &>::value));
+    COMPARE(typeid(*it--), typeid(typename It::reference));
+
+    // RandomAccessIterator:
+    COMPARE(typeid(it += 1), typeid(It &));
+    COMPARE(typeid(it + 1), typeid(It));
+    COMPARE(typeid(1 + it), typeid(It));
+    COMPARE(typeid(it -= 1), typeid(It &));
+    COMPARE(typeid(it - 1), typeid(It));
+    COMPARE(typeid(it - it), typeid(typename It::difference_type));
+    COMPARE(typeid(it[0]), typeid(typename It::reference));
+    COMPARE(typeid(it < it), typeid(bool));
+    COMPARE(typeid(it > it), typeid(bool));
+    COMPARE(typeid(it >= it), typeid(bool));
+    COMPARE(typeid(it <= it), typeid(bool));
+}
+
+TEST_TYPES(V, input_iterator, (ALL_VECTORS, SIMD_ARRAY_LIST))
+{
+    using T = typename V::EntryType;
+    V a = V::IndexesFromZero();
+    auto k = a == 0;
+
+    {
+        auto &&it = cbegin(a);
+        VERIFY(it != cend(a));
+        VERIFY(!(it != it));
+        COMPARE(*it, T(0));
+        int n = 0;
+        while (++it != cend(a)) {
+            COMPARE(*it, T(++n));
+        }
+    }
+    {
+        auto &&it = begin(a);
+        VERIFY(it != end(a));
+        VERIFY(!(it != it));
+        COMPARE(*it, T(0));
+        int n = 0;
+        while (++it != end(a)) {
+            COMPARE(*it, T(++n));
+        }
+    }
+    {
+        auto &&it = cbegin(k);
+        VERIFY(it != cend(k));
+        VERIFY(!(it != it));
+        COMPARE(*it, true);
+        int n = 0;
+        while (++it != cend(k)) {
+            COMPARE(*it, false) << ++n;
+        }
+    }
+    {
+        auto &&it = begin(k);
+        VERIFY(it != end(k));
+        VERIFY(!(it != it));
+        COMPARE(*it, true);
+        while (++it != end(k)) {
+            COMPARE(*it, false);
+        }
+    }
+}
+
+TEST_TYPES(V, output_iterator, (ALL_VECTORS, SIMD_ARRAY_LIST))
+{
+    using T = typename V::EntryType;
+    V a = V::IndexesFromZero();
+    auto k = a == 0;
+    {
+        auto it = begin(a);
+        int n = 0;
+        for (; it != end(a); ++it) {
+            COMPARE(*it, T(n++));
+            *it = T(n);
+        }
+        n = 1;
+        for (it = begin(a); it != end(a); ++it) {
+            COMPARE(*it, T(n++));
+        }
+    }
+    {
+        auto it = begin(k);
+        int n = 0;
+        for (; it != end(k); ++it) {
+            *it = n++ & 1;
+        }
+        n = 0;
+        for (it = begin(k); it != end(k); ++it) {
+            COMPARE(*it, n++ & 1);
+        }
+    }
+}
+
+TEST_TYPES(V, forward_iterator, (ALL_VECTORS, SIMD_ARRAY_LIST))
+{
+    using T = typename V::EntryType;
+    V a = V::IndexesFromZero();
+    auto &&it = begin(a);
+    using It = typename std::decay<decltype(it)>::type;
+    T value = *it;
+    (void)++It(it); // increment a temporary iterator copy
+    COMPARE(*it, value);
+}
+
+TEST_TYPES(V, range_for, (ALL_VECTORS))
+{
+    typedef typename V::EntryType T;
+    typedef typename V::Mask M;
+
+    {
+        V x = V::Zero();
+        for (auto &&i : x) {
+            COMPARE(i, T(0));
+            VERIFY(!(std::is_assignable<decltype((i)), T>::value));
+        }
+        x = V::IndexesFromZero();
+        int n = 0;
+        for (T i : x) {
+            COMPARE(i, T(n++));
+            i = 0;
+        }
+        COMPARE(x, V::IndexesFromZero());
+    }
+
+    {
+        M m{true};
+        for (auto &&i : m) {
+            VERIFY(i);
+            VERIFY(!(std::is_assignable<decltype((i)), bool>::value));
+        }
+        for (auto i : static_cast<const M &>(m)) {
+            VERIFY(i);
+            i = false;
+            VERIFY(!i);
+        }
+        for (bool i : m) {
+            VERIFY(i);
+        }
+    }
+
+    for_all_masks(V, mask) {
+        int count = 0;
+        V test = V::Zero();
+        for (size_t i : where(mask)) {
+            VERIFY(i < V::Size);
+            test[i] = T(1);
+            ++count;
+        }
+        COMPARE(test == V::One(), mask);
+        COMPARE(count, mask.count());
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/linkTest0.cpp vc-1.3.0/tests/linkTest0.cpp
--- vc-0.7.4/tests/linkTest0.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/linkTest0.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,7 +1,3 @@
-#include <Vc/global.h>
-#if !(defined VC_GCC && VC_GCC < 0x40400) && !defined VC_MSVC
-#include <x86intrin.h>
-#endif
 #include <Vc/Vc>
 #include <Vc/IO>
 #include <Vc/support.h>
diff -Nru vc-0.7.4/tests/linkTest1.cpp vc-1.3.0/tests/linkTest1.cpp
--- vc-0.7.4/tests/linkTest1.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/linkTest1.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -18,9 +18,9 @@
     return b;
 }
 
-int main()
+int Vc_CDECL main()
 {
     float_v x = float_v::Random();
     x = fooLib0A(fooLib0B(fooLib1A(fooLib1B(fooLib2(fooLib3(foo0(foo1(x))))))));
-    return static_cast<int>(x.sum());
+    return static_cast<int>(x.sum()) >> 8;
 }
diff -Nru vc-0.7.4/tests/linkTestLib0.cpp vc-1.3.0/tests/linkTestLib0.cpp
--- vc-0.7.4/tests/linkTestLib0.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/linkTestLib0.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,12 +1,13 @@
 #include <Vc/Vc>
 #include <Vc/IO>
+#include <Vc/support.h>
 
 #define CAT(a, b) a##b
 #define name(a, b) CAT(a, b)
 
 using namespace Vc;
 float_v
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
 __declspec(dllexport)
 #endif
 name(fooLib0, POSTFIX)(float_v::AsArg a)
diff -Nru vc-0.7.4/tests/linkTestLib1.cpp vc-1.3.0/tests/linkTestLib1.cpp
--- vc-0.7.4/tests/linkTestLib1.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/linkTestLib1.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,12 +1,13 @@
 #include <Vc/Vc>
 #include <Vc/IO>
+#include <Vc/support.h>
 
 #define CAT(a, b) a##b
 #define name(a, b) CAT(a, b)
 
 using namespace Vc;
 float_v
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
 __declspec(dllexport)
 #endif
 name(fooLib1, POSTFIX)(float_v::AsArg a)
diff -Nru vc-0.7.4/tests/load.cpp vc-1.3.0/tests/load.cpp
--- vc-0.7.4/tests/load.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/load.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,39 +1,50 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
-#include <iostream>
 
 using namespace Vc;
 
-template<typename Vec> unsigned long alignmentMask()
+#define ALL_TYPES (ALL_VECTORS)
+
+template<typename T> static constexpr T min(T a, T b) { return a < b ? a : b; }
+
+template<typename Vec> constexpr unsigned long alignmentMask()
 {
-    if (Vec::Size == 1) {
-        // on 32bit the maximal alignment is 4 Bytes, even for 8-Byte doubles.
-        return std::min(sizeof(void*), sizeof(typename Vec::EntryType)) - 1;
-    }
-    // sizeof(SSE::sfloat_v) is too large
-    // AVX::VectorAlignment is too large
-    return std::min<unsigned long>(sizeof(Vec), VectorAlignment) - 1;
+    return Vec::Size == 1 ? (
+            // on 32bit the maximal alignment is 4 Bytes, even for 8-Byte doubles.
+            min(sizeof(void*), sizeof(typename Vec::EntryType)) - 1
+        ) : (
+            // AVX::VectorAlignment is too large
+            min(sizeof(Vec), alignof(Vec)) - 1
+        );
 }
 
-template<typename Vec> void checkAlignment()
+TEST_TYPES(Vec, checkAlignment, ALL_TYPES)
 {
     unsigned char i = 1;
     Vec a[10];
@@ -43,82 +54,86 @@
     }
     const char *data = reinterpret_cast<const char *>(&a[0]);
     for (i = 0; i < 10; ++i) {
-        VERIFY(&data[i * Vec::Size * sizeof(typename Vec::EntryType)] == reinterpret_cast<const char *>(&a[i]));
+        VERIFY(&data[i * sizeof(Vec)] == reinterpret_cast<const char *>(&a[i]));
     }
 }
 
 void *hack_to_put_b_on_the_stack = 0;
 
-template<typename Vec> void checkMemoryAlignment()
+TEST_TYPES(Vec, checkMemoryAlignment, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
     const T *b = 0;
     Vc::Memory<Vec, 10> a;
     b = a;
     hack_to_put_b_on_the_stack = &b;
-    unsigned long mask = alignmentMask<Vec>();
+    size_t mask = memory_alignment<Vec>::value - 1;
     for (int i = 0; i < 10; ++i) {
         VERIFY((reinterpret_cast<size_t>(&b[i * Vec::Size]) & mask) == 0) << "b = " << b << ", mask = " << mask;
     }
 }
 
-template<typename Vec> void loadArray()
+enum Enum {
+    loadArrayShortCount = 32 * 1024,
+    streamingLoadCount = 1024
+};
+TEST_TYPES(Vec, loadArrayShort, (short_v, ushort_v, SimdArray<short, 32>, SimdArray<unsigned short, 32>))
 {
     typedef typename Vec::EntryType T;
-    typedef typename Vec::IndexType I;
 
-    enum loadArrayEnum { count = 256 * 1024 / sizeof(T) };
-    Vc::Memory<Vec, count> array;
-    for (int i = 0; i < count; ++i) {
+    Vc::Memory<Vec, loadArrayShortCount> array;
+    for (int i = 0; i < loadArrayShortCount; ++i) {
         array[i] = i;
     }
 
-    const I indexesFromZero(IndexesFromZero);
-
-    const Vec offsets(indexesFromZero);
-    for (int i = 0; i < count; i += Vec::Size) {
+    const Vec offsets(IndexesFromZero);
+    for (int i = 0; i < loadArrayShortCount; i += Vec::Size) {
         const T *const addr = &array[i];
         Vec ii(i);
         ii += offsets;
 
-        Vec a(addr);
+        Vec a(addr, Vc::Aligned);
         COMPARE(a, ii);
 
         Vec b = Vec::Zero();
-        b.load(addr);
+        b.load(addr, Vc::Aligned);
         COMPARE(b, ii);
     }
 }
 
-enum Enum {
-    loadArrayShortCount = 32 * 1024,
-    streamingLoadCount = 1024
-};
-template<typename Vec> void loadArrayShort()
+TEST_TYPES(Vec, loadArray, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
+    if (sizeof(T) < 4) {
+        return;
+    }
 
-    Vc::Memory<Vec, loadArrayShortCount> array;
-    for (int i = 0; i < loadArrayShortCount; ++i) {
+    enum loadArrayEnum { count = 256 * 1024 / sizeof(T) };
+    Vc::Memory<Vec, count> array;
+    for (int i = 0; i < count; ++i) {
         array[i] = i;
     }
 
-    const Vec &offsets = static_cast<Vec>(ushort_v::IndexesFromZero());
-    for (int i = 0; i < loadArrayShortCount; i += Vec::Size) {
+    const Vec offsets(IndexesFromZero);
+    for (int i = 0; i < count; i += Vec::Size) {
         const T *const addr = &array[i];
         Vec ii(i);
         ii += offsets;
 
-        Vec a(addr);
+        Vec a(addr, Vc::Aligned);
         COMPARE(a, ii);
 
         Vec b = Vec::Zero();
-        b.load(addr);
+        b.load(addr, Vc::Aligned);
         COMPARE(b, ii);
     }
+
+    // check that Vc allows construction from objects that auto-convert to T*
+    Vec tmp0(array, Vc::Aligned);
+    tmp0.load(array, Vc::Aligned);
 }
 
-template<typename Vec> void streamingLoad()
+TEST_TYPES(Vec, streamingLoad, ALL_TYPES)
 {
     typedef typename Vec::EntryType T;
 
@@ -130,141 +145,78 @@
     }
 
     Vec ref = data.firstVector();
-    for (int i = 0; i < streamingLoadCount - Vec::Size; ++i, ++ref) {
+    for (size_t i = 0; i < streamingLoadCount - Vec::Size; ++i, ++ref) {
         Vec v1, v2;
         if (0 == i % Vec::Size) {
-            v1 = Vec(&data[i], Vc::Streaming | Vc::Aligned);
-            v2.load (&data[i], Vc::Streaming | Vc::Aligned);
+            v1 = Vec(&data[i], Vc::Aligned | Vc::Streaming);
+            v2.load (&data[i], Vc::Aligned | Vc::Streaming);
         } else {
             v1 = Vec(&data[i], Vc::Streaming | Vc::Unaligned);
-            v2.load (&data[i], Vc::Streaming | Vc::Unaligned);
+            v2.load (&data[i], Vc::Unaligned | Vc::Streaming);
         }
-        COMPARE(v1, ref);
-        COMPARE(v2, ref);
+        COMPARE(v1, ref) << ", i = " << i;
+        COMPARE(v2, ref) << ", i = " << i;
     }
 }
 
-template<typename T> struct TypeInfo;
-template<> struct TypeInfo<double        > { static const char *string() { return "double"; } };
-template<> struct TypeInfo<float         > { static const char *string() { return "float"; } };
-template<> struct TypeInfo<int           > { static const char *string() { return "int"; } };
-template<> struct TypeInfo<unsigned int  > { static const char *string() { return "uint"; } };
-template<> struct TypeInfo<short         > { static const char *string() { return "short"; } };
-template<> struct TypeInfo<unsigned short> { static const char *string() { return "ushort"; } };
-template<> struct TypeInfo<signed char   > { static const char *string() { return "schar"; } };
-template<> struct TypeInfo<unsigned char > { static const char *string() { return "uchar"; } };
-template<> struct TypeInfo<double_v      > { static const char *string() { return "double_v"; } };
-template<> struct TypeInfo<float_v       > { static const char *string() { return "float_v"; } };
-template<> struct TypeInfo<sfloat_v      > { static const char *string() { return "sfloat_v"; } };
-template<> struct TypeInfo<int_v         > { static const char *string() { return "int_v"; } };
-template<> struct TypeInfo<uint_v        > { static const char *string() { return "uint_v"; } };
-template<> struct TypeInfo<short_v       > { static const char *string() { return "short_v"; } };
-template<> struct TypeInfo<ushort_v      > { static const char *string() { return "ushort_v"; } };
-
-template<typename T, typename Current = void> struct SupportedConversions { typedef void Next; };
-template<> struct SupportedConversions<float, void>           { typedef double         Next; };
-template<> struct SupportedConversions<float, double>         { typedef int            Next; };
-template<> struct SupportedConversions<float, int>            { typedef unsigned int   Next; };
-template<> struct SupportedConversions<float, unsigned int>   { typedef short          Next; };
-template<> struct SupportedConversions<float, short>          { typedef unsigned short Next; };
-template<> struct SupportedConversions<float, unsigned short> { typedef signed char    Next; };
-template<> struct SupportedConversions<float, signed char>    { typedef unsigned char  Next; };
-template<> struct SupportedConversions<float, unsigned char>  { typedef void           Next; };
-template<> struct SupportedConversions<int  , void          > { typedef unsigned int   Next; };
-template<> struct SupportedConversions<int  , unsigned int  > { typedef short          Next; };
-template<> struct SupportedConversions<int  , short         > { typedef unsigned short Next; };
-template<> struct SupportedConversions<int  , unsigned short> { typedef signed char    Next; };
-template<> struct SupportedConversions<int  , signed char   > { typedef unsigned char  Next; };
-template<> struct SupportedConversions<int  , unsigned char > { typedef void           Next; };
-template<> struct SupportedConversions<unsigned int, void          > { typedef unsigned short Next; };
-template<> struct SupportedConversions<unsigned int, unsigned short> { typedef unsigned char  Next; };
-template<> struct SupportedConversions<unsigned int, unsigned char > { typedef void           Next; };
-template<> struct SupportedConversions<unsigned short, void          > { typedef unsigned char  Next; };
-template<> struct SupportedConversions<unsigned short, unsigned char > { typedef void           Next; };
-template<> struct SupportedConversions<         short, void          > { typedef unsigned char  Next; };
-template<> struct SupportedConversions<         short, unsigned char > { typedef signed char    Next; };
-template<> struct SupportedConversions<         short,   signed char > { typedef void           Next; };
-
-template<typename Vec, typename MemT> struct LoadCvt {
-    static void test() {
-        typedef typename Vec::EntryType VecT;
-        MemT *data = Vc::malloc<MemT, Vc::AlignOnCacheline>(128);
-        for (size_t i = 0; i < 128; ++i) {
-            data[i] = static_cast<MemT>(i - 64);
+TEST_TYPES(
+    Pair, loadCvt,
+    (concat<
+        outer_product<Typelist<float>,
+                      Typelist<double, int, unsigned int, short, unsigned short,
+                               signed char, unsigned char>>,
+        outer_product<Typelist<int>, Typelist<unsigned int, short, unsigned short,
+                                              signed char, unsigned char>>,
+        outer_product<Typelist<unsigned int>, Typelist<unsigned short, unsigned char>>,
+        outer_product<Typelist<short>, Typelist<unsigned char, unsigned char>>,
+        outer_product<Typelist<unsigned short>, Typelist<unsigned char>>>))
+{
+    using Vec = Vector<typename Pair::template at<0>>;
+    using MemT = typename Pair::template at<1>;
+
+    typedef typename Vec::EntryType VecT;
+    MemT *data = Vc::malloc<MemT, Vc::AlignOnCacheline>(128);
+    for (size_t i = 0; i < 128; ++i) {
+        data[i] = static_cast<MemT>(i - 64);
+    }
+
+    for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
+        Vec v;
+        if (i % (2 * Vec::Size) == 0) {
+            v = Vec(&data[i]);
+        } else if (i % Vec::Size == 0) {
+            v = Vec(&data[i], Vc::Aligned);
+        } else {
+            v = Vec(&data[i], Vc::Unaligned);
         }
-
-        for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
-            Vec v;
-            if (i % (2 * Vec::Size) == 0) {
-                v = Vec(&data[i]);
-            } else if (i % Vec::Size == 0) {
-                v = Vec(&data[i], Vc::Aligned);
-            } else {
-                v = Vec(&data[i], Vc::Unaligned);
-            }
-            for (size_t j = 0; j < Vec::Size; ++j) {
-                COMPARE(v[j], static_cast<VecT>(data[i + j])) << " " << TypeInfo<MemT>::string();
-            }
+        for (size_t j = 0; j < Vec::Size; ++j) {
+            COMPARE(v[j], static_cast<VecT>(data[i + j])) << "j: " << j;
         }
-        for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
-            Vec v;
-            if (i % (2 * Vec::Size) == 0) {
-                v.load(&data[i]);
-            } else if (i % Vec::Size == 0) {
-                v.load(&data[i], Vc::Aligned);
-            } else {
-                v.load(&data[i], Vc::Unaligned);
-            }
-            for (size_t j = 0; j < Vec::Size; ++j) {
-                COMPARE(v[j], static_cast<VecT>(data[i + j])) << " " << TypeInfo<MemT>::string();
-            }
+    }
+    for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
+        Vec v;
+        if (i % (2 * Vec::Size) == 0) {
+            v.load(&data[i]);
+        } else if (i % Vec::Size == 0) {
+            v.load(&data[i], Vc::Aligned);
+        } else {
+            v.load(&data[i], Vc::Unaligned);
         }
-        for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
-            Vec v;
-            if (i % (2 * Vec::Size) == 0) {
-                v = Vec(&data[i], Vc::Streaming);
-            } else if (i % Vec::Size == 0) {
-                v = Vec(&data[i], Vc::Streaming | Vc::Aligned);
-            } else {
-                v = Vec(&data[i], Vc::Streaming | Vc::Unaligned);
-            }
-            for (size_t j = 0; j < Vec::Size; ++j) {
-                COMPARE(v[j], static_cast<VecT>(data[i + j])) << " " << TypeInfo<MemT>::string();
-            }
+        for (size_t j = 0; j < Vec::Size; ++j) {
+            COMPARE(v[j], static_cast<VecT>(data[i + j])) << "j: " << j;
+        }
+    }
+    for (size_t i = 0; i < 128 - Vec::Size + 1; ++i) {
+        Vec v;
+        if (i % (2 * Vec::Size) == 0) {
+            v = Vec(&data[i], Vc::Streaming);
+        } else if (i % Vec::Size == 0) {
+            v = Vec(&data[i], Vc::Streaming | Vc::Aligned);
+        } else {
+            v = Vec(&data[i], Vc::Streaming | Vc::Unaligned);
+        }
+        for (size_t j = 0; j < Vec::Size; ++j) {
+            COMPARE(v[j], static_cast<VecT>(data[i + j])) << "j: " << j;
         }
-
-        ADD_PASS() << "loadCvt: load " << TypeInfo<MemT>::string() << "* as " << TypeInfo<Vec>::string();
-        LoadCvt<Vec, typename SupportedConversions<VecT, MemT>::Next>::test();
     }
-};
-template<typename Vec> struct LoadCvt<Vec, void> { static void test() {} };
-
-template<typename Vec> void loadCvt()
-{
-    typedef typename Vec::EntryType T;
-    LoadCvt<Vec, typename SupportedConversions<T>::Next>::test();
-}
-
-int main()
-{
-    runTest(checkAlignment<int_v>);
-    runTest(checkAlignment<uint_v>);
-    runTest(checkAlignment<float_v>);
-    runTest(checkAlignment<double_v>);
-    runTest(checkAlignment<short_v>);
-    runTest(checkAlignment<ushort_v>);
-    runTest(checkAlignment<sfloat_v>);
-    testAllTypes(checkMemoryAlignment);
-    runTest(loadArray<int_v>);
-    runTest(loadArray<uint_v>);
-    runTest(loadArray<float_v>);
-    runTest(loadArray<double_v>);
-    runTest(loadArray<sfloat_v>);
-    runTest(loadArrayShort<short_v>);
-    runTest(loadArrayShort<ushort_v>);
-
-    testAllTypes(streamingLoad);
-
-    testAllTypes(loadCvt);
-    return 0;
 }
diff -Nru vc-0.7.4/tests/logarithm.cpp vc-1.3.0/tests/logarithm.cpp
--- vc-0.7.4/tests/logarithm.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/logarithm.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,148 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include "mathreference.h"
+
+template <typename T> struct Denormals { //{{{1
+    static T *data;
+};
+template <> float *Denormals<float>::data = 0;
+template <> double *Denormals<double>::data = 0;
+enum { NDenormals = 64 };
+
+TEST(prepareDenormals) //{{{1
+{
+    Denormals<float>::data = Vc::malloc<float, Vc::AlignOnVector>(NDenormals);
+    Denormals<float>::data[0] = std::numeric_limits<float>::denorm_min();
+    for (int i = 1; i < NDenormals; ++i) {
+        Denormals<float>::data[i] = Denormals<float>::data[i - 1] * 2.173f;
+    }
+    Denormals<double>::data = Vc::malloc<double, Vc::AlignOnVector>(NDenormals);
+    Denormals<double>::data[0] = std::numeric_limits<double>::denorm_min();
+    for (int i = 1; i < NDenormals; ++i) {
+        Denormals<double>::data[i] = Denormals<double>::data[i - 1] * 2.173;
+    }
+}
+
+template <typename V, typename F> void testAllDenormals(F &&fun)  //{{{1
+{
+    using T = typename V::EntryType;
+    fun(V(&Denormals<T>::data[0], Vc::Aligned));  // the first one is always aligned.
+    for (auto i = V::Size; i + V::Size <= NDenormals; i += V::Size) {
+        using AlignedLoadTag = typename std::conditional<
+            (V::Size & (V::Size - 1)) == 0,  // if V::Size is even
+            decltype(Vc::Aligned),           // use aligned loads
+            decltype(Vc::Unaligned)          // otherwise use unaliged loads
+            >::type;
+        fun(V(&Denormals<T>::data[i], AlignedLoadTag()));
+    }
+    if (NDenormals % V::Size != 0) {
+        fun(V(&Denormals<T>::data[NDenormals - V::Size], Vc::Unaligned));
+    }
+}
+
+TEST_TYPES(V, testLog, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+#ifdef Vc_IMPL_MIC
+    UnitTest::setFuzzyness<float>(2);
+#else
+    UnitTest::setFuzzyness<float>(1);
+#endif
+    typedef typename V::EntryType T;
+    Array<Reference<T> > reference = referenceData<T, Log>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, ref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            ref[j] = reference.data[i + j].ref;
+        }
+        FUZZY_COMPARE(Vc::log(x), ref) << " x = " << x << ", i = " << i;
+    }
+
+    COMPARE(Vc::log(V::Zero()), V(std::log(T(0))));
+    testAllDenormals<V>([](const V x) {
+        V ref = x.apply([](T _x) { return std::log(_x); });
+        FUZZY_COMPARE(Vc::log(x), ref) << ", x = " << x;
+    });
+}
+
+TEST_TYPES(V, testLog2, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+#if defined(Vc_LOG_ILP) || defined(Vc_LOG_ILP2)
+    UnitTest::setFuzzyness<float>(3);
+#else
+    UnitTest::setFuzzyness<float>(1);
+#endif
+    UnitTest::setFuzzyness<double>(1);
+#if defined(Vc_MSVC) || defined(__APPLE__)
+    if (Vc::Scalar::is_vector<V>::value || !Vc::Traits::isAtomicSimdArray<V>::value) {
+        UnitTest::setFuzzyness<double>(2);
+    }
+#endif
+    typedef typename V::EntryType T;
+    Array<Reference<T> > reference = referenceData<T, Log2>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, ref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            ref[j] = reference.data[i + j].ref;
+        }
+        FUZZY_COMPARE(Vc::log2(x), ref) << " x = " << x << ", i = " << i;
+    }
+
+    COMPARE(Vc::log2(V::Zero()), V(std::log2(T(0))));
+    testAllDenormals<V>([](const V x) {
+        V ref = x.apply([](T _x) { return std::log2(_x); });
+        FUZZY_COMPARE(Vc::log2(x), ref) << ", x = " << x;
+    });
+}
+
+TEST_TYPES(V, testLog10, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    UnitTest::setFuzzyness<float>(2);
+    UnitTest::setFuzzyness<double>(2);
+    typedef typename V::EntryType T;
+    Array<Reference<T> > reference = referenceData<T, Log10>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, ref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            ref[j] = reference.data[i + j].ref;
+        }
+        FUZZY_COMPARE(Vc::log10(x), ref) << " x = " << x << ", i = " << i;
+    }
+
+    COMPARE(Vc::log10(V::Zero()), V(std::log10(T(0))));
+    testAllDenormals<V>([](const V x) {
+        V ref = x.apply([](T _x) { return std::log10(_x); });
+        FUZZY_COMPARE(Vc::log10(x), ref) << ", x = " << x;
+    });
+}
+
+//}}}1
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/mask.cpp vc-1.3.0/tests/mask.cpp
--- vc-0.7.4/tests/mask.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/mask.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,38 +1,57 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 #include <iostream>
 #include "vectormemoryhelper.h"
 #include <cmath>
 
-using namespace Vc;
+using Vc::float_m;
+using Vc::double_m;
+using Vc::int_m;
+using Vc::uint_m;
+using Vc::short_m;
+using Vc::ushort_m;
+
+template<typename T> T two() { return T(2); }
+template<typename T> T three() { return T(3); }
+
+#define ALL_TYPES (ALL_VECTORS)
+//, SIMD_ARRAYS(33), SIMD_ARRAYS(32), SIMD_ARRAYS(31), SIMD_ARRAYS(16), SIMD_ARRAYS(8), SIMD_ARRAYS(7), SIMD_ARRAYS(4), SIMD_ARRAYS(3), SIMD_ARRAYS(2), SIMD_ARRAYS(1))
 
-template<typename Vec> void testInc()
+TEST_TYPES(Vec, testInc, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {/*{{{*/
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i);
             data[i + Vec::Size] = data[i] + static_cast<T>(data[i] < border ? 1 : 0);
         }
@@ -45,17 +64,33 @@
         COMPARE(++a(m), b) << ", border: " << border << ", m: " << m;
         COMPARE(a, b) << ", border: " << border << ", m: " << m;
     }
+/*}}}*/
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
+        const T border = static_cast<T>(borderI);
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            data[i] = static_cast<T>(i);
+            data[i + Vec::Size] = data[i] + static_cast<T>(data[i] < border ? 1 : 0);
+        }
+        Vec a(&data[0]);
+        Vec b(&data[Vec::Size]);
+        Mask m = a < border;
+        Vec aa(a);
+        where(m)(aa)++;
+        COMPARE(aa, b) << ", border: " << border << ", m: " << m;
+        ++where(m)(a);
+        COMPARE(a, b) << ", border: " << border << ", m: " << m;
+    }
 }
-
-template<typename Vec> void testDec()
+/*}}}*/
+TEST_TYPES(Vec, testDec, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i + 1);
             data[i + Vec::Size] = data[i] - static_cast<T>(data[i] < border ? 1 : 0);
         }
@@ -64,158 +99,225 @@
         Mask m = a < border;
         Vec aa(a);
         COMPARE(aa(m)--, a);
+        COMPARE(aa, b);
+
+        aa = a;
+        where(m)(aa)--;
+        COMPARE(aa, b);
+
+        aa = a;
+        --where(m)(aa);
+        COMPARE(aa, b);
+
         COMPARE(--a(m), b);
         COMPARE(a, b);
-        COMPARE(aa, b);
     }
 }
-
-template<typename Vec> void testPlusEq()
+/*}}}*/
+TEST_TYPES(Vec, testPlusEq, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i + 1);
             data[i + Vec::Size] = data[i] + static_cast<T>(data[i] < border ? 2 : 0);
         }
         Vec a(&data[0]);
         Vec b(&data[Vec::Size]);
+        Vec c = a;
         Mask m = a < border;
-        COMPARE(a(m) += static_cast<T>(2), b);
+        a(m) += two<T>();
         COMPARE(a, b);
+        where(m) | c += two<T>();
+        COMPARE(c, b);
     }
 }
-
-template<typename Vec> void testMinusEq()
+/*}}}*/
+TEST_TYPES(Vec, testMinusEq, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i + 2);
             data[i + Vec::Size] = data[i] - static_cast<T>(data[i] < border ? 2 : 0);
         }
         Vec a(&data[0]);
         Vec b(&data[Vec::Size]);
         Mask m = a < border;
-        COMPARE(a(m) -= static_cast<T>(2), b);
+
+        Vec c = a;
+        where(m) | c -= two<T>();
+        COMPARE(c, b);
+
+        a(m) -= two<T>();
         COMPARE(a, b);
     }
 }
-
-template<typename Vec> void testTimesEq()
+/*}}}*/
+TEST_TYPES(Vec, testTimesEq, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i);
             data[i + Vec::Size] = data[i] * static_cast<T>(data[i] < border ? 2 : 1);
         }
         Vec a(&data[0]);
         Vec b(&data[Vec::Size]);
         Mask m = a < border;
-        COMPARE(a(m) *= static_cast<T>(2), b);
+
+        Vec c = a;
+        where(m) | c *= two<T>();
+        COMPARE(c, b);
+
+        a(m) *= two<T>();
         COMPARE(a, b);
     }
 }
-
-template<typename Vec> void testDivEq()
+/*}}}*/
+TEST_TYPES(Vec, testDivEq, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(5 * i);
             data[i + Vec::Size] = data[i] / static_cast<T>(data[i] < border ? 3 : 1);
         }
         Vec a(&data[0]);
         Vec b(&data[Vec::Size]);
         Mask m = a < border;
-        COMPARE(a(m) /= static_cast<T>(3), b);
+
+        Vec c = a;
+        where(m) | c /= three<T>();
+        COMPARE(c, b);
+
+        a(m) /= three<T>();
         COMPARE(a, b);
     }
 }
-
-template<typename Vec> void testAssign()
+/*}}}*/
+TEST_TYPES(Vec, testAssign, ALL_TYPES) /*{{{*/
 {
     VectorMemoryHelper<Vec> mem(2);
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     T *data = mem;
-    for (int borderI = 0; borderI < Vec::Size; ++borderI) {
+    for (size_t borderI = 0; borderI < Vec::Size; ++borderI) {
         const T border = static_cast<T>(borderI);
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             data[i] = static_cast<T>(i);
             data[i + Vec::Size] = data[i] + static_cast<T>(data[i] < border ? 2 : 0);
         }
         Vec a(&data[0]);
         Vec b(&data[Vec::Size]);
         Mask m = a < border;
-        COMPARE(a(m) = b, b);
+
+        Vec c = a;
+        where(m) | c = b;
+        COMPARE(c, b);
+
+        a(m) = b;
         COMPARE(a, b);
     }
 }
-
-template<typename Vec> void testZero()
+/*}}}*/
+TEST_TYPES(Vec, testZero, ALL_TYPES) /*{{{*/
 {
     typedef typename Vec::EntryType T;
     typedef typename Vec::Mask Mask;
     typedef typename Vec::IndexType I;
 
-    for (int cut = 0; cut < Vec::Size; ++cut) {
-        const Mask mask(I(Vc::IndexesFromZero) < cut);
+    for (size_t cut = 0; cut < Vec::Size; ++cut) {
+        const Mask mask = Vc::simd_cast<Mask>(I::IndexesFromZero() < cut);
         //std::cout << mask << std::endl;
 
         const T aa = 4;
         Vec a(aa);
         Vec b(Vc::Zero);
 
-        b(!mask) = a;
+        where(!mask) | b = a;
         a.setZero(mask);
 
         COMPARE(a, b);
     }
 }
-
-template<typename Vec> void testCount()
+/*}}}*/
+TEST_TYPES(V, testIntegerConversion, ALL_TYPES) /*{{{*/
 {
-    for_all_masks(Vec, m) {
+    UnitTest::withRandomMask<V>([](typename V::Mask m) {
+        auto bit = m.toInt();
+        for (size_t i = 0; i < m.Size; ++i) {
+            COMPARE(!!((bit >> i) & 1), m[i]) << std::hex << bit;
+        }
+    });
+}
+/*}}}*/
+TEST_TYPES(Vec, testCount, ALL_TYPES) /*{{{*/
+{
+    typedef typename Vec::Mask M;
+
+    UnitTest::withRandomMask<Vec>([](M m) {
         int count = 0;
-        for (int i = 0; i < Vec::Size; ++i) {
+        for (size_t i = 0; i < Vec::Size; ++i) {
             if (m[i]) {
                 ++count;
             }
         }
         COMPARE(m.count(), count) << ", m = " << m;
-    }
+    });
 }
-
-template<typename Vec> void testFirstOne()
+/*}}}*/
+TEST_TYPES(Vec, testFirstOne, ALL_TYPES) /*{{{*/
 {
     typedef typename Vec::IndexType I;
     typedef typename Vec::Mask M;
 
-    for (int i = 0; i < Vec::Size; ++i) {
-        const M mask(I(Vc::IndexesFromZero) == i);
-        COMPARE(mask.firstOne(), i);
-    }
+    for (unsigned int i = 0; i < Vec::Size; ++i) {
+        const M mask = Vc::simd_cast<M>(I(Vc::IndexesFromZero) == i);
+        COMPARE(mask.firstOne(), int(i)) << mask << ' ' << I::IndexesFromZero() << ' ' << (I::IndexesFromZero() == i);
+    }
+}
+/*}}}*/
+TEST_TYPES(V, shifted, (ALL_VECTORS, SIMD_ARRAYS(16), SIMD_ODD_ARRAYS(31)))/*{{{*/
+{
+    using M = typename V::Mask;
+    UnitTest::withRandomMask<V>([](const M &reference) {
+        constexpr int Size = V::Size;
+        for (int shift = -2 * Size; shift <= 2 * Size; ++shift) {
+            const M test = reference.shifted(shift);
+            for (int i = 0; i < Size; ++i) {
+                if (i + shift >= 0 && i + shift < Size) {
+                    COMPARE(test[i], reference[i + shift])
+                        << "shift: " << shift << ", i: " << i << ", test: " << test
+                        << ", reference: " << reference;
+                } else {
+                    COMPARE(test[i], false) << "shift: " << shift << ", i: " << i
+                                            << ", test: " << test
+                                            << ", reference: " << reference;
+                }
+            }
+        }
+    });
 }
+/*}}}*/
 
-template<typename M1, typename M2> void testLogicalOperatorsImpl()
+template<typename M1, typename M2> void testLogicalOperatorsImpl()/*{{{*/
 {
     VERIFY((M1(true) && M2(true)).isFull());
     VERIFY((M1(true) && M2(false)).isEmpty());
@@ -223,8 +325,8 @@
     VERIFY((M1(true) || M2(false)).isFull());
     VERIFY((M1(false) || M2(false)).isEmpty());
 }
-
-template<typename M1, typename M2> void testBinaryOperatorsImpl()
+/*}}}*/
+template<typename M1, typename M2> void testBinaryOperatorsImpl()/*{{{*/
 {
     testLogicalOperatorsImpl<M1, M2>();
 
@@ -236,77 +338,148 @@
     VERIFY((M1(true) ^ M2(true)).isEmpty());
     VERIFY((M1(true) ^ M2(false)).isFull());
 }
-
-void testBinaryOperators()
+/*}}}*/
+TEST(testBinaryOperators) /*{{{*/
 {
-    testLogicalOperatorsImpl< short_m, sfloat_m>();
-    testLogicalOperatorsImpl<ushort_m, sfloat_m>();
-    testLogicalOperatorsImpl<sfloat_m,  short_m>();
-    testLogicalOperatorsImpl<sfloat_m, ushort_m>();
-
     testBinaryOperatorsImpl< short_m,  short_m>();
     testBinaryOperatorsImpl< short_m, ushort_m>();
     testBinaryOperatorsImpl<ushort_m,  short_m>();
     testBinaryOperatorsImpl<ushort_m, ushort_m>();
-    testBinaryOperatorsImpl<sfloat_m, sfloat_m>();
 
     testBinaryOperatorsImpl<   int_m,    int_m>();
     testBinaryOperatorsImpl<   int_m,   uint_m>();
-    testBinaryOperatorsImpl<   int_m,  float_m>();
     testBinaryOperatorsImpl<  uint_m,    int_m>();
     testBinaryOperatorsImpl<  uint_m,   uint_m>();
-    testBinaryOperatorsImpl<  uint_m,  float_m>();
-    testBinaryOperatorsImpl< float_m,    int_m>();
-    testBinaryOperatorsImpl< float_m,   uint_m>();
+
     testBinaryOperatorsImpl< float_m,  float_m>();
 
     testBinaryOperatorsImpl<double_m, double_m>();
 }
+/*}}}*/
 
-#ifdef VC_IMPL_SSE
-void testFloat8GatherMask()
+TEST_TYPES(V, maskReductions, ALL_TYPES) /*{{{*/
 {
-    Memory<short_v, short_v::Size * 256> data;
-    short_v::Memory andMemory;
-    for (int i = 0; i < short_v::Size; ++i) {
-        andMemory[i] = 1 << i;
-    }
-    const short_v andMask(andMemory);
+    UnitTest::withRandomMask<V>([](typename V::Mask mask) {
+        constexpr decltype(mask.count()) size = V::Size;
+        COMPARE(all_of(mask), mask.count() == size);
+        if (mask.count() > 0) {
+            VERIFY(any_of(mask));
+            VERIFY(!none_of(mask));
+            COMPARE(some_of(mask), mask.count() < size);
+        } else {
+            VERIFY(!any_of(mask));
+            VERIFY(none_of(mask));
+            VERIFY(!some_of(mask));
+        }
+    });
+}/*}}}*/
+TEST_TYPES(V, maskInit, ALL_TYPES) /*{{{*/
+{
+    typedef typename V::Mask M;
+    COMPARE(M(Vc::One), M(true));
+    COMPARE(M(Vc::Zero), M(false));
+}
+/*}}}*/
+TEST_TYPES(V, maskScalarAccess, ALL_TYPES) /*{{{*/
+{
+    typedef typename V::Mask M;
+    UnitTest::withRandomMask<V>([](M mask) {
+        const auto &mask2 = mask;
+        for (size_t i = 0; i < V::Size; ++i) {
+            COMPARE(bool(mask[i]), mask2[i]);
+        }
 
-    for (unsigned int i = 0; i < data.vectorsCount(); ++i) {
-        data.vector(i) = andMask & i;
-    }
+        const auto maskInv = !mask;
+        for (size_t i = 0; i < V::Size; ++i) {
+            mask[i] = !mask[i];
+        }
+        COMPARE(mask, maskInv);
 
-    for (unsigned int i = 0; i < data.vectorsCount(); ++i) {
-        const short_m mask = data.vector(i) == short_v::Zero();
+        for (size_t i = 0; i < V::Size; ++i) {
+            mask[i] = true;
+        }
+        COMPARE(mask, M(true));
+    });
+}/*}}}*/
+template<typename MTo, typename MFrom> void testMaskConversion(const MFrom &m)/*{{{*/
+{
+    MTo test = Vc::simd_cast<MTo>(m);
+    size_t i = 0;
+    for (; i < std::min(m.Size, test.Size); ++i) {
+        COMPARE(test[i], m[i]) << i << " conversion from " << UnitTest::typeToString<MFrom>()
+                               << " to " << UnitTest::typeToString<MTo>();
+    }
+    for (; i < test.Size; ++i) {
+        COMPARE(test[i], false) << i << " conversion from " << UnitTest::typeToString<MFrom>()
+                                << " to " << UnitTest::typeToString<MTo>();
+    }
+}/*}}}*/
+TEST_TYPES(V, maskConversions, ALL_TYPES) /*{{{*/
+{
+    typedef typename V::Mask M;
+    UnitTest::withRandomMask<V>([](M m) {
+        testMaskConversion< float_m>(m);
+        testMaskConversion<double_m>(m);
+        testMaskConversion<   int_m>(m);
+        testMaskConversion<  uint_m>(m);
+        testMaskConversion< short_m>(m);
+        testMaskConversion<ushort_m>(m);
+    });
+}
+/*}}}*/
+TEST_TYPES(V, boolConversion, ALL_TYPES) /*{{{*/
+{
+    alignas(16) bool mem[V::Size + 64];
+    UnitTest::withRandomMask<V>([&](typename V::Mask m) {
+        bool *ptr = mem;
+        m.store(ptr);
+        for (size_t i = 0; i < V::Size; ++i) {
+            COMPARE(ptr[i], m[i]) << "offset: " << ptr - mem;
+        }
 
-        SSE::Float8GatherMask
-            gatherMaskA(mask),
-            gatherMaskB(static_cast<sfloat_m>(mask));
-        COMPARE(gatherMaskA.toInt(), gatherMaskB.toInt());
-    }
-}
-#endif
+        typename V::Mask m2(ptr);
+        COMPARE(m2, m) << "offset: " << ptr - mem;
+        for (++ptr; ptr < &mem[64]; ++ptr) {
+            m.store(ptr, Vc::Unaligned);
+            for (size_t i = 0; i < V::Size; ++i) {
+                COMPARE(ptr[i], m[i]) << "offset: " << ptr - mem;
+            }
 
-int main(int argc, char **argv)
+            typename V::Mask m3(ptr, Vc::Unaligned);
+            COMPARE(m3, m) << "offset: " << ptr - mem;
+        }
+    });
+}
+/*}}}*/
+TEST_TYPES(V, testCompareOperators, ALL_TYPES) /*{{{*/
 {
-    initTest(argc, argv);
-
-    testAllTypes(testInc);
-    testAllTypes(testDec);
-    testAllTypes(testPlusEq);
-    testAllTypes(testMinusEq);
-    testAllTypes(testTimesEq);
-    testAllTypes(testDivEq);
-    testAllTypes(testAssign);
-    testAllTypes(testZero);
-    testAllTypes(testCount);
-    testAllTypes(testFirstOne);
-    runTest(testBinaryOperators);
-
-#ifdef VC_IMPL_SSE
-    runTest(testFloat8GatherMask);
-#endif
-
-    return 0;
+    typedef typename V::Mask M;
+    const M a(true);
+    const M b(false);
+    VERIFY(!(a == b));
+    VERIFY(!(b == a));
+    VERIFY(a != b);
+    VERIFY(b != a);
+
+    for_all_masks(V, k)
+    {
+        M randomMask;
+        do {
+            randomMask = V::Random() < V::Random();
+        } while (randomMask.isEmpty());
+        const M k2 = k ^ randomMask;
+
+        VERIFY( (k  == k )) << k;
+        VERIFY(!(k2 == k )) << k << k2;
+        VERIFY(!(k  == k2)) << k << k2;
+        VERIFY( (k2 == k2)) << k << k2;
+
+        VERIFY(!(k  != k )) << k;
+        VERIFY( (k  != k2)) << k << k2;
+        VERIFY( (k2 != k )) << k << k2;
+        VERIFY(!(k2 != k2)) << k << k2;
+    }
 }
+/*}}}*/
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/math.cpp vc-1.3.0/tests/math.cpp
--- vc-0.7.4/tests/math.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/math.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,632 +1,234 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 /*includes {{{*/
 #include "unittest.h"
-#include <iostream>
+#include <Vc/array>
 #include "vectormemoryhelper.h"
-#include "const.h"
 #include <cmath>
 #include <algorithm>
-#include <common/macros.h>
+#include <common/const.h>
 /*}}}*/
 using namespace Vc;
-/*fix isfinite and isnan{{{*/
+
+using RealTypes = concat<RealVectors, RealSimdArrays>;
+using AllTypes = concat<AllVectors, AllSimdArrays>;
+
+// fix isfinite and isnan {{{1
 #ifdef isfinite
 #undef isfinite
 #endif
 #ifdef isnan
 #undef isnan
 #endif
-/*}}}*/
-template<typename T> struct SincosReference/*{{{*/
-{
-    T x, s, c;
-};
-template<typename T> struct Reference
-{
-    T x, ref;
-};
-
-template<typename T> struct Array
-{
-    size_t size;
-    T *data;
-    Array() : size(0), data(0) {}
-};
-template<typename T> struct StaticDeleter
-{
-    T *ptr;
-    StaticDeleter(T *p) : ptr(p) {}
-    ~StaticDeleter() { delete[] ptr; }
-};
-
-enum Function {
-    Sincos, Atan, Asin, Acos, Log, Log2, Log10
-};
-template<typename T, Function F> static inline const char *filename();
-template<> inline const char *filename<float , Sincos>() { return "reference-sincos-sp.dat"; }
-template<> inline const char *filename<double, Sincos>() { return "reference-sincos-dp.dat"; }
-template<> inline const char *filename<float , Atan  >() { return "reference-atan-sp.dat"; }
-template<> inline const char *filename<double, Atan  >() { return "reference-atan-dp.dat"; }
-template<> inline const char *filename<float , Asin  >() { return "reference-asin-sp.dat"; }
-template<> inline const char *filename<double, Asin  >() { return "reference-asin-dp.dat"; }
-// template<> inline const char *filename<float , Acos  >() { return "reference-acos-sp.dat"; }
-// template<> inline const char *filename<double, Acos  >() { return "reference-acos-dp.dat"; }
-template<> inline const char *filename<float , Log   >() { return "reference-ln-sp.dat"; }
-template<> inline const char *filename<double, Log   >() { return "reference-ln-dp.dat"; }
-template<> inline const char *filename<float , Log2  >() { return "reference-log2-sp.dat"; }
-template<> inline const char *filename<double, Log2  >() { return "reference-log2-dp.dat"; }
-template<> inline const char *filename<float , Log10 >() { return "reference-log10-sp.dat"; }
-template<> inline const char *filename<double, Log10 >() { return "reference-log10-dp.dat"; }
-
-template<typename T>
-static Array<SincosReference<T> > sincosReference()
-{
-    static Array<SincosReference<T> > data;
-    if (data.data == 0) {
-        FILE *file = fopen(filename<T, Sincos>(), "rb");
-        if (file) {
-            fseek(file, 0, SEEK_END);
-            const size_t size = ftell(file) / sizeof(SincosReference<T>);
-            rewind(file);
-            data.data = new SincosReference<T>[size];
-            static StaticDeleter<SincosReference<T> > _cleanup(data.data);
-            data.size = fread(data.data, sizeof(SincosReference<T>), size, file);
-            fclose(file);
-        } else {
-            FAIL() << "the reference data " << filename<T, Sincos>() << " does not exist in the current working directory.";
-        }
-    }
-    return data;
-}
 
-template<typename T, Function Fun>
-static Array<Reference<T> > referenceData()
-{
-    static Array<Reference<T> > data;
-    if (data.data == 0) {
-        FILE *file = fopen(filename<T, Fun>(), "rb");
-        if (file) {
-            fseek(file, 0, SEEK_END);
-            const size_t size = ftell(file) / sizeof(Reference<T>);
-            rewind(file);
-            data.data = new Reference<T>[size];
-            static StaticDeleter<Reference<T> > _cleanup(data.data);
-            data.size = fread(data.data, sizeof(Reference<T>), size, file);
-            fclose(file);
-        } else {
-            FAIL() << "the reference data " << filename<T, Fun>() << " does not exist in the current working directory.";
-        }
-    }
-    return data;
-}/*}}}*/
-
-template<typename T> struct Denormals { static T *data; };/*{{{*/
-template<> float  *Denormals<float >::data = 0;
-template<> double *Denormals<double>::data = 0;
-enum {
-    NDenormals = 64
-};
-/*}}}*/
-template<typename V> V apply_v(VC_ALIGNED_PARAMETER(V) x, typename V::EntryType (func)(typename V::EntryType))/*{{{*/
-{
-    V r;
-    for (size_t i = 0; i < V::Size; ++i) {
-        r[i] = func(x[i]);
-    }
-    return r;
-}
-/*}}}*/
-template<typename Vec> void testAbs()/*{{{*/
-{
-    for (int i = 0; i < 0x7fff; ++i) {
-        Vec a(i);
-        Vec b(-i);
+// abs {{{1
+TEST_TYPES(V, testAbs, (concat<RealTypes, int_v, short_v, SimdArray<int, 8>,
+                               SimdArray<int, 2>, SimdArray<int, 7>>))
+{
+    for (int i = 0; i < 0x7fff - int(V::size()); ++i) {
+        V a = V::IndexesFromZero() + i;
+        V b = -a;
         COMPARE(a, Vc::abs(a));
         COMPARE(a, Vc::abs(b));
     }
-}
-/*}}}*/
-static inline float my_trunc(float x)/*{{{*/
-{
-#if __cplusplus >= 201103 /*C++11*/
-    return std::trunc(x);
-#elif defined(_ISOC99_SOURCE)
-    return truncf(x);
-#else
-    return x > 0 ? std::floor(x) : std::ceil(x);
-#endif
+    for (int i = 0; i < 1000; ++i) {
+        const V a = V::Random();
+        const V ref = V::generate([&](int j) { return std::abs(a[j]); });
+        COMPARE(abs(a), ref) << "a : " << a;
+    }
 }
 
-static inline double my_trunc(double x)
-{
-#if __cplusplus >= 201103 /*C++11*/
-    return std::trunc(x);
-#elif defined(_ISOC99_SOURCE)
-    return trunc(x);
-#else
-    return x > 0 ? std::floor(x) : std::ceil(x);
-#endif
-}
-/*}}}*/
-template<typename V> void testTrunc()/*{{{*/
+TEST_TYPES(V, testTrunc, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
     for (size_t i = 0; i < 100000 / V::Size; ++i) {
         V x = (V::Random() - T(0.5)) * T(100);
-        V reference = apply_v(x, my_trunc);
+        V reference = x.apply([](T _x) { return std::trunc(_x); });
         COMPARE(Vc::trunc(x), reference) << ", x = " << x << ", i = " << i;
     }
-    V x = static_cast<V>(I::IndexesFromZero());
-    V reference = apply_v(x, my_trunc);
+    V x = V::IndexesFromZero();
+    V reference = x.apply([](T _x) { return std::trunc(_x); });
     COMPARE(Vc::trunc(x), reference) << ", x = " << x;
 }
-/*}}}*/
-template<typename V> void testFloor()/*{{{*/
+
+TEST_TYPES(V, testFloor, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
     for (size_t i = 0; i < 100000 / V::Size; ++i) {
         V x = (V::Random() - T(0.5)) * T(100);
-        V reference = apply_v(x, std::floor);
+        V reference = x.apply([](T _x) { return std::floor(_x); });
         COMPARE(Vc::floor(x), reference) << ", x = " << x << ", i = " << i;
     }
-    V x = static_cast<V>(I::IndexesFromZero());
-    V reference = apply_v(x, std::floor);
+    V x = V::IndexesFromZero();
+    V reference = x.apply([](T _x) { return std::floor(_x); });
     COMPARE(Vc::floor(x), reference) << ", x = " << x;
 }
-/*}}}*/
-template<typename V> void testCeil()/*{{{*/
+
+TEST_TYPES(V, testCeil, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
     for (size_t i = 0; i < 100000 / V::Size; ++i) {
         V x = (V::Random() - T(0.5)) * T(100);
-        V reference = apply_v(x, std::ceil);
+        V reference = x.apply([](T _x) { return std::ceil(_x); });
         COMPARE(Vc::ceil(x), reference) << ", x = " << x << ", i = " << i;
     }
-    V x = static_cast<V>(I::IndexesFromZero());
-    V reference = apply_v(x, std::ceil);
+    V x = V::IndexesFromZero();
+    V reference = x.apply([](T _x) { return std::ceil(_x); });
     COMPARE(Vc::ceil(x), reference) << ", x = " << x;
 }
-/*}}}*/
-template<typename V> void testExp()/*{{{*/
+
+TEST_TYPES(V, testExp, (RealTypes)) //{{{1
 {
-    setFuzzyness<float>(1);
-    setFuzzyness<double>(2);
+    UnitTest::setFuzzyness<float>(1);
+    UnitTest::setFuzzyness<double>(2);
     typedef typename V::EntryType T;
     for (size_t i = 0; i < 100000 / V::Size; ++i) {
         V x = (V::Random() - T(0.5)) * T(20);
-        V reference = apply_v(x, std::exp);
+        V reference = x.apply([](T _x) { return std::exp(_x); });
         FUZZY_COMPARE(Vc::exp(x), reference) << ", x = " << x << ", i = " << i;
     }
     COMPARE(Vc::exp(V::Zero()), V::One());
 }
-/*}}}*/
-template<typename V> void testLog()/*{{{*/
-{
-    setFuzzyness<float>(1);
-    typedef typename V::EntryType T;
-    Array<Reference<T> > reference = referenceData<T, Log>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, ref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            ref[j] = reference.data[i + j].ref;
-        }
-        FUZZY_COMPARE(Vc::log(x), ref) << " x = " << x << ", i = " << i;
-    }
-
-    COMPARE(Vc::log(V::Zero()), V(std::log(T(0))));
-    for (int i = 0; i < NDenormals; i += V::Size) {
-        V x(&Denormals<T>::data[i]);
-        V ref = apply_v(x, std::log);
-        FUZZY_COMPARE(Vc::log(x), ref) << ", x = " << x << ", i = " << i;
-    }
-}
-/*}}}*/
-#if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600) || defined(_ISOC99_SOURCE) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L)
-static inline float my_log2(float x) { return ::log2f(x); }
-/* I need to make sure whether the log2 that I compare against is really precise to <0.5ulp. At
- * least I get different results when I use "double log2(double)", which is somewhat unexpected.
- * Well, conversion from double to float goes via truncation, so if the most significant truncated
- * mantissa bit is set the resulting float is incorrect by 1 ulp
-
-static inline float my_log2(float x) { return ::log2(static_cast<double>(x)); }
-static inline float my_log2(float x) {
-    double tmp = ::log2(static_cast<double>(x));
-    int e;
-    frexp(tmp, &e); // frexp(0.5) -> e = 0
-    return tmp + ldexp(tmp < 0 ? -0.5 : 0.5, e - 24);
-}
- */
-static inline double my_log2(double x) { return ::log2(x); }
-#else
-static inline float my_log2(float x) { return ::logf(x) / Vc::Math<float>::ln2(); }
-static inline double my_log2(double x) { return ::log(x) / Vc::Math<double>::ln2(); }
-#endif
-/*}}}*/
-template<typename V> void testLog2()/*{{{*/
-{
-#if defined(VC_LOG_ILP) || defined(VC_LOG_ILP2)
-    setFuzzyness<float>(3);
-#else
-    setFuzzyness<float>(1);
-#endif
-#if (defined(VC_MSVC) || defined(__APPLE__)) && defined(VC_IMPL_Scalar)
-    setFuzzyness<double>(2);
-#else
-    setFuzzyness<double>(1);
-#endif
-    typedef typename V::EntryType T;
-    Array<Reference<T> > reference = referenceData<T, Log2>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, ref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            ref[j] = reference.data[i + j].ref;
-        }
-        FUZZY_COMPARE(Vc::log2(x), ref) << " x = " << x << ", i = " << i;
-    }
 
-    COMPARE(Vc::log2(V::Zero()), V(my_log2(T(0))));
-    for (int i = 0; i < NDenormals; i += V::Size) {
-        V x(&Denormals<T>::data[i]);
-        V ref = apply_v(x, my_log2);
-        FUZZY_COMPARE(Vc::log2(x), ref) << ", x = " << x << ", i = " << i;
-    }
-}
-/*}}}*/
-template<typename V> void testLog10()/*{{{*/
+TEST_TYPES(V, testMax, (AllTypes)) //{{{1
 {
-    setFuzzyness<float>(2);
-    setFuzzyness<double>(2);
     typedef typename V::EntryType T;
-    Array<Reference<T> > reference = referenceData<T, Log10>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, ref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            ref[j] = reference.data[i + j].ref;
-        }
-        FUZZY_COMPARE(Vc::log10(x), ref) << " x = " << x << ", i = " << i;
-    }
-
-    COMPARE(Vc::log10(V::Zero()), V(std::log10(T(0))));
-    for (int i = 0; i < NDenormals; i += V::Size) {
-        V x(&Denormals<T>::data[i]);
-        V ref = apply_v(x, std::log10);
-        FUZZY_COMPARE(Vc::log10(x), ref) << ", x = " << x << ", i = " << i;
-    }
-}
-/*}}}*/
-template<typename Vec> void testMax()/*{{{*/
-{
-    typedef typename Vec::EntryType T;
-    VectorMemoryHelper<Vec> mem(3);
+    VectorMemoryHelper<V> mem(3);
     T *data = mem;
-    for (int i = 0; i < Vec::Size; ++i) {
+    for (size_t i = 0; i < V::Size; ++i) {
         data[i] = i;
-        data[i + Vec::Size] = Vec::Size + 1 - i;
-        data[i + 2 * Vec::Size] = std::max(data[i], data[i + Vec::Size]);
+        data[i + V::Size] = V::Size + 1 - i;
+        data[i + 2 * V::Size] = std::max(data[i], data[i + V::Size]);
     }
-    Vec a(&data[0]);
-    Vec b(&data[Vec::Size]);
-    Vec c(&data[2 * Vec::Size]);
+    V a(&data[0]);
+    V b(&data[V::Size]);
+    V c(&data[2 * V::Size]);
 
     COMPARE(Vc::max(a, b), c);
 }
-/*}}}*/
-    /*{{{*/
-#define FillHelperMemory(code) \
-    typename V::Memory data; \
-    typename V::Memory reference; \
-    for (int ii = 0; ii < V::Size; ++ii) { \
-        const T i = static_cast<T>(ii); \
-        data[ii] = i; \
-        reference[ii] = code; \
-    } do {} while (false)
-/*}}}*/
-template<typename V> void testSqrt()/*{{{*/
+
+TEST_TYPES(V, testSqrt, (RealTypes)) //{{{1
 {
-    typedef typename V::EntryType T;
-    FillHelperMemory(std::sqrt(i));
-    V a(data);
-    V b(reference);
+    V data = V::IndexesFromZero();
+    V reference = V::generate([&](int i) { return std::sqrt(data[i]); });
 
-    FUZZY_COMPARE(Vc::sqrt(a), b);
+    FUZZY_COMPARE(Vc::sqrt(data), reference);
 }
-/*}}}*/
-template<typename V> void testRSqrt()/*{{{*/
+
+TEST_TYPES(V, testRSqrt, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
     for (size_t i = 0; i < 1024 / V::Size; ++i) {
         const V x = V::Random() * T(1000);
         // RSQRTPS is documented as having a relative error <= 1.5 * 2^-12
-        VERIFY(Vc::abs(Vc::rsqrt(x) * Vc::sqrt(x) - V::One()) < static_cast<T>(std::ldexp(1.5, -12)));
-    }
-}
-/*}}}*/
-template<typename V> void testSincos()/*{{{*/
-{
-    typedef typename V::EntryType T;
-    setFuzzyness<float>(2);
-    setFuzzyness<double>(1e7);
-    Array<SincosReference<T> > reference = sincosReference<T>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, sref, cref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            sref[j] = reference.data[i + j].s;
-            cref[j] = reference.data[i + j].c;
-        }
-        V sin, cos;
-        Vc::sincos(x, &sin, &cos);
-        FUZZY_COMPARE(sin, sref) << " x = " << x << ", i = " << i;
-        FUZZY_COMPARE(cos, cref) << " x = " << x << ", i = " << i;
-        Vc::sincos(-x, &sin, &cos);
-        FUZZY_COMPARE(sin, -sref) << " x = " << -x << ", i = " << i;
-        FUZZY_COMPARE(cos, cref) << " x = " << -x << ", i = " << i;
-    }
-}
-/*}}}*/
-template<typename V> void testSin()/*{{{*/
-{
-    typedef typename V::EntryType T;
-    setFuzzyness<float>(2);
-    setFuzzyness<double>(1e7);
-    Array<SincosReference<T> > reference = sincosReference<T>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, sref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            sref[j] = reference.data[i + j].s;
-        }
-        FUZZY_COMPARE(Vc::sin(x), sref) << " x = " << x << ", i = " << i;
-        FUZZY_COMPARE(Vc::sin(-x), -sref) << " x = " << x << ", i = " << i;
-    }
-}
-/*}}}*/
-template<typename V> void testCos()/*{{{*/
-{
-    typedef typename V::EntryType T;
-    setFuzzyness<float>(2);
-    setFuzzyness<double>(1e7);
-    Array<SincosReference<T> > reference = sincosReference<T>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, cref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            cref[j] = reference.data[i + j].c;
-        }
-        FUZZY_COMPARE(Vc::cos(x), cref) << " x = " << x << ", i = " << i;
-        FUZZY_COMPARE(Vc::cos(-x), cref) << " x = " << x << ", i = " << i;
+        VERIFY(all_of(Vc::abs(Vc::rsqrt(x) * Vc::sqrt(x) - V::One()) < static_cast<T>(std::ldexp(1.5, -12))));
     }
 }
-/*}}}*/
-template<typename V> void testAsin()/*{{{*/
-{
-    typedef typename V::EntryType T;
-    setFuzzyness<float>(2);
-    setFuzzyness<double>(36);
-    Array<Reference<T> > reference = referenceData<T, Asin>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, ref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            ref[j] = reference.data[i + j].ref;
-        }
-        FUZZY_COMPARE(Vc::asin(x), ref) << " x = " << x << ", i = " << i;
-        FUZZY_COMPARE(Vc::asin(-x), -ref) << " -x = " << -x << ", i = " << i;
-    }
-}
-/*}}}*/
-const union {
-    unsigned int hex;
-    float value;
-} INF = { 0x7f800000 };
-
-#if defined(__APPLE__) && defined(VC_IMPL_Scalar)
-#define ATAN_COMPARE FUZZY_COMPARE
-#else
-#define ATAN_COMPARE COMPARE
-#endif
 
-template<typename V> void testAtan()/*{{{*/
+TEST_TYPES(V, testReciprocal, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    setFuzzyness<float>(3);
-    setFuzzyness<double>(2);
-
-    {
-        const V Pi_2 = T(Vc_buildDouble(1, 0x921fb54442d18ull,  0));
-        V nan; nan.setQnan();
-        const V inf = T(INF.value);
-
-        VERIFY(Vc::isnan(Vc::atan(nan)));
-        ATAN_COMPARE(Vc::atan(+inf), +Pi_2);
-#ifdef VC_MSVC
-#pragma warning(suppress: 4756) // overflow in constant arithmetic
-#endif
-        ATAN_COMPARE(Vc::atan(-inf), -Pi_2);
-    }
-
-    Array<Reference<T> > reference = referenceData<T, Atan>();
-    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
-        V x, ref;
-        for (int j = 0; j < V::Size; ++j) {
-            x[j] = reference.data[i + j].x;
-            ref[j] = reference.data[i + j].ref;
-        }
-        FUZZY_COMPARE(Vc::atan(x), ref) << " x = " << x << ", i = " << i;
-        FUZZY_COMPARE(Vc::atan(-x), -ref) << " -x = " << -x << ", i = " << i;
-    }
-}
-/*}}}*/
-template<typename V> void testAtan2()/*{{{*/
-{
-    typedef typename V::EntryType T;
-    setFuzzyness<float>(3);
-    setFuzzyness<double>(2);
-
-    {
-        const V Pi   = T(Vc_buildDouble(1, 0x921fb54442d18ull,  1));
-        const V Pi_2 = T(Vc_buildDouble(1, 0x921fb54442d18ull,  0));
-        V nan; nan.setQnan();
-        const V inf = T(INF.value);
-
-        // If y is +0 (-0) and x is less than 0, +pi (-pi) is returned.
-        ATAN_COMPARE(Vc::atan2(V(T(+0.)), V(T(-3.))), +Pi);
-        ATAN_COMPARE(Vc::atan2(V(T(-0.)), V(T(-3.))), -Pi);
-        // If y is +0 (-0) and x is greater than 0, +0 (-0) is returned.
-        COMPARE(Vc::atan2(V(T(+0.)), V(T(+3.))), V(T(+0.)));
-        VERIFY(!Vc::atan2(V(T(+0.)), V(T(+3.))).isNegative());
-        COMPARE(Vc::atan2(V(T(-0.)), V(T(+3.))), V(T(-0.)));
-        VERIFY (Vc::atan2(V(T(-0.)), V(T(+3.))).isNegative());
-        // If y is less than 0 and x is +0 or -0, -pi/2 is returned.
-        COMPARE(Vc::atan2(V(T(-3.)), V(T(+0.))), -Pi_2);
-        COMPARE(Vc::atan2(V(T(-3.)), V(T(-0.))), -Pi_2);
-        // If y is greater than 0 and x is +0 or -0, pi/2 is returned.
-        COMPARE(Vc::atan2(V(T(+3.)), V(T(+0.))), +Pi_2);
-        COMPARE(Vc::atan2(V(T(+3.)), V(T(-0.))), +Pi_2);
-        // If either x or y is NaN, a NaN is returned.
-        VERIFY(Vc::isnan(Vc::atan2(nan, V(T(3.)))));
-        VERIFY(Vc::isnan(Vc::atan2(V(T(3.)), nan)));
-        VERIFY(Vc::isnan(Vc::atan2(nan, nan)));
-        // If y is +0 (-0) and x is -0, +pi (-pi) is returned.
-        ATAN_COMPARE(Vc::atan2(V(T(+0.)), V(T(-0.))), +Pi);
-        ATAN_COMPARE(Vc::atan2(V(T(-0.)), V(T(-0.))), -Pi);
-        // If y is +0 (-0) and x is +0, +0 (-0) is returned.
-        COMPARE(Vc::atan2(V(T(+0.)), V(T(+0.))), V(T(+0.)));
-        COMPARE(Vc::atan2(V(T(-0.)), V(T(+0.))), V(T(-0.)));
-        VERIFY(!Vc::atan2(V(T(+0.)), V(T(+0.))).isNegative());
-        VERIFY( Vc::atan2(V(T(-0.)), V(T(+0.))).isNegative());
-        // If y is a finite value greater (less) than 0, and x is negative infinity, +pi (-pi) is returned.
-        ATAN_COMPARE(Vc::atan2(V(T(+1.)), -inf), +Pi);
-        ATAN_COMPARE(Vc::atan2(V(T(-1.)), -inf), -Pi);
-        // If y is a finite value greater (less) than 0, and x is positive infinity, +0 (-0) is returned.
-        COMPARE(Vc::atan2(V(T(+3.)), +inf), V(T(+0.)));
-        VERIFY(!Vc::atan2(V(T(+3.)), +inf).isNegative());
-        COMPARE(Vc::atan2(V(T(-3.)), +inf), V(T(-0.)));
-        VERIFY (Vc::atan2(V(T(-3.)), +inf).isNegative());
-        // If y is positive infinity (negative infinity), and x is finite, pi/2 (-pi/2) is returned.
-        COMPARE(Vc::atan2(+inf, V(T(+3.))), +Pi_2);
-        COMPARE(Vc::atan2(-inf, V(T(+3.))), -Pi_2);
-        COMPARE(Vc::atan2(+inf, V(T(-3.))), +Pi_2);
-        COMPARE(Vc::atan2(-inf, V(T(-3.))), -Pi_2);
-#ifndef _WIN32 // the Microsoft implementation of atan2 fails this test
-        const V Pi_4 = T(Vc_buildDouble(1, 0x921fb54442d18ull, -1));
-        // If y is positive infinity (negative infinity) and x is negative	infinity, +3*pi/4 (-3*pi/4) is returned.
-        COMPARE(Vc::atan2(+inf, -inf), T(+3.) * Pi_4);
-        COMPARE(Vc::atan2(-inf, -inf), T(-3.) * Pi_4);
-        // If y is positive infinity (negative infinity) and x is positive infinity, +pi/4 (-pi/4) is returned.
-        COMPARE(Vc::atan2(+inf, +inf), +Pi_4);
-        COMPARE(Vc::atan2(-inf, +inf), -Pi_4);
-#endif
-    }
-
-    for (int xoffset = -100; xoffset < 54613; xoffset += 47 * V::Size) {
-        for (int yoffset = -100; yoffset < 54613; yoffset += 47 * V::Size) {
-            FillHelperMemory(std::atan2((i + xoffset) * T(0.15), (i + yoffset) * T(0.15)));
-            const V a(data);
-            const V b(reference);
-
-            const V x = (a + xoffset) * T(0.15);
-            const V y = (a + yoffset) * T(0.15);
-            FUZZY_COMPARE(Vc::atan2(x, y), b) << ", x = " << x << ", y = " << y;
-        }
-    }
-}
-/*}}}*/
-template<typename Vec> void testReciprocal()/*{{{*/
-{
-    typedef typename Vec::EntryType T;
-    setFuzzyness<float>(1.258295e+07);
-    setFuzzyness<double>(0);
+    UnitTest::setFuzzyness<float>(1.258295e+07);
+    UnitTest::setFuzzyness<double>(0);
     const T one = 1;
     for (int offset = -1000; offset < 1000; offset += 10) {
         const T scale = T(0.1);
-        typename Vec::Memory data;
-        typename Vec::Memory reference;
-        for (int ii = 0; ii < Vec::Size; ++ii) {
+        V data;
+        V reference;
+        for (size_t ii = 0; ii < V::Size; ++ii) {
             const T i = static_cast<T>(ii);
             data[ii] = i;
             T tmp = (i + offset) * scale;
             reference[ii] = one / tmp;
         }
-        Vec a(data);
-        Vec b(reference);
 
-        FUZZY_COMPARE(Vc::reciprocal((a + offset) * scale), b);
+        FUZZY_COMPARE(Vc::reciprocal((data + offset) * scale), reference);
     }
 }
-/*}}}*/
-template<typename V> void isNegative()/*{{{*/
+
+TEST_TYPES(V, isNegative, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    VERIFY(V::One().isNegative().isEmpty());
-    VERIFY(V::Zero().isNegative().isEmpty());
-    VERIFY((-V::One()).isNegative().isFull());
-    VERIFY(V(T(-0.)).isNegative().isFull());
+    VERIFY(isnegative(V::One()).isEmpty());
+    VERIFY(isnegative(V::Zero()).isEmpty());
+    VERIFY(isnegative((-V::One())).isFull());
+    VERIFY(isnegative(V(T(-0.))).isFull());
 }
-/*}}}*/
-template<typename Vec> void testInf()/*{{{*/
+
+TEST_TYPES(V, testInf, (RealTypes)) //{{{1
 {
-    typedef typename Vec::EntryType T;
+    typedef typename V::EntryType T;
     const T one = 1;
-    const Vec zero(Zero);
-    VERIFY(Vc::isfinite(zero));
-    VERIFY(Vc::isfinite(Vec(one)));
-    VERIFY(!Vc::isfinite(one / zero));
+    const V zero(Zero);
+    const V inf = one / zero;
+    V nan;
+    nan.setQnan();
+
+    VERIFY(all_of(Vc::isfinite(zero)));
+    VERIFY(all_of(Vc::isfinite(V(one))));
+    VERIFY(none_of(Vc::isfinite(inf)));
+    VERIFY(none_of(Vc::isfinite(nan)));
+
+    VERIFY(none_of(Vc::isinf(zero)));
+    VERIFY(none_of(Vc::isinf(V(one))));
+    VERIFY(all_of(Vc::isinf(inf)));
+    VERIFY(none_of(Vc::isinf(nan)));
 }
-/*}}}*/
-template<typename Vec> void testNaN()/*{{{*/
+
+TEST_TYPES(V, testNaN, (RealTypes)) //{{{1
 {
-    typedef typename Vec::EntryType T;
-    typedef typename Vec::IndexType I;
-    typedef typename Vec::Mask M;
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType I;
+    typedef typename V::Mask M;
     const T one = 1;
-    const Vec zero(Zero);
-    VERIFY(!Vc::isnan(zero));
-    VERIFY(!Vc::isnan(Vec(one)));
-    const Vec inf = one / zero;
-    VERIFY(Vc::isnan(Vec(inf * zero)));
-    Vec nan = Vec::Zero();
-    const M mask(I::IndexesFromZero() == I::Zero());
+    const V zero(Zero);
+    VERIFY(none_of(Vc::isnan(zero)));
+    VERIFY(none_of(Vc::isnan(V(one))));
+    const V inf = one / zero;
+    VERIFY(all_of(Vc::isnan(V(inf * zero))));
+    V nan = V::Zero();
+    const M mask = simd_cast<M>(I::IndexesFromZero() == I::Zero());
     nan.setQnan(mask);
     COMPARE(Vc::isnan(nan), mask);
     nan.setQnan();
-    VERIFY(Vc::isnan(nan));
+    VERIFY(all_of(Vc::isnan(nan)));
 }
-/*}}}*/
-template<typename Vec> void testRound()/*{{{*/
+
+TEST_TYPES(V, testRound, (RealTypes)) //{{{1
 {
-    typedef typename Vec::EntryType T;
+    typedef typename V::EntryType T;
     enum {
-        Count = (16 + Vec::Size) / Vec::Size
+        Count = (16 + V::Size) / V::Size
     };
-    VectorMemoryHelper<Vec> mem1(Count);
-    VectorMemoryHelper<Vec> mem2(Count);
+    VectorMemoryHelper<V> mem1(Count);
+    VectorMemoryHelper<V> mem2(Count);
     T *data = mem1;
     T *reference = mem2;
-    for (int i = 0; i < Count * Vec::Size; ++i) {
+    for (size_t i = 0; i < Count * V::Size; ++i) {
         data[i] = i * 0.25 - 2.0;
         reference[i] = std::floor(i * 0.25 - 2.0 + 0.5);
         if (i % 8 == 2) {
@@ -636,93 +238,18 @@
     }
     //std::cout << std::endl;
     for (int i = 0; i < Count; ++i) {
-        const Vec a(&data[i * Vec::Size]);
-        const Vec ref(&reference[i * Vec::Size]);
+        const V a(&data[i * V::Size]);
+        const V ref(&reference[i * V::Size]);
         //std::cout << a << ref << std::endl;
         COMPARE(Vc::round(a), ref);
     }
 }
-/*}}}*/
-template<typename Vec> void testReduceMin()/*{{{*/
-{
-    typedef typename Vec::EntryType T;
-    const T one = 1;
-    VectorMemoryHelper<Vec> mem(Vec::Size);
-    T *data = mem;
-    for (int i = 0; i < Vec::Size * Vec::Size; ++i) {
-        data[i] = i % (Vec::Size + 1) + one;
-    }
-    for (int i = 0; i < Vec::Size; ++i, data += Vec::Size) {
-        const Vec a(&data[0]);
-        //std::cout << a << std::endl;
-        COMPARE(a.min(), one);
-    }
-}
-/*}}}*/
-template<typename Vec> void testReduceMax()/*{{{*/
-{
-    typedef typename Vec::EntryType T;
-    const T max = Vec::Size + 1;
-    VectorMemoryHelper<Vec> mem(Vec::Size);
-    T *data = mem;
-    for (int i = 0; i < Vec::Size * Vec::Size; ++i) {
-        data[i] = (i + Vec::Size) % (Vec::Size + 1) + 1;
-    }
-    for (int i = 0; i < Vec::Size; ++i, data += Vec::Size) {
-        const Vec a(&data[0]);
-        //std::cout << a << std::endl;
-        COMPARE(a.max(), max);
-    }
-}
-/*}}}*/
-template<typename Vec> void testReduceProduct()/*{{{*/
-{
-    enum {
-        Max = Vec::Size > 8 ? Vec::Size / 2 : Vec::Size
-    };
-    typedef typename Vec::EntryType T;
-    int _product = 1;
-    for (int i = 1; i < Vec::Size; ++i) {
-        _product *= (i % Max) + 1;
-    }
-    const T product = _product;
-    VectorMemoryHelper<Vec> mem(Vec::Size);
-    T *data = mem;
-    for (int i = 0; i < Vec::Size * Vec::Size; ++i) {
-        data[i] = ((i + (i / Vec::Size)) % Max) + 1;
-    }
-    for (int i = 0; i < Vec::Size; ++i, data += Vec::Size) {
-        const Vec a(&data[0]);
-        //std::cout << a << std::endl;
-        COMPARE(a.product(), product);
-    }
-}
-/*}}}*/
-template<typename Vec> void testReduceSum()/*{{{*/
-{
-    typedef typename Vec::EntryType T;
-    int _sum = 1;
-    for (int i = 2; i <= Vec::Size; ++i) {
-        _sum += i;
-    }
-    const T sum = _sum;
-    VectorMemoryHelper<Vec> mem(Vec::Size);
-    T *data = mem;
-    for (int i = 0; i < Vec::Size * Vec::Size; ++i) {
-        data[i] = (i + i / Vec::Size) % Vec::Size + 1;
-    }
-    for (int i = 0; i < Vec::Size; ++i, data += Vec::Size) {
-        const Vec a(&data[0]);
-        //std::cout << a << std::endl;
-        COMPARE(a.sum(), sum);
-    }
-}
-/*}}}*/
-template<typename V> void testExponent()/*{{{*/
+
+TEST_TYPES(V, testExponent, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    Vc::Memory<V, 32> input;
-    Vc::Memory<V, 32> expected;
+    Vc::array<T, 32> input;
+    Vc::array<T, 32> expected;
     input[ 0] = T(0.25); expected[ 0] = T(-2);
     input[ 1] = T(   1); expected[ 1] = T( 0);
     input[ 2] = T(   2); expected[ 2] = T( 1);
@@ -755,21 +282,20 @@
     input[29] = T(  29); expected[29] = T( 4);
     input[30] = T(  32); expected[30] = T( 5);
     input[31] = T(  31); expected[31] = T( 4);
-    for (size_t i = 0; i < input.vectorsCount(); ++i) {
-        COMPARE(V(input.vector(i)).exponent(), V(expected.vector(i)));
+    for (size_t i = 0; i <= input.size() - V::size(); ++i) {
+        COMPARE(exponent(V(&input[i])), V(&expected[i]));
     }
 }
-/*}}}*/
+
 template<typename T> struct _ExponentVector { typedef int_v Type; };
-template<> struct _ExponentVector<sfloat_v> { typedef short_v Type; };
 
-template<typename V> void testFrexp()/*{{{*/
+TEST_TYPES(V, testFrexp, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    typedef typename _ExponentVector<V>::Type ExpV;
-    Vc::Memory<V, 32> input;
-    Vc::Memory<V, 32> expectedFraction;
-    Vc::Memory<ExpV, 32> expectedExponent;
+    using ExpV = typename V::IndexType;
+    Vc::array<T, 33> input;
+    Vc::array<T, 33> expectedFraction;
+    Vc::array<int, 33> expectedExponent;
     input[ 0] = T(0.25); expectedFraction[ 0] = T(.5     ); expectedExponent[ 0] = -1;
     input[ 1] = T(   1); expectedFraction[ 1] = T(.5     ); expectedExponent[ 1] =  1;
     input[ 2] = T(   0); expectedFraction[ 2] = T(0.     ); expectedExponent[ 2] =  0;
@@ -802,24 +328,22 @@
     input[29] = T(  29); expectedFraction[29] = T(29./32.); expectedExponent[29] =  5;
     input[30] = T(  32); expectedFraction[30] = T(32./64.); expectedExponent[30] =  6;
     input[31] = T(  31); expectedFraction[31] = T(31./32.); expectedExponent[31] =  5;
-    for (size_t i = 0; i < input.vectorsCount(); ++i) {
-        const V v = input.vector(i);
+    input[32] = T( -0.); expectedFraction[32] = T(-0.    ); expectedExponent[32] =  0;
+    for (size_t i = 0; i <= 33 - V::size(); ++i) {
+        const V v(&input[i]);
         ExpV exp;
-        COMPARE(frexp(v, &exp), V(expectedFraction.vector(i)));
-        if (V::Size * 2 == ExpV::Size) {
-            for (size_t j = 0; j < V::Size; ++j) {
-                COMPARE(exp[j * 2], expectedExponent[i * V::Size + j]);
-            }
-        } else {
-            COMPARE(exp, ExpV(expectedExponent.vector(i)));
-        }
+        const V fraction = frexp(v, &exp);
+        COMPARE(fraction, V(&expectedFraction[i]))
+            << ", v = " << v << ", delta: " << fraction - V(&expectedFraction[i]);
+        COMPARE(exp, ExpV(&expectedExponent[i]))
+            << "\ninput: " << v << ", fraction: " << fraction << ", i: " << i;
     }
 }
-/*}}}*/
-template<typename V> void testLdexp()/*{{{*/
+
+TEST_TYPES(V, testLdexp, (RealTypes)) //{{{1
 {
     typedef typename V::EntryType T;
-    typedef typename _ExponentVector<V>::Type ExpV;
+    using ExpV = typename V::IndexType;
     for (size_t i = 0; i < 1024 / V::Size; ++i) {
         const V v = (V::Random() - T(0.5)) * T(1000);
         ExpV e;
@@ -827,131 +351,19 @@
         COMPARE(ldexp(m, e), v) << ", m = " << m << ", e = " << e;
     }
 }
-/*}}}*/
-#include "ulp.h"
-template<typename V> void testUlpDiff()/*{{{*/
-{
-    typedef typename V::EntryType T;
 
-    COMPARE(ulpDiffToReference(V::Zero(), V::Zero()), V::Zero());
-    COMPARE(ulpDiffToReference(std::numeric_limits<V>::min(), V::Zero()), V::One());
-    COMPARE(ulpDiffToReference(V::Zero(), std::numeric_limits<V>::min()), V::One());
-    for (size_t count = 0; count < 1024 / V::Size; ++count) {
-        const V base = (V::Random() - T(0.5)) * T(1000);
-        typename _Ulp_ExponentVector<V>::Type exp;
-        Vc::frexp(base, &exp);
-        const V eps = ldexp(V(std::numeric_limits<T>::epsilon()), exp - 1);
-        //std::cout << base << ", " << exp << ", " << eps << std::endl;
-        for (int i = -10000; i <= 10000; ++i) {
-            const V i_v = V(T(i));
-            const V diff = base + i_v * eps;
-
-            // if diff and base have a different exponent then ulpDiffToReference has an uncertainty
-            // of +/-1
-            const V ulpDifference = ulpDiffToReference(diff, base);
-            const V expectedDifference = Vc::abs(i_v);
-            const V maxUncertainty = Vc::abs(abs(diff).exponent() - abs(base).exponent());
-
-            VERIFY(Vc::abs(ulpDifference - expectedDifference) <= maxUncertainty)
-                << ", base = " << base << ", epsilon = " << eps << ", diff = " << diff;
-            for (int k = 0; k < V::Size; ++k) {
-                VERIFY(std::abs(ulpDifference[k] - expectedDifference[k]) <= maxUncertainty[k]);
-            }
-        }
-    }
-}/*}}}*/
-
-int main(int argc, char **argv)/*{{{*/
+#include "ulp.h"
+// copysign {{{1
+TEST_TYPES(V, testCopysign, (RealTypes))
 {
-    initTest(argc, argv);
-
-    Denormals<float>::data = Vc::malloc<float, Vc::AlignOnVector>(NDenormals);/*{{{*/
-    Denormals<float>::data[0] = std::numeric_limits<float>::denorm_min();
-    for (int i = 1; i < NDenormals; ++i) {
-        Denormals<float>::data[i] = Denormals<float>::data[i - 1] * 2.173f;
-    }
-    Denormals<double>::data = Vc::malloc<double, Vc::AlignOnVector>(NDenormals);
-    Denormals<double>::data[0] = std::numeric_limits<double>::denorm_min();
-    for (int i = 1; i < NDenormals; ++i) {
-        Denormals<double>::data[i] = Denormals<double>::data[i - 1] * 2.173;
-    }/*}}}*/
-
-    testRealTypes(isNegative);
-    testRealTypes(testFrexp);
-    testRealTypes(testLdexp);
-
-    runTest(testAbs<int_v>);
-    runTest(testAbs<float_v>);
-    runTest(testAbs<double_v>);
-    runTest(testAbs<short_v>);
-    runTest(testAbs<sfloat_v>);
-
-    testRealTypes(testUlpDiff);
-
-    testRealTypes(testTrunc);
-    testRealTypes(testFloor);
-    testRealTypes(testCeil);
-    testRealTypes(testExp);
-    testRealTypes(testLog);
-    testRealTypes(testLog2);
-    testRealTypes(testLog10);
-
-    runTest(testMax<int_v>);
-    runTest(testMax<uint_v>);
-    runTest(testMax<float_v>);
-    runTest(testMax<double_v>);
-    runTest(testMax<short_v>);
-    runTest(testMax<ushort_v>);
-    runTest(testMax<sfloat_v>);
-
-    testRealTypes(testSqrt);
-    testRealTypes(testRSqrt);
-    testRealTypes(testSin);
-    testRealTypes(testCos);
-    testRealTypes(testAsin);
-    testRealTypes(testAtan);
-    testRealTypes(testAtan2);
-    testRealTypes(testReciprocal);
-    testRealTypes(testInf);
-    testRealTypes(testNaN);
-    testRealTypes(testRound);
-
-    runTest(testReduceMin<float_v>);
-    runTest(testReduceMin<sfloat_v>);
-    runTest(testReduceMin<double_v>);
-    runTest(testReduceMin<int_v>);
-    runTest(testReduceMin<uint_v>);
-    runTest(testReduceMin<short_v>);
-    runTest(testReduceMin<ushort_v>);
-
-    runTest(testReduceMax<float_v>);
-    runTest(testReduceMax<sfloat_v>);
-    runTest(testReduceMax<double_v>);
-    runTest(testReduceMax<int_v>);
-    runTest(testReduceMax<uint_v>);
-    runTest(testReduceMax<short_v>);
-    runTest(testReduceMax<ushort_v>);
-
-    runTest(testReduceProduct<float_v>);
-    runTest(testReduceProduct<sfloat_v>);
-    runTest(testReduceProduct<double_v>);
-    runTest(testReduceProduct<int_v>);
-    runTest(testReduceProduct<uint_v>);
-    runTest(testReduceProduct<short_v>);
-    runTest(testReduceProduct<ushort_v>);
-
-    runTest(testReduceSum<float_v>);
-    runTest(testReduceSum<sfloat_v>);
-    runTest(testReduceSum<double_v>);
-    runTest(testReduceSum<int_v>);
-    runTest(testReduceSum<uint_v>);
-    runTest(testReduceSum<short_v>);
-    runTest(testReduceSum<ushort_v>);
-
-    testRealTypes(testSincos);
-    testRealTypes(testExponent);
+    const V x = V::Random();
+    const V y = -x;
+    const V z = copysign(x, y);
+    COMPARE(abs(x), abs(z));
+    COMPARE(y > 0, z > 0);
+    COMPARE(z, V::generate([&](int i) { return std::copysign(x[i], y[i]); }));
+}
 
-    return 0;
-}/*}}}*/
+//}}}1
 
 // vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/mathreference.h vc-1.3.0/tests/mathreference.h
--- vc-0.7.4/tests/mathreference.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/mathreference.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,263 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include <utility>
+#include <cstdio>
+
+template<typename T> struct SincosReference //{{{1
+{
+    T x, s, c;
+};
+template<typename T> struct Reference
+{
+    T x, ref;
+};
+
+template<typename T> struct Array
+{
+    size_t size;
+    const T *data;
+    Array() : size(0), data(0) {}
+    Array(size_t s, const T *p) : size(s), data(p) {}
+};
+template<typename T> struct StaticDeleter
+{
+    const T *ptr;
+    StaticDeleter(const T *p) : ptr(p) {}
+    ~StaticDeleter() { delete[] ptr; }
+};
+
+enum Function {
+    Sincos, Atan, Asin, Acos, Log, Log2, Log10
+};
+template<typename T, Function F> static inline const char *filename();
+template<> inline const char *filename<float , Sincos>() { return "reference-sincos-sp.dat"; }
+template<> inline const char *filename<double, Sincos>() { return "reference-sincos-dp.dat"; }
+template<> inline const char *filename<float , Atan  >() { return "reference-atan-sp.dat"; }
+template<> inline const char *filename<double, Atan  >() { return "reference-atan-dp.dat"; }
+template<> inline const char *filename<float , Asin  >() { return "reference-asin-sp.dat"; }
+template<> inline const char *filename<double, Asin  >() { return "reference-asin-dp.dat"; }
+// template<> inline const char *filename<float , Acos  >() { return "reference-acos-sp.dat"; }
+// template<> inline const char *filename<double, Acos  >() { return "reference-acos-dp.dat"; }
+template<> inline const char *filename<float , Log   >() { return "reference-ln-sp.dat"; }
+template<> inline const char *filename<double, Log   >() { return "reference-ln-dp.dat"; }
+template<> inline const char *filename<float , Log2  >() { return "reference-log2-sp.dat"; }
+template<> inline const char *filename<double, Log2  >() { return "reference-log2-dp.dat"; }
+template<> inline const char *filename<float , Log10 >() { return "reference-log10-sp.dat"; }
+template<> inline const char *filename<double, Log10 >() { return "reference-log10-dp.dat"; }
+
+#ifdef Vc_IMPL_MIC
+extern "C" {
+extern const Reference<double> _binary_reference_acos_dp_dat_start;
+extern const Reference<double> _binary_reference_acos_dp_dat_end;
+extern const Reference<float > _binary_reference_acos_sp_dat_start;
+extern const Reference<float > _binary_reference_acos_sp_dat_end;
+extern const Reference<double> _binary_reference_asin_dp_dat_start;
+extern const Reference<double> _binary_reference_asin_dp_dat_end;
+extern const Reference<float > _binary_reference_asin_sp_dat_start;
+extern const Reference<float > _binary_reference_asin_sp_dat_end;
+extern const Reference<double> _binary_reference_atan_dp_dat_start;
+extern const Reference<double> _binary_reference_atan_dp_dat_end;
+extern const Reference<float > _binary_reference_atan_sp_dat_start;
+extern const Reference<float > _binary_reference_atan_sp_dat_end;
+extern const Reference<double> _binary_reference_ln_dp_dat_start;
+extern const Reference<double> _binary_reference_ln_dp_dat_end;
+extern const Reference<float > _binary_reference_ln_sp_dat_start;
+extern const Reference<float > _binary_reference_ln_sp_dat_end;
+extern const Reference<double> _binary_reference_log10_dp_dat_start;
+extern const Reference<double> _binary_reference_log10_dp_dat_end;
+extern const Reference<float > _binary_reference_log10_sp_dat_start;
+extern const Reference<float > _binary_reference_log10_sp_dat_end;
+extern const Reference<double> _binary_reference_log2_dp_dat_start;
+extern const Reference<double> _binary_reference_log2_dp_dat_end;
+extern const Reference<float > _binary_reference_log2_sp_dat_start;
+extern const Reference<float > _binary_reference_log2_sp_dat_end;
+extern const SincosReference<double> _binary_reference_sincos_dp_dat_start;
+extern const SincosReference<double> _binary_reference_sincos_dp_dat_end;
+extern const SincosReference<float > _binary_reference_sincos_sp_dat_start;
+extern const SincosReference<float > _binary_reference_sincos_sp_dat_end;
+}
+
+template <typename T, Function F>
+inline std::pair<const T *, const T *> binary();
+template <>
+inline std::pair<const SincosReference<float> *, const SincosReference<float> *>
+binary<SincosReference<float>, Sincos>()
+{
+    return std::make_pair(&_binary_reference_sincos_sp_dat_start,
+                          &_binary_reference_sincos_sp_dat_end);
+}
+template <>
+inline std::pair<const SincosReference<double> *,
+                 const SincosReference<double> *>
+binary<SincosReference<double>, Sincos>()
+{
+    return std::make_pair(&_binary_reference_sincos_dp_dat_start,
+                          &_binary_reference_sincos_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Atan>()
+{
+    return std::make_pair(&_binary_reference_atan_sp_dat_start,
+                          &_binary_reference_atan_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Atan>()
+{
+    return std::make_pair(&_binary_reference_atan_dp_dat_start,
+                          &_binary_reference_atan_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Asin>()
+{
+    return std::make_pair(&_binary_reference_asin_sp_dat_start,
+                          &_binary_reference_asin_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Asin>()
+{
+    return std::make_pair(&_binary_reference_asin_dp_dat_start,
+                          &_binary_reference_asin_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Acos>()
+{
+    return std::make_pair(&_binary_reference_acos_sp_dat_start,
+                          &_binary_reference_acos_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Acos>()
+{
+    return std::make_pair(&_binary_reference_acos_dp_dat_start,
+                          &_binary_reference_acos_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Log>()
+{
+    return std::make_pair(&_binary_reference_ln_sp_dat_start,
+                          &_binary_reference_ln_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Log>()
+{
+    return std::make_pair(&_binary_reference_ln_dp_dat_start,
+                          &_binary_reference_ln_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Log2>()
+{
+    return std::make_pair(&_binary_reference_log2_sp_dat_start,
+                          &_binary_reference_log2_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Log2>()
+{
+    return std::make_pair(&_binary_reference_log2_dp_dat_start,
+                          &_binary_reference_log2_dp_dat_end);
+}
+template <>
+inline std::pair<const Reference<float> *, const Reference<float> *>
+binary<Reference<float>, Log10>()
+{
+    return std::make_pair(&_binary_reference_log10_sp_dat_start,
+                          &_binary_reference_log10_sp_dat_end);
+}
+template <>
+inline std::pair<const Reference<double> *, const Reference<double> *>
+binary<Reference<double>, Log10>()
+{
+    return std::make_pair(&_binary_reference_log10_dp_dat_start,
+                          &_binary_reference_log10_dp_dat_end);
+}
+#endif
+
+template<typename T>
+static Array<SincosReference<T> > sincosReference()
+{
+#ifdef Vc_IMPL_MIC
+    const auto range = binary<SincosReference<T>, Sincos>();
+    return {range.second - range.first, range.first};
+#else
+    static Array<SincosReference<T> > data;
+    if (data.data == 0) {
+        FILE *file = std::fopen(filename<T, Sincos>(), "rb");
+        if (file) {
+            std::fseek(file, 0, SEEK_END);
+            const size_t size = std::ftell(file) / sizeof(SincosReference<T>);
+            std::rewind(file);
+            auto mem = new SincosReference<T>[size];
+            static StaticDeleter<SincosReference<T> > _cleanup(data.data);
+            data.size = std::fread(mem, sizeof(SincosReference<T>), size, file);
+            data.data = mem;
+            std::fclose(file);
+        } else {
+            FAIL() << "the reference data " << filename<T, Sincos>() << " does not exist in the current working directory.";
+        }
+    }
+    return data;
+#endif
+}
+
+template<typename T, Function Fun>
+static Array<Reference<T> > referenceData()
+{
+#ifdef Vc_IMPL_MIC
+    const auto range = binary<Reference<T>, Fun>();
+    return {range.second - range.first, range.first};
+#else
+    static Array<Reference<T> > data;
+    if (data.data == 0) {
+        FILE *file = std::fopen(filename<T, Fun>(), "rb");
+        if (file) {
+            std::fseek(file, 0, SEEK_END);
+            const size_t size = std::ftell(file) / sizeof(Reference<T>);
+            std::rewind(file);
+            auto mem = new Reference<T>[size];
+            static StaticDeleter<Reference<T> > _cleanup(data.data);
+            data.size = std::fread(mem, sizeof(Reference<T>), size, file);
+            data.data = mem;
+            std::fclose(file);
+        } else {
+            FAIL() << "the reference data " << filename<T, Fun>() << " does not exist in the current working directory.";
+        }
+    }
+    return data;
+#endif
+}
+
+//}}}1
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/memory.cpp vc-1.3.0/tests/memory.cpp
--- vc-0.7.4/tests/memory.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/memory.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,21 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
 
@@ -77,8 +85,8 @@
     }
     for (size_t i = 0; i < Size; ++i) {
         for (size_t j = 0; j < Size; ++j) {
-            COMPARE(m[i][j], T(x + i + j));
-            COMPARE(m2[i][j], T(x + i + j));
+            COMPARE(m[i][j], T(x + i + j)) << i << ", j = " << j;
+            COMPARE(m2[i][j], T(x + i + j)) << i << ", j = " << j;
         }
     }
     for (size_t i = 0; i < Size; ++i) {
@@ -97,12 +105,12 @@
 
 template<typename V, unsigned int Size> struct TestVectors { static void test()
 {
-    const V startX(V::IndexType::IndexesFromZero() + Size);
+    const V startX = V::IndexesFromZero() + Size;
     Memory<V, Size> m;
     const Memory<V, Size> &m2 = m;
     Memory<V> m3(Size);
     V x = startX;
-    for (unsigned int i = 0; i < m.vectorsCount(); ++i, x += V::Size) {
+    for (unsigned int i = 0; i < m.vectorsCount(); ++i, x += int(V::size())) {
         m.vector(i) = x;
         m3.vector(i) = x;
     }
@@ -112,7 +120,7 @@
         COMPARE(V(m.vector(i)), x);
         COMPARE(V(m2.vector(i)), x);
         COMPARE(V(m3.vector(i)), x);
-        for (int shift = 0; shift < V::Size; ++shift, ++x) {
+        for (size_t shift = 0; shift < V::Size; ++shift, ++x) {
             COMPARE(V(m.vector(i, shift)), x);
             COMPARE(V(m2.vector(i, shift)), x);
             COMPARE(V(m3.vector(i, shift)), x);
@@ -125,38 +133,38 @@
 
 template<typename V, unsigned int Size> struct TestVectors2D { static void test()
 {
-    const V startX(V::IndexType::IndexesFromZero() + Size);
+    const V startX = V::IndexesFromZero() + Size;
     Memory<V, Size, Size> m;
     const Memory<V, Size, Size> &m2 = m;
     V x = startX;
-    for (size_t i = 0; i < m.rowsCount(); ++i, x += V::Size) {
-        Memory<V, Size> &mrow = m[i];
-        for (size_t j = 0; j < mrow.vectorsCount(); ++j, x += V::Size) {
+    for (size_t i = 0; i < m.rowsCount(); ++i, x += int(V::size())) {
+        auto &mrow = m[i];
+        for (size_t j = 0; j < mrow.vectorsCount(); ++j, x += int(V::size())) {
             mrow.vector(j) = x;
         }
     }
     x = startX;
-    for (size_t i = 0; i < m.rowsCount(); ++i, x += V::Size) {
-        Memory<V, Size> &mrow = m[i];
-        const Memory<V, Size> &m2row = m2[i];
+    for (size_t i = 0; i < m.rowsCount(); ++i, x += int(V::size())) {
+        auto &mrow = m[i];
+        const auto &m2row = m2[i];
         size_t j;
         for (j = 0; j < mrow.vectorsCount() - 1; ++j) {
             COMPARE(V(mrow.vector(j)), x);
             COMPARE(V(m2row.vector(j)), x);
-            for (int shift = 0; shift < V::Size; ++shift, ++x) {
+            for (size_t shift = 0; shift < V::Size; ++shift, ++x) {
                 COMPARE(V(mrow.vector(j, shift)), x);
                 COMPARE(V(m2row.vector(j, shift)), x);
             }
         }
         COMPARE(V(mrow.vector(j)), x) << i << " " << j;
         COMPARE(V(m2row.vector(j)), x);
-        x += V::Size;
+        x += int(V::size());
     }
 }};
 
 template<typename V, unsigned int Size> struct TestVectorReorganization { static void test()
 {
-    typename V::Memory init;
+    Vc::Memory<V, V::Size> init;
     for (unsigned int i = 0; i < V::Size; ++i) {
         init[i] = i;
     }
@@ -166,14 +174,14 @@
     for (unsigned int i = 0; i < m.vectorsCount(); ++i) {
         m.vector(i) = x;
         m3.vector(i) = x;
-        x += V::Size;
+        x += int(V::size());
     }
     ///////////////////////////////////////////////////////////////////////////
     x = V(init);
     for (unsigned int i = 0; i < m.vectorsCount(); ++i) {
         COMPARE(V(m.vector(i)), x);
         COMPARE(V(m3.vector(i)), x);
-        x += V::Size;
+        x += int(V::size());
     }
     ///////////////////////////////////////////////////////////////////////////
     x = V(init);
@@ -202,32 +210,20 @@
     }
 }};
 
-template<typename V> void testEntries()
-{
-    TestWrapper<V, 128, TestEntries>::run();
-}
+TEST_TYPES(V, testEntries, (ALL_VECTORS)) { TestWrapper<V, 128, TestEntries>::run(); }
 
-template<typename V> void testEntries2D()
-{
-    TestWrapper<V, 32, TestEntries2D>::run();
-}
+TEST_TYPES(V, testEntries2D, (ALL_VECTORS)) { TestWrapper<V, 32, TestEntries2D>::run(); }
 
-template<typename V> void testVectors()
-{
-    TestWrapper<V, 128, TestVectors>::run();
-}
+TEST_TYPES(V, testVectors, (ALL_VECTORS)) { TestWrapper<V, 128, TestVectors>::run(); }
 
-template<typename V> void testVectors2D()
-{
-    TestWrapper<V, 32, TestVectors2D>::run();
-}
+TEST_TYPES(V, testVectors2D, (ALL_VECTORS)) { TestWrapper<V, 32, TestVectors2D>::run(); }
 
-template<typename V> void testVectorReorganization()
+TEST_TYPES(V, testVectorReorganization, (ALL_VECTORS))
 {
     TestWrapper<V, 128, TestVectorReorganization>::run();
 }
 
-template<typename V> void memoryOperators()
+TEST_TYPES(V, memoryOperators, (ALL_VECTORS))
 {
     Memory<V, 129> m1, m2;
     m1.setZero();
@@ -266,7 +262,7 @@
     VERIFY(m1 == m2);
 }
 
-template<typename V> void testCCtor()
+TEST_TYPES(V, testCCtor, (ALL_VECTORS))
 {
     Memory<V> m1(5);
     for (size_t i = 0; i < m1.entriesCount(); ++i) {
@@ -281,10 +277,35 @@
     }
 }
 
-template<typename V> void testCopyAssignment()
+void *hackToStoreToStack = 0;
+
+TEST_TYPES(V, paddingMustBeZero, (ALL_VECTORS))
 {
     typedef typename V::EntryType T;
+    { // poison the stack
+        V v = V::Random();
+        hackToStoreToStack = &v;
+    }
+    Memory<V, 1> m;
+    m[0] = T(0);
+    V x = m.vector(0);
+    COMPARE(x, V::Zero());
+}
+
+#ifndef Vc_ICC
+TEST_TYPES(V, initializerList, (ALL_VECTORS))
+{
+    typedef typename V::EntryType T;
+    Memory<V, 3> m = { T(1), T(2), T(3) };
+    for (int i = 0; i < 3; ++i) {
+        COMPARE(m[i], T(i + 1));
+    }
+}
+#endif
 
+TEST_TYPES(V, testCopyAssignment, (ALL_VECTORS))
+{
+    using T = typename V::EntryType;
     Memory<V, 99> m1;
     m1.setZero();
 
@@ -298,17 +319,3 @@
         COMPARE(m1[i], T(1));
     }
 }
-
-int main()
-{
-    testAllTypes(testEntries);
-    testAllTypes(testEntries2D);
-    testAllTypes(testVectors);
-    testAllTypes(testVectors2D);
-    testAllTypes(testVectorReorganization);
-    testAllTypes(memoryOperators);
-    testAllTypes(testCCtor);
-    testAllTypes(testCopyAssignment);
-
-    return 0;
-}
diff -Nru vc-0.7.4/tests/random.cpp vc-1.3.0/tests/random.cpp
--- vc-0.7.4/tests/random.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/random.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,136 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+#ifdef _WIN32
+void bzero(void *p, size_t n) { memset(p, 0, n); }
+#else
+#include <strings.h>
+#endif
+
+using Vc::float_v;
+using Vc::double_v;
+using Vc::SimdArray;
+
+TEST_TYPES(V, Random, (ALL_VECTORS))
+{
+    typedef typename V::EntryType T;
+    enum {
+        NBits = 3,
+        NBins = 1 << NBits,                        // short int
+        TotalBits = sizeof(T) * 8,                 //    16  32
+        RightShift = TotalBits - NBits,            //    13  29
+        NHistograms = TotalBits - NBits + 1,       //    14  30
+        LeftShift = (RightShift + 1) / NHistograms,//     1   1
+        Mean = 135791,
+        MinGood = Mean - Mean/10,
+        MaxGood = Mean + Mean/10
+    };
+    const V mask((1 << NBits) - 1);
+    int histogram[NHistograms][NBins];
+    bzero(&histogram[0][0], sizeof(histogram));
+    for (size_t i = 0; i < NBins * Mean / V::Size; ++i) {
+        const V rand = V::Random();
+        for (size_t hist = 0; hist < NHistograms; ++hist) {
+            const V bin = ((rand << (hist * LeftShift)) >> RightShift) & mask;
+            for (size_t k = 0; k < V::Size; ++k) {
+                ++histogram[hist][bin[k]];
+            }
+        }
+    }
+//#define PRINT_RANDOM_HISTOGRAM
+#ifdef PRINT_RANDOM_HISTOGRAM
+    for (size_t hist = 0; hist < NHistograms; ++hist) {
+        std::cout << "histogram[" << std::setw(2) << hist << "]: ";
+        for (size_t bin = 0; bin < NBins; ++bin) {
+            std::cout << std::setw(3) << (histogram[hist][bin] - Mean) * 1000 / Mean << "|";
+        }
+        std::cout << std::endl;
+    }
+#endif
+    for (size_t hist = 0; hist < NHistograms; ++hist) {
+        for (size_t bin = 0; bin < NBins; ++bin) {
+            VERIFY(histogram[hist][bin] > MinGood)
+                << " bin = " << bin << " is " << histogram[0][bin];
+            VERIFY(histogram[hist][bin] < MaxGood)
+                << " bin = " << bin << " is " << histogram[0][bin];
+        }
+    }
+}
+
+template<typename V, typename I> void FloatRandom()
+{
+    typedef typename V::EntryType T;
+    enum {
+        NBins = 64,
+        NHistograms = 1,
+        Mean = 135791,
+        MinGood = Mean - Mean/10,
+        MaxGood = Mean + Mean/10
+    };
+    int histogram[NHistograms][NBins];
+    bzero(&histogram[0][0], sizeof(histogram));
+    for (size_t i = 0; i < NBins * Mean / V::Size; ++i) {
+        const V rand = V::Random();
+        const I bin = static_cast<I>(rand * T(NBins));
+        for (size_t k = 0; k < V::Size; ++k) {
+            ++histogram[0][bin[k]];
+        }
+    }
+#ifdef PRINT_RANDOM_HISTOGRAM
+    for (size_t hist = 0; hist < NHistograms; ++hist) {
+        std::cout << "histogram[" << std::setw(2) << hist << "]: ";
+        for (size_t bin = 0; bin < NBins; ++bin) {
+            std::cout << std::setw(3) << (histogram[hist][bin] - Mean) * 1000 / Mean << "|";
+        }
+        std::cout << std::endl;
+    }
+#endif
+    for (size_t hist = 0; hist < NHistograms; ++hist) {
+        for (size_t bin = 0; bin < NBins; ++bin) {
+            VERIFY(histogram[hist][bin] > MinGood)
+                << " bin = " << bin << " is " << histogram[0][bin];
+            VERIFY(histogram[hist][bin] < MaxGood)
+                << " bin = " << bin << " is " << histogram[0][bin];
+        }
+    }
+}
+
+namespace Tests
+{
+template <> void Random_<float_v>::run()
+{
+    FloatRandom<float_v, SimdArray<int, float_v::size()>>();
+}
+template <> void Random_<double_v>::run()
+{
+    FloatRandom<double_v, SimdArray<int, double_v::size()>>();
+}
+}  // namespace Tests
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/reductions.cpp vc-1.3.0/tests/reductions.cpp
--- vc-0.7.4/tests/reductions.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/reductions.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,108 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include "vectormemoryhelper.h"
+
+TEST_TYPES(Vec, testReduceMin, (ALL_VECTORS, SIMD_ARRAY_LIST)) //{{{1
+{
+    typedef typename Vec::EntryType T;
+    const T one = 1;
+    VectorMemoryHelper<Vec> mem(Vec::Size);
+    T *data = mem;
+    for (size_t i = 0; i < Vec::Size * Vec::Size; ++i) {
+        data[i] = i % (Vec::Size + 1) + one;
+    }
+    for (size_t i = 0; i < Vec::Size; ++i, data += Vec::Size) {
+        const Vec a(&data[0]);
+        //std::cout << a << std::endl;
+        COMPARE(a.min(), one);
+    }
+}
+
+TEST_TYPES(Vec, testReduceMax, (ALL_VECTORS, SIMD_ARRAY_LIST)) //{{{1
+{
+    typedef typename Vec::EntryType T;
+    const T max = Vec::Size + 1;
+    VectorMemoryHelper<Vec> mem(Vec::Size);
+    T *data = mem;
+    for (size_t i = 0; i < Vec::Size * Vec::Size; ++i) {
+        data[i] = (i + Vec::Size) % (Vec::Size + 1) + 1;
+    }
+    for (size_t i = 0; i < Vec::Size; ++i, data += Vec::Size) {
+        const Vec a(&data[0]);
+        //std::cout << a << std::endl;
+        COMPARE(a.max(), max);
+    }
+}
+
+TEST_TYPES(V, testReduceProduct, (ALL_VECTORS, SIMD_ARRAY_LIST)) //{{{1
+{
+    using T = typename V::EntryType;
+    V test = 0;
+    COMPARE(test.product(), T(0)) << "test = " << test;
+    test = 1;
+    COMPARE(test.product(), T(1)) << "test = " << test;
+    test[0] = 2;
+    COMPARE(test.product(), T(2)) << "test = " << test;
+    test[0] = 3;
+    COMPARE(test.product(), T(3)) << "test = " << test;
+
+    for (std::size_t i = 0; i + 1 < V::size(); ++i) {
+        test[i] = 1;
+        test[i + 1] = 5;
+        COMPARE(test.product(), T(5)) << "test = " << test << ", i = " << i;
+    }
+    for (std::size_t i = 0; i + 2 < V::size(); ++i) {
+        test[i] = 1;
+        test[i + 1] = 7;
+        COMPARE(test.product(), T(5 * 7)) << "test = " << test << ", i = " << i;
+    }
+}
+
+TEST_TYPES(Vec, testReduceSum, (ALL_VECTORS, SIMD_ARRAY_LIST)) //{{{1
+{
+    typedef typename Vec::EntryType T;
+    int _sum = 1;
+    for (size_t i = 2; i <= Vec::Size; ++i) {
+        _sum += i;
+    }
+    const T sum = _sum;
+    VectorMemoryHelper<Vec> mem(Vec::Size);
+    T *data = mem;
+    for (size_t i = 0; i < Vec::Size * Vec::Size; ++i) {
+        data[i] = (i + i / Vec::Size) % Vec::Size + 1;
+    }
+    for (size_t i = 0; i < Vec::Size; ++i, data += Vec::Size) {
+        const Vec a(&data[0]);
+        //std::cout << a << std::endl;
+        COMPARE(a.sum(), sum);
+    }
+}
+
+//}}}1
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/scalaraccess.cpp vc-1.3.0/tests/scalaraccess.cpp
--- vc-0.7.4/tests/scalaraccess.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/scalaraccess.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,47 +1,73 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2010-2016 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2010-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
+#include "generators.h"
 #include "unittest.h"
 
 using namespace Vc;
 
-template<typename V> void reads()
+TEST_TYPES(V, reads, (ALL_VECTORS, SIMD_ARRAY_LIST))
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
 
     V a = V::Zero();
     const T zero = 0;
-    for (int i = 0; i < V::Size; ++i) {
+    for (size_t i = 0; i < V::Size; ++i) {
         const T x = a[i];
         COMPARE(x, zero);
     }
-    a = static_cast<V>(I::IndexesFromZero());
-    for (int i = 0; i < V::Size; ++i) {
+    a = V::IndexesFromZero();
+    for (size_t i = 0; i < V::Size; ++i) {
         const T x = a[i];
         const T y = i;
         COMPARE(x, y);
     }
+    // The non-const operator[] returns a smart reference that mimics an lvalue reference.
+    // But since it's not an actual lvalue reference the proxy is supposed to live as
+    // short as possible. To achieve this all move & copy operations must be disabled.
+    VERIFY(!std::is_move_constructible<decltype(a[0])>::value);
+    VERIFY(!std::is_copy_constructible<decltype(a[0])>::value);
+    VERIFY(!std::is_move_assignable<decltype(a[0])>::value);
+    VERIFY(!std::is_copy_assignable<decltype(a[0])>::value);
+    VERIFY(!std::is_reference<decltype(a[0])>::value);
+    COMPARE(typeid(decltype(a[0])), typeid(typename V::reference));
+
+    // the operator[] const overload returns an rvalue T and is therefore not constrained
+    // in the same way as the non-const operator[]
+    const V b = a;
+    VERIFY(std::is_move_constructible<decltype(b[0])>::value);
+    VERIFY(std::is_copy_constructible<decltype(b[0])>::value);
+    VERIFY(std::is_move_assignable<decltype(b[0])>::value);
+    VERIFY(std::is_copy_assignable<decltype(b[0])>::value);
+    VERIFY(!std::is_reference<decltype(b[0])>::value);
+    COMPARE(typeid(decltype(b[0])), typeid(typename V::value_type));
 }
 
-template<typename V, size_t Index>
-inline void readsConstantIndexTest(VC_ALIGNED_PARAMETER(V) a, VC_ALIGNED_PARAMETER(V) b)
+template <typename V, size_t Index> inline void readsConstantIndexTest(V a, V b)
 {
     typedef typename V::EntryType T;
     {
@@ -58,7 +84,7 @@
 template<typename V, size_t Index>
 struct ReadsConstantIndex
 {
-    ReadsConstantIndex(VC_ALIGNED_PARAMETER(V) a, VC_ALIGNED_PARAMETER(V) b)
+    ReadsConstantIndex(V a, V b)
     {
         readsConstantIndexTest<V, Index>(a, b);
         ReadsConstantIndex<V, Index - 1>(a, b);
@@ -69,78 +95,220 @@
 template<typename V>
 struct ReadsConstantIndex<V, 0>
 {
-    ReadsConstantIndex(VC_ALIGNED_PARAMETER(V) a, VC_ALIGNED_PARAMETER(V) b)
-    {
-        readsConstantIndexTest<V, 0>(a, b);
-    }
+    ReadsConstantIndex(V a, V b) { readsConstantIndexTest<V, 0>(a, b); }
 };
 
-template<typename V> void readsConstantIndex()
+TEST_TYPES(V, readsConstantIndex, (ALL_VECTORS, SIMD_ARRAY_LIST))
 {
-    typedef typename V::IndexType I;
-
     V a = V::Zero();
-    V b = static_cast<V>(I::IndexesFromZero());
+    V b = V::IndexesFromZero();
     ReadsConstantIndex<V, V::Size - 1>(a, b);
 }
 
-template<typename V> void writes()
+TEST_TYPES(V, writes, (ALL_VECTORS, SIMD_ARRAY_LIST))
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
 
-    V a;
-    for (int i = 0; i < V::Size; ++i) {
-        a[i] = static_cast<T>(i);
-    }
-    V b = static_cast<V>(I::IndexesFromZero());
-    COMPARE(a, b);
-
-    const T one = 1;
-    const T two = 2;
-
-    if (V::Size == 1) {
-        a(a == 0) += one;
-        a[0] += one;
-        a(a == 0) += one;
-        COMPARE(a, V(2));
-    } else if (V::Size == 4) {
-        a(a == 1) += two;
-        a[2] += one;
-        a(a == 3) += one;
-        b(b == 1) += one;
-        b(b == 2) += one;
-        b(b == 3) += one;
-        COMPARE(a, b);
-    } else if (V::Size == 8 || V::Size == 16) {
-        a(a == 2) += two;
-        a[3] += one;
-        a(a == 4) += one;
-        b(b == 2) += one;
-        b(b == 3) += one;
-        b(b == 4) += one;
-        COMPARE(a, b);
-    } else if (V::Size == 2) { // a = [0, 1]; b = [0, 1]
-        a(a == 0) += two;      // a = [2, 1]
-        a[1] += one;           // a = [2, 2]
-        a(a == 2) += one;      // a = [3, 3]
-        b(b == 0) += one;      // b = [1, 1]
-        b(b == 1) += one;      // b = [2, 2]
-        b(b == 2) += one;      // b = [3, 3]
-        COMPARE(a, b);
-    } else {
-        FAIL() << "unsupported Vector::Size";
-    }
+    V a = 0;
+    std::array<T, V::size()> reference = {0};
+    int i = 0;
+    iterateNumericRange<T>([&](T x) {
+        reference[i] = x;
+        a[i] = x;
+        COMPARE(a, V(&reference[0]));
+        i = (i + 1) % V::size();
+    });
 }
 
-int main(int argc, char **argv)
-{
-    initTest(argc, argv);
-
-    testAllTypes(reads);
-    testAllTypes(writes);
-    testAllTypes(readsConstantIndex);
-    //testAllTypes(writesConstantIndex);
+template <typename T> using decayed = typename std::decay<T>::type;
+template <typename V> using EntryType = typename decayed<V>::EntryType;
 
-    return 0;
+#define INT_OP(op, name)                                                                 \
+    template <typename V> bool test_##name##_assign(V &&, float, int) { return false; }  \
+    template <typename V,                                                                \
+              typename = decltype(std::declval<V>()[0] op## = EntryType<V>())>           \
+    bool test_##name##_assign(V &&a, int x, int y)                                       \
+    {                                                                                    \
+        using T = EntryType<V>;                                                          \
+        COMPARE(a[0] op## = T(x), T(y));                                                 \
+        COMPARE(a[0], T(y));                                                             \
+        return true;                                                                     \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+INT_OP(+, plus);
+INT_OP(-, minus);
+INT_OP(*, times);
+INT_OP(/, divide);
+INT_OP(%, percent);
+INT_OP(<<, lshift);
+INT_OP(>>, rshift);
+INT_OP(|, bor);
+INT_OP(&, band);
+INT_OP(^, bxor);
+#undef INT_OP
+
+#define UNARY_OP(op, name)                                                               \
+    template <typename V> bool test_unary_##name(V &&, ...) { return false; }            \
+    template <typename V>                                                                \
+    bool test_unary_##name(V &&a, decltype(op(std::declval<V>()[0])) x)                  \
+    {                                                                                    \
+        COMPARE(op a[0], x);                                                             \
+        return true;                                                                     \
+    }                                                                                    \
+    template <typename V> bool test_unary_##name##_nosubscript(V &&, ...)                \
+    {                                                                                    \
+        return false;                                                                    \
+    }                                                                                    \
+    template <typename V>                                                                \
+    bool test_unary_##name##_nosubscript(V &&a, decltype(op std::declval<V>()) x)        \
+    {                                                                                    \
+        COMPARE(op a, x);                                                                \
+        return true;                                                                     \
+    }                                                                                    \
+    Vc_NOTHING_EXPECTING_SEMICOLON
+UNARY_OP(!, not);
+UNARY_OP(+, plus);
+UNARY_OP(-, minus);
+UNARY_OP(~, bitflip);
+#undef UNARY_OP
+
+template <typename V> bool test_pre_increment(V &&, float) { return false; }
+template <typename V, typename = decltype(++std::declval<V>()[0])>
+bool test_pre_increment(V &&a, int x)
+{
+    using T = EntryType<V>;
+    COMPARE(++a[0], T(x));
+    COMPARE(a[0], T(x));
+    return true;
+}
+template <typename V> bool test_post_increment(V &&, float) { return false; }
+template <typename V, typename = decltype(std::declval<V>()[0]++)>
+bool test_post_increment(V &&a, int x)
+{
+    using T = EntryType<V>;
+    COMPARE(a[0]++, T(x - 1));
+    COMPARE(a[0], T(x));
+    return true;
+}
+template <typename V> bool test_pre_decrement(V &&, float) { return false; }
+template <typename V, typename = decltype(--std::declval<V>()[0])>
+bool test_pre_decrement(V &&a, int x)
+{
+    using T = EntryType<V>;
+    COMPARE(--a[0], T(x));
+    COMPARE(a[0], T(x));
+    return true;
+}
+template <typename V> bool test_post_decrement(V &&, float) { return false; }
+template <typename V, typename = decltype(std::declval<V>()[0]--)>
+bool test_post_decrement(V &&a, int x)
+{
+    using T = EntryType<V>;
+    COMPARE(a[0]--, T(x + 1));
+    COMPARE(a[0], T(x));
+    return true;
+}
+
+TEST_TYPES(V, operators, (ALL_VECTORS, SIMD_ARRAY_LIST))
+{
+    using T = EntryType<V>;
+    V a = 10;
+    VERIFY(test_unary_not(a, false));
+    VERIFY(test_unary_plus(a, 10));
+    VERIFY(test_unary_minus(a, -10));
+    COMPARE(test_unary_bitflip(a, ~10), std::is_integral<T>::value);
+    VERIFY(test_plus_assign(a, 1, 11));
+    VERIFY(test_minus_assign(a, 1, 10));
+    VERIFY(test_times_assign(a, 2, 20));
+    VERIFY(test_divide_assign(a, 2, 10));
+    VERIFY(test_pre_decrement(a, 9));
+    VERIFY(test_post_decrement(a, 8));
+    VERIFY(test_pre_increment(a, 9));
+    VERIFY(test_post_increment(a, 10));
+    COMPARE(test_percent_assign(a, 6, 4), std::is_integral<T>::value);
+    COMPARE(test_lshift_assign(a, 1, 8), std::is_integral<T>::value);
+    COMPARE(test_rshift_assign(a, 2, 2), std::is_integral<T>::value);
+    COMPARE(test_bor_assign(a, 9, 11), std::is_integral<T>::value);
+    COMPARE(test_band_assign(a, 13, 9), std::is_integral<T>::value);
+    COMPARE(test_bxor_assign(a, 1, 8), std::is_integral<T>::value);
+
+    // assignment operators should never work on const ref
+    a = 10;
+    const auto &x = a[0];
+    COMPARE(x, T(10));
+    VERIFY(!test_plus_assign(x, 1, 11));
+    VERIFY(!test_minus_assign(x, 1, 10));
+    VERIFY(!test_times_assign(x, 2, 20));
+    VERIFY(!test_divide_assign(x, 2, 10));
+    VERIFY(!test_pre_decrement(x, 9));
+    VERIFY(!test_post_decrement(x, 8));
+    VERIFY(!test_pre_increment(x, 9));
+    VERIFY(!test_post_increment(x, 10));
+    VERIFY(!test_percent_assign(x, 6, 4));
+    VERIFY(!test_lshift_assign(x, 1, 8));
+    VERIFY(!test_rshift_assign(x, 2, 2));
+    VERIFY(!test_bor_assign(x, 9, 11));
+    VERIFY(!test_band_assign(x, 13, 9));
+    VERIFY(!test_bxor_assign(x, 1, 8));
+
+    // unary operators should work, though
+    VERIFY(test_unary_not_nosubscript(x, false));
+    VERIFY(test_unary_plus_nosubscript(x, 10));
+    VERIFY(test_unary_minus_nosubscript(x, -10));
+    COMPARE(test_unary_bitflip_nosubscript(x, ~10), std::is_integral<T>::value);
+
+    // Just to make sure, the assignment operators also should not work on lvalue
+    // references
+    decltype(a[0]) *y = nullptr;
+    VERIFY(!test_plus_assign(*y, 1, 11));
+    VERIFY(!test_minus_assign(*y, 1, 10));
+    VERIFY(!test_times_assign(*y, 2, 20));
+    VERIFY(!test_divide_assign(*y, 2, 10));
+    VERIFY(!test_pre_decrement(*y, 9));
+    VERIFY(!test_post_decrement(*y, 8));
+    VERIFY(!test_pre_increment(*y, 9));
+    VERIFY(!test_post_increment(*y, 10));
+    VERIFY(!test_percent_assign(*y, 6, 4));
+    VERIFY(!test_lshift_assign(*y, 1, 8));
+    VERIFY(!test_rshift_assign(*y, 2, 2));
+    VERIFY(!test_bor_assign(*y, 9, 11));
+    VERIFY(!test_band_assign(*y, 13, 9));
+    VERIFY(!test_bxor_assign(*y, 1, 8));
+
+    auto k0 = a == a;
+    const auto &k1 = k0;
+    VERIFY(test_unary_not(k0, 0));
+    VERIFY(test_unary_not(k1, 0));
+    k0 = a != a;
+    VERIFY(test_unary_not(k0, 1));
+}
+
+TEST_TYPES(V, ensure_noexcept, (ALL_VECTORS, SIMD_ARRAY_LIST))
+{
+    V a{};
+    {
+        const V &b = a;
+        EntryType<V> x = a[0]; if (x == x) {}
+        VERIFY(noexcept(a[0]));
+        VERIFY(noexcept(x = b[0]));
+        VERIFY(noexcept(x = a[0]));
+        VERIFY(noexcept(a[0] = 1));
+        VERIFY(noexcept(a[0] += 1));
+        VERIFY(noexcept(a[0] -= 1));
+        VERIFY(noexcept(a[0] *= 1));
+        VERIFY(noexcept(a[0] /= 1));
+        VERIFY(noexcept(++a[0]));
+        VERIFY(noexcept(--a[0]));
+        VERIFY(noexcept(a[0]++));
+        VERIFY(noexcept(a[0]--));
+    }
+    {
+        auto k0 = a == a;
+        const auto &k1 = k0;
+        bool x = false; if (x) {}
+        VERIFY(noexcept(k0[0]));
+        VERIFY(noexcept(x = k1[0]));
+        VERIFY(noexcept(x = k0[0]));
+        VERIFY(noexcept(k0[0] = 1));
+    }
 }
diff -Nru vc-0.7.4/tests/scatter.cpp vc-1.3.0/tests/scatter.cpp
--- vc-0.7.4/tests/scatter.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/scatter.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,92 +1,125 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 // includes {{{1
 #include "unittest.h"
 #include <iostream>
 #include <cstring>
+#include <Vc/array>
 
 using namespace Vc;
 
-template<typename Vec> void maskedScatterArray() //{{{1
-{
-    typedef typename Vec::IndexType It;
-    typedef typename Vec::EntryType T;
-
-    T mem[Vec::Size];
-    const Vec v(It::IndexesFromZero() + 1);
-
-    for_all_masks(Vec, m) {
-        Vec::Zero().store(mem, Vc::Unaligned);
-        v.scatter(&mem[0], It::IndexesFromZero(), m);
-
-        for (int i = 0; i < Vec::Size; ++i) {
-            COMPARE(mem[i], m[i] ? v[i] : T(0)) << " i = " << i << ", m = " << m;
-        }
-    }
-}
+#define ALL_TYPES SIMD_ARRAY_LIST, ALL_VECTORS
 
-template<typename Vec> void scatterArray() //{{{1
+TEST_TYPES(Vec, scatterArray, (ALL_TYPES)) //{{{1
 {
+    typedef typename Vec::EntryType T;
     typedef typename Vec::IndexType It;
-    const int count = 31999;
-    typename Vec::EntryType array[count], out[count];
+    constexpr int count = 31999;
+    Vc::array<T, count> array, out;
     for (int i = 0; i < count; ++i) {
-        array[i] = i - 100;
+        array[i] = i;
+        if (!std::is_integral<T>::value || !std::is_unsigned<T>::value) {
+            array[i] -= 100;
+        }
     }
     typename It::Mask mask;
     for (It i(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
-        typename Vec::Mask castedMask(mask);
-        if (castedMask.isFull()) {
-            Vec a(array, i);
-            a += Vec(One);
-            a.scatter(out, i);
+        auto castedMask = simd_cast<typename Vec::Mask>(mask);
+        if (all_of(castedMask)) {
+            Vec a(&array[0], i);
+            a += 1;
+            a.scatter(&out[0], i);
+        } else {
+            Vec a(&array[0], i, castedMask);
+            a += 1;
+            a.scatter(&out[0], i, castedMask);
+        }
+    }
+    for (int i = 0; i < count; ++i) {
+        array[i] += 1;
+        COMPARE(array[i], out[i]);
+    }
+    COMPARE(0, std::memcmp(&array[0], &out[0], count * sizeof(typename Vec::EntryType)));
+
+    for (It i(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
+        auto castedMask = simd_cast<typename Vec::Mask>(mask);
+        if (all_of(castedMask)) {
+            Vec a = array[i];
+            out[i] = a + 1;
         } else {
-            Vec a(array, i, castedMask);
-            a += Vec(One);
-            a.scatter(out, i, castedMask);
+            Vec a;
+            where(castedMask) | a = array[i];
+            where(castedMask) | out[i] = a + 1;
         }
     }
     for (int i = 0; i < count; ++i) {
         array[i] += 1;
         COMPARE(array[i], out[i]);
     }
-    COMPARE(0, std::memcmp(array, out, count * sizeof(typename Vec::EntryType)));
+    COMPARE(0, std::memcmp(&array[0], &out[0], count * sizeof(typename Vec::EntryType)));
+}
+
+TEST_TYPES(Vec, maskedScatterArray, (ALL_TYPES)) //{{{1
+{
+    typedef typename Vec::IndexType It;
+    typedef typename Vec::EntryType T;
+
+    Vc::array<T, Vec::Size> mem;
+    const Vec v = Vec::IndexesFromZero() + 1;
+
+    UnitTest::withRandomMask<Vec>([&](typename Vec::mask_type m) {
+        Vec::Zero().store(&mem[0], Vc::Unaligned);
+        where(m) | mem[It::IndexesFromZero()] = v;
+
+        Vec reference = v;
+        reference.setZeroInverted(m);
+
+        COMPARE(Vec(&mem[0], Vc::Unaligned), reference) << "m = " << m;
+    });
 }
 
-template<typename T> struct Struct //{{{1
+template<typename T, std::size_t Align> struct Struct //{{{1
 {
-    T a;
+    alignas(Align) T a;
     char x;
-    T b;
+    alignas(Align) T b;
     short y;
-    T c;
+    alignas(Align) T c;
     char z;
 };
 
-template<typename Vec> void scatterStruct() //{{{1
+TEST_TYPES(Vec, scatterStruct, (ALL_TYPES)) //{{{1
 {
     typedef typename Vec::IndexType It;
-    typedef Struct<typename Vec::EntryType> S;
-    const int count = 3999;
-    S array[count], out[count];
-    memset(array, 0, count * sizeof(S));
-    memset(out, 0, count * sizeof(S));
+    typedef Struct<typename Vec::EntryType, alignof(typename Vec::EntryType)> S;
+    constexpr int count = 3999;
+    Vc::array<S, count> array, out;
+    memset(&array[0], 0, count * sizeof(S));
+    memset(&out[0], 0, count * sizeof(S));
     for (int i = 0; i < count; ++i) {
         array[i].a = i;
         array[i].b = i + 1;
@@ -94,80 +127,87 @@
     }
     typename It::Mask mask;
     for (It i(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
-        typename Vec::Mask castedMask(mask);
-        Vec a(array, &S::a, i, castedMask);
-        Vec b(array, &S::b, i, castedMask);
-        Vec c(array, &S::c, i, castedMask);
-        a.scatter(out, &S::a, i, castedMask);
-        b.scatter(out, &S::b, i, castedMask);
-        c.scatter(out, &S::c, i, castedMask);
+        auto castedMask = simd_cast<typename Vec::Mask>(mask);
+        Vec a; a(castedMask) = array[i][&S::a];
+        where(castedMask) | out[i][&S::a] = a;
+        Vec b; b(castedMask) = array[i][&S::b];
+        where(castedMask) | out[i][&S::b] = b;
+        Vec c; c(castedMask) = array[i][&S::c];
+        where(castedMask) | out[i][&S::c] = c;
     }
-    VERIFY(0 == memcmp(array, out, count * sizeof(S)));
+    VERIFY(0 == memcmp(&array[0], &out[0], count * sizeof(S)));
 }
 
-template<typename T> struct Struct2 //{{{1
+template<typename T, std::size_t Align> struct Struct2 //{{{1
 {
     char x;
-    Struct<T> b;
+    Struct<T, Align> b;
     short y;
 };
 
-template<typename Vec> void scatterStruct2() //{{{1
+constexpr int scatterStruct2Count = 97;
+
+template<typename T, std::size_t Align>
+static std::ostream &operator<<(std::ostream &out, const Struct2<T, Align> &s)
+{
+    return out << '{' << s.b.a << ' ' << s.b.b << ' ' << s.b.c << '}';
+}
+
+template<typename T, std::size_t Align>
+static std::ostream &operator<<(std::ostream &out, const Struct2<T, Align> *s)
+{
+    for (int i = 0; i < scatterStruct2Count; ++i) {
+        out << s[i];
+    }
+    return out;
+}
+
+template <typename T, std::size_t N>
+static std::ostream &operator<<(std::ostream &out, const Vc::array<T, N> &x)
+{
+    out << x[0];
+    for (std::size_t i = 1; i < N; ++i) {
+        out << ' ' << x[i];
+    }
+    return out;
+}
+
+template<typename V> V makeReference(V v, typename V::Mask m)
+{
+    v.setZero(!m);
+    return v;
+}
+TEST_TYPES(Vec, scatterStruct2, (ALL_TYPES)) //{{{1
 {
     typedef typename Vec::IndexType It;
-    typedef Struct2<typename Vec::EntryType> S1;
-    typedef Struct<typename Vec::EntryType> S2;
-    const int count = 97;
-    S1 array[count], out[count];
-    memset(array, 0, count * sizeof(S1));
-    memset(out, 0, count * sizeof(S1));
-    for (int i = 0; i < count; ++i) {
+    typedef Struct2<typename Vec::EntryType, alignof(typename Vec::EntryType)> S1;
+    typedef Struct<typename Vec::EntryType, alignof(typename Vec::EntryType)> S2;
+    Vc::array<S1, scatterStruct2Count> array, out;
+    memset(&array[0], 0, scatterStruct2Count * sizeof(S1));
+    memset(&out[0], 0, scatterStruct2Count * sizeof(S1));
+    for (int i = 0; i < scatterStruct2Count; ++i) {
         array[i].b.a = i + 0;
         array[i].b.b = i + 1;
         array[i].b.c = i + 2;
     }
     typename It::Mask mask;
-    for (It i(IndexesFromZero); !(mask = (i < count)).isEmpty(); i += Vec::Size) {
-        typename Vec::Mask castedMask(mask);
-        Vec a(array, &S1::b, &S2::a, i, castedMask);
-        Vec b(array, &S1::b, &S2::b, i, castedMask);
-        Vec c(array, &S1::b, &S2::c, i, castedMask);
-        a.scatter(out, &S1::b, &S2::a, i, castedMask);
-        b.scatter(out, &S1::b, &S2::b, i, castedMask);
-        c.scatter(out, &S1::b, &S2::c, i, castedMask);
-    }
-    VERIFY(0 == memcmp(array, out, count * sizeof(S1)));
-}
-
-int main(int argc, char **argv) //{{{1
-{
-    initTest(argc, argv);
-
-    runTest(scatterArray<int_v>);
-    runTest(scatterArray<uint_v>);
-    runTest(scatterArray<float_v>);
-    runTest(scatterArray<double_v>);
-    runTest(scatterArray<sfloat_v>);
-    runTest(scatterArray<short_v>);
-    runTest(scatterArray<ushort_v>);
-    testAllTypes(maskedScatterArray);
-#if defined(VC_CLANG) && VC_CLANG <= 0x030000
-    // clang fails with:
-    //  candidate template ignored: failed template argument deduction
-    //  template<typename S1, typename IT> inline Vector(const S1 *array, const T S1::*
-    //          member1, IT indexes, Mask mask = true)
-#warning "Skipping compilation of tests scatterStruct and scatterStruct2 because of clang bug"
-#else
-    runTest(scatterStruct<int_v>);
-    runTest(scatterStruct<uint_v>);
-    runTest(scatterStruct<float_v>);
-    runTest(scatterStruct<double_v>);
-    runTest(scatterStruct<sfloat_v>);
-    runTest(scatterStruct<short_v>);
-    runTest(scatterStruct<ushort_v>);
-    testAllTypes(scatterStruct2);
-#endif
-    return 0;
+    typename Vec::Mask castedMask;
+    for (It i(IndexesFromZero); !(mask = (i < scatterStruct2Count)).isEmpty(); i += Vec::Size) {
+        castedMask = simd_cast<decltype(castedMask)>(mask);
+        Vec a = Vec(); a(castedMask) = array[i][&S1::b][&S2::a];
+        Vec b = Vec(); b(castedMask) = array[i][&S1::b][&S2::b];
+        Vec c = Vec(); c(castedMask) = array[i][&S1::b][&S2::c];
+        COMPARE(a, Vc::simd_cast<Vec>(makeReference(i, mask)));
+        COMPARE(b, Vc::simd_cast<Vec>(makeReference(i + 1, mask)));
+        COMPARE(c, Vc::simd_cast<Vec>(makeReference(i + 2, mask)));
+        where(castedMask) | out[i][&S1::b][&S2::a] = a;
+        where(castedMask) | out[i][&S1::b][&S2::b] = b;
+        where(castedMask) | out[i][&S1::b][&S2::c] = c;
+    }
+    // castedmask != mask here because mask is changed in the for loop, but castedmask has the value
+    // from the previous iteration
+    VERIFY(0 == memcmp(&array[0], &out[0], scatterStruct2Count * sizeof(S1))) << mask << ' ' << castedMask << '\n'
+        << array << '\n' << out;
 }
 
 // vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/scatterinterleavedmemory.cpp vc-1.3.0/tests/scatterinterleavedmemory.cpp
--- vc-0.7.4/tests/scatterinterleavedmemory.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/scatterinterleavedmemory.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,173 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+using namespace Vc;
+
+template<typename T, size_t N> struct SomeStruct
+{
+    T d[N];
+};
+
+size_t createNMask(size_t N)
+{
+    size_t NMask = (N >> 1) | (N >> 2);
+    for (size_t shift = 2; shift < sizeof(size_t) * 8; shift *= 2) {
+        NMask |= NMask >> shift;
+    }
+    return NMask;
+}
+
+#if !defined __GNUC__ || defined __OPTIMIZE__
+static constexpr int TotalRetests = 10000;
+#else
+static constexpr int TotalRetests = 1000;
+#endif
+
+template <typename T> T rotate(T x)
+{
+    return x.rotated(1);
+}
+template <typename T, std::size_t N> Vc::SimdArray<T, N> rotate(const Vc::SimdArray<T, N> &x)
+{
+    Vc::SimdArray<T, N> r;
+    r[0] = x[N - 1];
+    for (std::size_t i = 0; i < N - 1; ++i) {
+        r[i + 1] = x[i];
+    }
+    return r;
+}
+
+namespace std
+{
+template <typename T, std::size_t N>
+inline std::ostream &operator<<(std::ostream &out, const std::array<T, N> &a)
+{
+    out << "\narray{" << a[0];
+    for (std::size_t i = 1; i < N; ++i) {
+        out << ", " << a[i];
+    }
+    return out << '}';
+}
+template <typename T, std::size_t N>
+inline bool operator==(const std::array<Vc::Vector<T>, N> &a, const std::array<Vc::Vector<T>, N> &b)
+{
+    for (std::size_t i = 0; i < N; ++i) {
+        if (!Vc::all_of(a[i] == b[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+}  // namespace std
+
+template <typename V, typename Wrapper, typename IndexType, std::size_t... Indexes>
+void testInterleavingScatterCompare(Wrapper &data, const IndexType &i,
+                                    Vc::index_sequence<Indexes...>)
+{
+    const std::array<V, sizeof...(Indexes)> reference = {
+        {((void)Indexes, V::Random())...}};
+
+    data[i] = tie(reference[Indexes]...);
+    std::array<V, sizeof...(Indexes)> t = data[i];
+    COMPARE(t, reference) << "i: " << i;
+
+    for (auto &x : t) {
+        x.setZero();
+    }
+    tie(t[Indexes]...) = data[i];
+    COMPARE(t, reference);
+
+    if (sizeof...(Indexes) > 2) {
+        testInterleavingScatterCompare<V>(
+            data, i, Vc::make_index_sequence<
+                         (sizeof...(Indexes) > 2 ? sizeof...(Indexes) - 1 : 2)>());
+    }
+}
+
+TEST_TYPES(Param, testInterleavingScatter,
+           (outer_product<Typelist<ALL_VECTORS>,
+                          Typelist<std::integral_constant<std::size_t, 2>,
+                                   std::integral_constant<std::size_t, 3>,
+                                   std::integral_constant<std::size_t, 4>,
+                                   std::integral_constant<std::size_t, 5>,
+                                   std::integral_constant<std::size_t, 6>,
+                                   std::integral_constant<std::size_t, 7>,
+                                   std::integral_constant<std::size_t, 8>>>))
+{
+    typedef typename Param::template at<0> V;
+    constexpr auto StructSize = Param::template at<1>::value;
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType I;
+    typedef SomeStruct<T, StructSize> S;
+    typedef Vc::InterleavedMemoryWrapper<S, V> Wrapper;
+    const size_t N = std::min<size_t>(std::numeric_limits<typename I::EntryType>::max(),
+                                      1024 * 1024 / sizeof(S));
+    const size_t NMask = createNMask(N);
+
+    S *data = Vc::malloc<S, Vc::AlignOnVector>(N);
+    std::memset(data, 0, sizeof(S) * N);
+    Wrapper data_v(data);
+
+    try {
+        testInterleavingScatterCompare<V>(
+            data_v, static_cast<typename I::EntryType>(N - 1) - I::IndexesFromZero(),
+            Vc::make_index_sequence<StructSize>());
+        for (int retest = 0; retest < TotalRetests; ++retest) {
+            I indexes = (I::Random() >> 10) & I(NMask);
+            if (I::Size != 1) {
+                // ensure the indexes are unique
+                while (any_of(indexes.sorted() == rotate(indexes.sorted()))) {
+                    indexes = (I::Random() >> 10) & I(NMask);
+                }
+            }
+            VERIFY(all_of(indexes >= 0));
+            VERIFY(all_of(indexes < N));
+
+            testInterleavingScatterCompare<V>(data_v, indexes,
+                                              Vc::make_index_sequence<StructSize>());
+        }
+
+        for (size_t i = 0; i < N - V::Size; ++i) {
+            testInterleavingScatterCompare<V>(data_v, i,
+                                              Vc::make_index_sequence<StructSize>());
+        }
+    } catch (...) {
+        std::cout << "data was:";
+        for (size_t n = 0; n < StructSize; ++n) {
+            std::cout << '\n' << n << ": ";
+            for (size_t i = 0; i < N; ++i) {
+                std::cout << data[i].d[n] << ' ';
+            }
+        }
+        std::cout << '\n';
+        throw;
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/simdarray.cpp vc-1.3.0/tests/simdarray.cpp
--- vc-0.7.4/tests/simdarray.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/simdarray.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,230 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include "../common/simdarray.h"
+
+using namespace Vc;
+
+template <typename T, size_t N> constexpr size_t captureN(const SimdArray<T, N> &)
+{
+    return N;
+}
+
+TEST_TYPES(V, createArray, (SIMD_ARRAY_LIST))
+{
+    typedef typename V::VectorEntryType VT;
+    V array;
+
+    COMPARE(array.size(), captureN(V()));
+    VERIFY(sizeof(array) >= array.size() * sizeof(VT));
+    VERIFY(sizeof(array) <= 2 * array.size() * sizeof(VT));
+}
+
+TEST_TYPES(V, checkArrayAlignment, (SIMD_ARRAY_LIST))
+{
+    using T = typename V::value_type;
+    using M = typename V::mask_type;
+
+    auto &&bound_to_max_alignment = [](std::size_t n) {
+#ifdef Vc_GCC
+#ifdef __AVX__
+        return n > 256u ? 256u : n;
+#else
+        return n > 128u ? 128u : n;
+#endif
+#elif defined Vc_MSVC
+        return n > 32u ? 32u : n;
+#else
+        return n;
+#endif
+    };
+
+    COMPARE(alignof(V),
+            bound_to_max_alignment(
+                sizeof(V)));  // sizeof must be at least as large as alignof to
+                              // ensure proper padding in arrays. alignof is
+                              // supposed to be at least as large as the actual
+                              // data size requirements
+    COMPARE(alignof(M), bound_to_max_alignment(sizeof(M)));
+    VERIFY(alignof(V) >= bound_to_max_alignment(V::Size * sizeof(T)));
+    if (V::Size > 1) {
+        using V2 = SimdArray<T, Vc::Common::left_size<V::Size>()>;
+        using M2 = typename V2::mask_type;
+        VERIFY(alignof(V) >= bound_to_max_alignment(2 * alignof(V2)));
+        VERIFY(alignof(M) >= bound_to_max_alignment(2 * alignof(M2)));
+    }
+}
+
+TEST_TYPES(V, broadcast, (SIMD_ARRAY_LIST))
+{
+    typedef typename V::EntryType T;
+    V array = 0;
+    array = 1;
+    V v0(T(1));
+    V v1 = T(2);
+    v0 = 2;
+    v1 = 3;
+    COMPARE(V(), V(0));
+}
+
+TEST_TYPES(V, broadcast_equal, (SIMD_ARRAY_LIST))
+{
+    V a = 0;
+    V b = 0;
+    COMPARE(a, b);
+    a = 1;
+    b = 1;
+    COMPARE(a, b);
+}
+
+TEST_TYPES(V, broadcast_not_equal, (SIMD_ARRAY_LIST))
+{
+    V a = 0;
+    V b = 1;
+    VERIFY(all_of(a != b));
+    VERIFY(all_of(a < b));
+    VERIFY(all_of(a <= b));
+    VERIFY(none_of(a > b));
+    VERIFY(none_of(a >= b));
+    a = 1;
+    VERIFY(all_of(a <= b));
+    VERIFY(all_of(a >= b));
+}
+
+TEST_TYPES(V, arithmetics, (SIMD_ARRAY_LIST))
+{
+    V a = 0;
+    V b = 1;
+    V c = 10;
+    COMPARE(a + b, b);
+    COMPARE(c + b, V(11));
+    COMPARE(c - b, V(9));
+    COMPARE(b - a, b);
+    COMPARE(b * a, a);
+    COMPARE(b * b, b);
+    COMPARE(c * b, c);
+    COMPARE(c * c, V(100));
+    COMPARE(c / c, b);
+    COMPARE(a / c, a);
+    COMPARE(c / b, c);
+}
+
+TEST_TYPES(V, indexesFromZero, (SIMD_ARRAY_LIST))
+{
+    typedef typename V::EntryType T;
+    V a(Vc::IndexesFromZero);
+#if defined Vc_IMPL_MIC && Vc_VERSION_NUMBER < Vc_VERSION_CHECK(1, 99, 0)
+// see https://github.com/VcDevel/Vc/issues/47:
+// The subscript access to a[i] with i >= V::N0 might access Scalar::Vector<(u)short>
+// storing 2-Byte data, whereas the MIC::Vector<(u)short> stores 4-Byte data.
+// The plan is to have it fixed in Vc 2.0.
+    if (sizeof(T) < 4) {
+        alignas(V::MemoryAlignment) T mem[V::size()];
+        a.store(mem, Vc::Aligned);
+        for (std::size_t i = 0; i < a.size(); ++i) {
+            COMPARE(mem[i], T(i));
+        }
+        return;
+    }
+#endif
+    for (std::size_t i = 0; i < a.size(); ++i) {
+        COMPARE(a[i], T(i));
+    }
+}
+
+TEST_TYPES(V, load, (SIMD_ARRAY_LIST))
+{
+    typedef typename V::EntryType T;
+    alignas(static_cast<size_t>(V::MemoryAlignment)) T data[V::Size + 2];
+    {
+        int n = 0;
+        for (auto &entry : data) {
+            entry = T(n++);
+        }
+    }
+
+    V a(&data[0], Vc::Aligned);
+    V b(Vc::IndexesFromZero);
+    COMPARE(a, b);
+
+    a = V(data, Vc::Aligned);  // this is different to the constructor call above since
+                               // the type is T[N] (vs. T *)
+    COMPARE(a, b);
+
+    b.load(&data[0], Vc::Aligned);
+    COMPARE(a, b);
+
+    a.load(&data[1], Vc::Unaligned);
+    COMPARE(a, b + 1);
+
+    b = decltype(b)(&data[2], Vc::Unaligned | Vc::Streaming);
+    COMPARE(a, b - 1);
+}
+
+TEST_TYPES(A,
+           load_converting,
+           (SimdArray<float, 32>,
+            SimdArray<float, 17>,
+            SimdArray<float, 16>,
+            SimdArray<float, 8>,
+            SimdArray<float, 4>,
+            SimdArray<float, 3>,
+            SimdArray<float, 2>,
+            SimdArray<float, 1>))
+{
+    Vc::Memory<double_v, 34> data;
+    for (size_t i = 0; i < data.entriesCount(); ++i) {
+        data[i] = double(i);
+    }
+
+    A a{ &data[0] };
+    A b(Vc::IndexesFromZero);
+    COMPARE(a, b);
+
+    b.load(&data[1], Vc::Unaligned);
+    COMPARE(a + 1, b);
+
+    a = A(&data[2], Vc::Unaligned | Vc::Streaming);
+    COMPARE(a, b + 1);
+}
+
+TEST_TYPES(V, store, (SIMD_ARRAY_LIST))
+{
+    using T = typename V::EntryType;
+    alignas(static_cast<size_t>(V::MemoryAlignment)) T data[34] = {};
+
+    V a(Vc::IndexesFromZero);
+    a.store(&data[0], Vc::Aligned);
+    for (size_t i = 0; i < V::Size; ++i) COMPARE(data[i], T(i));
+    a.store(&data[1], Vc::Unaligned);
+    for (size_t i = 0; i < V::Size; ++i) COMPARE(data[i + 1], T(i));
+    a.store(&data[0], Vc::Aligned | Vc::Streaming);
+    for (size_t i = 0; i < V::Size; ++i) COMPARE(data[i], T(i));
+    a.store(&data[1], Vc::Unaligned | Vc::Streaming);
+    for (size_t i = 0; i < V::Size; ++i) COMPARE(data[i + 1], T(i));
+}
diff -Nru vc-0.7.4/tests/simdize.cpp vc-1.3.0/tests/simdize.cpp
--- vc-0.7.4/tests/simdize.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/simdize.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,605 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include <list>
+
+using Vc::simdize;
+using Vc::float_v;
+using Vc::int_v;
+using Vc::int_m;
+
+template <typename Scalar, typename Base, std::size_t N>
+using SimdizeAdapter = Vc::SimdizeDetail::Adapter<Scalar, Base, N>;
+
+TEST(test_simdize)
+{
+    using namespace std;
+    using namespace Vc;
+    using Test0 = simdize<float>;
+    using Test1 = simdize<tuple<float, double>>;
+    using Test1_0 = typename std::decay<decltype(get<0>(Test1()))>::type;
+    using Test1_1 = typename tuple_element<1, typename Test1::base_type>::type;
+    using Test2 = simdize<tuple<double, float>>;
+    using Test2_0 = typename tuple_element<0, typename Test2::base_type>::type;
+    using Test2_1 = typename tuple_element<1, typename Test2::base_type>::type;
+    using Test3 = simdize<tuple<std::string, float>>;
+    using Test3_1 = typename tuple_element<1, typename Test3::base_type>::type;
+    using Test4 = simdize<tuple<double, std::string, float>>;
+    using Test4_0 = typename tuple_element<0, typename Test4::base_type>::type;
+    using Test4_1 = typename tuple_element<1, typename Test4::base_type>::type;
+    using Test4_2 = typename tuple_element<2, typename Test4::base_type>::type;
+    COMPARE(Test0::size(), float_v::size());
+    COMPARE(Test1_0::size(), float_v::size());
+    COMPARE(Test1_1::size(), float_v::size());
+    COMPARE(Test1::size(), float_v::size());
+    COMPARE(Test2_0::size(), double_v::size());
+    COMPARE(Test2_1::size(), double_v::size());
+    COMPARE(Test2::size(), double_v::size());
+    COMPARE(Test3_1::size(), float_v::size());
+    COMPARE(Test3::size(), float_v::size());
+    COMPARE(Test4_0::size(), double_v::size());
+    COMPARE(Test4_2::size(), double_v::size());
+    COMPARE(Test4::size(), double_v::size());
+    COMPARE(typeid(Test4_0), typeid(double_v));
+    COMPARE(typeid(Test4_1), typeid(std::string));
+    COMPARE(typeid(Test4_2), typeid(simdize<float, double_v::size()>));
+    COMPARE(typeid(simdize<tuple<std::string>>), typeid(tuple<std::string>));
+    COMPARE(typeid(simdize<float>), typeid(float_v));
+    COMPARE(typeid(Test1),
+            typeid(SimdizeAdapter<tuple<float, double>,
+                                  tuple<float_v, simdize<double, float_v::size()>>,
+                                  float_v::size()>));
+}
+
+TEST(simdize_bools)
+{
+    using namespace std;
+    using namespace Vc;
+    COMPARE(typeid(simdize<bool>), typeid(float_m));
+    COMPARE(typeid(simdize<bool, float_m::size()>), typeid(float_m));
+    COMPARE(typeid(simdize<bool, 0, int>), typeid(int_m));
+    COMPARE(typeid(simdize<bool, int_m::size(), int>), typeid(int_m));
+    COMPARE(typeid(simdize<bool, float_m::size() + 1>),
+            typeid(SimdMaskArray<float, float_m::size() + 1>));
+    COMPARE(typeid(simdize<bool, int_m::size() + 1, int>),
+            typeid(SimdMaskArray<int, int_m::size() + 1>));
+
+    COMPARE(typeid(simdize<tuple<bool>>),
+            typeid(SimdizeAdapter<tuple<bool>, tuple<float_m>, float_m::size()>));
+    COMPARE(typeid(simdize<tuple<bool>, float_m::size()>),
+            typeid(SimdizeAdapter<tuple<bool>, tuple<float_m>, float_m::size()>));
+    COMPARE(
+        typeid(simdize<tuple<bool>, float_m::size() + 1>),
+        typeid(
+            SimdizeAdapter<tuple<bool>, tuple<SimdMaskArray<float, float_m::size() + 1>>,
+                           float_m::size() + 1>));
+
+    COMPARE(typeid(simdize<tuple<int, bool>>),
+            typeid(SimdizeAdapter<tuple<int, bool>, tuple<int_v, int_m>, int_v::size()>));
+    COMPARE(
+        typeid(simdize<tuple<int, bool>, 3>),
+        typeid(SimdizeAdapter<tuple<int, bool>,
+                              tuple<SimdArray<int, 3>, SimdMaskArray<float, 3>>, 3>));
+
+    COMPARE(
+        typeid(simdize<tuple<bool, double, bool>>),
+        typeid(SimdizeAdapter<
+            tuple<bool, double, bool>,
+            tuple<float_m,
+                  typename std::conditional<float_m::size() == double_v::size(), double_v,
+                                            SimdArray<double, float_m::size()>>::type,
+                  float_m>,
+            float_m::size()>));
+    COMPARE(typeid(simdize<tuple<bool, double, bool>, float_m::size() + 1>),
+            typeid(SimdizeAdapter<tuple<bool, double, bool>,
+                                  tuple<SimdMaskArray<float, float_m::size() + 1>,
+                                        SimdArray<double, float_m::size() + 1>,
+                                        SimdMaskArray<float, float_m::size() + 1>>,
+                                  float_m::size() + 1>));
+    COMPARE(typeid(simdize<tuple<bool, double, bool>, 0, double>),
+            typeid(SimdizeAdapter<tuple<bool, double, bool>,
+                                  tuple<double_m, double_v, double_m>, double_m::size()>));
+
+    COMPARE(typeid(simdize<tuple<int, double, bool>, 0, double>),
+            typeid(SimdizeAdapter<tuple<int, double, bool>,
+                                  tuple<int_v, simdize<double, int_v::size()>,
+                                        simdize<bool, int_v::size(), double>>,
+                                  int_v::size()>));
+}
+
+template <typename, int...> struct Foo1
+{
+    static constexpr std::size_t tuple_size = 1;
+};
+template <typename, typename, unsigned...> struct Foo2
+{
+    static constexpr std::size_t tuple_size = 2;
+};
+template <typename, typename, typename, std::size_t...> struct Foo3
+{
+    static constexpr std::size_t tuple_size = 3;
+};
+
+// ICC and MSVC do not support packs of values
+#ifndef Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+TEST(nontype_template_parameters)
+{
+    using namespace std;
+    using namespace Vc;
+    using std::array;
+
+    using float_intsize = typename std::conditional<
+        int_v::size() == float_v::size(), float_v, SimdArray<float, int_v::size()>>::type;
+
+    static_assert(SimdizeDetail::is_class_template<array<float, 3>>::value, "");
+    static_assert(SimdizeDetail::is_class_template<Foo1<float, 3, 5, 6>>::value, "");
+    static_assert(SimdizeDetail::is_class_template<Foo2<int, float, 3, 5, 6>>::value, "");
+
+    COMPARE(typeid(simdize<array<float, 3>>),
+            typeid(SimdizeAdapter<array<float, 3>, array<float_v, 3>, float_v::size()>));
+    COMPARE(typeid(simdize<array<bool, 3>>),
+            typeid(SimdizeAdapter<array<bool, 3>, array<float_m, 3>, float_m::size()>));
+    COMPARE(
+        typeid(simdize<Foo1<float, 3, 5, 6>>),
+        typeid(
+            SimdizeAdapter<Foo1<float, 3, 5, 6>, Foo1<float_v, 3, 5, 6>, float_v::size()>));
+    COMPARE(typeid(simdize<Foo2<int, float, 3, 5, 6>>),
+            typeid(SimdizeAdapter<Foo2<int, float, 3, 5, 6>,
+                                  Foo2<int_v, float_intsize, 3, 5, 6>, int_v::size()>));
+    COMPARE(
+        typeid(simdize<Foo3<int, int, float, 3, 5, 6>>),
+        typeid(
+            SimdizeAdapter<Foo3<int, int, float, 3, 5, 6>,
+                           Foo3<int_v, int_v, float_intsize, 3, 5, 6>, int_v::size()>));
+}
+#endif  // Vc_VALUE_PACK_EXPANSION_IS_BROKEN
+
+TEST(tuple_interface)
+{
+    using V0 = simdize<std::tuple<int, bool>>;
+    COMPARE(std::tuple_size<V0>::value, 2u);
+    COMPARE(typeid(typename std::tuple_element<0, V0>::type), typeid(int_v));
+    COMPARE(typeid(typename std::tuple_element<1, V0>::type), typeid(int_m));
+
+    V0 v;
+    COMPARE(typeid(decltype(std::get<0>(v))), typeid(int_v));
+    COMPARE(typeid(decltype(std::get<1>(v))), typeid(int_m));
+    std::get<0>(v) = int_v::IndexesFromZero();
+    COMPARE(std::get<0>(v), int_v::IndexesFromZero());
+    std::get<0>(v) += 1;
+    COMPARE(std::get<0>(v), int_v::IndexesFromZero() + 1);
+}
+
+TEST(assign)
+{
+    using T = std::tuple<float, unsigned>;
+    using V = simdize<T>;
+    V v;
+    for (unsigned i = 0; i < v.size(); ++i) {
+        assign(v, i, T{1.f * i, i});
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+    for (unsigned i = 0; i < v.size(); ++i) {
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+}
+
+template <typename T> T copy_by_value(T x) { return T(x); }
+
+TEST(copy)
+{
+    using T = std::tuple<float, int>;
+    using V = simdize<T>;
+    V v = {1.f, 1};
+    for (unsigned i = 0; i < v.size(); ++i) {
+        COMPARE(std::get<0>(v)[i], 1.f);
+        COMPARE(std::get<1>(v)[i], 1);
+    }
+    V v2 = copy_by_value(v);
+    for (unsigned i = 0; i < v2.size(); ++i) {
+        COMPARE(std::get<0>(v2)[i], 1.f);
+        COMPARE(std::get<1>(v2)[i], 1);
+    }
+    v = {2.f, 2};
+    v2 = copy_by_value(v);
+    for (unsigned i = 0; i < v2.size(); ++i) {
+        COMPARE(std::get<0>(v2)[i], 2.f);
+        COMPARE(std::get<1>(v2)[i], 2);
+    }
+}
+
+TEST(extract)
+{
+    using T = std::tuple<float, unsigned>;
+    using V = simdize<T>;
+    V v;
+    for (unsigned i = 0; i < v.size(); ++i) {
+        assign(v, i, T{1.f * i, i});
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+    for (unsigned i = 0; i < v.size(); ++i) {
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+    for (unsigned i = 0; i < v.size(); ++i) {
+        COMPARE(extract(v, i), T(1.f * i, i));
+    }
+}
+
+TEST(decorate)
+{
+    using T = std::tuple<float, unsigned>;
+    using V = simdize<T>;
+    V v;
+    auto vv = decorate(v);
+    for (unsigned i = 0; i < v.size(); ++i) {
+        vv[i] = T{1.f * i, i};
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+    for (unsigned i = 0; i < v.size(); ++i) {
+        COMPARE(std::get<0>(v)[i], 1.f * i);
+        COMPARE(std::get<1>(v)[i], i);
+    }
+    for (unsigned i = 0; i < v.size(); ++i) {
+        T x = vv[i];
+        COMPARE(x, T(1.f * i, i));
+    }
+    const V &v2 = v;
+    for (unsigned i = 0; i < v.size(); ++i) {
+        T x = decorate(v2)[i];
+        COMPARE(x, T(1.f * i, i));
+    }
+}
+
+TEST(broadcast)
+{
+    {
+        using T = std::tuple<float, int>;
+        using V = simdize<T>;
+
+        T scalar(2.f, 3);
+        V vector(scalar);
+        COMPARE(std::get<0>(vector), float_v(2.f));
+        COMPARE(std::get<1>(vector), (simdize<int, V::size()>(3)));
+    }
+    {
+        using T = std::array<int, 3>;
+        using V = simdize<T>;
+        T scalar{{1, 2, 3}};
+        V vector(scalar);
+        COMPARE(vector[0], int_v(1));
+        COMPARE(vector[1], int_v(2));
+        COMPARE(vector[2], int_v(3));
+    }
+}
+
+TEST(list_iterator_vectorization)
+{
+    {
+        using L = std::list<float>;
+        using LIV = simdize<L::iterator>;
+        L list;
+        for (auto i = 1024; i; --i) {
+            list.push_back(i);
+        }
+        LIV b = list.begin();
+        LIV e = list.end();
+        float_v reference = list.size() - float_v::IndexesFromZero();
+        for (; b != e; ++b, reference -= float_v::size()) {
+            float_v x = *b;
+            COMPARE(x, reference);
+            COMPARE(*b, reference);
+            *b = x + 1;
+            COMPARE(*b, reference + 1);
+            auto &&ref = *b;
+            ref = x + 2;
+            COMPARE(*b, reference + 2);
+            COMPARE(ref, reference + 2);
+            ref = x + 1;
+            COMPARE(*b, reference + 1);
+            COMPARE(ref, reference + 1);
+        }
+        reference = list.size() - float_v::IndexesFromZero() + 1;
+        for (b = list.begin(); b != e; ++b, reference -= float_v::size()) {
+            float_v x = *b;
+            COMPARE(x, reference);
+            COMPARE(*b, reference);
+        }
+    }
+    {
+        using T = std::tuple<float, unsigned, float>;
+        using V = simdize<T>;
+        using L = std::list<T>;
+        using LIV = simdize<L::iterator>;
+        L list;
+        for (auto i = 1024; i; --i) {
+            list.push_back(T(i, i * 2, i * 3));
+        }
+        LIV b = list.begin();
+        LIV e = list.end();
+        auto reference1 = list.size() - float_v::IndexesFromZero();
+        auto reference2 =
+            unsigned(list.size()) - simdize<unsigned, V::size()>::IndexesFromZero();
+        for (; b != e; ++b, reference1 -= int(V::size()), reference2 -= int(V::size())) {
+            V x = *b;
+            COMPARE(x, V(reference1, reference2 * 2, reference1 * 3));
+            COMPARE(std::get<0>(*b), reference1);
+        }
+    }
+}
+
+TEST_TYPES(L, cast_simdized_iterator_to_scalar,
+           (std::vector<float>, std::list<float>, std::vector<std::tuple<float, int>>))
+{
+    using T = typename L::value_type;
+    using LI = typename L::iterator;
+    using LIV = simdize<LI>;
+    L list;
+    for (auto i = 13; i; --i) {
+        list.push_back(T());
+    }
+    LIV b = list.begin();
+    LIV e = list.end();
+    COMPARE(static_cast<LI>(b), list.begin());
+    COMPARE(static_cast<LI>(e), list.end());
+}
+
+TEST(vector_iterator_vectorization)
+{
+    {
+        using L = std::vector<float>;
+        using LIV = simdize<L::iterator>;
+        L list;
+        for (auto i = 1024; i; --i) {
+            list.push_back(i);
+        }
+        LIV b = list.begin();
+        LIV e = list.end();
+        const auto &bconst = b;
+
+        COMPARE(b->sum(), (1024 - float_v::IndexesFromZero()).sum());
+        COMPARE(bconst->sum(), (1024 - float_v::IndexesFromZero()).sum());
+        COMPARE((*b).sum(), (1024 - float_v::IndexesFromZero()).sum());
+        COMPARE((*bconst).sum(), (1024 - float_v::IndexesFromZero()).sum());
+        COMPARE((e - 1)->sum(), (1 + float_v::IndexesFromZero()).sum());
+        COMPARE((e + -1)->sum(), (1 + float_v::IndexesFromZero()).sum());
+        COMPARE((-1 + e)->sum(), (1 + float_v::IndexesFromZero()).sum());
+        COMPARE((b + 1)->sum(), (1024 - b.size() - float_v::IndexesFromZero()).sum());
+        COMPARE((1 + b)->sum(), (1024 - b.size() - float_v::IndexesFromZero()).sum());
+        COMPARE(e - b, static_cast<LIV::difference_type>(1024 / b.size()));
+        COMPARE(b - e, -static_cast<LIV::difference_type>(1024 / b.size()));
+
+        VERIFY(b < e);
+        VERIFY(!(b > e));
+        VERIFY(e > b);
+        VERIFY(!(e < b));
+        VERIFY(b <= e);
+        VERIFY(!(b >= e));
+        VERIFY(e >= b);
+        VERIFY(!(e <= b));
+        VERIFY(b != e);
+        VERIFY(!(b == e));
+
+        VERIFY(!(b < b));
+        VERIFY(!(b > b));
+        if (b.size() > 1) {
+            VERIFY(!(b <= b));
+            VERIFY(!(b >= b));
+        } else {
+            VERIFY(b <= b);
+            VERIFY(b >= b);
+        }
+        VERIFY(b == b);
+        VERIFY(!(b != b));
+
+        auto next = b + 1;
+        VERIFY(next > b);
+        VERIFY(!(b > next));
+        VERIFY(!(next < b));
+        VERIFY(b < next);
+        VERIFY(next >= b);
+        VERIFY(!(b >= next));
+        VERIFY(!(next <= b));
+        VERIFY(b <= next);
+        VERIFY(b != next);
+        VERIFY(!(b == next));
+
+        next--;
+        COMPARE(next, b);
+        COMPARE(*next, *b);
+
+
+        float_v reference = list.size() - float_v::IndexesFromZero();
+        for (; b != e; ++b, reference -= float_v::size()) {
+            float_v x = *b;
+            COMPARE(x, reference);
+            COMPARE(*b, reference);
+            *b = x + 1;
+            COMPARE(*b, reference + 1);
+        }
+        reference = list.size() - float_v::IndexesFromZero() + 1;
+        for (b = list.begin(); b != e; ++b, reference -= float_v::size()) {
+            float_v x = *b;
+            COMPARE(x, reference);
+            COMPARE(*b, reference);
+        }
+    }
+}
+
+TEST(shifted)
+{
+    using T = std::tuple<float, int>;
+    using V = simdize<T>;
+
+    using V0 = float_v;
+    using V1 = simdize<int, V::size()>;
+
+    V v;
+    std::get<0>(v) = V0::IndexesFromZero() + 1;
+    std::get<1>(v) = V1::IndexesFromZero() + 1;
+
+    for (int shift = -int(V::size()); shift <= int(V::size()); ++shift) {
+        V test = shifted(v, shift);
+        COMPARE(std::get<0>(test), (V0::IndexesFromZero() + 1).shifted(shift));
+        COMPARE(std::get<1>(test), (V1::IndexesFromZero() + 1).shifted(shift));
+        V test2 = decorate(v).shifted(shift);
+        COMPARE(test2, test);
+    }
+
+    V test = shifted(v, int(V::size()));
+    COMPARE(test, V{});
+
+    test = shifted(v, -int(V::size()));
+    COMPARE(test, V{});
+
+    V reference{};
+    assign(reference, 0, T(V::size(), V::size()));
+    test = shifted(v, int(V::size()) - 1);
+    COMPARE(test, reference);
+
+    reference = {};
+    assign(reference, V::size() - 1, T(1, 1));
+    test = shifted(v, -int(V::size()) + 1);
+    COMPARE(test, reference);
+}
+
+TEST(swap)
+{
+    using T = std::tuple<float, int>;
+    using V = simdize<T>;
+
+    using V0 = float_v;
+    using V1 = simdize<int, V::size()>;
+
+    V v;
+    std::get<0>(v) = V0::IndexesFromZero() + 1;
+    std::get<1>(v) = V1::IndexesFromZero() + 1;
+    for (std::size_t i = 0; i < V::size(); ++i) {
+        const T atI(1 + i, 1 + i);
+
+        T scalar(V::size() + 1, V::size() + 1);
+        T copy = scalar;
+
+        COMPARE(extract(v, i), atI);
+        swap(v, i, scalar);
+        COMPARE(scalar, atI);
+        COMPARE(extract(v, i), copy);
+
+        for (std::size_t j = 0; j < V::size(); ++j) {
+            if (j != i) {
+                COMPARE(extract(v, j), T(j + 1, j + 1));
+            }
+        }
+
+        std::swap(scalar, decorate(v)[i]);
+        COMPARE(scalar, copy);
+        COMPARE(extract(v, i), atI);
+
+        for (std::size_t j = 0; j < V::size(); ++j) {
+            if (j != i) {
+                COMPARE(extract(v, j), T(j + 1, j + 1));
+            }
+        }
+    }
+
+    if (V::size() > 1) {
+        auto vv = decorate(v);
+        COMPARE(T(vv[0]), T(1, 1));
+        COMPARE(T(vv[1]), T(2, 2));
+        std::swap(vv[0], vv[1]);
+        COMPARE(T(vv[0]), T(2, 2));
+        COMPARE(T(vv[1]), T(1, 1));
+        swap(v, 0, v, 1);
+        COMPARE(T(vv[0]), T(1, 1));
+        COMPARE(T(vv[1]), T(2, 2));
+    }
+}
+
+TEST(conditional_assignment)
+{
+    using T = std::tuple<float, int, double>;
+    using V = simdize<T>;
+
+    using V0 = float_v;
+    using V1 = simdize<int, V::size()>;
+    using V2 = simdize<double, V::size()>;
+    using M0 = typename V0::mask_type;
+    using M1 = typename V1::mask_type;
+    using M2 = typename V2::mask_type;
+
+    V v;
+    UnitTest::withRandomMask<V0, 1000>([&](M0 m) {
+        using Vc::simd_cast;
+        std::get<0>(v) = V0::IndexesFromZero() + 1;
+        std::get<1>(v) = V1::IndexesFromZero() + 1;
+        std::get<2>(v) = V2::IndexesFromZero() + 1;
+
+        where(m) | v = V{};
+        COMPARE(std::get<0>(v) == V0::Zero(), m) << std::get<0>(v);
+        COMPARE(std::get<1>(v) == V1::Zero(), simd_cast<M1>(m)) << std::get<1>(v);
+        COMPARE(std::get<2>(v) == V2::Zero(), simd_cast<M2>(m)) << std::get<2>(v);
+
+        where(m) | v += V{T{V::size() + 2, V::size() + 2, V::size() + 2}};
+        COMPARE(std::get<0>(v) == V0(V::size() + 2), m) << std::get<0>(v);
+        COMPARE(std::get<1>(v) == V1(V::size() + 2), simd_cast<M1>(m)) << std::get<1>(v);
+        COMPARE(std::get<2>(v) == V2(V::size() + 2), simd_cast<M2>(m)) << std::get<2>(v);
+
+        where(m) | v *= V{T{2, 2, 2}};
+        COMPARE(std::get<0>(v) == V0(2 * (V::size() + 2)), m) << std::get<0>(v);
+        COMPARE(std::get<1>(v) == V1(2 * (V::size() + 2)), simd_cast<M1>(m)) << std::get<1>(v);
+        COMPARE(std::get<2>(v) == V2(2 * (V::size() + 2)), simd_cast<M2>(m)) << std::get<2>(v);
+
+        where(m) | v -= V{T{V::size() + 2, V::size() + 2, V::size() + 2}};
+        COMPARE(std::get<0>(v) == V0(V::size() + 2), m) << std::get<0>(v);
+        COMPARE(std::get<1>(v) == V1(V::size() + 2), simd_cast<M1>(m)) << std::get<1>(v);
+        COMPARE(std::get<2>(v) == V2(V::size() + 2), simd_cast<M2>(m)) << std::get<2>(v);
+    });
+}
+
+TEST(copy_simdized_objects)
+{
+    using T = std::tuple<float, double>;
+    using V = simdize<T>;
+
+    using V0 = typename std::tuple_element<0, V>::type;
+    using V1 = typename std::tuple_element<1, V>::type;
+
+    V v;
+    V v2 = v;
+    v = v2;
+    v2 = std::move(v);
+    V v3 = std::move(v2);
+    COMPARE(std::get<0>(v3), V0::Zero());
+    COMPARE(std::get<1>(v3), V1::Zero());
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/sorted.cpp vc-1.3.0/tests/sorted.cpp
--- vc-0.7.4/tests/sorted.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/sorted.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,92 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+TEST_TYPES(Vec, testSort, (ALL_VECTORS, SIMD_ARRAYS(15), SIMD_ARRAYS(8), SIMD_ARRAYS(3), SIMD_ARRAYS(1)))
+{
+// On GCC/clang (i.e. __GNUC__ compatible) __OPTIMIZE__ is not defined on -O0.
+// We use this information to make the test complete in a sane timeframe on debug
+// builds.
+#if !defined __GNUC__ || defined __OPTIMIZE__
+    Vec ref(Vc::IndexesFromZero);
+    Vec a;
+    using limits = std::numeric_limits<typename Vec::value_type>;
+    if (limits::has_infinity) {
+        ref[0] = -std::numeric_limits<typename Vec::value_type>::infinity();
+        if (Vec::size() > 2) {
+            ref[Vec::Size - 1] =
+                std::numeric_limits<typename Vec::value_type>::infinity();
+        }
+    }
+
+    int maxPerm = 1;
+    for (int x = Vec::Size; x > 0 && maxPerm < 200000; --x) {
+        maxPerm *= x;
+    }
+    for (int perm = 0; perm < maxPerm; ++perm) {
+        int rest = perm;
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            a[i] = 0;
+            for (size_t j = 0; j < i; ++j) {
+                if (a[i] == a[j]) {
+                    ++a[i];
+                    j = -1;
+                }
+            }
+            a[i] += rest % (Vec::Size - i);
+            rest /= (Vec::Size - i);
+            for (size_t j = 0; j < i; ++j) {
+                if (a[i] == a[j]) {
+                    ++a[i];
+                    j = -1;
+                }
+            }
+        }
+        if (limits::has_infinity) {
+            where(a == 0) | a =
+                -std::numeric_limits<typename Vec::value_type>::infinity();
+            if (Vec::size() > 2) {
+                where(a == int(Vec::Size) - 1) | a =
+                    std::numeric_limits<typename Vec::value_type>::infinity();
+            }
+        }
+        COMPARE(a.sorted(), ref) << ", a: " << a;
+    }
+#endif
+
+    for (int repetition = 0; repetition < 1000; ++repetition) {
+        Vec test = Vec::Random();
+        alignas(static_cast<size_t>(
+            Vec::MemoryAlignment)) typename Vec::EntryType reference[Vec::Size] = {};
+        test.store(&reference[0], Vc::Aligned);
+        std::sort(std::begin(reference), std::end(reference));
+        COMPARE(test.sorted(), Vec(&reference[0], Vc::Aligned));
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/sse_blend.cpp vc-1.3.0/tests/sse_blend.cpp
--- vc-0.7.4/tests/sse_blend.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/sse_blend.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,23 +1,31 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "unittest.h"
+#include "unittest-old.h"
 #include <sse/intrinsics.h>
 
 namespace std
@@ -37,62 +45,51 @@
 }
 } // namespace std
 
+namespace UnitTest
+{
 template<> inline bool unittest_compareHelper<__m128i, __m128i>(const __m128i &a, const __m128i &b)
 {
     return _mm_movemask_epi8(_mm_cmpeq_epi16(a, b)) == 0xffff;
 }
+}  // namespace UnitTest
 
 void blendpd()
 {
-#ifdef VC_IMPL_SSE4_1
-#define blend _mm_blend_pd
-#else
-#define blend Vc::SSE::mm_blend_pd
-#endif
+    using Vc::SSE::blend_pd;
     __m128d a = _mm_set_pd(11, 10);
     __m128d b = _mm_set_pd(21, 20);
 
-    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend(a, b, 0x0), a)), 0x3);
-    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend(a, b, 0x1), _mm_set_pd(11, 20))), 0x3);
-    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend(a, b, 0x2), _mm_set_pd(21, 10))), 0x3);
-    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend(a, b, 0x3), b)), 0x3);
-#undef blend
+    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend_pd<0x0>(a, b), a)), 0x3);
+    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend_pd<0x1>(a, b), _mm_set_pd(11, 20))), 0x3);
+    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend_pd<0x2>(a, b), _mm_set_pd(21, 10))), 0x3);
+    COMPARE(_mm_movemask_pd(_mm_cmpeq_pd(blend_pd<0x3>(a, b), b)), 0x3);
 }
 void blendps()
 {
-#ifdef VC_IMPL_SSE4_1
-#define blend _mm_blend_ps
-#else
-#define blend Vc::SSE::mm_blend_ps
-#endif
+    using Vc::SSE::blend_ps;
     __m128 a = _mm_set_ps(13, 12, 11, 10);
     __m128 b = _mm_set_ps(23, 22, 21, 20);
 
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x0), a)), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x1), _mm_set_ps(13, 12, 11, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x2), _mm_set_ps(13, 12, 21, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x3), _mm_set_ps(13, 12, 21, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x4), _mm_set_ps(13, 22, 11, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x5), _mm_set_ps(13, 22, 11, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x6), _mm_set_ps(13, 22, 21, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x7), _mm_set_ps(13, 22, 21, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x8), _mm_set_ps(23, 12, 11, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0x9), _mm_set_ps(23, 12, 11, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xa), _mm_set_ps(23, 12, 21, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xb), _mm_set_ps(23, 12, 21, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xc), _mm_set_ps(23, 22, 11, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xd), _mm_set_ps(23, 22, 11, 20))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xe), _mm_set_ps(23, 22, 21, 10))), 0xf);
-    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend(a, b, 0xf), b)), 0xf);
-#undef blend
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x0>(a, b), a)), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x1>(a, b), _mm_set_ps(13, 12, 11, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x2>(a, b), _mm_set_ps(13, 12, 21, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x3>(a, b), _mm_set_ps(13, 12, 21, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x4>(a, b), _mm_set_ps(13, 22, 11, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x5>(a, b), _mm_set_ps(13, 22, 11, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x6>(a, b), _mm_set_ps(13, 22, 21, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x7>(a, b), _mm_set_ps(13, 22, 21, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x8>(a, b), _mm_set_ps(23, 12, 11, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0x9>(a, b), _mm_set_ps(23, 12, 11, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xa>(a, b), _mm_set_ps(23, 12, 21, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xb>(a, b), _mm_set_ps(23, 12, 21, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xc>(a, b), _mm_set_ps(23, 22, 11, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xd>(a, b), _mm_set_ps(23, 22, 11, 20))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xe>(a, b), _mm_set_ps(23, 22, 21, 10))), 0xf);
+    COMPARE(_mm_movemask_ps(_mm_cmpeq_ps(blend_ps<0xf>(a, b), b)), 0xf);
 }
 void blendepi16()
 {
-#ifdef VC_IMPL_SSE4_1
-#define blend _mm_blend_epi16
-#else
-#define blend Vc::SSE::mm_blend_epi16
-#endif
+    using Vc::SSE::blend_epi16;
     __m128i a = _mm_set_epi16(17, 16, 15, 14, 13, 12, 11, 10);
     __m128i b = _mm_set_epi16(27, 26, 25, 24, 23, 22, 21, 20);
 
@@ -112,12 +109,11 @@
             r[j] = j + ((((i >> j) & 1) == 0) ? 10 : 20);
         }
         __m128i reference = _mm_set_epi16(r[7], r[6], r[5], r[4], r[3], r[2], r[1], r[0]);
-        COMPARE_NOEQ(blend(a, b, i), reference);
+        COMPARE_NOEQ(blend_epi16<i>(a, b), reference);
     )
-#undef blend
 }
 
-int main()
+void testmain()
 {
     runTest(blendpd);
     runTest(blendps);
diff -Nru vc-0.7.4/tests/stlcontainer.cpp vc-1.3.0/tests/stlcontainer.cpp
--- vc-0.7.4/tests/stlcontainer.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/stlcontainer.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,5 +1,5 @@
 /*{{{
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2012-2015 Matthias Kretz <kretz@kde.org>
 
     Permission to use, copy, modify, and distribute this software
     and its documentation for any purpose and without fee is hereby
@@ -21,9 +21,13 @@
 
 }}}*/
 
+#include "unittest.h"
 #include <Vc/Allocator>
 #include <vector>
-#include "unittest.h"
+#include <array>
+#include <forward_list>
+#include <list>
+#include <deque>
 
 #include "common/macros.h"
 
@@ -33,14 +37,13 @@
         // on 32bit the maximal alignment is 4 Bytes, even for 8-Byte doubles.
         return std::min(sizeof(void*), sizeof(typename Vec::EntryType)) - 1;
     }
-    // sizeof(SSE::sfloat_v) is too large
     // AVX::VectorAlignment is too large
     return std::min<size_t>(sizeof(Vec), Vc::VectorAlignment) - 1;
 }
 
 template<typename T> struct SomeStruct { char a; T x; };
 
-template<typename V> void stdVectorAlignment()
+TEST_TYPES(V, stdVectorAlignment, (ALL_VECTORS))
 {
     const size_t mask = alignmentMask<V>();
     const char *const null = 0;
@@ -60,16 +63,114 @@
 
     typedef typename V::EntryType T;
     for (int i = 1; i < 100; ++i) {
-        std::vector<T, Vc::Allocator<T> > v5(i);
-        const size_t expectedAlignment = Vc_ALIGNOF(V);
-        COMPARE((&v5[0] - static_cast<const T *>(0)) * sizeof(T) & (expectedAlignment - 1), 0u);
+        std::vector<T, Vc::Allocator<T>> v5(i);
+        const size_t expectedAlignment = alignof(V);
+        COMPARE(reinterpret_cast<std::uintptr_t>(v5.data()) & (expectedAlignment - 1), 0u)
+            << "expectedAlignment: " << expectedAlignment;
     }
 }
 
-int main(int argc, char **argv)
+template <typename V, typename Container, std::size_t... Indexes>
+void listInitializationImpl(Vc::index_sequence<Indexes...>)
+{
+    typedef typename V::EntryType T;
+    const auto data = Vc::makeContainer<Container>({T(Indexes + 1)...});
+    V reference = V::IndexesFromZero() + 1;
+    for (const auto &v : data) {
+        reference.setZero(reference > int(sizeof...(Indexes)));
+        COMPARE(v, reference) << UnitTest::typeToString<Container>() << " -> "
+                              << UnitTest::typeToString<decltype(data)>();
+        reference += int(V::size());
+    }
+}
+TEST_TYPES(V, listInitialization, (ALL_VECTORS))
 {
-    initTest(argc, argv);
+    listInitializationImpl<V, std::vector<V>>(Vc::make_index_sequence<9>());
+    listInitializationImpl<V, std::vector<V>>(Vc::make_index_sequence<3>());
+    listInitializationImpl<V, std::array<V, 9>>(Vc::make_index_sequence<9>());
+    listInitializationImpl<V, std::array<V, 3>>(Vc::make_index_sequence<3>());
+#ifndef Vc_MSVC
+    listInitializationImpl<V, std::deque<V>>(Vc::make_index_sequence<9>());
+    listInitializationImpl<V, std::deque<V>>(Vc::make_index_sequence<3>());
+#endif
+
+    // The following two crash (at least with AVX). Probably unaligned memory access.
+    //listInitialization<V, std::forward_list<V>>();
+    //listInitialization<V, std::list<V>>();
+}
 
-    using namespace Vc;
-    testAllTypes(stdVectorAlignment);
+#ifdef Vc_CXX14
+TEST_TYPES(V, simdForEach, (ALL_VECTORS))
+{
+    typedef typename V::EntryType T;
+    std::vector<T> data;
+    data.resize(100);
+
+    for (int variant = 0; variant < 2; ++variant) {
+        std::iota(data.begin(), data.end(), T(0));
+        T reference = 1;
+        int called_with_scalar = 0;
+        int called_with_V = 0;
+        int position = 1;
+
+        auto &&test1 = [&](auto &x) {
+            const auto ref = reference + x.IndexesFromZero();
+            COMPARE(ref, x);
+            reference += x.Size;
+            x += 1;
+            if (std::is_same<decltype(x), Vc::Scalar::Vector<T> &>::value) {
+                ++called_with_scalar;
+            }
+            if (std::is_same<decltype(x), V &>::value) {
+                ++called_with_V;
+            }
+            for (std::size_t i = 0; i < x.Size; ++i) {
+                data[position++] += T(2);  // modify the container directly - if it is not
+                                           // undone by simd_for_each we have a bug
+            }
+        };
+        auto &&test2 = [&](auto x) {
+            const auto ref = reference + x.IndexesFromZero();
+            COMPARE(ref, x);
+            reference += x.Size;
+            x += 1;
+            for (std::size_t i = 0; i < x.Size; ++i) {
+                data[position++] += T(2);  // modify the container directly - if it is
+                                           // undone by simd_for_each we have a bug
+            }
+        };
+        auto &&test3 = [&reference](auto x) {
+            const auto ref = reference + x.IndexesFromZero();
+            COMPARE(ref, x) << "if ref == x + 2 then simd_for_each wrote back the "
+                               "closure argument, even though it should not have";
+            reference += x.Size;
+        };
+
+        auto &&for_each = [&](auto test) {
+            auto b = std::next(data.begin());
+            if (variant == 0) {
+                Vc::simd_for_each(b, data.end(), test);
+            } else {
+                Vc::simd_for_each_n(b, data.size() - 1, test);
+            }
+        };
+        for_each(test1);
+        VERIFY(called_with_scalar > 0);
+        VERIFY(called_with_V > 0);
+        if (Vc::Scalar::is_vector<V>::value) {
+            // in this case called_with_V and called_with_scalar will have been
+            // incremented both on every call
+            COMPARE(called_with_V, called_with_scalar);
+            COMPARE(called_with_scalar, int(data.size() - 1));
+        } else {
+            COMPARE(called_with_V * V::Size + called_with_scalar, data.size() - 1);
+        }
+
+        reference = 2;
+        position = 1;
+        for_each(test2);
+        reference = 4;
+        for_each(test3);
+    }
 }
+#endif
diff -Nru vc-0.7.4/tests/store.cpp vc-1.3.0/tests/store.cpp
--- vc-0.7.4/tests/store.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/store.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,23 +1,31 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2011 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
+}}}*/
 
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "unittest.h"
+#include "unittest-old.h"
 #include <iostream>
 #include <cstring>
 
@@ -37,12 +45,30 @@
     T xValue = 1;
     const Vec x(xValue);
     for (int i = 0; i < Count; i += Vec::Size) {
-        x.store(&array[i]);
+        x.store(&array[i], Vc::Aligned);
     }
 
     for (int i = 0; i < Count; ++i) {
         COMPARE(array[i], xValue);
     }
+
+    // make sure store can be used with parameters that auto-convert to T*
+    x.store(array, Vc::Aligned);
+
+    if (std::is_integral<T>::value && std::is_unsigned<T>::value) {
+        // ensure that over-/underflowed values are stored correctly.
+        Vec v = Vec::Zero() - Vec::One(); // underflow
+        v.store(array, Vc::Aligned);
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            COMPARE(array[i], v[i]);
+        }
+
+        v = std::numeric_limits<T>::max() + Vec::One(); // overflow
+        v.store(array, Vc::Aligned);
+        for (size_t i = 0; i < Vec::Size; ++i) {
+            COMPARE(array[i], v[i]);
+        }
+    }
 }
 
 template<typename Vec> void unalignedStore()
@@ -58,11 +84,11 @@
     std::memset(array, 0xff, Count * sizeof(T));
     T xValue = 1;
     const Vec x(xValue);
-    for (int i = 1; i < Count - Vec::Size + 1; i += Vec::Size) {
+    for (size_t i = 1; i < Count - Vec::Size + 1; i += Vec::Size) {
         x.store(&array[i], Unaligned);
     }
 
-    for (int i = 1; i < Count - Vec::Size + 1; ++i) {
+    for (size_t i = 1; i < Count - Vec::Size + 1; ++i) {
         COMPARE(array[i], xValue);
     }
 }
@@ -102,11 +128,11 @@
     std::memset(array, 0xff, Count * sizeof(T));
     T xValue = 1;
     const Vec x(xValue);
-    for (int i = 1; i < Count - Vec::Size + 1; i += Vec::Size) {
+    for (size_t i = 1; i < Count - Vec::Size + 1; i += Vec::Size) {
         x.store(&array[i], Streaming | Unaligned);
     }
 
-    for (int i = 1; i < Count - Vec::Size + 1; ++i) {
+    for (size_t i = 1; i < Count - Vec::Size + 1; ++i) {
         COMPARE(array[i], xValue);
     }
 }
@@ -120,45 +146,61 @@
         typedef typename Vec::IndexType I;
         const I tmp(IndexesFromZero);
         const typename I::Mask k = (tmp & I(One)) > 0;
-        mask = M(k);
+        mask = simd_cast<M>(k);
     }
 
     const int count = 256 * 1024 / sizeof(T);
-    const int outerCount = count / Vec::Size;
     Vc::Memory<Vec> array(count);
-	array.setZero();
+    array.setZero();
     const T nullValue = 0;
     const T setValue = 170;
     const Vec x(setValue);
     for (int i = 0; i < count; i += Vec::Size) {
-        x.store(&array[i], mask);
+        x.store(&array[i], mask, Vc::Aligned);
     }
 
     for (int i = 1; i < count; i += 2) {
-        COMPARE(array[i], setValue) << ", i: " << i << ", count: " << count << ", outer: " << outerCount;
+        COMPARE(array[i], setValue) << ", i: " << i << ", count: " << count << ", mask: " << mask << ", array:\n" << array;
     }
     for (int i = 0; i < count; i += 2) {
-        COMPARE(array[i], nullValue) << ", i: " << i << ", count: " << count << ", outer: " << outerCount;
+        COMPARE(array[i], nullValue) << ", i: " << i << ", count: " << count << ", mask: " << mask << ", array:\n" << array;
+    }
+
+    for (int offset = 0; offset < count - int(Vec::Size); ++offset) {
+        auto mem = &array[offset];
+        Vec::Zero().store(mem, Vc::Unaligned);
+
+        constexpr std::ptrdiff_t alignment = sizeof(T) * Vec::Size;
+        constexpr std::ptrdiff_t alignmentMask = ~(alignment - 1);
+
+        const auto loAddress = reinterpret_cast<T *>(
+            (reinterpret_cast<char *>(mem) - static_cast<const char *>(0)) & alignmentMask);
+        const auto offset2 = mem - loAddress;
+
+        const Vec rand = Vec::Random();
+        const auto mean = (rand / T(Vec::Size)).sum();
+        mask = rand < mean;
+        rand.store(mem, mask, Vc::Unaligned);
+        for (std::size_t i = 0; i < Vec::Size; ++i) {
+            COMPARE(mem[i], mask[i] ? rand[i] : T(0))
+                << ", i: " << i << ", mask: " << mask << "\nrand: " << rand << "\nmean: " << mean
+                << ", offset: " << offset << ", offset2: " << offset2 << ", mem: " << mem
+                << ", loAddress: " << loAddress;
+        }
     }
 }
 
-int main(int argc, char **argv)
+void testmain()
 {
-    initTest(argc, argv);
-
     testAllTypes(alignedStore);
     testAllTypes(unalignedStore);
     testAllTypes(streamingAndAlignedStore);
     testAllTypes(streamingAndUnalignedStore);
 
     if (float_v::Size > 1) {
-        runTest(maskedStore<int_v>);
-        runTest(maskedStore<uint_v>);
-        runTest(maskedStore<float_v>);
-        runTest(maskedStore<double_v>);
-        runTest(maskedStore<short_v>);
-        runTest(maskedStore<ushort_v>);
-        runTest(maskedStore<sfloat_v>);
+        // only works with an even number of vector entries
+        // a) masked store with 01010101 will use only 0 for size 1
+        // b) the random masks will not be random, because mean == value
+        testAllTypes(maskedStore);
     }
-    return 0;
 }
diff -Nru vc-0.7.4/tests/subscript.cpp vc-1.3.0/tests/subscript.cpp
--- vc-0.7.4/tests/subscript.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/subscript.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,363 @@
+/*{{{
+    Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#include "unittest.h"
+#include <Vc/array>
+#include <Vc/vector>
+
+#define ALL_TYPES (ALL_VECTORS)
+
+TEST_TYPES(V, init, ALL_TYPES)
+{
+    typedef typename V::EntryType T;
+    Vc::array<T, 256> data;
+    Vc::vector<T> data2(256);
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        data[i] = i;
+        data2[i] = i;
+    }
+
+    std::initializer_list<T> initList1 = {T(), T()};
+    const std::initializer_list<T> initList2 = {T(), T()};
+
+    Vc::vector<T> ctorTest1(6, T());
+    Vc::vector<T> ctorTest2{T(), T()};
+    Vc::vector<T> ctorTest3 = initList1;
+    Vc::vector<T> ctorTest4 = initList2;
+    Vc::vector<T> ctorTest5(initList1);
+    Vc::vector<T> ctorTest6(initList2);
+    COMPARE(ctorTest1.size(), 6u);
+    COMPARE(ctorTest2.size(), 2u);
+    COMPARE(ctorTest3.size(), 2u);
+    COMPARE(ctorTest4.size(), 2u);
+    COMPARE(ctorTest5.size(), 2u);
+    COMPARE(ctorTest6.size(), 2u);
+}
+
+template <typename V>
+static typename std::enable_if<Vc::is_unsigned<V>::value, V>::type positiveRandom()
+{
+    return V::Random();
+}
+template <typename V>
+static typename std::enable_if<!Vc::is_unsigned<V>::value, V>::type positiveRandom()
+{
+    return abs(V::Random());
+}
+
+template <typename V, int Modulo> static V randomIndexes()
+{
+    V indexes = positiveRandom<V>() % Modulo;
+    for (std::size_t i = 0; i < V::Size; ++i) {
+        while ((indexes == static_cast<int>(indexes[i])).count() !=
+               1) {  // the static_cast prevents an ICE with GCC 4.8.1
+            indexes[i] = (indexes[i] + 1) % Modulo;
+        }
+    }
+    if (V::size() > 1) {
+        VERIFY(none_of(indexes.sorted() == indexes.sorted().rotated(1)))
+            << "\nindexes must not contain duplicate values, otherwise the scatter tests "
+               "will fail without actually doing anything wrong!\nindexes: " << indexes;
+    }
+    return indexes;
+}
+
+TEST_TYPES(V, gathers, ALL_TYPES)
+{
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType IT;
+    Vc::array<T, 256> data;
+    Vc::vector<T> data2(256);
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        data[i] = i;
+        data2[i] = i;
+    }
+
+    static_assert(Vc::Common::is_valid_indexvector_<const IT &>::value, "");
+    V test = data[IT::IndexesFromZero()];
+    COMPARE(test, V::IndexesFromZero());
+    test = data2[IT::IndexesFromZero()];
+    COMPARE(test, V::IndexesFromZero());
+
+    for (std::size_t repetition = 0; repetition < 1024 / V::Size; ++repetition) {
+        const IT indexes = randomIndexes<IT, 256>();
+        test = data[indexes];
+        COMPARE(test, Vc::simd_cast<V>(indexes));
+        test = data2[indexes];
+        COMPARE(test, Vc::simd_cast<V>(indexes));
+    }
+}
+
+template <typename T, std::size_t N>
+std::ostream &operator<<(std::ostream &s, const Vc::array<T, N> &data)
+{
+    for (std::size_t i = 0; i < N; ++i) {
+        s << data[i];
+        if (i % 32 == 31) {
+            s << '\n';
+        } else {
+            s << ' ';
+        }
+    }
+    s << std::setw(0);
+    return s;
+}
+
+TEST_TYPES(V, scatters, ALL_TYPES)
+{
+    static_assert(std::is_same<decltype(V() + 1), V>::value, "");
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType IT;
+    Vc::array<T, 256> data1;
+    Vc::vector<T> data2(256);
+    std::fill_n(&data1[0], 256, 0);
+    std::fill_n(&data2[0], 256, 0);
+
+    data1[IT::IndexesFromZero()] = V::IndexesFromZero();
+    data2[IT::IndexesFromZero()] = V::IndexesFromZero();
+
+    for (size_t i = 0; i < V::Size; ++i) {
+        COMPARE(data1[i], T(i));
+        COMPARE(data2[i], T(i));
+    }
+
+    for (std::size_t repetition = 0; repetition < 1024 / V::Size; ++repetition) {
+        std::fill_n(&data1[0], 256, 0);
+        std::fill_n(&data2[0], 256, 0);
+
+        const IT indexes = randomIndexes<IT, 256>();
+        data1[indexes] = V::IndexesFromZero() + 1;
+        data2[indexes] = V::IndexesFromZero() + 1;
+
+        //std::cerr << data1 << '\n';
+
+        for (size_t i = 0; i < V::Size; ++i) {
+            COMPARE(data1[indexes[i]], T(i + 1)) << ", indexes: " << indexes
+                                                 << ", i: " << i << ", data1:\n" << data1;
+            COMPARE(data2[indexes[i]], T(i + 1)) << ", indexes: " << indexes
+                                                 << ", i: " << i << ", data2:\n" << data2;
+        }
+    }
+}
+
+template <typename T, std::size_t Align = alignof(T)> struct S {
+    void operator=(int x)
+    {
+        a = x;
+        b = x + 1;
+        c = x + 2;
+    }
+    double x0;
+    alignas(Align) T a;
+    char x1;
+    alignas(Align) T b;
+    short x2;
+    alignas(Align) T c;
+    char x3;
+};
+
+TEST_TYPES(V, structGathers, ALL_TYPES)
+{
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType IT;
+    Vc::array<S<T, alignof(T)>, 256> data1;
+    Vc::array<S<S<T>>, 256> data2;
+    Vc::array<S<S<S<T>>>, 256> data3;
+    Vc::array<S<S<S<S<T>>>>, 256> data4;
+    for (int i = 0; i < 256; ++i) {
+        data1[i] = i;
+        data2[i] = i;
+        data3[i] = i;
+        data4[i] = i;
+    }
+
+    V test;
+
+    test = data1[IT::IndexesFromZero()][&S<T>::a];
+    COMPARE(test, V::IndexesFromZero());
+    test = data1[IT::IndexesFromZero()][&S<T>::b];
+    COMPARE(test, V::IndexesFromZero() + 1);
+    test = data1[IT::IndexesFromZero()][&S<T>::c];
+    COMPARE(test, V::IndexesFromZero() + 2);
+
+    test = -V(data1[IT::IndexesFromZero()][&S<T>::a]);
+    COMPARE(test, -V::IndexesFromZero());
+    test = data1[IT::IndexesFromZero()][&S<T>::a] + V::One();
+    COMPARE(test, V::IndexesFromZero() + 1);
+    // TODO: should this work? if yes, how? a gather needs to know the type it gets converted to,
+    // applying a unary operator before conversion implies that all operations must be delayed until
+    // conversion. => expression templates?
+    //test = -data1[IT::IndexesFromZero()][&S<T>::a];
+    //COMPARE(test, -V::IndexesFromZero());
+
+    test = data2[IT::IndexesFromZero()][&S<S<T>>::a][&S<T>::a];
+    COMPARE(test, V::IndexesFromZero());
+    test = data2[IT::IndexesFromZero()][&S<S<T>>::b][&S<T>::c];
+    COMPARE(test, V::IndexesFromZero() + 3);
+
+    test = data3[IT::IndexesFromZero()][&S<S<S<T>>>::a][&S<S<T>>::a][&S<T>::a];
+    COMPARE(test, V::IndexesFromZero());
+    test = data3[IT::IndexesFromZero()][&S<S<S<T>>>::b][&S<S<T>>::c][&S<T>::b];
+    COMPARE(test, V::IndexesFromZero() + 4);
+
+    test = data4[IT::IndexesFromZero()][&S<S<S<S<T>>>>::a][&S<S<S<T>>>::a][&S<S<T>>::a][&S<T>::a];
+    COMPARE(test, V::IndexesFromZero());
+    test = data4[IT::IndexesFromZero()][&S<S<S<S<T>>>>::a][&S<S<S<T>>>::a][&S<S<T>>::a][&S<T>::b];
+    COMPARE(test, V::IndexesFromZero() + 1);
+    test = data4[IT::IndexesFromZero()][&S<S<S<S<T>>>>::a][&S<S<S<T>>>::a][&S<S<T>>::b][&S<T>::a];
+    COMPARE(test, V::IndexesFromZero() + 1);
+    test = data4[IT::IndexesFromZero()][&S<S<S<S<T>>>>::c][&S<S<S<T>>>::b][&S<S<T>>::b][&S<T>::c];
+    COMPARE(test, V::IndexesFromZero() + 6);
+
+    for (std::size_t repetition = 0; repetition < 1024 / V::Size; ++repetition) {
+        const IT indexes = randomIndexes<IT, 256>();
+        test = data1[indexes][&S<T>::b];
+        COMPARE(test, Vc::simd_cast<V>(indexes + 1));
+
+        test = data2[indexes][&S<S<T>>::c][&S<T>::b];
+        COMPARE(test, Vc::simd_cast<V>(indexes + 3));
+
+        test = data3[indexes][&S<S<S<T>>>::b][&S<S<T>>::c][&S<T>::b];
+        COMPARE(test, Vc::simd_cast<V>(indexes + 4));
+
+        test = data4[indexes][&S<S<S<S<T>>>>::c][&S<S<S<T>>>::b][&S<S<T>>::c][&S<T>::b];
+        COMPARE(test, Vc::simd_cast<V>(indexes + 6));
+    }
+}
+
+TEST_TYPES(V, subarrayGathers, ALL_TYPES)
+{
+    typedef typename V::EntryType T;
+    typedef typename V::IndexType IT;
+    Vc::array<Vc::array<T, 256>, 256> data1;
+    for (int i = 0; i < 256; ++i) {
+        for (int j = 0; j < 256; ++j) {
+            data1[i][j] = i + j;
+        }
+    }
+
+    V test;
+
+    test = data1[IT::IndexesFromZero()][0];
+    COMPARE(test, V::IndexesFromZero());
+    test = data1[IT::IndexesFromZero()][255];
+    COMPARE(test, V::IndexesFromZero() + 255);
+    test = data1[254][IT::IndexesFromZero()];
+    COMPARE(test, V::IndexesFromZero() + 254);
+
+    test = data1[IT::IndexesFromZero()][IT::IndexesFromZero()];
+    COMPARE(test, V::IndexesFromZero() * 2);
+
+    for (std::size_t repetition = 0; repetition < 1024 / V::Size; ++repetition) {
+        const IT indexes1 = randomIndexes<IT, 256>();
+        const IT indexes2 = randomIndexes<IT, 256>();
+
+        test = data1[indexes1][indexes2];
+        COMPARE(test, Vc::simd_cast<V>(indexes1 + indexes2));
+    }
+
+    Vc::vector<std::array<T, 256>> data2(64);
+    for (int i = 0; i < 64; ++i) {
+        for (int j = 0; j < 256; ++j) {
+            data2[i][j] = i + j;
+        }
+    }
+
+    test = data2[IT::IndexesFromZero()][0];
+    COMPARE(test, V::IndexesFromZero());
+}
+
+TEST_TYPES(V, fixedWidthGatherScatter4, (SIMD_ARRAYS(4)))
+{
+    typedef typename V::EntryType T;
+    Vc::array<T, 256> data;
+    Vc::vector<T> data2(256);
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        data[i] = i;
+        data2[i] = i + 1;
+    }
+    V test;
+
+    const std::initializer_list<int> indexes = { 0, 5, 8, 3 };
+    test = data[indexes];
+    const V reference = {0, 5, 8, 3};
+    COMPARE(test, reference);
+    test = data2[indexes];
+    COMPARE(test, reference + 1);
+
+    const int indexes2[4] = {3, 8, 5, 0};
+    test = data[indexes2];
+    const V reference2 = {3, 8, 5, 0};
+    COMPARE(test, reference2);
+    test = data2[indexes2];
+    COMPARE(test, reference2 + 1);
+
+    /*
+    test = V::Random();
+    data[indexes] = test;
+    data2[indexes] = test;
+
+    std::size_t i = 0;
+    for (const auto x : indexes) {
+        COMPARE(data[x], test[i]);
+        COMPARE(data2[x], test[i]);
+        ++i;
+    }
+    */
+}
+
+TEST_TYPES(V, fixedWidthGatherScatter32, (SIMD_ARRAYS(32)))
+{
+    typedef typename V::EntryType T;
+    Vc::array<T, 256> data;
+    Vc::vector<T> data2(256);
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        data[i] = i;
+        data2[i] = i;
+    }
+    V test;
+    const std::initializer_list<int> indexes = {73, 17, 15, 0,  38, 74, 25, 41, 7, 28, 68,
+                                                2,  23, 98, 5,  87, 72, 18, 16, 1, 39, 75,
+                                                26, 42, 8,  29, 69, 3,  24, 99, 6, 88};
+    test = data[indexes];
+    const V reference = {73, 17, 15, 0, 38, 74, 25, 41, 7, 28, 68, 2, 23, 98, 5, 87,
+                         72, 18, 16, 1, 39, 75, 26, 42, 8, 29, 69, 3, 24, 99, 6, 88};
+    COMPARE(test, reference);
+    test = data2[indexes];
+    COMPARE(test, reference);
+}
+
+TEST(promotionOfIndexVectorType)
+{
+    Vc::vector<Vc::array<int, 1024>> data;
+    data.resize(1024);
+    int *ptr = &data[0][0];
+    for (std::size_t i = 0; i < 1024 * 1024; ++i) {
+        ptr[i] = i;
+    }
+
+    const Vc::short_v indexes = 1023 - Vc::short_v::IndexesFromZero();
+    Vc::int_v reference = Vc::simd_cast<Vc::int_v>(indexes) * 1024;
+    Vc::int_v test = data[indexes][0];
+    COMPARE(test, reference);
+}
diff -Nru vc-0.7.4/tests/supportfunctions.cpp vc-1.3.0/tests/supportfunctions.cpp
--- vc-0.7.4/tests/supportfunctions.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/supportfunctions.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,22 +1,31 @@
-/*{{{
-    Copyright (C) 2013 Matthias Kretz <kretz@kde.org>
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
 
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
-#include "unittest.h"
+#include "unittest-old.h"
 
 void testCompiledImplementation()
 {
@@ -33,7 +42,7 @@
     COMPARE(Vc::isImplementationSupported(Vc::SSE41Impl), CpuId::hasSse41());
     COMPARE(Vc::isImplementationSupported(Vc::SSE42Impl), CpuId::hasSse42());
     COMPARE(Vc::isImplementationSupported(Vc::AVXImpl  ), CpuId::hasOsxsave() && CpuId::hasAvx());
-    COMPARE(Vc::isImplementationSupported(Vc::AVX2Impl ), false);
+    COMPARE(Vc::isImplementationSupported(Vc::AVX2Impl ), CpuId::hasOsxsave() && CpuId::hasAvx2());
 }
 
 void testBestImplementation()
@@ -41,7 +50,7 @@
     // when building with a recent and fully featured compiler the following should pass
     // but - old GCC versions have to fall back to Scalar, even though SSE is supported by the CPU
     //     - ICC/MSVC can't use XOP/FMA4
-    //COMPARE(Vc::bestImplementationSupported(), VC_IMPL);
+    COMPARE(Vc::bestImplementationSupported(), Vc::CurrentImplementation::current());
 }
 
 void testExtraInstructions()
@@ -53,16 +62,16 @@
     COMPARE(!(extra & Vc::Fma4Instructions), !CpuId::hasFma4());
     COMPARE(!(extra & Vc::PopcntInstructions), !CpuId::hasPopcnt());
     COMPARE(!(extra & Vc::Sse4aInstructions), !CpuId::hasSse4a());
+    COMPARE(!(extra & Vc::FmaInstructions), !CpuId::hasFma());
+    COMPARE(!(extra & Vc::Bmi2Instructions), !CpuId::hasBmi2());
 }
 
-int main(int argc, char **argv)
+void testmain()
 {
-    initTest(argc, argv);
-
     runTest(testCompiledImplementation);
     runTest(testIsSupported);
     runTest(testBestImplementation);
     runTest(testExtraInstructions);
-
-    return 0;
 }
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/swizzles.cpp vc-1.3.0/tests/swizzles.cpp
--- vc-0.7.4/tests/swizzles.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/swizzles.cpp	1969-12-31 18:00:00.000000000 -0600
@@ -1,145 +0,0 @@
-/*  This file is part of the Vc library. {{{
-
-    Copyright (C) 2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-}}}*/
-
-#include "unittest.h"
-
-using namespace Vc;
-
-enum Swizzle {
-    BADC, CDAB, AAAA, BBBB, CCCC, DDDD, BCAD, BCDA, DABC, ACBD, DBCA, DCBA
-};
-
-template<typename V> V scalarSwizzle(VC_ALIGNED_PARAMETER(V) v, Swizzle s)
-{
-    V r = v;
-    for (int i = 0; i + 4 <= V::Size; i += 4) {
-        switch (s) {
-        case BADC:
-            r[i + 0] = v[i + 1];
-            r[i + 1] = v[i + 0];
-            r[i + 2] = v[i + 3];
-            r[i + 3] = v[i + 2];
-            break;
-        case CDAB:
-            r[i + 0] = v[i + 2];
-            r[i + 1] = v[i + 3];
-            r[i + 2] = v[i + 0];
-            r[i + 3] = v[i + 1];
-            break;
-        case AAAA:
-            r[i + 0] = v[i + 0];
-            r[i + 1] = v[i + 0];
-            r[i + 2] = v[i + 0];
-            r[i + 3] = v[i + 0];
-            break;
-        case BBBB:
-            r[i + 0] = v[i + 1];
-            r[i + 1] = v[i + 1];
-            r[i + 2] = v[i + 1];
-            r[i + 3] = v[i + 1];
-            break;
-        case CCCC:
-            r[i + 0] = v[i + 2];
-            r[i + 1] = v[i + 2];
-            r[i + 2] = v[i + 2];
-            r[i + 3] = v[i + 2];
-            break;
-        case DDDD:
-            r[i + 0] = v[i + 3];
-            r[i + 1] = v[i + 3];
-            r[i + 2] = v[i + 3];
-            r[i + 3] = v[i + 3];
-            break;
-        case BCAD:
-            r[i + 0] = v[i + 1];
-            r[i + 1] = v[i + 2];
-            r[i + 2] = v[i + 0];
-            r[i + 3] = v[i + 3];
-            break;
-        case BCDA:
-            r[i + 0] = v[i + 1];
-            r[i + 1] = v[i + 2];
-            r[i + 2] = v[i + 3];
-            r[i + 3] = v[i + 0];
-            break;
-        case DABC:
-            r[i + 0] = v[i + 3];
-            r[i + 1] = v[i + 0];
-            r[i + 2] = v[i + 1];
-            r[i + 3] = v[i + 2];
-            break;
-        case ACBD:
-            r[i + 0] = v[i + 0];
-            r[i + 1] = v[i + 2];
-            r[i + 2] = v[i + 1];
-            r[i + 3] = v[i + 3];
-            break;
-        case DBCA:
-            r[i + 0] = v[i + 3];
-            r[i + 1] = v[i + 1];
-            r[i + 2] = v[i + 2];
-            r[i + 3] = v[i + 0];
-            break;
-        case DCBA:
-            r[i + 0] = v[i + 3];
-            r[i + 1] = v[i + 2];
-            r[i + 2] = v[i + 1];
-            r[i + 3] = v[i + 0];
-            break;
-        }
-    }
-    return r;
-}
-
-template<typename V> void testSwizzle()
-{
-    for (int i = 0; i < 100; ++i) {
-        const V test = V::Random();
-        COMPARE(test.abcd(), test);
-        COMPARE(test.badc(), scalarSwizzle(test, BADC));
-        COMPARE(test.cdab(), scalarSwizzle(test, CDAB));
-        COMPARE(test.aaaa(), scalarSwizzle(test, AAAA));
-        COMPARE(test.bbbb(), scalarSwizzle(test, BBBB));
-        COMPARE(test.cccc(), scalarSwizzle(test, CCCC));
-        COMPARE(test.dddd(), scalarSwizzle(test, DDDD));
-        COMPARE(test.bcad(), scalarSwizzle(test, BCAD));
-        COMPARE(test.bcda(), scalarSwizzle(test, BCDA));
-        COMPARE(test.dabc(), scalarSwizzle(test, DABC));
-        COMPARE(test.acbd(), scalarSwizzle(test, ACBD));
-        COMPARE(test.dbca(), scalarSwizzle(test, DBCA));
-        COMPARE(test.dcba(), scalarSwizzle(test, DCBA));
-    }
-}
-
-int main(int argc, char **argv)
-{
-    initTest(argc, argv);
-
-#if VC_DOUBLE_V_SIZE >= 4 || VC_DOUBLE_V_SIZE == 1
-    runTest(testSwizzle<double_v>);
-#endif
-    runTest(testSwizzle<float_v>);
-    runTest(testSwizzle<sfloat_v>);
-    runTest(testSwizzle<int_v>);
-    runTest(testSwizzle<uint_v>);
-    runTest(testSwizzle<short_v>);
-    runTest(testSwizzle<ushort_v>);
-
-    return 0;
-}
diff -Nru vc-0.7.4/tests/trigonometric.cpp vc-1.3.0/tests/trigonometric.cpp
--- vc-0.7.4/tests/trigonometric.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/trigonometric.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,235 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include "mathreference.h"
+
+using Vc::Detail::doubleConstant;
+
+TEST_TYPES(V, testSincos, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+    UnitTest::setFuzzyness<float>(2);
+    UnitTest::setFuzzyness<double>(1e7);
+    Array<SincosReference<T> > reference = sincosReference<T>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, sref, cref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            sref[j] = reference.data[i + j].s;
+            cref[j] = reference.data[i + j].c;
+        }
+        V sin, cos;
+        Vc::sincos(x, &sin, &cos);
+        FUZZY_COMPARE(sin, sref) << " x = " << x << ", i = " << i;
+        FUZZY_COMPARE(cos, cref) << " x = " << x << ", i = " << i;
+        Vc::sincos(-x, &sin, &cos);
+        FUZZY_COMPARE(sin, -sref) << " x = " << -x << ", i = " << i;
+        FUZZY_COMPARE(cos, cref) << " x = " << -x << ", i = " << i;
+    }
+}
+
+TEST_TYPES(V, testSin, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+    UnitTest::setFuzzyness<float>(2);
+    UnitTest::setFuzzyness<double>(1e7);
+    Array<SincosReference<T> > reference = sincosReference<T>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, sref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            sref[j] = reference.data[i + j].s;
+        }
+        FUZZY_COMPARE(Vc::sin(x), sref) << " x = " << x << ", i = " << i;
+        FUZZY_COMPARE(Vc::sin(-x), -sref) << " x = " << x << ", i = " << i;
+    }
+}
+
+TEST_TYPES(V, testCos, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+    UnitTest::setFuzzyness<float>(2);
+    UnitTest::setFuzzyness<double>(1e7);
+    Array<SincosReference<T> > reference = sincosReference<T>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, cref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            cref[j] = reference.data[i + j].c;
+        }
+        FUZZY_COMPARE(Vc::cos(x), cref) << " x = " << x << ", i = " << i;
+        FUZZY_COMPARE(Vc::cos(-x), cref) << " x = " << x << ", i = " << i;
+    }
+}
+
+TEST_TYPES(V, testAsin, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+#ifdef Vc_IMPL_MIC
+    UnitTest::setFuzzyness<float>(3);
+#else
+    UnitTest::setFuzzyness<float>(2);
+#endif
+    UnitTest::setFuzzyness<double>(36);
+    Array<Reference<T> > reference = referenceData<T, Asin>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, ref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            ref[j] = reference.data[i + j].ref;
+        }
+        FUZZY_COMPARE(Vc::asin(x), ref) << " x = " << x << ", i = " << i;
+        FUZZY_COMPARE(Vc::asin(-x), -ref) << " -x = " << -x << ", i = " << i;
+    }
+}
+
+const union {
+    unsigned int hex;
+    float value;
+} INF = { 0x7f800000 };
+
+#if defined(__APPLE__)
+// On Mac OS X, std::atan and std::atan2 don't return the special values defined in the
+// Linux man pages (whether it's C99 or POSIX.1-2001 that specifies the special values is
+// not mentioned in the man page). This issue is only relevant for VectorAbi::Scalar. But
+// since the SimdArray types can inclue scalar Vector objects in the odd variants, the
+// tests must use fuzzy compares in all cases on Mac OS X.
+#define ATAN_COMPARE FUZZY_COMPARE
+#else
+#define ATAN_COMPARE COMPARE
+#endif
+
+TEST_TYPES(V, testAtan, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+    UnitTest::setFuzzyness<float>(3);
+    UnitTest::setFuzzyness<double>(2);
+
+    {
+        const V Pi_2 = T(doubleConstant<1, 0x921fb54442d18ull,  0>());
+        V nan; nan.setQnan();
+        const V inf = T(INF.value);
+
+        VERIFY(all_of(Vc::isnan(Vc::atan(nan))));
+        ATAN_COMPARE(Vc::atan(+inf), +Pi_2);
+#ifdef Vc_MSVC
+#pragma warning(suppress: 4756) // overflow in constant arithmetic
+#endif
+        ATAN_COMPARE(Vc::atan(-inf), -Pi_2);
+    }
+
+    Array<Reference<T> > reference = referenceData<T, Atan>();
+    for (size_t i = 0; i + V::Size - 1 < reference.size; i += V::Size) {
+        V x, ref;
+        for (size_t j = 0; j < V::Size; ++j) {
+            x[j] = reference.data[i + j].x;
+            ref[j] = reference.data[i + j].ref;
+        }
+        FUZZY_COMPARE(Vc::atan(x), ref) << " x = " << x << ", i = " << i;
+        FUZZY_COMPARE(Vc::atan(-x), -ref) << " -x = " << -x << ", i = " << i;
+    }
+}
+
+TEST_TYPES(V, testAtan2, (REAL_VECTORS, SIMD_REAL_ARRAY_LIST)) //{{{1
+{
+    typedef typename V::EntryType T;
+    UnitTest::setFuzzyness<float>(3);
+    UnitTest::setFuzzyness<double>(2);
+
+    {
+        const V Pi   = T(doubleConstant<1, 0x921fb54442d18ull,  1>());
+        const V Pi_2 = T(doubleConstant<1, 0x921fb54442d18ull,  0>());
+        V nan; nan.setQnan();
+        const V inf = T(INF.value);
+
+        // If y is +0 (-0) and x is less than 0, +pi (-pi) is returned.
+        ATAN_COMPARE(Vc::atan2(V(T(+0.)), V(T(-3.))), +Pi);
+        ATAN_COMPARE(Vc::atan2(V(T(-0.)), V(T(-3.))), -Pi);
+        // If y is +0 (-0) and x is greater than 0, +0 (-0) is returned.
+        COMPARE(Vc::atan2(V(T(+0.)), V(T(+3.))), V(T(+0.)));
+        VERIFY(none_of(isnegative(Vc::atan2(V(T(+0.)), V(T(+3.))))));
+        COMPARE(Vc::atan2(V(T(-0.)), V(T(+3.))), V(T(-0.)));
+        VERIFY (all_of(isnegative(Vc::atan2(V(T(-0.)), V(T(+3.))))));
+        // If y is less than 0 and x is +0 or -0, -pi/2 is returned.
+        COMPARE(Vc::atan2(V(T(-3.)), V(T(+0.))), -Pi_2);
+        COMPARE(Vc::atan2(V(T(-3.)), V(T(-0.))), -Pi_2);
+        // If y is greater than 0 and x is +0 or -0, pi/2 is returned.
+        COMPARE(Vc::atan2(V(T(+3.)), V(T(+0.))), +Pi_2);
+        COMPARE(Vc::atan2(V(T(+3.)), V(T(-0.))), +Pi_2);
+        // If either x or y is NaN, a NaN is returned.
+        VERIFY(all_of(Vc::isnan(Vc::atan2(nan, V(T(3.))))));
+        VERIFY(all_of(Vc::isnan(Vc::atan2(V(T(3.)), nan))));
+        VERIFY(all_of(Vc::isnan(Vc::atan2(nan, nan))));
+        // If y is +0 (-0) and x is -0, +pi (-pi) is returned.
+        ATAN_COMPARE(Vc::atan2(V(T(+0.)), V(T(-0.))), +Pi);
+        ATAN_COMPARE(Vc::atan2(V(T(-0.)), V(T(-0.))), -Pi);
+        // If y is +0 (-0) and x is +0, +0 (-0) is returned.
+        COMPARE(Vc::atan2(V(T(+0.)), V(T(+0.))), V(T(+0.)));
+        COMPARE(Vc::atan2(V(T(-0.)), V(T(+0.))), V(T(-0.)));
+        VERIFY(none_of(isnegative(Vc::atan2(V(T(+0.)), V(T(+0.))))));
+        VERIFY( all_of(isnegative(Vc::atan2(V(T(-0.)), V(T(+0.))))));
+        // If y is a finite value greater (less) than 0, and x is negative infinity, +pi (-pi) is returned.
+        ATAN_COMPARE(Vc::atan2(V(T(+1.)), -inf), +Pi);
+        ATAN_COMPARE(Vc::atan2(V(T(-1.)), -inf), -Pi);
+        // If y is a finite value greater (less) than 0, and x is positive infinity, +0 (-0) is returned.
+        COMPARE(Vc::atan2(V(T(+3.)), +inf), V(T(+0.)));
+        VERIFY(none_of(isnegative(Vc::atan2(V(T(+3.)), +inf))));
+        COMPARE(Vc::atan2(V(T(-3.)), +inf), V(T(-0.)));
+        VERIFY( all_of(isnegative(Vc::atan2(V(T(-3.)), +inf))));
+        // If y is positive infinity (negative infinity), and x is finite, pi/2 (-pi/2) is returned.
+        COMPARE(Vc::atan2(+inf, V(T(+3.))), +Pi_2);
+        COMPARE(Vc::atan2(-inf, V(T(+3.))), -Pi_2);
+        COMPARE(Vc::atan2(+inf, V(T(-3.))), +Pi_2);
+        COMPARE(Vc::atan2(-inf, V(T(-3.))), -Pi_2);
+#ifndef _WIN32 // the Microsoft implementation of atan2 fails this test
+        const V Pi_4 = T(doubleConstant<1, 0x921fb54442d18ull, -1>());
+        // If y is positive infinity (negative infinity) and x is negative	infinity, +3*pi/4 (-3*pi/4) is returned.
+        COMPARE(Vc::atan2(+inf, -inf), T(+3.) * Pi_4);
+        COMPARE(Vc::atan2(-inf, -inf), T(-3.) * Pi_4);
+        // If y is positive infinity (negative infinity) and x is positive infinity, +pi/4 (-pi/4) is returned.
+        COMPARE(Vc::atan2(+inf, +inf), +Pi_4);
+        COMPARE(Vc::atan2(-inf, +inf), -Pi_4);
+#endif
+    }
+
+    for (int xoffset = -100; xoffset < 54613; xoffset += 47 * V::Size) {
+        for (int yoffset = -100; yoffset < 54613; yoffset += 47 * V::Size) {
+            const V data = V::IndexesFromZero();
+            const V reference = V::generate([&](size_t i) {
+                return std::atan2((data[i] + xoffset) * T(0.15), (data[i] + yoffset) * T(0.15));
+            });
+
+            const V x = (data + xoffset) * T(0.15);
+            const V y = (data + yoffset) * T(0.15);
+            FUZZY_COMPARE(Vc::atan2(x, y), reference) << ", x = " << x << ", y = " << y;
+        }
+    }
+}
+
+//}}}1
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/typelist.h vc-1.3.0/tests/typelist.h
--- vc-0.7.4/tests/typelist.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/typelist.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,460 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TESTS_TYPELIST_H_
+#define VC_TESTS_TYPELIST_H_
+
+#include <type_traits>
+#include <utility>
+#include "../common/indexsequence.h"
+
+template <typename... Ts> struct Typelist;
+
+template <template <typename...> class T, typename... Fixed> struct Template {
+    template <typename... Us> using type = T<Us..., Fixed...>;
+};
+
+// list indexing{{{1
+namespace TypelistIndexing
+{
+template <std::size_t I, typename T> struct indexed {
+    using type = T;
+};
+template <typename Is, typename... Ts> struct indexer;
+template <std::size_t... Is, typename... Ts>
+struct indexer<Vc::index_sequence<Is...>, Ts...> : indexed<Is, Ts>... {
+};
+template <std::size_t I, typename T> static indexed<I, T> select(indexed<I, T>);
+}  // namespace TypelistIndexing
+
+// concat {{{1
+template <typename... More> struct concat_impl;
+/**
+ * Concatenate two type arguments into a single Typelist.
+ */
+template <typename... Ts> using concat = typename concat_impl<Ts...>::type;
+
+// concat implementation:
+template <typename A> struct concat_impl<A> {
+    using type = A;
+};
+template <typename A, typename B> struct concat_impl<A, B> {
+    using type = Typelist<A, B>;
+};
+template <typename... As, typename B> struct concat_impl<Typelist<As...>, B> {
+    using type = Typelist<As..., B>;
+};
+template <typename A, typename... Bs> struct concat_impl<A, Typelist<Bs...>> {
+    using type = Typelist<A, Bs...>;
+};
+template <typename... As, typename... Bs>
+struct concat_impl<Typelist<As...>, Typelist<Bs...>> {
+    using type = Typelist<As..., Bs...>;
+};
+template <typename A, typename B, typename C, typename... More>
+struct concat_impl<A, B, C, More...> {
+    using type = typename concat_impl<typename concat_impl<A, B>::type,
+                                      typename concat_impl<C, More...>::type>::type;
+};
+
+// split {{{1
+template <std::size_t N, typename T> struct split_impl;
+template <typename... Ts> struct split_impl<0, Typelist<Ts...>> {
+    using first = Typelist<>;
+    using second = Typelist<Ts...>;
+};
+template <typename T, typename... Ts> struct split_impl<1, Typelist<T, Ts...>> {
+    using first = Typelist<T>;
+    using second = Typelist<Ts...>;
+};
+template <typename T0, typename T1, typename... Ts>
+struct split_impl<2, Typelist<T0, T1, Ts...>> {
+    using first = Typelist<T0, T1>;
+    using second = Typelist<Ts...>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename... Ts>
+struct split_impl<4, Typelist<T0, T1, T2, T3, Ts...>> {
+    using first = Typelist<T0, T1, T2, T3>;
+    using second = Typelist<Ts...>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename... Ts>
+struct split_impl<8, Typelist<T0, T1, T2, T3, T4, T5, T6, T7, Ts...>> {
+    using first = Typelist<T0, T1, T2, T3, T4, T5, T6, T7>;
+    using second = Typelist<Ts...>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10, typename T11,
+          typename T12, typename T13, typename T14, typename T15, typename... Ts>
+struct split_impl<16, Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+                               T14, T15, Ts...>> {
+    using first =
+        Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>;
+    using second = Typelist<Ts...>;
+};
+template <std::size_t N, typename... Ts> struct split_impl<N, Typelist<Ts...>> {
+private:
+    using A = split_impl<N / 2, Typelist<Ts...>>;
+    using B = split_impl<N - N / 2, typename A::second>;
+
+public:
+    using first = concat<typename A::first, typename B::first>;
+    using second = typename B::second;
+};
+template <typename T> using split = split_impl<T::size() / 2, T>;
+
+// split4 {{{1
+template <typename T> struct split4;
+template <typename T0> struct split4<Typelist<T0>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<>;
+    using type2 = Typelist<>;
+    using type3 = Typelist<>;
+};
+template <typename T0,typename T1> struct split4<Typelist<T0, T1>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<T1>;
+    using type2 = Typelist<>;
+    using type3 = Typelist<>;
+};
+template <typename T0, typename T1, typename T2> struct split4<Typelist<T0, T1, T2>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<T1>;
+    using type2 = Typelist<T2>;
+    using type3 = Typelist<>;
+};
+template <typename T0, typename T1, typename T2, typename T3>
+struct split4<Typelist<T0, T1, T2, T3>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<T1>;
+    using type2 = Typelist<T2>;
+    using type3 = Typelist<T3>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct split4<Typelist<T0, T1, T2, T3, T4>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<T1>;
+    using type2 = Typelist<T2>;
+    using type3 = Typelist<T3, T4>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5>> {
+    using type0 = Typelist<T0>;
+    using type1 = Typelist<T1>;
+    using type2 = Typelist<T2>;
+    using type3 = Typelist<T3, T4, T5>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4>;
+    using type2 = Typelist<T5>;
+    using type3 = Typelist<T6>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6, T7>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4>;
+    using type2 = Typelist<T5>;
+    using type3 = Typelist<T6, T7>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4>;
+    using type2 = Typelist<T5>;
+    using type3 = Typelist<T6, T7, T8>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4, T5, T6, T7>;
+    using type2 = Typelist<T8>;
+    using type3 = Typelist<T9>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4, T5, T6, T7>;
+    using type2 = Typelist<T8>;
+    using type3 = Typelist<T9, T10>;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+struct split4<Typelist<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> {
+    using type0 = Typelist<T0, T1, T2, T3>;
+    using type1 = Typelist<T4, T5, T6, T7>;
+    using type2 = Typelist<T8>;
+    using type3 = Typelist<T9, T10, T11>;
+};
+namespace
+{
+constexpr std::size_t nextPowerOfTwo(std::size_t x)
+{
+    return (x & (x - 1)) == 0 ? x
+                              : nextPowerOfTwo((x | (x >> 1) | (x >> 2) | (x >> 5)) + 1);
+}
+constexpr std::size_t nextPowerOfFour(std::size_t x)
+{
+    return (nextPowerOfTwo(x) & 0x55555555u) ? nextPowerOfTwo(x) : nextPowerOfTwo(x) * 2u;
+}
+}  // unnamed namespace
+template <typename... Ts> struct split4<Typelist<Ts...>> {
+private:
+    static const auto N = sizeof...(Ts);
+    static const auto NA = nextPowerOfFour(N / 4);
+    static const auto tmp0 = nextPowerOfFour((N - NA) / 3);
+    static const auto NB = tmp0 + NA + 2 <= N ? tmp0 : tmp0 / 4;
+    static const auto tmp1 = nextPowerOfFour((N - NA - NB) / 2);
+    static const auto NC = tmp1 + NA + NB + 1 <= N ? tmp1 : tmp1 / 4;
+    using A = split_impl<NA, Typelist<Ts...>>;     // A, B+C+D
+    using B = split_impl<NB, typename A::second>;  // B, C+D
+    using C = split_impl<NC, typename B::second>;  // C, D
+
+public:
+    using type0 = typename A::first;
+    using type1 = typename B::first;
+    using type2 = typename C::first;
+    using type3 = typename C::second;
+};
+
+// outer_product {{{1
+template <typename A, typename B> struct outer_product_impl;
+template <typename... Bs> struct outer_product_impl<Typelist<>, Typelist<Bs...>>
+{
+    using type = Typelist<>;
+};
+template <typename A0, typename... Bs>
+struct outer_product_impl<Typelist<A0>, Typelist<Bs...>>
+{
+    using type = Typelist<concat<A0, Bs>...>;
+};
+template <typename A0, typename... As, typename... Bs>
+struct outer_product_impl<Typelist<A0, As...>, Typelist<Bs...>>
+{
+    using type =
+        concat<Typelist<concat<A0, Bs>...>,
+               typename outer_product_impl<Typelist<As...>, Typelist<Bs...>>::type>;
+};
+
+template <typename A, typename B>
+using outer_product = typename outer_product_impl<A, B>::type;
+
+// expand_one {{{1
+template <typename A, typename B> struct expand_one_impl;
+template <typename A> struct expand_one_impl<A, Typelist<>> {
+    using type = Typelist<>;
+};
+template <typename A, typename B0, typename... Bs>
+struct expand_one_impl<A, Typelist<B0, Bs...>> {
+    using type = concat<typename A::template type<B0>,
+                        typename expand_one_impl<A, Typelist<Bs...>>::type>;
+};
+
+template <typename A, typename B>
+using expand_one = typename expand_one_impl<A, B>::type;
+
+// expand_list {{{1
+template <typename A, typename B> struct expand_list_impl;
+template <typename B> struct expand_list_impl<Typelist<>, B> {
+    using type = Typelist<>;
+};
+template <typename A0, typename... As, typename B>
+struct expand_list_impl<Typelist<A0, As...>, B> {
+    using type = concat<expand_one<A0, B>, typename expand_list_impl<Typelist<As...>, B>::type>;
+};
+template <typename A, typename B>
+using expand_list = typename expand_list_impl<A, B>::type;
+
+// extract_type_impl {{{1
+struct TypelistSentinel;
+template <std::size_t N, bool N_less_4, bool N_larger_32, typename... Ts>
+struct extract_type_impl
+{
+    using type = TypelistSentinel;
+};
+template <typename T0, typename... Ts> struct extract_type_impl<0, true, false, T0, Ts...>
+{
+    using type = T0;
+};
+template <typename T0, typename T1, typename... Ts>
+struct extract_type_impl<1, true, false, T0, T1, Ts...>
+{
+    using type = T1;
+};
+template <typename T0, typename T1, typename T2, typename... Ts>
+struct extract_type_impl<2, true, false, T0, T1, T2, Ts...>
+{
+    using type = T2;
+};
+template <typename T0, typename T1, typename T2, typename T3, typename... Ts>
+struct extract_type_impl<3, true, false, T0, T1, T2, T3, Ts...>
+{
+    using type = T3;
+};
+template <std::size_t N,
+          typename T00,
+          typename T01,
+          typename T02,
+          typename T03,
+          typename T04,
+          typename T05,
+          typename T06,
+          typename T07,
+          typename T08,
+          typename T09,
+          typename T10,
+          typename T11,
+          typename T12,
+          typename T13,
+          typename T14,
+          typename T15,
+          typename T16,
+          typename T17,
+          typename T18,
+          typename T19,
+          typename T20,
+          typename T21,
+          typename T22,
+          typename T23,
+          typename T24,
+          typename T25,
+          typename T26,
+          typename T27,
+          typename T28,
+          typename T29,
+          typename T30,
+          typename T31,
+          typename... Ts>
+struct extract_type_impl<N,
+                    false,
+                    true,
+                    T00,
+                    T01,
+                    T02,
+                    T03,
+                    T04,
+                    T05,
+                    T06,
+                    T07,
+                    T08,
+                    T09,
+                    T10,
+                    T11,
+                    T12,
+                    T13,
+                    T14,
+                    T15,
+                    T16,
+                    T17,
+                    T18,
+                    T19,
+                    T20,
+                    T21,
+                    T22,
+                    T23,
+                    T24,
+                    T25,
+                    T26,
+                    T27,
+                    T28,
+                    T29,
+                    T30,
+                    T31,
+                    Ts...>
+{
+    static constexpr std::size_t NN = N - 32;
+    using type = typename extract_type_impl<NN, (NN < 4), (NN >= 32), Ts...>::type;
+};
+
+template <std::size_t N,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename... Ts>
+struct extract_type_impl<N, false, false, T0, T1, T2, T3, Ts...>
+{
+    static constexpr std::size_t NN = N - 4;
+    using type = typename extract_type_impl<NN, (NN < 4), (NN >= 32), Ts...>::type;
+};
+
+template <std::size_t N, typename... Ts>
+using extract_type = typename extract_type_impl<N, (N < 4), (N >= 32), Ts...>::type;
+
+template <typename... Ts> struct Typelist
+{
+    template <std::size_t N>
+    using at = typename extract_type_impl<N, (N < 4), (N >= 32), Ts...>::type;
+
+    static constexpr std::size_t size() { return sizeof...(Ts); }
+};
+
+// static_asserts {{{1
+static_assert(std::is_same<outer_product<Typelist<int, float>, Typelist<short, double>>,
+                           Typelist<Typelist<int, short>,
+                                    Typelist<int, double>,
+                                    Typelist<float, short>,
+                                    Typelist<float, double>>>::value,
+              "outer_product does not work as expected");
+static_assert(
+    std::is_same<
+        outer_product<Typelist<long, char>,
+                      outer_product<Typelist<int, float>, Typelist<short, double>>>,
+        Typelist<Typelist<long, int, short>,
+                 Typelist<long, int, double>,
+                 Typelist<long, float, short>,
+                 Typelist<long, float, double>,
+                 Typelist<char, int, short>,
+                 Typelist<char, int, double>,
+                 Typelist<char, float, short>,
+                 Typelist<char, float, double>>>::value,
+    "outer_product does not work as expected");
+
+namespace
+{
+template<typename T> struct TestType {};
+template<typename T> struct TestType2 {};
+static_assert(std::is_same<expand_one<Template<TestType>, Typelist<int, float>>,
+                           Typelist<TestType<int>, TestType<float>>>::value,
+              "expand_one is broken");
+static_assert(std::is_same<expand_list<Typelist<Template<TestType>, Template<TestType2>>,
+                                       Typelist<int, float>>,
+                           Typelist<TestType<int>, TestType<float>, TestType2<int>,
+                                    TestType2<float>>>::value,
+              "expand_list is broken");
+}  // namespace
+// }}}1
+
+#endif  // VC_TESTS_TYPELIST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/types.cpp vc-1.3.0/tests/types.cpp
--- vc-0.7.4/tests/types.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/types.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,68 @@
+/*{{{
+    Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+    Permission to use, copy, modify, and distribute this software
+    and its documentation for any purpose and without fee is hereby
+    granted, provided that the above copyright notice appear in all
+    copies and that both that the copyright notice and this
+    permission notice and warranty disclaimer appear in supporting
+    documentation, and that the name of the author not be used in
+    advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    The author disclaim all warranties with regard to this
+    software, including all implied warranties of merchantability
+    and fitness.  In no event shall the author be liable for any
+    special, indirect or consequential damages or any damages
+    whatsoever resulting from loss of use, data or profits, whether
+    in an action of contract, negligence or other tortious action,
+    arising out of or in connection with the use or performance of
+    this software.
+
+}}}*/
+
+#include "unittest.h"
+
+#define ALL_TYPES (ALL_VECTORS, SIMD_ARRAYS(32))
+
+TEST_TYPES(V, check_EntryType, ALL_TYPES)
+{
+    V v = V();
+    auto scalar = v.sum();
+    static_assert(std::is_same<typename V::EntryType, decltype(scalar)>::value, "");
+    static_assert(std::is_same<typename V::value_type, decltype(scalar)>::value, "");
+}
+
+TEST_TYPES(V, check_VectorType, (ALL_VECTORS))
+{
+    V v = V();
+    auto internalData = v.data();
+    static_assert(std::is_same<typename V::VectorType, decltype(internalData)>::value, "");
+    static_assert(std::is_same<typename V::vector_type, decltype(internalData)>::value, "");
+}
+
+TEST_TYPES(V, check_MaskType, ALL_TYPES)
+{
+    V v = V();
+    auto mask = v == v;
+    static_assert(std::is_same<typename V::MaskType, decltype(mask)>::value, "");
+    static_assert(std::is_same<typename V::mask_type, decltype(mask)>::value, "");
+}
+
+TEST_TYPES(V, check_IndexType, ALL_TYPES)
+{
+    using IndexType = typename V::IndexType;
+    static_assert(Vc::Traits::isSimdArray<IndexType>::value,
+                  "IndexType is not a SimdArray instance");
+    static_assert(IndexType::Size >= V::Size,
+                  "IndexType does not have the expected minimum size");
+    static_assert(std::is_same<typename IndexType::value_type, int>::value,
+                  "IndexType does not have the expected value_type");
+}
+
+TEST_TYPES(V, checkIntegerType, (Vc::int64_v, Vc::uint64_v, Vc::int32_v, Vc::uint32_v,
+                                 Vc::int16_v, Vc::uint16_v, Vc::int8_v, Vc::uint8_v))
+{
+    V v;
+    MEMCOMPARE(v, v);
+}
diff -Nru vc-0.7.4/tests/type_traits.cpp vc-1.3.0/tests/type_traits.cpp
--- vc-0.7.4/tests/type_traits.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/type_traits.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,222 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+#include <Vc/type_traits>
+#include <memory>
+#include <list>
+#include <map>
+#include <unordered_map>
+
+using Vc::float_v;
+using Vc::double_v;
+using Vc::int_v;
+using Vc::uint_v;
+using Vc::short_v;
+using Vc::ushort_v;
+
+TEST_TYPES(V, isIntegral, (ALL_VECTORS))
+{
+    using T = typename V::EntryType;
+    COMPARE(Vc::is_integral<V>::value, std::is_integral<T>::value);
+}
+
+TEST_TYPES(V, isFloatingPoint, (ALL_VECTORS))
+{
+    using T = typename V::EntryType;
+    COMPARE(Vc::is_floating_point<V>::value, std::is_floating_point<T>::value);
+}
+
+TEST_TYPES(V, isSigned, (ALL_VECTORS))
+{
+    using T = typename V::EntryType;
+    COMPARE(Vc::is_signed<V>::value, std::is_signed<T>::value);
+    COMPARE(Vc::is_unsigned<V>::value, std::is_unsigned<T>::value);
+}
+
+TEST_TYPES(V, hasSubscript, (ALL_VECTORS))
+{
+    VERIFY(Vc::Traits::has_subscript_operator<V>::value);
+}
+
+TEST_TYPES(V, hasMultiply, (ALL_VECTORS))
+{
+    VERIFY(Vc::Traits::has_multiply_operator<V>::value);
+}
+
+TEST_TYPES(V, hasEquality, (ALL_VECTORS))
+{
+    VERIFY(Vc::Traits::has_equality_operator<V>::value);
+}
+
+TEST_TYPES(V, isSimdMask, (ALL_VECTORS))
+{
+    VERIFY(!Vc::is_simd_mask<V>::value);
+    VERIFY( Vc::is_simd_mask<typename V::Mask>::value);
+}
+
+TEST_TYPES(V, isSimdVector, (ALL_VECTORS))
+{
+    VERIFY( Vc::is_simd_vector<V>::value);
+    VERIFY(!Vc::is_simd_vector<typename V::Mask>::value);
+}
+
+template <typename T> void hasContiguousStorageImpl(T &&, const char *type)
+{
+    VERIFY(Vc::Traits::has_contiguous_storage<T>::value) << type;
+}
+
+TEST(hasContiguousStorage)
+{
+    std::unique_ptr<int[]> a(new int[3]);
+    int b[3] = {1, 2, 3};
+    const std::unique_ptr<int[]> c(new int[3]);
+    const int d[3] = {1, 2, 3};
+    auto &&e = {1, 2, 3};
+    const auto &f = {1, 2, 3};
+    std::vector<int> g;
+    std::array<int, 3> h;
+    hasContiguousStorageImpl(a.get(), "T[]");
+    hasContiguousStorageImpl(a, "std::unique_ptr<T[]>");
+    hasContiguousStorageImpl(&a[0], "T *");
+    hasContiguousStorageImpl(b, "T[3]");
+    hasContiguousStorageImpl(c.get(), "const T[]");
+    hasContiguousStorageImpl(c, "std::unique_ptr<const T[]>");
+    hasContiguousStorageImpl(&c[0], "const T *");
+    hasContiguousStorageImpl(d, "const T[3]");
+    hasContiguousStorageImpl(e, "std::initializer_list 1");
+    hasContiguousStorageImpl(f, "std::initializer_list 2");
+    hasContiguousStorageImpl(g, "std::vector<int>");
+    hasContiguousStorageImpl(g.begin(), "std::vector<int>::iterator");
+    hasContiguousStorageImpl(g.cbegin(), "std::vector<int>::iterator");
+    hasContiguousStorageImpl(h, "std::array<int, 3>");
+    hasContiguousStorageImpl(h.begin(), "std::array<int, 3>::iterator");
+    hasContiguousStorageImpl(h.cbegin(), "std::array<int, 3>::iterator");
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::list<int>>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::list<int>::iterator>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::list<int>::const_iterator>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::map<int, int>>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::map<int, int>::iterator>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::unordered_map<int, int>>::value));
+    VERIFY(!(Vc::Traits::has_contiguous_storage<std::unordered_map<int, int>::iterator>::value));
+}
+
+struct F0 {
+    template <typename T> void operator()(T &) const {}
+};
+struct F1 {
+    template <typename T> void operator()(const T &) const {}
+};
+struct F2 {
+    template <typename T> void operator()(T) const {}
+};
+struct F3 {
+    template <typename T> void operator()(const T) const {}
+};
+struct F4 {
+    // this could be a reference argument but with move semantics. Then, the caller cannot
+    // see changes to the argument as the variable is in an undefined state after the
+    // call.
+    // But as forwarding reference T can also bind as T &, in which case the argument is
+    // mutable.
+    template <typename T> void operator()(T &&) const {}
+};
+void fun1(int &) {}
+void fun2(const int &) {}
+
+TEST(test_is_functor_argument_immutable)
+{
+    using Vc::Traits::is_functor_argument_immutable;
+    VERIFY(!(is_functor_argument_immutable<F0, int>::value));
+    VERIFY( (is_functor_argument_immutable<F1, int>::value));
+    VERIFY( (is_functor_argument_immutable<F2, int>::value));
+    VERIFY( (is_functor_argument_immutable<F3, int>::value));
+    VERIFY(!(is_functor_argument_immutable<F4, int>::value));
+
+    VERIFY(!(is_functor_argument_immutable<decltype(fun1), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(fun2), int>::value));
+
+    int x = 0;
+    auto &&  int_lambda   = [&](int) { x += 1; };
+    auto &&  int_lambda_l = [&](int &y) { x += 1; y += 1; };
+    auto &&  int_lambda_r = [&](int &&) { x += 1; };
+    auto &&c_int_lambda   = [&](const int) { x += 1; };
+    auto &&c_int_lambda_l = [&](const int &) { x += 1; };
+    auto &&c_int_lambda_r = [&](const int &&) { x += 1; };
+    auto &&v_int_lambda   = [&](volatile int) { x += 1; };
+    auto &&v_int_lambda_l = [&](volatile int &) { x += 1; };
+    auto &&v_int_lambda_r = [&](volatile int &&) { x += 1; };
+    auto &&cv_int_lambda   = [&](const volatile int) { x += 1; };
+    auto &&cv_int_lambda_l = [&](const volatile int &) { x += 1; };
+    auto &&cv_int_lambda_r = [&](const volatile int &&) { x += 1; };
+    VERIFY( (is_functor_argument_immutable<decltype(   int_lambda  ), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(   int_lambda_l), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(   int_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype( c_int_lambda  ), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype( c_int_lambda_l), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype( c_int_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype( v_int_lambda  ), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype( v_int_lambda_l), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype( v_int_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_int_lambda  ), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_int_lambda_l), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_int_lambda_r), int>::value));
+#ifdef Vc_CXX14
+    auto &&auto_lambda = [&](auto) { x += 1; };
+    auto &&auto_lambda_l = [&](auto &y) { x += 1; y += 1; };
+    auto &&auto_lambda_r = [&](auto &&) { x += 1; };
+    auto &&c_auto_lambda   = [&](const auto) { x += 1; };
+    auto &&c_auto_lambda_l = [&](const auto &) { x += 1; };
+    auto &&c_auto_lambda_r = [&](const auto &&) { x += 1; };
+    auto &&v_auto_lambda   = [&](volatile auto) { x += 1; };
+    auto &&v_auto_lambda_l = [&](volatile auto &) { x += 1; };
+    auto &&v_auto_lambda_r = [&](volatile auto &&) { x += 1; };
+    auto &&cv_auto_lambda   = [&](const volatile auto) { x += 1; };
+    auto &&cv_auto_lambda_l = [&](const volatile auto &) { x += 1; };
+    auto &&cv_auto_lambda_r = [&](const volatile auto &&) { x += 1; };
+    VERIFY( (is_functor_argument_immutable<decltype(auto_lambda  ), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(auto_lambda_l), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(auto_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(c_auto_lambda  ), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(c_auto_lambda_l), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(c_auto_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(v_auto_lambda  ), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(v_auto_lambda_l), int>::value));
+    VERIFY(!(is_functor_argument_immutable<decltype(v_auto_lambda_r), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_auto_lambda  ), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_auto_lambda_l), int>::value));
+    VERIFY( (is_functor_argument_immutable<decltype(cv_auto_lambda_r), int>::value));
+#endif
+}
+
+TEST(test_is_output_iterator)
+{
+    VERIFY( (Vc::Traits::is_output_iterator<std::vector<int>::iterator>::value));
+    VERIFY(!(Vc::Traits::is_output_iterator<std::vector<int>::const_iterator>::value));
+    VERIFY( (Vc::Traits::is_output_iterator<std::ostream_iterator<int>>::value));
+    VERIFY(!(Vc::Traits::is_output_iterator<std::istream_iterator<int>>::value));
+}
diff -Nru vc-0.7.4/tests/ulp.cpp vc-1.3.0/tests/ulp.cpp
--- vc-0.7.4/tests/ulp.cpp	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/ulp.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,63 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#include "unittest.h"
+
+TEST_TYPES(V, testUlpDiff, (concat<RealVectors, RealSimdArrays>))  //{{{1
+{
+    typedef typename V::EntryType T;
+
+    COMPARE(ulpDiffToReference(V::Zero(), V::Zero()), V::Zero());
+    COMPARE(ulpDiffToReference(std::numeric_limits<V>::min(), V::Zero()), V::One());
+    COMPARE(ulpDiffToReference(V::Zero(), std::numeric_limits<V>::min()), V::One());
+    for (size_t count = 0; count < 1024 / V::Size; ++count) {
+        const V base = (V::Random() - T(0.5)) * T(1000);
+        typename V::IndexType exp;
+        frexp(base, &exp);
+        const V eps = ldexp(V(std::numeric_limits<T>::epsilon()), exp - 1);
+        //std::cout << base << ", " << exp << ", " << eps << std::endl;
+        for (int i = -10000; i <= 10000; ++i) {
+            const V i_v = V(T(i));
+            const V diff = base + i_v * eps;
+
+            // if diff and base have a different exponent then ulpDiffToReference has an uncertainty
+            // of +/-1
+            const V ulpDifference = ulpDiffToReference(diff, base);
+            const V expectedDifference = abs(i_v);
+            const V maxUncertainty = abs(exponent(abs(diff)) - exponent(abs(base)));
+
+            VERIFY(all_of(abs(ulpDifference - expectedDifference) <= maxUncertainty))
+                << ", base = " << base << ", epsilon = " << eps << ", diff = " << diff;
+            for (size_t k = 0; k < V::Size; ++k) {
+                VERIFY(std::abs(ulpDifference[k] - expectedDifference[k]) <= maxUncertainty[k]);
+            }
+        }
+    }
+}
+
+//}}}1
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/ulp.h vc-1.3.0/tests/ulp.h
--- vc-0.7.4/tests/ulp.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/ulp.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,19 +1,27 @@
 /*  This file is part of the Vc library. {{{
+Copyright © 2011-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2011-2012 Matthias Kretz <kretz@kde.org>
-
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 }}}*/
 
@@ -23,7 +31,7 @@
 #include <Vc/Vc>
 #include <Vc/limits>
 
-#ifdef VC_MSVC
+#ifdef Vc_MSVC
 namespace std
 {
     static inline bool isnan(float  x) { return _isnan(x); }
@@ -31,7 +39,8 @@
 } // namespace std
 #endif
 
-template<typename T> static T ulpDiffToReference(T val, T ref)
+template <typename T, typename = Vc::enable_if<std::is_floating_point<T>::value>>
+static T ulpDiffToReference(T val, T ref)
 {
     if (val == ref || (std::isnan(val) && std::isnan(ref))) {
         return 0;
@@ -50,20 +59,25 @@
     // val * 2 ^ -exp
     return ldexp(std::abs(ref - val), std::numeric_limits<T>::digits - exp);
 }
-template<typename T> static T ulpDiffToReferenceSigned(T val, T ref)
+
+template <typename T, typename = Vc::enable_if<std::is_floating_point<T>::value>>
+inline T ulpDiffToReferenceSigned(T val, T ref)
 {
     return ulpDiffToReference(val, ref) * (val - ref < 0 ? -1 : 1);
 }
 
-template<typename T> struct _Ulp_ExponentVector { typedef Vc::int_v Type; };
-template<> struct _Ulp_ExponentVector<Vc::sfloat_v> { typedef Vc::short_v Type; };
+template<typename T> struct UlpExponentVector_ { typedef Vc::int_v Type; };
+template <typename T, std::size_t N> struct UlpExponentVector_<Vc::SimdArray<T, N>>
+{
+    using Type = Vc::SimdArray<int, N>;
+};
 
-template<typename _T> static Vc::Vector<_T> ulpDiffToReference(const Vc::Vector<_T> &_val, const Vc::Vector<_T> &_ref)
+template <typename V, typename = Vc::enable_if<Vc::is_simd_vector<V>::value>>
+static V ulpDiffToReference(const V &_val, const V &_ref)
 {
     using namespace Vc;
-    typedef Vector<_T> V;
-    typedef typename V::EntryType T;
-    typedef typename V::Mask M;
+    using T = typename V::EntryType;
+    using M = typename V::Mask;
 
     V val = _val;
     V ref = _ref;
@@ -79,16 +93,25 @@
     val  (zeroMask)= std::numeric_limits<V>::min();
     diff (zeroMask)+= V::One();
 
-    typename _Ulp_ExponentVector<V>::Type exp;
+    typename V::IndexType exp;
     frexp(ref, &exp);
     diff += ldexp(abs(ref - val), std::numeric_limits<T>::digits - exp);
     diff.setZero(_val == _ref || (isnan(_val) && isnan(_ref)));
     return diff;
 }
 
-template<typename _T> static Vc::Vector<_T> ulpDiffToReferenceSigned(const Vc::Vector<_T> &_val, const Vc::Vector<_T> &_ref)
+template <typename T>
+inline Vc::enable_if<Vc::is_simd_vector<T>::value && Vc::is_floating_point<T>::value, T> ulpDiffToReferenceSigned(
+    const T &_val, const T &_ref)
+{
+    return copysign(ulpDiffToReference(_val, _ref), _val - _ref);
+}
+
+template <typename T>
+inline Vc::enable_if<!Vc::is_floating_point<T>::value, T> ulpDiffToReferenceSigned(
+    const T &, const T &)
 {
-    return ulpDiffToReference(_val, _ref).copySign(_val - _ref);
+    return 0;
 }
 
 #endif // TESTS_ULP_H
diff -Nru vc-0.7.4/tests/unittest.h vc-1.3.0/tests/unittest.h
--- vc-0.7.4/tests/unittest.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/unittest.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,161 +1,365 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2015 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #ifndef UNITTEST_H
 #define UNITTEST_H
 
-#ifdef VC_ASSERT
+#ifdef WIN32
+// just to break min/max
+#include <windows.h>
+#endif  // WIN32
+
+#include "typelist.h"
+
+#ifdef Vc_ASSERT
 #error "include unittest.h before any Vc header"
 #endif
-inline void unittest_assert(bool cond, const char *code, const char *file, int line);
-#define VC_ASSERT(cond) unittest_assert(cond, #cond, __FILE__, __LINE__);
+namespace UnitTest
+{
+static void unittest_assert(bool cond, const char *code, const char *file, int line);
+}  // namespace UnitTest
+#define Vc_ASSERT(cond) UnitTest::unittest_assert(cond, #cond, __FILE__, __LINE__);
 
 #include <Vc/Vc>
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <cstdlib>
-#include <cstring>
-#include <cmath>
 #include <Vc/support.h>
 #include "ulp.h"
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <random>
+#include <sstream>
+#include <tuple>
 #include <typeinfo>
+#include <vector>
+#ifdef HAVE_CXX_ABI_H
+#include <cxxabi.h>
+#endif
 #include <common/macros.h>
 
-#define _expand(name) #name
-#define runTest(name) _unit_test_global.runTestInt(&name, _expand(name))
-#define testAllTypes(name) \
-    _unit_test_global.runTestInt(&name<float_v>, #name "<float_v>"); \
-    _unit_test_global.runTestInt(&name<short_v>, #name "<short_v>"); \
-    _unit_test_global.runTestInt(&name<sfloat_v>, #name "<sfloat_v>"); \
-    _unit_test_global.runTestInt(&name<ushort_v>, #name "<ushort_v>"); \
-    _unit_test_global.runTestInt(&name<int_v>, #name "<int_v>"); \
-    _unit_test_global.runTestInt(&name<double_v>, #name "<double_v>"); \
-    _unit_test_global.runTestInt(&name<uint_v>, #name "<uint_v>")
-#define testRealTypes(name) \
-    _unit_test_global.runTestInt(&name<float_v>, #name "<float_v>"); \
-    _unit_test_global.runTestInt(&name<double_v>, #name "<double_v>"); \
-    _unit_test_global.runTestInt(&name<sfloat_v>, #name "<sfloat_v>");
+#ifdef DOXYGEN
 
-template<typename A, typename B> struct isEqualType
-{
-    operator bool() const { return false; }
-};
+/**
+ * \defgroup unittest Unit Testing
+ * @{
+ *
+ * In Vc we use a unit testing framework that was developed for easy use with typelists (i.e. the Vc
+ * SIMD types).
+ * It simplifies test creation to the bare minimum. The following code suffices to
+ * run a test:
+ * \code
+ * #include "tests/unittest.h"
+ *
+ * TEST(test_name) {
+ *   int test = 1 + 1;
+ *   COMPARE(test, 2) << "more details";
+ *   VERIFY(1 > 0);
+ * }
+ * \endcode
+ * This creates one test function (called "test_name"). This function is called
+ * without any further code and executes to checks. If, for some reason, the
+ * compiler would determine that test needs to have the value 3, then the output
+ * would be:
+   \verbatim
+    FAIL: ┍ at tests/testfile.cpp:5 (0x40451f):
+    FAIL: │ test (3) == 2 (2) -> false more details
+    FAIL: ┕ test_name
+
+    Testing done. 0 tests passed. 1 tests failed.
+   \endverbatim
+ * Let's take a look at what this tells us.
+ * 1. The test macro that failed was in testfile.cpp in line 5.
+ * 2. If you want to look at the disassembly, the failure was at 0x40451f.
+ * 3. The COMPARE macro compared the expression `test` against the expression
+ *    `2`. It shows that `test` had a value of `3` while `2` had a value of `2`
+ *    (what a surprise). Since the values are not equal `test == 2` returns \c
+ *    false.
+ * 4. The COMPARE, FUZZY_COMPARE, VERIFY, and FAIL macros can be used as
+ *    streams. The output will only appear on failure and will be printed right
+ *    after the normal output of the macro.
+ * 5. Finally the name of the failed test (the name specified inside the TEST()
+ *    macro) is printed.
+ * 6. At the end of the run, a summary of the test results is shown. This may be
+ *    important when there are many TEST functions.
+ *
+ * If the test passed you'll see:
+   \verbatim
+    PASS: test_name
+
+    Testing done. 1 tests passed. 0 tests failed.
+   \endverbatim
+ */
+
+/**
+ * \brief Defines a test function.
+ *
+ * Consider this to expand to `void
+ * function_name()`. The function_name will also be the name that appears in the
+ * output after PASS/FAIL.
+ */
+#define TEST(function_name)
+
+/**
+ * \brief Same as above, but expects the code to throw an exception of type \p
+ * ExceptionType.
+ *
+ * If the code does not throw (or throws a different exception),
+ * the test is considered failed.
+ */
+#define TEST_CATCH(function_name, ExceptionType)
+
+/**
+ * \brief Tests that should be tested with several types as template parameter
+ * can use this macro.
+ *
+ * Your test function then has this signature: `template <typename
+ * T> void function_name()`.
+ */
+#define TEST_BEGIN(T, function_name, typelist)
+
+/**
+ * \brief Test functions created with TEST_BEGIN need to end with TEST_END.
+ */
+#define TEST_END
+
+/**
+ * \brief Verifies that \p condition is \c true.
+ */
+#define VERIFY(condition)
+
+/**
+ * \brief Verifies that \p test_value is equal to \p reference.
+ */
+#define COMPARE(test_value, reference)
+
+/**
+ * \brief Verifies that the difference between \p test_value and \p reference is
+ * smaller than \p allowed_difference.
+ *
+ * If the test fails the output will show the actual difference between \p
+ * test_value and \p reference. If this value is positive \p test_value is too
+ * large. If it is negative \p test_value is too small.
+ */
+#define COMPARE_ABSOLUTE_ERROR(test_value, reference, allowed_difference)
+
+/**
+ * \brief Verifies that the difference between \p test_value and \p reference is
+ * smaller than `allowed_relative_difference * reference`.
+ *
+ * If the test fails the output will show the actual difference between \p
+ * test_value and \p reference. If this value is positive \p test_value is too
+ * large. If it is negative \p test_value is too small.
+ *
+ * The following example tests that `a` is no more than 1% different from `b`:
+ * \code
+ * COMPARE_ABSOLUTE_ERROR(a, b, 0.01);
+ * \endcode
+ *
+ * \note This test macro still works even if \p reference is set to 0. It will
+ * then compare the difference against `allowed_relative_difference * <smallest
+ * positive normalized value of reference type>`.
+ */
+#define COMPARE_RELATIVE_ERROR(test_value, reference, allowed_relative_difference)
+
+/**
+ * \brief Verifies that \p test_value is equal to \p reference within a
+ * pre-defined distance in units of least precision (ulp).
+ *
+ * If the test fails it will print the distance in ulp between \p test_value and
+ * \p reference as well as the maximum allowed distance. Often this difference
+ * is not visible in the value because the conversion of a double/float to a
+ * string needs to round the value to a sensible length.
+ *
+ * The allowed distance can be modified by calling:
+ * \code
+ * UnitTest::setFuzzyness<float>(4);
+ * UnitTest::setFuzzyness<double>(7);
+ * \endcode
+ *
+ * ### ulp
+ * Unit of least precision is a unit that is derived from the the least
+ * significant bit in the mantissa of a floating-point value. Consider a
+ * single-precision number (23 mantissa bits) with exponent \f$e\f$. Then 1
+ * ulp is \f$2^{e-23}\f$. Thus, \f$\log_2(u)\f$ signifies the the number
+ * incorrect mantissa bits (with \f$u\f$ the distance in ulp).
+ *
+ * If \p test_value and \p reference have a different exponent the meaning of
+ * ulp depends on the variable you look at. The FUZZY_COMPARE code always uses
+ * \p reference to determine the magnitude of 1 ulp.
+ *
+ * Example:
+ * The value `1.f` is `0x3f800000` in binary. The value
+ * `1.00000011920928955078125f` with binary representation `0x3f800001`
+ * therefore has a distance of 1 ulp.
+ * A positive distance means the \p test_value is larger than the \p reference.
+ * A negative distance means the \p test_value is smaller than the \p reference.
+ * * `FUZZY_COMPARE(1.00000011920928955078125f, 1.f)` will show a distance of 1
+ * * `FUZZY_COMPARE(1.f, 1.00000011920928955078125f)` will show a distance of -1
+ *
+ * The value `0.999999940395355224609375f` with binary representation
+ * `0x3f7fffff` has a smaller exponent than `1.f`:
+ * * `FUZZY_COMPARE(0.999999940395355224609375f, 1.f)` will show a distance of
+ * -0.5
+ * * `FUZZY_COMPARE(1.f, 0.999999940395355224609375f)` will show a distance of 1
+ *
+ * ### Comparing to 0
+ * Distance to 0 is implemented as comparing to `std::numeric_limits<T>::min()`
+ * instead and adding 1 to the resulting distance.
+ */
+#define FUZZY_COMPARE(test_value, reference)
+
+/**
+ * \brief Call this to fail a test.
+ */
+#define FAIL()
+
+/**
+ * \brief Wrap code that should fail an assertion with this macro.
+ */
+#define EXPECT_ASSERT_FAILURE(code)
+
+/**
+ * @}
+ */
 
-template<typename T> struct isEqualType<T, T>
-{
-    operator bool() const { return true; }
-};
+#else
 
-inline void printPass()
+namespace UnitTest
 {
-    std::cout << AnsiColor::green << " PASS: " << AnsiColor::normal;
-}
+// using statements {{{1
+using std::vector;
+using std::tuple;
+using std::get;
+
+// printPass {{{1
+static inline void printPass() { std::cout << Vc::AnsiColor::green << " PASS: " << Vc::AnsiColor::normal; }
+static inline void printSkip() { std::cout << Vc::AnsiColor::yellow << " SKIP: " << Vc::AnsiColor::normal; }
 
-bool _UnitTest_verify_vector_unit_supported()
+// verify_vector_unit_supported {{{1
+namespace
+{
+struct verify_vector_unit_supported
 {
-    bool s = Vc::currentImplementationSupported();
-    if (!s) {
-        std::cerr << "CPU or OS requirements not met for the compiled in vector unit!\n";
-        exit(-1);
+    verify_vector_unit_supported()
+    {
+        if (!Vc::currentImplementationSupported()) {
+            std::cerr
+                << "CPU or OS requirements not met for the compiled in vector unit!\n";
+            exit(-1);
+        }
     }
-    return s;
-}
-
-static bool _UnitTest_verify_vector_unit_supported_result = _UnitTest_verify_vector_unit_supported();
+} verify_vector_unit_supported_;
+}  // unnamed namespace
 
-class _UnitTest_Failure
+class UnitTestFailure //{{{1
 {
 };
 
-typedef void (*testFunction)();
-class _UnitTest_Global_Object
+struct SkippedTest //{{{1
 {
-    public:
-        _UnitTest_Global_Object()
-            : status(true),
-            expect_failure(false),
-            assert_failure(0),
-            expect_assert_failure(false),
-            float_fuzzyness( 1.f ),
-            double_fuzzyness( 1. ),
-            only_name(0),
-            m_finalized(false),
-            failedTests(0), passedTests(0),
-            findMaximumDistance(false),
-            maximumDistance(0),
-            meanDistance(0),
-            meanCount(0)
-        {
-        }
-
-        ~_UnitTest_Global_Object()
-        {
-            if (m_finalized) {
-                // on windows std::exit will call the dtor again, leading to infinite recursion
-                return;
-            }
-            if (plotFile.is_open()) {
-                plotFile.flush();
-                plotFile.close();
-            }
-            std::cout << "\n Testing done. " << passedTests << " tests passed. " << failedTests << " tests failed." << std::endl;
-            m_finalized = true;
-            std::exit(failedTests);
-        }
-
-        void runTestInt(testFunction fun, const char *name);
-
-        bool status;
-        bool expect_failure;
-        int assert_failure;
-        bool expect_assert_failure;
-        float float_fuzzyness;
-        double double_fuzzyness;
-        const char *only_name;
-        std::fstream plotFile;
-    private:
-        bool m_finalized;
-        int failedTests;
-    public:
-        int passedTests;
-        bool findMaximumDistance;
-        double maximumDistance;
-        double meanDistance;
-        int meanCount;
+    std::string message;
 };
 
-static _UnitTest_Global_Object _unit_test_global;
+using TestFunction = void (*)(void); //{{{1
 
-void EXPECT_FAILURE()
+class UnitTester  //{{{1
 {
-    _unit_test_global.expect_failure = true;
-}
+public:
+    UnitTester()
+        : status(true)
+        , expect_failure(false)
+        , assert_failure(0)
+        , expect_assert_failure(false)
+        , float_fuzzyness(1.f)
+        , double_fuzzyness(1.)
+        , only_name(0)
+        , m_finalized(false)
+        , failedTests(0)
+        , passedTests(0)
+        , skippedTests(0)
+        , findMaximumDistance(false)
+        , maximumDistance(0)
+        , meanDistance(0)
+        , meanCount(0)
+    {
+    }
+
+    int finalize()
+    {
+        if (plotFile.is_open()) {
+            plotFile.flush();
+            plotFile.close();
+        }
+        m_finalized = true;
+        std::cout << "\n Testing done. " << passedTests << " tests passed. "
+                  << failedTests << " tests failed. " << skippedTests << " tests skipped."
+                  << std::endl;
+        return failedTests;
+    }
+
+    void runTestInt(TestFunction fun, const char *name);
+
+    bool status;
+    bool expect_failure;
+    int assert_failure;
+    bool expect_assert_failure;
+    float float_fuzzyness;
+    double double_fuzzyness;
+    const char *only_name;
+    bool vim_lines = false;
+    std::fstream plotFile;
+
+private:
+    bool m_finalized;
+    int failedTests;
+
+public:
+    int passedTests;
+    int skippedTests;
+    bool findMaximumDistance;
+    double maximumDistance;
+    double meanDistance;
+    int meanCount;
+};
 
-inline const char *_unittest_fail()
+static UnitTester global_unit_test_object_;
+
+void EXPECT_FAILURE() { global_unit_test_object_.expect_failure = true; }
+
+static const char *failString()  // {{{1
 {
-    if (_unit_test_global.expect_failure) {
+    if (global_unit_test_object_.expect_failure) {
         return "XFAIL: ";
     }
     static const char *str = 0;
     if (str == 0) {
-        if (mayUseColor(std::cout)) {
+        if (Vc::mayUseColor(std::cout)) {
             static const char *fail = " \033[1;40;31mFAIL:\033[0m ";
             str = fail;
         } else {
@@ -166,66 +370,102 @@
     return str;
 }
 
-void initTest(int argc, char **argv)
+void initTest(int argc, char **argv)  //{{{1
 {
     for (int i = 1; i < argc; ++i) {
         if (0 == std::strcmp(argv[i], "--help") || 0 == std::strcmp(argv[i], "-h")) {
-            std::cout <<
-                "Usage: " << argv[0] << " [-h|--help] [--only <testname>] [--maxdist] [--plotdist <plot.dat>]\n";
+            std::cout << "Usage: " << argv[0]
+                      << " [-h|--help] [--only <testname>] [-v|--vim] [--maxdist] [--plotdist <plot.dat>]\n";
             exit(0);
         }
         if (0 == std::strcmp(argv[i], "--only") && i + 1 < argc) {
-            _unit_test_global.only_name = argv[i + 1];
+            global_unit_test_object_.only_name = argv[i + 1];
         } else if (0 == std::strcmp(argv[i], "--maxdist")) {
-            _unit_test_global.findMaximumDistance = true;
+            global_unit_test_object_.findMaximumDistance = true;
         } else if (0 == std::strcmp(argv[i], "--plotdist") && i + 1 < argc) {
-            _unit_test_global.plotFile.open(argv[i + 1], std::ios_base::out);
-            _unit_test_global.plotFile << "# reference\tdistance\n";
+            global_unit_test_object_.plotFile.open(argv[i + 1], std::ios_base::out);
+            global_unit_test_object_.plotFile << "# reference\tdistance\n";
+        } else if (0 == std::strcmp(argv[i], "--vim") ||
+                   0 == std::strcmp(argv[i], "-v")) {
+            global_unit_test_object_.vim_lines = true;
         }
     }
 }
+// setFuzzyness {{{1
+template <typename T> static inline void setFuzzyness(T);
+template <> inline void setFuzzyness<float>(float fuzz)
+{
+    global_unit_test_object_.float_fuzzyness = fuzz;
+}
+template <> inline void setFuzzyness<double>(double fuzz)
+{
+    global_unit_test_object_.double_fuzzyness = fuzz;
+}
 
-template<typename T> inline void setFuzzyness( T );
-template<> inline void setFuzzyness<float>( float fuzz ) { _unit_test_global.float_fuzzyness = fuzz; }
-template<> inline void setFuzzyness<double>( double fuzz ) { _unit_test_global.double_fuzzyness = fuzz; }
-
-void _UnitTest_Global_Object::runTestInt(testFunction fun, const char *name)
+void UnitTester::runTestInt(TestFunction fun, const char *name)  //{{{1
 {
-    if (_unit_test_global.only_name && 0 != std::strcmp(name, _unit_test_global.only_name)) {
+    if (global_unit_test_object_.only_name &&
+        0 != std::strcmp(name, global_unit_test_object_.only_name)) {
         return;
     }
-    _unit_test_global.status = true;
-    _unit_test_global.expect_failure = false;
-    try {
+    global_unit_test_object_.status = true;
+    global_unit_test_object_.expect_failure = false;
+    try
+    {
         setFuzzyness<float>(1);
         setFuzzyness<double>(1);
         maximumDistance = 0.;
         meanDistance = 0.;
         meanCount = 0;
         fun();
-    } catch(_UnitTest_Failure) {
+    } catch (const SkippedTest &skip) {
+        UnitTest::printSkip();
+        std::cout << name << ' ' << skip.message << std::endl;
+        ++skippedTests;
+        return;
+    } catch (UnitTestFailure) {
+    } catch (std::exception &e) {
+        std::cout << failString() << "┍ " << name << " threw an unexpected exception:\n";
+        std::cout << failString() << "│ " << e.what() << '\n';
+        global_unit_test_object_.status = false;
+    }
+    catch (...)
+    {
+        std::cout << failString() << "┍ " << name
+                  << " threw an unexpected exception, of unknown type\n";
+        global_unit_test_object_.status = false;
     }
-    if (_unit_test_global.expect_failure) {
-        if (!_unit_test_global.status) {
+    if (global_unit_test_object_.expect_failure) {
+        if (!global_unit_test_object_.status) {
             std::cout << "XFAIL: " << name << std::endl;
         } else {
-            std::cout << "unexpected PASS: " << name <<
-                "\n    This test should have failed but didn't. Check the code!" << std::endl;
+            std::cout << "unexpected PASS: " << name
+                      << "\n    This test should have failed but didn't. Check the code!"
+                      << std::endl;
             ++failedTests;
         }
     } else {
-        if (!_unit_test_global.status) {
+        if (!global_unit_test_object_.status) {
             if (findMaximumDistance) {
-                std::cout << _unittest_fail() << "│ with a maximal distance of " << maximumDistance << " to the reference (mean: " << meanDistance / meanCount << ").\n";
+                std::cout << failString() << "│ with a maximal distance of " << maximumDistance
+                          << " to the reference (mean: " << meanDistance / meanCount << ").\n";
+            }
+            std::cout << failString();
+            if (!vim_lines) {
+                std::cout << "┕ ";
+            }
+            std::cout << name << std::endl;
+            if (vim_lines) {
+                std::cout << '\n';
             }
-            std::cout << _unittest_fail() << "┕ " << name << std::endl;
             ++failedTests;
         } else {
-            printPass();
+            UnitTest::printPass();
             std::cout << name;
             if (findMaximumDistance) {
                 if (maximumDistance > 0.) {
-                    std::cout << " with a maximal distance of " << maximumDistance << " to the reference (mean: " << meanDistance / meanCount << ").";
+                    std::cout << " with a maximal distance of " << maximumDistance
+                              << " to the reference (mean: " << meanDistance / meanCount << ").";
                 } else {
                     std::cout << " all values matched the reference precisely.";
                 }
@@ -236,303 +476,676 @@
     }
 }
 
-template<typename T1, typename T2> inline bool unittest_compareHelper( const T1 &a, const T2 &b ) { return a == b; }
-template<> inline bool unittest_compareHelper<Vc::int_v, Vc::int_v>( const Vc::int_v &a, const Vc::int_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::uint_v, Vc::uint_v>( const Vc::uint_v &a, const Vc::uint_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::float_v, Vc::float_v>( const Vc::float_v &a, const Vc::float_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::sfloat_v, Vc::sfloat_v>( const Vc::sfloat_v &a, const Vc::sfloat_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::double_v, Vc::double_v>( const Vc::double_v &a, const Vc::double_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::ushort_v, Vc::ushort_v>( const Vc::ushort_v &a, const Vc::ushort_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<Vc::short_v, Vc::short_v>( const Vc::short_v &a, const Vc::short_v &b ) { return (a == b).isFull(); }
-template<> inline bool unittest_compareHelper<std::type_info, std::type_info>(const std::type_info &a, const std::type_info &b ) { return &a == &b; }
+// unittest_compareHelper {{{1
+template <typename T1, typename T2>
+Vc_ALWAYS_INLINE bool unittest_compareHelper(const T1 &a, const T2 &b)
+{
+    return Vc::all_of(a == b);
+}
 
-template<typename T> T ulpDiffToReferenceWrapper(T a, T b) {
+template <>
+Vc_ALWAYS_INLINE bool unittest_compareHelper<std::type_info, std::type_info>(
+    const std::type_info &a,
+    const std::type_info &b)
+{
+    return &a == &b;
+}
+
+// ulpDiffToReferenceWrapper {{{1
+template <typename T, typename = Vc::enable_if<!Vc::Traits::is_simd_vector<T>::value>>
+T ulpDiffToReferenceWrapper(T a, T b)
+{
     const T diff = ulpDiffToReference(a, b);
-    if (VC_IS_UNLIKELY(_unit_test_global.findMaximumDistance)) {
-        _unit_test_global.maximumDistance = std::max<double>(std::abs(diff), _unit_test_global.maximumDistance);
-        _unit_test_global.meanDistance += std::abs(diff);
-        ++_unit_test_global.meanCount;
+    if (Vc_IS_UNLIKELY(global_unit_test_object_.findMaximumDistance)) {
+        global_unit_test_object_.maximumDistance =
+            std::max<double>(std::abs(diff), global_unit_test_object_.maximumDistance);
+        global_unit_test_object_.meanDistance += std::abs(diff);
+        ++global_unit_test_object_.meanCount;
     }
     return diff;
 }
-template<typename T> Vc::Vector<T> ulpDiffToReferenceWrapper(VC_ALIGNED_PARAMETER(Vc::Vector<T>) a, VC_ALIGNED_PARAMETER(Vc::Vector<T>) b) {
-    const Vc::Vector<T> diff = ulpDiffToReference(a, b);
-    if (VC_IS_UNLIKELY(_unit_test_global.findMaximumDistance)) {
-        _unit_test_global.maximumDistance = std::max<double>(Vc::abs(diff).max(), _unit_test_global.maximumDistance);
-        _unit_test_global.meanDistance += Vc::abs(diff).sum();
-        _unit_test_global.meanCount += Vc::Vector<T>::Size;
+template <typename T, typename = Vc::enable_if<Vc::Traits::is_simd_vector<T>::value>>
+T ulpDiffToReferenceWrapper(const T &a, const T &b)
+{
+    const T diff = ulpDiffToReference(a, b);
+    if (Vc_IS_UNLIKELY(global_unit_test_object_.findMaximumDistance)) {
+        global_unit_test_object_.maximumDistance =
+            std::max<double>(Vc::abs(diff).max(), global_unit_test_object_.maximumDistance);
+        global_unit_test_object_.meanDistance += Vc::abs(diff).sum();
+        global_unit_test_object_.meanCount += T::Size;
     }
     return diff;
 }
-template<typename T> inline bool unittest_fuzzyCompareHelper( const T &a, const T &b ) { return a == b; }
-template<> inline bool unittest_fuzzyCompareHelper<float>( const float &a, const float &b ) {
-    return ulpDiffToReferenceWrapper(a, b) <= _unit_test_global.float_fuzzyness;
+// unittest_fuzzyCompareHelper {{{1
+template <typename T>
+static inline bool unittest_fuzzyCompareHelper(
+    const T &a,
+    const T &b,
+    Vc::enable_if<std::is_same<float, Vc::Traits::scalar_type<T>>::value> = Vc::nullarg)
+{
+    return Vc::all_of(ulpDiffToReferenceWrapper(a, b) <= global_unit_test_object_.float_fuzzyness);
 }
-template<> inline bool unittest_fuzzyCompareHelper<Vc::float_v>( const Vc::float_v &a, const Vc::float_v &b ) {
-    return (ulpDiffToReferenceWrapper(a, b) <= _unit_test_global.float_fuzzyness).isFull();
+template <typename T>
+static inline bool unittest_fuzzyCompareHelper(
+    const T &a,
+    const T &b,
+    Vc::enable_if<std::is_same<double, Vc::Traits::scalar_type<T>>::value> = Vc::nullarg)
+{
+    return Vc::all_of(ulpDiffToReferenceWrapper(a, b) <= global_unit_test_object_.double_fuzzyness);
 }
-template<> inline bool unittest_fuzzyCompareHelper<Vc::sfloat_v>( const Vc::sfloat_v &a, const Vc::sfloat_v &b ) {
-    return (ulpDiffToReferenceWrapper(a, b) <= _unit_test_global.float_fuzzyness).isFull();
+template <typename T>
+static inline bool unittest_fuzzyCompareHelper(
+    const T &a,
+    const T &b,
+    Vc::enable_if<!std::is_floating_point<Vc::Traits::scalar_type<T>>::value> = Vc::nullarg)
+{
+    return Vc::all_of(a == b);
 }
-template<> inline bool unittest_fuzzyCompareHelper<double>( const double &a, const double &b ) {
-    return ulpDiffToReferenceWrapper(a, b) <= _unit_test_global.double_fuzzyness;
+
+// unittest_fuzzynessHelper {{{1
+template <typename T> inline double unittest_fuzzynessHelper(const T &) { return 0.; }
+template <> inline double unittest_fuzzynessHelper<float>(const float &)
+{
+    return global_unit_test_object_.float_fuzzyness;
 }
-template<> inline bool unittest_fuzzyCompareHelper<Vc::double_v>( const Vc::double_v &a, const Vc::double_v &b ) {
-    return (ulpDiffToReferenceWrapper(a, b) <= _unit_test_global.double_fuzzyness).isFull();
+template <> inline double unittest_fuzzynessHelper<Vc::float_v>(const Vc::float_v &)
+{
+    return global_unit_test_object_.float_fuzzyness;
 }
-
-template<typename T1, typename T2, typename M> inline void unitttest_comparePrintHelper(const T1 &a, const T2 &b, const M &m, const char *aa, const char *bb, const char *file, int line, double fuzzyness = 0.) {
-    std::cout << "       " << aa << " (" << std::setprecision(10) << a << std::setprecision(6) << ") == " << bb << " (" << std::setprecision(10) << b << std::setprecision(6) << ") -> " << m;
-    if (fuzzyness > 0.) {
-        std::cout << " with fuzzyness " << fuzzyness;
-    }
-    std::cout << " at " << file << ":" << line << " failed.\n";
+template <> inline double unittest_fuzzynessHelper<double>(const double &)
+{
+    return global_unit_test_object_.double_fuzzyness;
 }
-
-template<typename T> inline double unittest_fuzzynessHelper(const T &) { return 0.; }
-template<> inline double unittest_fuzzynessHelper<float>(const float &) { return _unit_test_global.float_fuzzyness; }
-template<> inline double unittest_fuzzynessHelper<Vc::float_v>(const Vc::float_v &) { return _unit_test_global.float_fuzzyness; }
-template<> inline double unittest_fuzzynessHelper<double>(const double &) { return _unit_test_global.double_fuzzyness; }
-template<> inline double unittest_fuzzynessHelper<Vc::double_v>(const Vc::double_v &) { return _unit_test_global.double_fuzzyness; }
-
-class _UnitTest_Compare
+template <> inline double unittest_fuzzynessHelper<Vc::double_v>(const Vc::double_v &)
 {
-    public:
-        enum OptionFuzzy { Fuzzy };
-        enum OptionNoEq { NoEq };
+    return global_unit_test_object_.double_fuzzyness;
+}
 
-        template<typename T1, typename T2>
-        Vc_ALWAYS_INLINE _UnitTest_Compare(const T1 &a, const T2 &b, const char *_a, const char *_b, const char *_file, int _line)
-            : m_ip(getIp()), m_failed(!unittest_compareHelper(a, b))
-        {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                printFirst();
-                printPosition(_file, _line); print(":\n");
-                print(_a); print(" ("); print(std::setprecision(10)); print(a); print(") == ");
-                print(_b); print(" ("); print(std::setprecision(10)); print(b); print(std::setprecision(6));
-                print(") -> "); print(a == b);
-            }
+class Compare  //{{{1
+{
+    // absoluteErrorTest{{{2
+    template <typename T, typename ET>
+    static bool absoluteErrorTest(const T &a, const T &b, ET error)
+    {
+        if (a > b) {  // don't use abs(a - b) because it doesn't work for unsigned
+                      // integers
+            return a - b > error;
+        } else {
+            return b - a > error;
         }
+    }
+    // relativeErrorTest{{{2
+    template <typename T, typename ET>
+    static bool relativeErrorTest(const T &a, const T &b, ET error)
+    {
+        if (b > 0) {
+            error *= b;
+        } else if (b < 0) {
+            error *= -b;
+        } else if (std::is_floating_point<T>::value) {
+            // if the reference value is 0 then use the smallest normalized number
+            error *= std::numeric_limits<T>::min();
+        } else {
+            // error *= 1;  // the smallest non-zero positive number is 1...
+        }
+        if (a > b) {  // don't use abs(a - b) because it doesn't work for unsigned
+                      // integers
+            return a - b > error;
+        } else {
+            return b - a > error;
+        }
+    }
 
-        template<typename T1, typename T2>
-        Vc_ALWAYS_INLINE _UnitTest_Compare(const T1 &a, const T2 &b, const char *_a, const char *_b, const char *_file, int _line, OptionNoEq)
-            : m_ip(getIp()), m_failed(!unittest_compareHelper(a, b))
-        {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                printFirst();
-                printPosition(_file, _line); print(":\n");
-                print(_a); print(" ("); print(std::setprecision(10)); print(a); print(") == ");
-                print(_b); print(" ("); print(std::setprecision(10)); print(b); print(std::setprecision(6));
-                print(')');
-            }
+public:
+    // tag types {{{2
+    struct Fuzzy {};
+    struct NoEq {};
+    struct AbsoluteError {};
+    struct RelativeError {};
+    struct Mem {};
+
+    // Normal Compare ctor {{{2
+    template <typename T1, typename T2>
+    Vc_ALWAYS_INLINE Compare(
+        const T1 &a,
+        const T2 &b,
+        const char *_a,
+        const char *_b,
+        const char *_file,
+        typename std::enable_if<Vc::Traits::has_equality_operator<T1, T2>::value, int>::type _line)
+        : m_ip(getIp()), m_failed(!unittest_compareHelper(a, b))
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFailure(a, b, _a, _b, _file, _line);
         }
+    }
 
-        template<typename T>
-        Vc_ALWAYS_INLINE _UnitTest_Compare(const T &a, const T &b, const char *_a, const char *_b, const char *_file, int _line, OptionFuzzy)
-            : m_ip(getIp()), m_failed(!unittest_fuzzyCompareHelper(a, b))
-        {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                printFirst();
-                printPosition(_file, _line); print(":\n");
-                print(_a); print(" ("); print(std::setprecision(10)); print(a); print(") ≈ ");
-                print(_b); print(" ("); print(std::setprecision(10)); print(b); print(std::setprecision(6));
-                print(") -> "); print(a == b);
-                printFuzzyInfo(a, b);
-            }
-            if (_unit_test_global.plotFile.is_open()) {
-                writePlotData(_unit_test_global.plotFile, a, b);
+    template <typename T1, typename T2>
+    Vc_ALWAYS_INLINE Compare(
+        const T1 &a,
+        const T2 &b,
+        const char *_a,
+        const char *_b,
+        const char *_file,
+        typename std::enable_if<!Vc::Traits::has_equality_operator<T1, T2>::value, int>::type _line)
+        : Compare(a, b, _a, _b, _file, _line, Mem())
+    {
+    }
+
+    // Mem Compare ctor {{{2
+    template <typename T1, typename T2>
+    Vc_ALWAYS_INLINE Compare(const T1 &valueA,
+                             const T2 &valueB,
+                             const char *variableNameA,
+                             const char *variableNameB,
+                             const char *filename,
+                             int line,
+                             Mem)
+        : m_ip(getIp()), m_failed(0 != std::memcmp(&valueA, &valueB, sizeof(T1)))
+    {
+        static_assert(
+            sizeof(T1) == sizeof(T2),
+            "MEMCOMPARE requires both of its arguments to have the same size (equal sizeof)");
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFirst();
+            printPosition(filename, line);
+            print("MEMCOMPARE(");
+            print(variableNameA);
+            print(", ");
+            print(variableNameB);
+            const int endian_test = 1;
+            if (reinterpret_cast<const char *>(&endian_test)[0] == 1) {
+                print("), memory contents (little-endian):\n");
+            } else {
+                print("), memory contents (big-endian):\n");
             }
+            printMem(valueA);
+            print('\n');
+            printMem(valueB);
         }
+    }
 
-        Vc_ALWAYS_INLINE _UnitTest_Compare(bool good, const char *cond, const char *_file, int _line)
-            : m_ip(getIp()), m_failed(!good)
-        {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                printFirst();
-                printPosition(_file, _line);
-                print(": "); print(cond);
-            }
+    // NoEq Compare ctor {{{2
+    template <typename T1, typename T2>
+    Vc_ALWAYS_INLINE Compare(const T1 &a,
+                                       const T2 &b,
+                                       const char *_a,
+                                       const char *_b,
+                                       const char *_file,
+                                       int _line,
+                                       NoEq)
+        : m_ip(getIp()), m_failed(!unittest_compareHelper(a, b))
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFirst();
+            printPosition(_file, _line);
+            print(_a);
+            print(" (");
+            print(std::setprecision(10));
+            print(a);
+            print(") == ");
+            print(_b);
+            print(" (");
+            print(std::setprecision(10));
+            print(b);
+            print(std::setprecision(6));
+            print(')');
         }
+    }
 
-        Vc_ALWAYS_INLINE _UnitTest_Compare(const char *_file, int _line)
-            : m_ip(getIp()), m_failed(true)
-        {
+    // Fuzzy Compare ctor {{{2
+    template <typename T>
+    Vc_ALWAYS_INLINE Compare(const T &a,
+                                       const T &b,
+                                       const char *_a,
+                                       const char *_b,
+                                       const char *_file,
+                                       int _line,
+                                       Fuzzy)
+        : m_ip(getIp()), m_failed(!unittest_fuzzyCompareHelper(a, b))
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
             printFirst();
             printPosition(_file, _line);
-            print(":\n");
+            print(_a);
+            print(" (");
+            print(std::setprecision(10));
+            print(a);
+            print(") ≈ ");
+            print(_b);
+            print(" (");
+            print(std::setprecision(10));
+            print(b);
+            print(std::setprecision(6));
+            print(") -> ");
+            print(a == b);
+            printFuzzyInfo(a, b);
+        }
+        if (global_unit_test_object_.plotFile.is_open()) {
+            writePlotData(global_unit_test_object_.plotFile, a, b);
         }
+    }
 
-        template<typename T> Vc_ALWAYS_INLINE const _UnitTest_Compare &operator<<(const T &x) const {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                print(x);
+    // Absolute Error Compare ctor {{{2
+    template <typename T, typename ET>
+    Vc_ALWAYS_INLINE Compare(const T &a,
+                                    const T &b,
+                                    const char *_a,
+                                    const char *_b,
+                                    const char *_file,
+                                    int _line,
+                                    AbsoluteError,
+                                    ET error)
+        : m_ip(getIp()), m_failed(absoluteErrorTest(a, b, error))
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFirst();
+            printPosition(_file, _line);
+            print(_a);
+            print(" (");
+            print(std::setprecision(10));
+            print(a);
+            print(") ≈ ");
+            print(_b);
+            print(" (");
+            print(std::setprecision(10));
+            print(b);
+            print(std::setprecision(6));
+            print(") -> ");
+            print(a == b);
+            print("\ndifference: ");
+            if (a > b) {
+                print(a - b);
+            } else {
+                print('-');
+                print(b - a);
             }
-            return *this;
+            print(", allowed difference: ±");
+            print(error);
+            print("\ndistance: ");
+            print(ulpDiffToReferenceSigned(a, b));
+            print(" ulp");
         }
+    }
 
-        Vc_ALWAYS_INLINE const _UnitTest_Compare &operator<<(const char *str) const {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                print(str);
+    // Relative Error Compare ctor {{{2
+    template <typename T, typename ET>
+    Vc_ALWAYS_INLINE Compare(const T &a,
+                                    const T &b,
+                                    const char *_a,
+                                    const char *_b,
+                                    const char *_file,
+                                    int _line,
+                                    RelativeError,
+                                    ET error)
+        : m_ip(getIp()), m_failed(relativeErrorTest(a, b, error))
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFirst();
+            printPosition(_file, _line);
+            print(_a);
+            print(" (");
+            print(std::setprecision(10));
+            print(a);
+            print(") ≈ ");
+            print(_b);
+            print(" (");
+            print(std::setprecision(10));
+            print(b);
+            print(std::setprecision(6));
+            print(") -> ");
+            print(a == b);
+            print("\nrelative difference: ");
+            if (a > b) {
+                print((a - b) / (b > 0 ? b : -b));
+            } else {
+                print('-');
+                print((b - a) / (b > 0 ? b : -b));
             }
-            return *this;
+            print(", allowed: ±");
+            print(error);
+            print("\nabsolute difference: ");
+            if (a > b) {
+                print(a - b);
+            } else {
+                print('-');
+                print(b - a);
+            }
+            print(", allowed: ±");
+            print(error * (b > 0 ? b : -b));
+            print("\ndistance: ");
+            print(ulpDiffToReferenceSigned(a, b));
+            print(" ulp");
         }
+    }
+    // VERIFY ctor {{{2
+    Vc_ALWAYS_INLINE Compare(bool good, const char *cond, const char *_file, int _line)
+        : m_ip(getIp()), m_failed(!good)
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printFirst();
+            printPosition(_file, _line);
+            print(cond);
+        }
+    }
 
-        Vc_ALWAYS_INLINE const _UnitTest_Compare &operator<<(const char ch) const {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                print(ch);
-            }
-            return *this;
+    // FAIL ctor {{{2
+    Vc_ALWAYS_INLINE Compare(const char *_file, int _line) : m_ip(getIp()), m_failed(true)
+    {
+        printFirst();
+        printPosition(_file, _line);
+    }
+
+    // stream operators {{{2
+    template <typename T> Vc_ALWAYS_INLINE const Compare &operator<<(const T &x) const
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            print(x);
         }
+        return *this;
+    }
 
-        Vc_ALWAYS_INLINE const _UnitTest_Compare &operator<<(bool b) const {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                print(b);
-            }
-            return *this;
+    Vc_ALWAYS_INLINE const Compare &operator<<(const char *str) const
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            print(str);
         }
+        return *this;
+    }
 
-        Vc_ALWAYS_INLINE ~_UnitTest_Compare() throw(_UnitTest_Failure)
-        {
-            if (VC_IS_UNLIKELY(m_failed)) {
-                printLast();
-            }
+    Vc_ALWAYS_INLINE const Compare &operator<<(const char ch) const
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            print(ch);
+        }
+        return *this;
+    }
+
+    Vc_ALWAYS_INLINE const Compare &operator<<(bool b) const
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            print(b);
         }
+        return *this;
+    }
 
-    private:
-        static Vc_ALWAYS_INLINE size_t getIp() {
-            size_t _ip;
-#if defined(__x86_64__) && defined(VC_GNU_ASM)
-            asm("lea 0(%%rip),%0" : "=r"(_ip));
+    Vc_ALWAYS_INLINE ~Compare()  // {{{2
+#ifdef Vc_NO_NOEXCEPT
+        throw(UnitTestFailure)
 #else
-            _ip = 0;
+        noexcept(false)
 #endif
-            return _ip;
+    {
+        if (Vc_IS_UNLIKELY(m_failed)) {
+            printLast();
         }
-        static void printFirst() { std::cout << _unittest_fail() << "┍ "; }
-        template<typename T> static void print(const T &x) { std::cout << x; }
-        static void print(const std::type_info &x) { std::cout << x.name(); }
-        static void print(const char *str) {
-            const char *pos = 0;
-            if (0 != (pos = std::strchr(str, '\n'))) {
-                if (pos == str) {
-                    std::cout << '\n' << _unittest_fail() << "│ " << &str[1];
-                } else {
-                    char *left = strdup(str);
-                    left[pos - str] = '\0';
-                    std::cout << left << '\n' << _unittest_fail() << "│ " << &pos[1];
-                    free(left);
+    }
+
+    // }}}2
+private:
+    static Vc_ALWAYS_INLINE size_t getIp()  //{{{2
+    {
+        size_t _ip;
+#ifdef Vc_GNU_ASM
+#ifdef __x86_64__
+        asm volatile("lea 0(%%rip),%0" : "=r"(_ip));
+#else
+        // asm volatile("call 1f\n\t1: pop %0" : "=r"(_ip));
+        asm volatile("1: movl $1b,%0" : "=r"(_ip));
+#endif
+#else
+        _ip = 0;
+#endif
+        return _ip;
+    }
+    static char hexChar(char x)
+    {
+        return x + (x > 9 ? 87 : 48);
+    }
+    template <typename T> static void printMem(const T &x)  // {{{2
+    {
+        constexpr std::size_t length = sizeof(T) * 2 + sizeof(T) / 4;
+        std::unique_ptr<char[]> tmp{new char[length + 3]};
+        tmp[0] = '0';
+        tmp[1] = 'x';
+        char *s = &tmp[2];
+        std::memset(s, '\'', length - 1);
+        s[length - 1] = '\0';
+        s[length] = '\0';
+        const auto bytes = reinterpret_cast<const std::uint8_t *>(&x);
+        for (std::size_t i = 0; i < sizeof(T); ++i) {
+            s[i * 2 + i / 4] = hexChar(bytes[i] >> 4);
+            s[i * 2 + 1 + i / 4] = hexChar(bytes[i] & 0xf);
+        }
+        std::cout << tmp.get();
+    }
+
+    // printFailure {{{2
+    template <typename T1, typename T2>
+    Vc_NEVER_INLINE void printFailure(const T1 &a, const T2 &b, const char *_a,
+                                      const char *_b, const char *_file, int _line)
+    {
+        printFirst();
+        printPosition(_file, _line);
+        print(_a);
+        print(" (");
+        print(std::setprecision(10));
+        print(a);
+        print(") == ");
+        print(_b);
+        print(" (");
+        print(std::setprecision(10));
+        print(b);
+        print(std::setprecision(6));
+        print(") -> ");
+        print(a == b);
+    }
+
+    // printFirst {{{2
+    static void printFirst()
+    {
+        if (!global_unit_test_object_.vim_lines) {
+            std::cout << failString() << "┍ ";
+        }
+    }
+    // print overloads {{{2
+    template <typename T, typename = decltype(std::cout << std::declval<const T &>())>
+    static inline void printImpl(const T &x, int)
+    {
+        std::cout << x;
+    }
+    template <typename T> static inline void printImpl(const T &x, ...) { printMem(x); }
+    template <typename T> static inline void print(const T &x) { printImpl(x, int()); }
+    static void print(const std::type_info &x)
+    {
+#ifdef HAVE_CXX_ABI_H
+        char buf[1024];
+        size_t size = 1024;
+        abi::__cxa_demangle(x.name(), buf, &size, nullptr);
+        std::cout << buf;
+#else
+        std::cout << x.name();
+#endif
+    }
+    static void print(const std::string &str)
+    {
+        print(str.c_str());
+    }
+    static void print(const char *str)
+    {
+        const char *pos = 0;
+        if (0 != (pos = std::strchr(str, '\n'))) {
+            if (pos == str) {
+                std::cout << '\n' << failString();
+                if (!global_unit_test_object_.vim_lines) {
+                    std::cout << "│ ";
                 }
+                print(&str[1]);
             } else {
-                std::cout << str;
+                char *left = strdup(str);
+                left[pos - str] = '\0';
+                std::cout << left << '\n' << failString();
+                if (!global_unit_test_object_.vim_lines) {
+                    std::cout << "│ ";
+                }
+                free(left);
+                print(&pos[1]);
             }
+        } else {
+            std::cout << str;
         }
-        static void print(const char ch) {
-            if (ch == '\n') {
-                std::cout << '\n' << _unittest_fail() << "│ ";
-            } else {
-                std::cout << ch;
+    }
+    static void print(const unsigned char ch) { std::cout << int(ch); }
+    static void print(const signed char ch) { std::cout << int(ch); }
+    static void print(const char ch)
+    {
+        if (ch == '\n') {
+            std::cout << '\n' << failString();
+            if (!global_unit_test_object_.vim_lines) {
+                std::cout << "│ ";
             }
+        } else {
+            std::cout << ch;
         }
-        static void print(bool b) {
-            std::cout << (b ? "true" : "false");
-        }
-        static void printLast() {
-            std::cout << std::endl;
-            _unit_test_global.status = false;
-            //if (!_unit_test_global.plotFile.is_open()) {
-            throw _UnitTest_Failure();
-            //}
-        }
-        void printPosition(const char *_file, int _line) {
-            std::cout << "at " << _file << ':' << _line << " (0x" << std::hex << m_ip << std::dec << ')';
-        }
-        template<typename T> static inline void writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(T) a, VC_ALIGNED_PARAMETER(T) b);
-        template<typename T> static inline void printFuzzyInfo(VC_ALIGNED_PARAMETER(T) a, VC_ALIGNED_PARAMETER(T) b);
-        template<typename T> static inline void printFuzzyInfoImpl(VC_ALIGNED_PARAMETER(T) a, VC_ALIGNED_PARAMETER(T) b, double fuzzyness) {
-            print("\ndistance: ");
-            print(ulpDiffToReferenceSigned(a, b));
-            print(", allowed distance: ");
-            print(fuzzyness);
-        }
-        const size_t m_ip;
-        const bool m_failed;
-};
-template<typename T> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(T), VC_ALIGNED_PARAMETER(T)) {}
-template<> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(float) a, VC_ALIGNED_PARAMETER(float) b) {
-    printFuzzyInfoImpl(a, b, _unit_test_global.float_fuzzyness);
-}
-template<> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(double) a, VC_ALIGNED_PARAMETER(double) b) {
-    printFuzzyInfoImpl(a, b, _unit_test_global.double_fuzzyness);
-}
-template<> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(Vc::float_v) a, VC_ALIGNED_PARAMETER(Vc::float_v) b) {
-    printFuzzyInfoImpl(a, b, _unit_test_global.float_fuzzyness);
-}
-template<> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(Vc::double_v) a, VC_ALIGNED_PARAMETER(Vc::double_v) b) {
-    printFuzzyInfoImpl(a, b, _unit_test_global.double_fuzzyness);
-}
-template<> inline void _UnitTest_Compare::printFuzzyInfo(VC_ALIGNED_PARAMETER(Vc::sfloat_v) a, VC_ALIGNED_PARAMETER(Vc::sfloat_v) b) {
-    printFuzzyInfoImpl(a, b, _unit_test_global.float_fuzzyness);
-}
-template<typename T> inline void _UnitTest_Compare::writePlotData(std::fstream &, VC_ALIGNED_PARAMETER(T), VC_ALIGNED_PARAMETER(T)) {}
-template<> inline void _UnitTest_Compare::writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(float) a, VC_ALIGNED_PARAMETER(float) b) {
-    file << std::setprecision(12) << b << "\t" << ulpDiffToReferenceSigned(a, b) << "\n";
-}
-template<> inline void _UnitTest_Compare::writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(double) a, VC_ALIGNED_PARAMETER(double) b) {
-    file << std::setprecision(12) << b << "\t" << ulpDiffToReferenceSigned(a, b) << "\n";
-}
-template<> inline void _UnitTest_Compare::writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(Vc::float_v) a, VC_ALIGNED_PARAMETER(Vc::float_v) b) {
-    const Vc::float_v ref = b;
-    const Vc::float_v dist = ulpDiffToReferenceSigned(a, b);
-    for (int i = 0; i < Vc::float_v::Size; ++i) {
-        file << std::setprecision(12) << ref[i] << "\t" << dist[i] << "\n";
     }
+    static void print(bool b) { std::cout << (b ? "true" : "false"); }
+    // printLast {{{2
+    static void printLast()
+    {
+        std::cout << std::endl;
+        global_unit_test_object_.status = false;
+        throw UnitTestFailure();
+    }
+    // printPosition {{{2
+    void printPosition(const char *_file, int _line)
+    {
+        if (global_unit_test_object_.vim_lines) {
+            std::cout << _file << ':' << _line << ": (0x" << std::hex << m_ip << std::dec
+                      << "): ";
+        } else {
+            std::cout << "at " << _file << ':' << _line << " (0x" << std::hex << m_ip
+                      << std::dec << ')';
+            print("):\n");
+        }
+    }
+    template <typename T> static inline void writePlotData(std::fstream &file, T a, T b);
+    template <typename T> static inline void printFuzzyInfo(T, T);
+    template <typename T>
+    static inline void printFuzzyInfoImpl(std::true_type, T a, T b, double fuzzyness)
+    {
+        print("\ndistance: ");
+        print(ulpDiffToReferenceSigned(a, b));
+        print(" ulp, allowed distance: ±");
+        print(fuzzyness);
+        print(" ulp");
+    }
+    template <typename T>
+    static inline void printFuzzyInfoImpl(std::false_type, T, T, double)
+    {
+    }
+    // member variables {{{2
+    const size_t m_ip;
+    const bool m_failed;
+};
+
+// asBytes{{{1
+template <typename T> struct PrintMemDecorator { T x; };
+template <typename T> PrintMemDecorator<T> asBytes(const T &x) { return {x}; }
+
+// printFuzzyInfo specializations for float and double {{{1
+template <typename T> inline void Compare::printFuzzyInfo(T a, T b)
+{
+  printFuzzyInfoImpl(std::integral_constant<bool, Vc::is_floating_point<T>::value>(), a,
+                     b,
+                     std::is_same<T, float>::value || std::is_same<T, Vc::float_v>::value
+                         ? global_unit_test_object_.float_fuzzyness
+                         : global_unit_test_object_.double_fuzzyness);
 }
-template<> inline void _UnitTest_Compare::writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(Vc::double_v) a, VC_ALIGNED_PARAMETER(Vc::double_v) b) {
-    const Vc::double_v ref = b;
-    const Vc::double_v dist = ulpDiffToReferenceSigned(a, b);
-    for (int i = 0; i < Vc::double_v::Size; ++i) {
+template <typename T>
+static inline void writePlotDataImpl(std::true_type, std::fstream &file, T ref, T dist)
+{
+    for (size_t i = 0; i < T::Size; ++i) {
         file << std::setprecision(12) << ref[i] << "\t" << dist[i] << "\n";
     }
 }
-template<> inline void _UnitTest_Compare::writePlotData(std::fstream &file, VC_ALIGNED_PARAMETER(Vc::sfloat_v) a, VC_ALIGNED_PARAMETER(Vc::sfloat_v) b) {
-    const Vc::sfloat_v ref = b;
-    const Vc::sfloat_v dist = ulpDiffToReferenceSigned(a, b);
-    for (int i = 0; i < Vc::sfloat_v::Size; ++i) {
-        file << std::setprecision(12) << ref[i] << "\t" << dist[i] << "\n";
-    }
+template <typename T>
+static inline void writePlotDataImpl(std::false_type, std::fstream &file, T ref, T dist)
+{
+    file << std::setprecision(12) << ref << "\t" << dist << "\n";
 }
+template <typename T> inline void Compare::writePlotData(std::fstream &file, T a, T b)
+{
+    const T ref = b;
+    const T dist = ulpDiffToReferenceSigned(a, b);
+    writePlotDataImpl(std::integral_constant<bool, Vc::is_simd_vector<T>::value>(), file, ref, dist);
+}
+
+// FUZZY_COMPARE {{{1
+// Workaround for clang: The "<< ' '" is only added to silence the warnings
+// about unused return values.
+#define FUZZY_COMPARE(a, b)                                                                        \
+    UnitTest::Compare(a, b, #a, #b, __FILE__, __LINE__, UnitTest::Compare::Fuzzy()) << ' '
+// COMPARE_ABSOLUTE_ERROR {{{1
+#define COMPARE_ABSOLUTE_ERROR(a_, b_, error_)                                           \
+    UnitTest::Compare(a_, b_, #a_, #b_, __FILE__, __LINE__,                              \
+                      UnitTest::Compare::AbsoluteError(), error_)                        \
+        << ' '
+// COMPARE_RELATIVE_ERROR {{{1
+#define COMPARE_RELATIVE_ERROR(a_, b_, error_)                                           \
+    UnitTest::Compare(a_, b_, #a_, #b_, __FILE__, __LINE__,                              \
+                      UnitTest::Compare::RelativeError(), error_)                        \
+        << ' '
+// COMPARE {{{1
+#define COMPARE(a, b) UnitTest::Compare(a, b, #a, #b, __FILE__, __LINE__) << ' '
+// COMPARE_NOEQ {{{1
+#define COMPARE_NOEQ(a, b)                                                                         \
+    UnitTest::Compare(a, b, #a, #b, __FILE__, __LINE__, UnitTest::Compare::NoEq()) << ' '
+// MEMCOMPARE {{{1
+#define MEMCOMPARE(a, b)                                                                           \
+    UnitTest::Compare(a, b, #a, #b, __FILE__, __LINE__, UnitTest::Compare::Mem()) << ' '
+// VERIFY {{{1
+#define VERIFY(cond) UnitTest::Compare(cond, #cond, __FILE__, __LINE__) << ' '
+// FAIL {{{1
+#define FAIL() UnitTest::Compare(__FILE__, __LINE__) << ' '
 
-// Workaround for clang: The "<< ' '" is only added to silence the warnings about unused return
-// values.
-#define FUZZY_COMPARE( a, b ) \
-    _UnitTest_Compare(a, b, #a, #b, __FILE__, __LINE__, _UnitTest_Compare::Fuzzy) << ' '
-
-#define COMPARE( a, b ) \
-    _UnitTest_Compare(a, b, #a, #b, __FILE__, __LINE__) << ' '
-
-#define COMPARE_NOEQ( a, b ) \
-    _UnitTest_Compare(a, b, #a, #b, __FILE__, __LINE__, _UnitTest_Compare::NoEq) << ' '
-
-#define VERIFY(cond) \
-    _UnitTest_Compare(cond, #cond, __FILE__, __LINE__) << ' '
+// Skip {{{1
+class Skip
+{
+    std::stringstream stream;
 
-#define FAIL() \
-    _UnitTest_Compare(__FILE__, __LINE__) << ' '
+public:
+    ~Skip() noexcept(false) { throw SkippedTest{stream.str()}; }
+    template <typename T> Skip &operator<<(T &&x)
+    {
+        stream << std::forward<T>(x);
+        return *this;
+    }
+};
 
+// ADD_PASS() << "text" {{{1
 class ADD_PASS
 {
-    public:
-        ADD_PASS() { ++_unit_test_global.passedTests; printPass(); }
-        ~ADD_PASS() { std::cout << std::endl; }
-        template<typename T> ADD_PASS &operator<<(const T &x) { std::cout << x; return *this; }
+public:
+    ADD_PASS()
+    {
+        ++global_unit_test_object_.passedTests;
+        printPass();
+    }
+    ~ADD_PASS() { std::cout << std::endl; }
+    template <typename T> ADD_PASS &operator<<(const T &x)
+    {
+        std::cout << x;
+        return *this;
+    }
 };
-
-inline void unittest_assert(bool cond, const char *code, const char *file, int line)
+// unittest_assert (called from assert macro) {{{1
+void unittest_assert(bool cond, const char *code, const char *file, int line)
 {
     if (!cond) {
-        if (_unit_test_global.expect_assert_failure) {
-            ++_unit_test_global.assert_failure;
+        if (global_unit_test_object_.expect_assert_failure) {
+            ++global_unit_test_object_.assert_failure;
         } else {
-            _UnitTest_Compare(file, line) << "assert(" << code << ") failed.";
+            Compare(file, line) << "assert(" << code << ") failed.";
         }
     }
 }
@@ -540,142 +1153,425 @@
 #undef assert
 #endif
 #define assert(cond) unittest_assert(cond, #cond, __FILE__, __LINE__)
+// EXPECT_ASSERT_FAILURE {{{1
+#define EXPECT_ASSERT_FAILURE(code)                                                                \
+    global_unit_test_object_.expect_assert_failure = true;                                         \
+    global_unit_test_object_.assert_failure = 0;                                                   \
+    code;                                                                                          \
+    if (global_unit_test_object_.assert_failure == 0) {                                            \
+        /* failure expected but it didn't fail */                                                  \
+        std::cout << "       " << #code << " at " << __FILE__ << ":" << __LINE__                   \
+                  << " did not fail as was expected.\n";                                           \
+        global_unit_test_object_.status = false;                                                   \
+        throw UnitTestFailure();                                                                   \
+        return;                                                                                    \
+    }                                                                                              \
+    global_unit_test_object_.expect_assert_failure = false
+// allMasks {{{1
+template <typename Vec>
+static Vc::enable_if<Vc::MIC::is_vector<Vec>::value, typename Vec::Mask> allMasks(
+    size_t i)
+{
+    using M = typename Vec::Mask;
+    decltype(std::declval<const M &>().data()) tmp = ((1 << Vec::Size) - 1) - i;
+    return M(tmp);
+}
 
-#define EXPECT_ASSERT_FAILURE(code) \
-    _unit_test_global.expect_assert_failure = true; \
-    _unit_test_global.assert_failure = 0; \
-    code; \
-    if (_unit_test_global.assert_failure == 0) { \
-        /* failure expected but it didn't fail */ \
-        std::cout << "       " << #code << " at " << __FILE__ << ":" << __LINE__ << \
-            " did not fail as was expected.\n"; \
-        _unit_test_global.status = false; \
-        throw _UnitTest_Failure(); \
-        return; \
-    } \
-    _unit_test_global.expect_assert_failure = false
-
-template<typename Vec> inline typename Vec::Mask allMasks(int i)
-{
-    typedef typename Vec::IndexType I;
-    typedef typename Vec::Mask M;
-
-    if (i == 0) {
-        return M(true);
-    }
-    --i;
-    if (i < Vec::Size) {
-        return M (I(Vc::IndexesFromZero) == i);
-    }
-    i -= Vec::Size;
-    if (Vec::Size < 3) {
-        return M(false);
-    }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            if (i == 0) {
-                I indexes(Vc::IndexesFromZero);
-                return M(indexes == a || indexes == b);
-            }
-            --i;
-        }
-    }
-    if (Vec::Size < 4) {
-        return M(false);
-    }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            for (int c = b + 1; c < Vec::Size; ++c) {
-                if (i == 0) {
-                    I indexes(Vc::IndexesFromZero);
-                    return M(indexes == a || indexes == b || indexes == c);
-                }
-                --i;
-            }
-        }
-    }
-    if (Vec::Size < 5) {
-        return M(false);
-    }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            for (int c = b + 1; c < Vec::Size; ++c) {
-                for (int d = c + 1; d < Vec::Size; ++d) {
-                    if (i == 0) {
-                        I indexes(Vc::IndexesFromZero);
-                        return M(indexes == a || indexes == b || indexes == c || indexes == d);
-                    }
-                    --i;
-                }
-            }
-        }
-    }
-    if (Vec::Size < 6) {
-        return M(false);
-    }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            for (int c = b + 1; c < Vec::Size; ++c) {
-                for (int d = c + 1; d < Vec::Size; ++d) {
-                    for (int e = d + 1; e < Vec::Size; ++e) {
-                        if (i == 0) {
-                            I indexes(Vc::IndexesFromZero);
-                            return M(indexes == a || indexes == b || indexes == c || indexes == d || indexes == e);
-                        }
-                        --i;
-                    }
-                }
-            }
-        }
+template <typename Vec>
+static Vc::enable_if<!Vc::MIC::is_vector<Vec>::value, typename Vec::Mask> allMasks(
+    size_t i)
+{
+    static_assert(Vec::size() <= 8 * sizeof(i),
+                  "allMasks cannot create all possible masks for the given type Vec.");
+    using M = typename Vec::Mask;
+    const Vec indexes(Vc::IndexesFromZero);
+    M mask(true);
+
+    for (int j = 0; j < int(Vec::size()); ++j) {
+        if (i & (size_t(1) << j)) {
+            mask ^= indexes == j;
+        }
+    }
+    return mask;
+}
+
+#define for_all_masks(VecType, _mask_)                                                   \
+    static_assert(VecType::size() <= 16, "for_all_masks takes too long with "            \
+                                         "VecType::size > 16. Use withRandomMask "       \
+                                         "instead.");                                    \
+    for (int _Vc_for_all_masks_i = 0; _Vc_for_all_masks_i == 0; ++_Vc_for_all_masks_i)   \
+        for (typename VecType::Mask _mask_ =                                             \
+                 UnitTest::allMasks<VecType>(_Vc_for_all_masks_i++);                     \
+             !_mask_.isEmpty();                                                          \
+             _mask_ = UnitTest::allMasks<VecType>(_Vc_for_all_masks_i++))
+
+template <typename V, int Repetitions = 10000, typename F> void withRandomMask(F &&f)
+{
+    std::default_random_engine engine;
+    std::uniform_int_distribution<std::size_t> dist(0, (1ull << V::Size) - 1);
+    for (int repetition = 0; repetition < Repetitions; ++repetition) {
+        f(UnitTest::allMasks<V>(dist(engine)));
     }
-    if (Vec::Size < 7) {
-        return M(false);
+}
+
+// typeToString {{{1
+template <typename T> inline std::string typeToString();
+// std::array<T, N> {{{2
+template <typename T, std::size_t N>
+inline std::string typeToString_impl(std::array<T, N> const &)
+{
+    std::stringstream s;
+    s << "array<" << typeToString<T>() << ", " << N << '>';
+    return s.str();
+}
+// std::vector<T> {{{2
+template <typename T>
+inline std::string typeToString_impl(std::vector<T> const &)
+{
+    std::stringstream s;
+    s << "vector<" << typeToString<T>() << '>';
+    return s.str();
+}
+// std::integral_constant<T, N> {{{2
+template <typename T, T N>
+inline std::string typeToString_impl(std::integral_constant<T, N> const &)
+{
+    std::stringstream s;
+    s << "integral_constant<" << N << '>';
+    return s.str();
+}
+// SimdArray to string {{{2
+template <typename T, std::size_t N, typename V, std::size_t M>
+inline std::string typeToString_impl(Vc::SimdArray<T, N, V, M> const &)
+{
+    std::stringstream s;
+    s << "SimdArray<" << typeToString<T>() << ", " << N << '>';
+    return s.str();
+}
+template <typename T, std::size_t N, typename V, std::size_t M>
+inline std::string typeToString_impl(Vc::SimdMaskArray<T, N, V, M> const &)
+{
+    std::stringstream s;
+    s << "SimdMaskArray<" << typeToString<T>() << ", " << N << ", " << typeToString<V>() << '>';
+    return s.str();
+}
+// template parameter pack to a comma separated string {{{2
+template <typename T0, typename... Ts> std::string typeToString_impl(Typelist<T0, Ts...> const &)
+{
+    std::stringstream s;
+    s << '{' << typeToString<T0>();
+    auto &&x = {(s << ", " << typeToString<Ts>(), 0)...};
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waddress"
+#endif
+    if (&x == nullptr) {}  // avoid warning about unused 'x'
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    s << '}';
+    return s.str();
+}
+// Vc::<Impl>::Vector<T> to string {{{2
+template <typename V>
+inline std::string typeToString_impl(
+    V const &, typename std::enable_if<Vc::is_simd_vector<V>::value, int>::type = 0)
+{
+    using T = typename V::EntryType;
+    std::stringstream s;
+    if (std::is_same<V, Vc::Scalar::Vector<T>>::value) {
+        s << "Scalar::";
+    } else if (std::is_same<V, Vc::SSE::Vector<T>>::value) {
+        s << "SSE::";
+    } else if (std::is_same<V, Vc::AVX::Vector<T>>::value) {
+        s << "AVX::";
+    } else if (std::is_same<V, Vc::MIC::Vector<T>>::value) {
+        s << "MIC::";
+    }
+    s << "Vector<" << typeToString<T>() << '>';
+    return s.str();
+}
+template <typename V>
+inline std::string typeToString_impl(
+    V const &, typename std::enable_if<Vc::is_simd_mask<V>::value, int>::type = 0)
+{
+    using T = typename V::EntryType;
+    std::stringstream s;
+    if (std::is_same<V, Vc::Scalar::Mask<T>>::value) {
+        s << "Scalar::";
+    } else if (std::is_same<V, Vc::SSE::Mask<T>>::value) {
+        s << "SSE::";
+    } else if (std::is_same<V, Vc::AVX::Mask<T>>::value) {
+        s << "AVX::";
+    } else if (std::is_same<V, Vc::MIC::Mask<T>>::value) {
+        s << "MIC::";
+    }
+    s << "Mask<" << typeToString<T>() << '>';
+    return s.str();
+}
+// generic fallback (typeid::name) {{{2
+template <typename T>
+inline std::string typeToString_impl(
+    T const &,
+    typename std::enable_if<!Vc::is_simd_vector<T>::value && !Vc::is_simd_mask<T>::value,
+                            int>::type = 0)
+{
+    return typeid(T).name();
+}
+// typeToString specializations {{{2
+template <typename T> inline std::string typeToString() { return typeToString_impl(T()); }
+template <> inline std::string typeToString<void>() { return ""; }
+
+template <> inline std::string typeToString<Vc:: float_v>() { return " float_v"; }
+template <> inline std::string typeToString<Vc:: short_v>() { return " short_v"; }
+template <> inline std::string typeToString<Vc::  uint_v>() { return "  uint_v"; }
+template <> inline std::string typeToString<Vc::double_v>() { return "double_v"; }
+template <> inline std::string typeToString<Vc::ushort_v>() { return "ushort_v"; }
+template <> inline std::string typeToString<Vc::   int_v>() { return "   int_v"; }
+template <> inline std::string typeToString<Vc:: schar_v>() { return " schar_v"; }
+template <> inline std::string typeToString<Vc:: uchar_v>() { return " uchar_v"; }
+template <> inline std::string typeToString<Vc::  long_v>() { return "  long_v"; }
+template <> inline std::string typeToString<Vc:: ulong_v>() { return " ulong_v"; }
+template <> inline std::string typeToString<Vc:: llong_v>() { return " llong_v"; }
+template <> inline std::string typeToString<Vc::ullong_v>() { return "ullong_v"; }
+template <> inline std::string typeToString<Vc:: float_m>() { return " float_m"; }
+template <> inline std::string typeToString<Vc:: short_m>() { return " short_m"; }
+template <> inline std::string typeToString<Vc::  uint_m>() { return "  uint_m"; }
+template <> inline std::string typeToString<Vc::double_m>() { return "double_m"; }
+template <> inline std::string typeToString<Vc::ushort_m>() { return "ushort_m"; }
+template <> inline std::string typeToString<Vc::   int_m>() { return "   int_m"; }
+template <> inline std::string typeToString<Vc:: schar_m>() { return " schar_m"; }
+template <> inline std::string typeToString<Vc:: uchar_m>() { return " uchar_m"; }
+template <> inline std::string typeToString<Vc::  long_m>() { return "  long_m"; }
+template <> inline std::string typeToString<Vc:: ulong_m>() { return " ulong_m"; }
+template <> inline std::string typeToString<Vc:: llong_m>() { return " llong_m"; }
+template <> inline std::string typeToString<Vc::ullong_m>() { return "ullong_m"; }
+
+template <> inline std::string typeToString<long double>() { return "long double"; }
+template <> inline std::string typeToString<double>() { return "double"; }
+template <> inline std::string typeToString< float>() { return " float"; }
+template <> inline std::string typeToString<         long long>() { return " llong"; }
+template <> inline std::string typeToString<unsigned long long>() { return "ullong"; }
+template <> inline std::string typeToString<         long>() { return "  long"; }
+template <> inline std::string typeToString<unsigned long>() { return " ulong"; }
+template <> inline std::string typeToString<         int>() { return "   int"; }
+template <> inline std::string typeToString<unsigned int>() { return "  uint"; }
+template <> inline std::string typeToString<         short>() { return " short"; }
+template <> inline std::string typeToString<unsigned short>() { return "ushort"; }
+template <> inline std::string typeToString<         char>() { return "  char"; }
+template <> inline std::string typeToString<unsigned char>() { return " uchar"; }
+template <> inline std::string typeToString<  signed char>() { return " schar"; }
+
+// runAll and TestData {{{1
+typedef tuple<TestFunction, std::string> TestData;
+vector<TestData> g_allTests;
+
+void runAll()
+{
+    for (const auto &data : g_allTests) {
+        global_unit_test_object_.runTestInt(get<0>(data), get<1>(data).c_str());
     }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            for (int c = b + 1; c < Vec::Size; ++c) {
-                for (int d = c + 1; d < Vec::Size; ++d) {
-                    for (int e = d + 1; e < Vec::Size; ++e) {
-                        for (int f = e + 1; f < Vec::Size; ++f) {
-                            if (i == 0) {
-                                I indexes(Vc::IndexesFromZero);
-                                return M(indexes == a || indexes == b || indexes == c || indexes == d || indexes == e || indexes == f);
-                            }
-                            --i;
-                        }
-                    }
-                }
-            }
+}
+
+// class Test {{{1
+template <typename TestWrapper, typename Exception = void>
+struct Test : public TestWrapper
+{
+    static void wrapper()
+    {
+        try {
+            TestWrapper::test_function();
+        } catch (const Exception &e) {
+            return;
         }
+        FAIL() << "Test was expected to throw, but it didn't";
     }
-    if (Vec::Size < 8) {
-        return M(false);
-    }
-    for (int a = 0; a < Vec::Size - 1; ++a) {
-        for (int b = a + 1; b < Vec::Size; ++b) {
-            for (int c = b + 1; c < Vec::Size; ++c) {
-                for (int d = c + 1; d < Vec::Size; ++d) {
-                    for (int e = d + 1; e < Vec::Size; ++e) {
-                        for (int f = e + 1; f < Vec::Size; ++f) {
-                            for (int g = f + 1; g < Vec::Size; ++g) {
-                                if (i == 0) {
-                                    I indexes(Vc::IndexesFromZero);
-                                    return M(indexes == a || indexes == b || indexes == c || indexes == d
-                                            || indexes == e || indexes == f || indexes == g);
-                                }
-                                --i;
-                            }
-                        }
-                    }
-                }
-            }
-        }
+
+    Test(std::string name) { g_allTests.emplace_back(wrapper, std::move(name)); }
+};
+
+template <typename TestWrapper> struct Test<TestWrapper, void> : public TestWrapper
+{
+    Test(std::string name)
+    {
+        g_allTests.emplace_back(&TestWrapper::run, std::move(name));
     }
-    return M(false);
+};
+
+// addTestInstantiations {{{1
+template <std::size_t I, typename Indexer> struct TypeAtIndexX {
+    typedef decltype(TypelistIndexing::select<I>(Indexer{})) T;
+    using type = typename T::type;
+};
+template <std::size_t I, typename Indexer>
+using TypeAtIndex = typename TypeAtIndexX<I, Indexer>::type;
+
+template <template <typename> class TestWrapper, typename... Ts, std::size_t... I>
+static int addTestInstantiations(const char *basename, Typelist<Ts...>,
+                                 Vc::index_sequence<I...>)
+{
+    using Indexer = TypelistIndexing::indexer<Vc::index_sequence<I...>, Ts...>;
+    std::string name(basename);
+    name += '<';
+    const auto &x = {
+        0, (g_allTests.emplace_back(
+                &TestWrapper<TypeAtIndex<I, Indexer>>::run,
+                name + typeToString<TypeAtIndex<I, Indexer>>() + '>'),
+            0)...};
+    auto &&unused = [](decltype(x)) {};
+    unused(x);
+    return 0;
+}
+
+// hackTypelist {{{1
+template <typename... Ts> Typelist<Ts...> hackTypelist(void (*)(Ts...));
+template <typename... Ts> Typelist<Ts...> hackTypelist(void (*)(Typelist<Ts...>));
+
+//}}}1
+}  // namespace UnitTest
+// pre-defined type lists {{{1
+#define REAL_VECTORS                                                                     \
+    Vc::double_v, Vc::float_v
+#define INT_VECTORS                                                                      \
+    Vc::int_v, Vc::ushort_v, Vc::uint_v, Vc::short_v
+#define ALL_VECTORS REAL_VECTORS, INT_VECTORS
+#define ALL_MASKS Vc::double_m, Vc::float_m, Vc::int_m, Vc::short_m
+#define SIMD_REAL_ARRAYS(N_) Vc::SimdArray<double, N_>, Vc::SimdArray<float, N_>
+#define SIMD_INT_ARRAYS(N_)                                                              \
+    Vc::SimdArray<int, N_>, Vc::SimdArray<unsigned short, N_>,                           \
+        Vc::SimdArray<unsigned int, N_>, Vc::SimdArray<short, N_>
+#if defined Vc_IMPL_MIC
+#define SIMD_INT_ODD_ARRAYS(N_) Vc::SimdArray<int, N_>, Vc::SimdArray<unsigned int, N_>
+#else
+#define SIMD_INT_ODD_ARRAYS(N_) SIMD_INT_ARRAYS(N_)
+#endif
+#define SIMD_ARRAYS(N_) SIMD_REAL_ARRAYS(N_), SIMD_INT_ARRAYS(N_)
+#define SIMD_ODD_ARRAYS(N_) SIMD_REAL_ARRAYS(N_), SIMD_INT_ODD_ARRAYS(N_)
+#ifdef Vc_IMPL_Scalar
+#define SIMD_ARRAY_LIST                                                                  \
+    SIMD_ARRAYS(3),                                                                      \
+    SIMD_ARRAYS(1)
+#define SIMD_REAL_ARRAY_LIST                                                             \
+    SIMD_REAL_ARRAYS(3),                                                                 \
+    SIMD_REAL_ARRAYS(1)
+#elif Vc_FLOAT_V_SIZE <= 4
+#define SIMD_ARRAY_LIST                                                                  \
+    SIMD_ODD_ARRAYS(19),                                                                 \
+    SIMD_ARRAYS(9),                                                                      \
+    SIMD_ARRAYS(8),                                                                      \
+    SIMD_ARRAYS(5),                                                                      \
+    SIMD_ARRAYS(4),                                                                      \
+    SIMD_ARRAYS(3)
+#define SIMD_REAL_ARRAY_LIST                                                             \
+    SIMD_REAL_ARRAYS(19),                                                                \
+    SIMD_REAL_ARRAYS(9),                                                                 \
+    SIMD_REAL_ARRAYS(8),                                                                 \
+    SIMD_REAL_ARRAYS(5),                                                                 \
+    SIMD_REAL_ARRAYS(4),                                                                 \
+    SIMD_REAL_ARRAYS(3)
+#else
+#define SIMD_ARRAY_LIST                                                                  \
+    SIMD_ARRAYS(32),                                                                     \
+    SIMD_ODD_ARRAYS(19),                                                                 \
+    SIMD_ARRAYS(9),                                                                      \
+    SIMD_ARRAYS(8),                                                                      \
+    SIMD_ARRAYS(5),                                                                      \
+    SIMD_ARRAYS(4),                                                                      \
+    SIMD_ARRAYS(3)
+#define SIMD_REAL_ARRAY_LIST                                                             \
+    SIMD_REAL_ARRAYS(32),                                                                \
+    SIMD_REAL_ARRAYS(19),                                                                \
+    SIMD_REAL_ARRAYS(9),                                                                 \
+    SIMD_REAL_ARRAYS(8),                                                                 \
+    SIMD_REAL_ARRAYS(5),                                                                 \
+    SIMD_REAL_ARRAYS(4),                                                                 \
+    SIMD_REAL_ARRAYS(3)
+#endif
+
+using RealVectors = Typelist<REAL_VECTORS>;
+using RealSimdArrays = Typelist<SIMD_REAL_ARRAY_LIST>;
+using IntVectors = Typelist<INT_VECTORS>;
+using AllVectors = Typelist<ALL_VECTORS>;
+using AllSimdArrays = Typelist<SIMD_ARRAY_LIST>;
+
+// TEST_TYPES / TEST_CATCH / TEST macros {{{1
+#define REAL_TEST_TYPES(V_, name_, typelist_)                                            \
+    namespace Tests                                                                      \
+    {                                                                                    \
+    template <typename V_> struct name_##_ {                                             \
+        static void run();                                                               \
+    };                                                                                   \
+    static struct name_##_ctor {                                                         \
+        name_##_ctor()                                                                   \
+        {                                                                                \
+            using list =                                                                 \
+                decltype(UnitTest::hackTypelist(std::declval<void typelist_>()));        \
+            UnitTest::addTestInstantiations<name_##_>(                                   \
+                #name_, list{}, Vc::make_index_sequence<list::size()>{});                \
+        }                                                                                \
+    } name_##_ctor_;                                                                     \
+    }                                                                                    \
+    template <typename V_> void Tests::name_##_<V_>::run()
+
+#define FAKE_TEST_TYPES(V_, name_, typelist_)                                            \
+    template <typename V_> struct Test##name_                                            \
+    {                                                                                    \
+        static void run();                                                               \
+    };                                                                                   \
+    template <typename V_> void Test##name_<V_>::run()
+
+#define REAL_TEST(name_)                                                                 \
+    struct Test##name_                                                                   \
+    {                                                                                    \
+        static void run();                                                               \
+    };                                                                                   \
+    UnitTest::Test<Test##name_> test_##name_##_(#name_);                                 \
+    void Test##name_::run()
+
+#define FAKE_TEST(name_) template <typename UnitTest_T_> void name_()
+
+#define REAL_TEST_CATCH(name_, exception_)                                               \
+    struct Test##name_                                                                   \
+    {                                                                                    \
+        static void run();                                                               \
+    };                                                                                   \
+    UnitTest::Test<Test##name_, exception_> test_##name_##_(#name_);                     \
+    void Test##name_::run()
+
+#define FAKE_TEST_CATCH(name_, exception_) template <typename UnitTesT_T_> void name_()
+
+#ifdef UNITTEST_ONLY_XTEST
+#define TEST_TYPES(V_, name_, typelist_) FAKE_TEST_TYPES(V_, name_, typelist_)
+#define XTEST_TYPES(V_, name_, typelist_) REAL_TEST_TYPES(V_, name_, typelist_)
+
+#define TEST(name_) FAKE_TEST(name_)
+#define XTEST(name_) REAL_TEST(name_)
+
+#define TEST_CATCH(name_, exception_) FAKE_TEST_CATCH(name_, exception_)
+#define XTEST_CATCH(name_, exception_) REAL_TEST_CATCH(name_, exception_)
+#else
+#define XTEST_TYPES(V_, name_, typelist_) FAKE_TEST_TYPES(V_, name_, typelist_)
+#define TEST_TYPES(V_, name_, typelist_) REAL_TEST_TYPES(V_, name_, typelist_)
+
+#define XTEST(name_) FAKE_TEST(name_)
+#define TEST(name_) REAL_TEST(name_)
+
+#define XTEST_CATCH(name_, exception_) FAKE_TEST_CATCH(name_, exception_)
+#define TEST_CATCH(name_, exception_) REAL_TEST_CATCH(name_, exception_)
+#endif
+
+int Vc_CDECL main(int argc, char **argv)  //{{{1
+{
+    UnitTest::initTest(argc, argv);
+    UnitTest::runAll();
+#ifdef testAllTypes
+    testmain();
+#endif
+    return UnitTest::global_unit_test_object_.finalize();
 }
 
-#define for_all_masks(VecType, _mask_) \
-    for (int _Vc_for_all_masks_i = 0; _Vc_for_all_masks_i == 0; ++_Vc_for_all_masks_i) \
-        for (typename VecType::Mask _mask_ = allMasks<VecType>(_Vc_for_all_masks_i++); !_mask_.isEmpty(); _mask_ = allMasks<VecType>(_Vc_for_all_masks_i++))
+//}}}1
+#endif  // DOXYGEN
+#endif  // UNITTEST_H
 
-#endif // UNITTEST_H
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/unittest-old.h vc-1.3.0/tests/unittest-old.h
--- vc-0.7.4/tests/unittest-old.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/tests/unittest-old.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,21 @@
+#ifndef TESTS_UNITTEST_OLD_H_
+#define TESTS_UNITTEST_OLD_H_
+
+#define Vc_expand(name) #name
+#define runTest(name) UnitTest::global_unit_test_object_.runTestInt(&name, Vc_expand(name))
+#define testAllTypes(name)                                                                         \
+    UnitTest::global_unit_test_object_.runTestInt(&name<float_v>, #name "<float_v>");              \
+    UnitTest::global_unit_test_object_.runTestInt(&name<short_v>, #name "<short_v>");              \
+    UnitTest::global_unit_test_object_.runTestInt(&name<ushort_v>, #name "<ushort_v>");            \
+    UnitTest::global_unit_test_object_.runTestInt(&name<int_v>, #name "<int_v>");                  \
+    UnitTest::global_unit_test_object_.runTestInt(&name<double_v>, #name "<double_v>");            \
+    UnitTest::global_unit_test_object_.runTestInt(&name<uint_v>, #name "<uint_v>")
+#define testRealTypes(name)                                                                        \
+    UnitTest::global_unit_test_object_.runTestInt(&name<float_v>, #name "<float_v>");              \
+    UnitTest::global_unit_test_object_.runTestInt(&name<double_v>, #name "<double_v>");
+
+void testmain();
+
+#include "unittest.h"
+
+#endif  // TESTS_UNITTEST_OLD_H_
diff -Nru vc-0.7.4/tests/utils.cpp vc-1.3.0/tests/utils.cpp
--- vc-0.7.4/tests/utils.cpp	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/utils.cpp	2016-10-27 02:05:02.000000000 -0500
@@ -1,73 +1,43 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2016 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009-2012 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #include "unittest.h"
-#include <iostream>
-#include "vectormemoryhelper.h"
-#include <Vc/cpuid.h>
 
 using namespace Vc;
 
-template<typename Vec> void testSort()
+// reversed{{{1
+TEST_TYPES(V, reversed, (ALL_VECTORS, SIMD_ARRAYS(2), SIMD_ARRAYS(3), SIMD_ARRAYS(15)))
 {
-    typedef typename Vec::IndexType IndexType;
-
-    const IndexType _ref(IndexesFromZero);
-    Vec ref(_ref);
-    Vec a;
-    int maxPerm = 1;
-    for (int x = Vec::Size; x > 0; --x) {
-        maxPerm *= x;
-    }
-    for (int perm = 0; perm < maxPerm; ++perm) {
-        int rest = perm;
-        for (int i = 0; i < Vec::Size; ++i) {
-            a[i] = 0;
-            for (int j = 0; j < i; ++j) {
-                if (a[i] == a[j]) {
-                    ++(a[i]);
-                    j = -1;
-                }
-            }
-            a[i] += rest % (Vec::Size - i);
-            rest /= (Vec::Size - i);
-            for (int j = 0; j < i; ++j) {
-                if (a[i] == a[j]) {
-                    ++(a[i]);
-                    j = -1;
-                }
-            }
-        }
-        //std::cout << a << a.sorted() << std::endl;
-        COMPARE(ref, a.sorted()) << ", a: " << a;
-    }
-
-    for (int repetition = 0; repetition < 1000; ++repetition) {
-        Vec test = Vec::Random();
-        Vc::Memory<Vec, Vec::Size> reference;
-        reference.vector(0) = test;
-        std::sort(&reference[0], &reference[Vec::Size]);
-        ref = reference.vector(0);
-        COMPARE(ref, test.sorted());
-    }
+    const V x = V::IndexesFromZero() + 1;
+    const V reference = V::generate([](int i) { return V::Size - i; });
+    COMPARE(x.reversed(), reference);
 }
 
+// testCall{{{1
 template<typename T, typename Mem> struct Foo
 {
     Foo() : i(0) {}
@@ -77,17 +47,15 @@
     int i;
 };
 
-template<typename V> void testCall()
+TEST_TYPES(V, testCall, (ALL_VECTORS))
 {
     typedef typename V::EntryType T;
     typedef typename V::IndexType I;
     typedef typename V::Mask M;
-    typedef typename I::Mask MI;
-    const I _indexes(IndexesFromZero);
-    const MI _odd = (_indexes & I(One)) > 0;
-    const M odd(_odd);
-    V a(_indexes);
-    Foo<T, typename V::Memory> f;
+    const I _indexes(Vc::IndexesFromZero);
+    const M odd = Vc::simd_cast<M>((_indexes & I(One)) > 0);
+    V a(Vc::IndexesFromZero);
+    Foo<T, Vc::Memory<V, V::Size>> f;
     a.callWithValuesSorted(f);
     V b(f.d);
     COMPARE(b, a);
@@ -96,28 +64,31 @@
     a(odd) -= 1;
     a.callWithValuesSorted(f);
     V c(f.d);
-    for (int i = 0; i < V::Size / 2; ++i) {
+#ifndef Vc_IMPL_Scalar // avoid -Wtautological-compare warnings because of V::Size == 1
+    for (size_t i = 0; i < V::Size / 2; ++i) {
         COMPARE(a[i * 2], c[i]);
     }
-    for (int i = V::Size / 2; i < V::Size; ++i) {
+#endif
+    for (size_t i = V::Size / 2; i < V::Size; ++i) {
         COMPARE(b[i], c[i]);
     }
 }
 
-template<typename V> void testForeachBit()
+// testForeachBit{{{1
+TEST_TYPES(V, testForeachBit, (ALL_VECTORS))
 {
     typedef typename V::EntryType T;
     typedef typename V::IndexType I;
     const I indexes(IndexesFromZero);
     for_all_masks(V, mask) {
         V tmp = V::Zero();
-        foreach_bit(int j, mask) {
+        for (int j : where(mask)) {
             tmp[j] = T(1);
         }
         COMPARE(tmp == V::One(), mask);
 
         int count = 0;
-        foreach_bit(int j, mask) {
+        for (int j : where(mask)) {
             ++count;
             if (j >= 0) {
                 continue;
@@ -126,7 +97,7 @@
         COMPARE(count, mask.count());
 
         count = 0;
-        foreach_bit(int j, mask) {
+        for (int j : where(mask)) {
             if (j >= 0) {
                 break;
             }
@@ -136,109 +107,7 @@
     }
 }
 
-template<typename V> void copySign()
-{
-    V v(One);
-    V positive(One);
-    V negative = -positive;
-    COMPARE(v, v.copySign(positive));
-    COMPARE(-v, v.copySign(negative));
-}
-
-#ifdef _WIN32
-void bzero(void *p, size_t n) { memset(p, 0, n); }
-#else
-#include <strings.h>
-#endif
-
-template<typename V> void Random()
-{
-    typedef typename V::EntryType T;
-    enum {
-        NBits = 3,
-        NBins = 1 << NBits,                        // short int
-        TotalBits = sizeof(T) * 8,                 //    16  32
-        RightShift = TotalBits - NBits,            //    13  29
-        NHistograms = TotalBits - NBits + 1,       //    14  30
-        LeftShift = (RightShift + 1) / NHistograms,//     1   1
-        Mean = 135791,
-        MinGood = Mean - Mean/10,
-        MaxGood = Mean + Mean/10
-    };
-    const V mask((1 << NBits) - 1);
-    int histogram[NHistograms][NBins];
-    bzero(&histogram[0][0], sizeof(histogram));
-    for (size_t i = 0; i < NBins * Mean / V::Size; ++i) {
-        const V rand = V::Random();
-        for (size_t hist = 0; hist < NHistograms; ++hist) {
-            const V bin = ((rand << (hist * LeftShift)) >> RightShift) & mask;
-            for (size_t k = 0; k < V::Size; ++k) {
-                ++histogram[hist][bin[k]];
-            }
-        }
-    }
-//#define PRINT_RANDOM_HISTOGRAM
-#ifdef PRINT_RANDOM_HISTOGRAM
-    for (size_t hist = 0; hist < NHistograms; ++hist) {
-        std::cout << "histogram[" << std::setw(2) << hist << "]: ";
-        for (size_t bin = 0; bin < NBins; ++bin) {
-            std::cout << std::setw(3) << (histogram[hist][bin] - Mean) * 1000 / Mean << "|";
-        }
-        std::cout << std::endl;
-    }
-#endif
-    for (size_t hist = 0; hist < NHistograms; ++hist) {
-        for (size_t bin = 0; bin < NBins; ++bin) {
-            VERIFY(histogram[hist][bin] > MinGood)
-                << " bin = " << bin << " is " << histogram[0][bin];
-            VERIFY(histogram[hist][bin] < MaxGood)
-                << " bin = " << bin << " is " << histogram[0][bin];
-        }
-    }
-}
-
-template<typename V, typename I> void FloatRandom()
-{
-    typedef typename V::EntryType T;
-    enum {
-        NBins = 64,
-        NHistograms = 1,
-        Mean = 135791,
-        MinGood = Mean - Mean/10,
-        MaxGood = Mean + Mean/10
-    };
-    int histogram[NHistograms][NBins];
-    bzero(&histogram[0][0], sizeof(histogram));
-    for (size_t i = 0; i < NBins * Mean / V::Size; ++i) {
-        const V rand = V::Random();
-        const I bin = static_cast<I>(rand * T(NBins));
-        for (size_t k = 0; k < V::Size; ++k) {
-            ++histogram[0][bin[k]];
-        }
-    }
-#ifdef PRINT_RANDOM_HISTOGRAM
-    for (size_t hist = 0; hist < NHistograms; ++hist) {
-        std::cout << "histogram[" << std::setw(2) << hist << "]: ";
-        for (size_t bin = 0; bin < NBins; ++bin) {
-            std::cout << std::setw(3) << (histogram[hist][bin] - Mean) * 1000 / Mean << "|";
-        }
-        std::cout << std::endl;
-    }
-#endif
-    for (size_t hist = 0; hist < NHistograms; ++hist) {
-        for (size_t bin = 0; bin < NBins; ++bin) {
-            VERIFY(histogram[hist][bin] > MinGood)
-                << " bin = " << bin << " is " << histogram[0][bin];
-            VERIFY(histogram[hist][bin] < MaxGood)
-                << " bin = " << bin << " is " << histogram[0][bin];
-        }
-    }
-}
-
-template<> void Random<float_v>() { FloatRandom<float_v, int_v>(); }
-template<> void Random<double_v>() { FloatRandom<double_v, int_v>(); }
-template<> void Random<sfloat_v>() { FloatRandom<sfloat_v, short_v>(); }
-
+// applyAndCall{{{1
 template<typename T> T add2(T x) { return x + T(2); }
 
 template<typename T, typename V>
@@ -259,29 +128,26 @@
 
     private:
         V v;
-        int i;
+        unsigned int i;
 };
 
-#if __cplusplus >= 201103 && (!defined(VC_CLANG) || VC_CLANG > 0x30000)
-#define DO_LAMBDA_TESTS 1
-#endif
-
-template<typename V>
-void applyAndCall()
+TEST_TYPES(V, applyAndCall, (ALL_VECTORS))
 {
+#if defined Vc_CLANG && Vc_CLANG >= 0x30500 && Vc_CLANG < 0x30700 && defined __i386__
+    UnitTest::Skip() << "clang 3.5 and 3.6 crash when compiling this test";
+#endif
     typedef typename V::EntryType T;
 
     const V two(T(2));
-    for (int i = 0; i < 1000; ++i) {
+    for (int i = 0; i < 10; ++i) {
         const V rand = V::Random();
-        COMPARE(rand.apply(add2<T>), rand + two);
-#ifdef DO_LAMBDA_TESTS
+        auto add2Reference = static_cast<T (*)(T)>(add2);
+        COMPARE(rand.apply(add2Reference), rand + two);
         COMPARE(rand.apply([](T x) { return x + T(2); }), rand + two);
-#endif
 
         CallTester<T, V> callTester;
         rand.call(callTester);
-        COMPARE(callTester.callCount(), int(V::Size));
+        COMPARE(callTester.callCount(), static_cast<int>(V::Size));
         COMPARE(callTester.callValues(), rand);
 
         for_all_masks(V, mask) {
@@ -289,12 +155,10 @@
             V copy2 = rand;
             copy1(mask) += two;
 
-            COMPARE(copy2(mask).apply(add2<T>), copy1) << mask;
-            COMPARE(rand.apply(add2<T>, mask), copy1) << mask;
-#ifdef DO_LAMBDA_TESTS
+            COMPARE(copy2(mask).apply(add2Reference), copy1) << mask;
+            COMPARE(rand.apply(add2Reference, mask), copy1) << mask;
             COMPARE(copy2(mask).apply([](T x) { return x + T(2); }), copy1) << mask;
             COMPARE(rand.apply([](T x) { return x + T(2); }, mask), copy1) << mask;
-#endif
 
             callTester.reset();
             copy2(mask).call(callTester);
@@ -307,35 +171,37 @@
     }
 }
 
+// fill{{{1
 template<typename T, int value> T returnConstant() { return T(value); }
 template<typename T, int value> T returnConstantOffset(int i) { return T(value) + T(i); }
 template<typename T, int value> T returnConstantOffset2(unsigned short i) { return T(value) + T(i); }
 
-template<typename V> void fill()
+TEST_TYPES(V, fill, (ALL_VECTORS))
 {
     typedef typename V::EntryType T;
-    typedef typename V::IndexType I;
     V test = V::Random();
     test.fill(returnConstant<T, 2>);
     COMPARE(test, V(T(2)));
 
     test = V::Random();
     test.fill(returnConstantOffset<T, 0>);
-    COMPARE(test, static_cast<V>(I::IndexesFromZero()));
+    COMPARE(test, static_cast<V>(V::IndexesFromZero()));
 
     test = V::Random();
     test.fill(returnConstantOffset2<T, 0>);
-    COMPARE(test, static_cast<V>(I::IndexesFromZero()));
+    COMPARE(test, static_cast<V>(V::IndexesFromZero()));
 }
 
-template<typename V> void shifted()
+// shifted{{{1
+TEST_TYPES(V, shifted, (ALL_VECTORS))
 {
     typedef typename V::EntryType T;
-    for (int shift = -2 * V::Size; shift <= 2 * V::Size; ++shift) {
+    constexpr int Size = V::Size;
+    for (int shift = -2 * Size; shift <= 2 * Size; ++shift) {
         const V reference = V::Random();
         const V test = reference.shifted(shift);
-        for (int i = 0; i < V::Size; ++i) {
-            if (i + shift >= 0 && i + shift < V::Size) {
+        for (int i = 0; i < Size; ++i) {
+            if (i + shift >= 0 && i + shift < Size) {
                 COMPARE(test[i], reference[i + shift]) << "shift: " << shift << ", i: " << i << ", test: " << test << ", reference: " << reference;
             } else {
                 COMPARE(test[i], T(0)) << "shift: " << shift << ", i: " << i << ", test: " << test << ", reference: " << reference;
@@ -344,26 +210,82 @@
     }
 }
 
-template<typename V> void rotated()
-{
-    for (int shift = -2 * V::Size; shift <= 2 * V::Size; ++shift) {
-        //std::cout << "amount = " << shift % V::Size << std::endl;
+// rotated{{{1
+TEST_TYPES(V, rotated, (ALL_VECTORS, SIMD_ARRAYS(16), SIMD_ARRAYS(15), SIMD_ARRAYS(11),
+                        SIMD_ARRAYS(9), SIMD_ARRAYS(8), SIMD_ARRAYS(7), SIMD_ARRAYS(3)))
+{
+    constexpr int Size = V::Size;
+    for (int shift = 2 * Size; shift >= -2 * Size; --shift) {
+        //std::cout << "amount = " << shift % Size << std::endl;
         const V reference = V::Random();
         const V test = reference.rotated(shift);
-        for (int i = 0; i < V::Size; ++i) {
-            unsigned int refShift = i + shift;
-            COMPARE(test[i], reference[refShift % V::Size]) << "shift: " << shift << ", i: " << i << ", test: " << test << ", reference: " << reference;
+        for (int i = 0; i < Size; ++i) {
+            int refShift = (i + shift) % int(V::size());
+            if (refShift < 0) {
+                refShift += V::size();
+            }
+            COMPARE(test[i], reference[refShift])
+                << "shift: " << shift << ", refShift: " << refShift << ", i: " << i
+                << ", test: " << test << ", reference: " << reference;
         }
     }
 }
 
-void testMallocAlignment()
+// shiftedIn{{{1
+template <typename V> V shiftReference(const V &data, int shift)
+{
+    constexpr int Size = V::Size;
+    VERIFY(shift <= 2 * Size && shift >= -2 * Size);
+    using T = typename V::value_type;
+    T r[5 * Size] = {0};
+    const V d1 = data + 1;
+    d1.store(&r[Size]);
+    data.store(&r[2 * Size]);
+    d1.store(&r[3 * Size]);
+    return V{&r[2 * Size + shift], Vc::Unaligned};
+}
+
+template <typename V>
+void shiftedInConstant(const V &, std::integral_constant<int, 2 * V::Size>)
+{
+}
+
+template <typename V, typename Shift> void shiftedInConstant(const V &data, Shift)
+{
+    const V reference = shiftReference(data, Shift::value);
+    const V test = data.shifted(Shift::value, data + V::One());
+    COMPARE(test, reference) << "shift = " << Shift::value;
+    if ((Shift::value + 1) % V::Size != 0) {
+        shiftedInConstant(
+            data, std::integral_constant<
+                      int, ((Shift::value + 1) % V::Size == 0 ? 2 * int(V::Size)
+                                                              : Shift::value + 1)>());
+    }
+}
+
+TEST_TYPES(V, shiftedIn, (ALL_VECTORS, SIMD_ARRAYS(1), SIMD_ARRAYS(16), SIMD_ODD_ARRAYS(17)))
+{
+    constexpr int Size = V::Size;
+    const V data = V::Random();
+    for (int shift = -2 * Size + 1; shift <= 2 * Size -1; ++shift) {
+        const V reference = shiftReference(data, shift);
+        const V test = data.shifted(shift, data + V::One());
+        COMPARE(test, reference) << "\nshift = " << shift << "\ndata = " << data;
+    }
+    shiftedInConstant(V::Random(), std::integral_constant<int, -2 * Size + 1>());
+    shiftedInConstant(V::Random(), std::integral_constant<int, -Size>());
+    shiftedInConstant(V::Random(), std::integral_constant<int, 0>());
+    shiftedInConstant(V::Random(), std::integral_constant<int, Size>());
+}
+
+// testMallocAlignment{{{1
+TEST(testMallocAlignment)
 {
     int_v *a = Vc::malloc<int_v, Vc::AlignOnVector>(10);
 
-    unsigned long mask = VectorAlignment - 1;
+    std::uintptr_t mask = int_v::MemoryAlignment - 1;
     for (int i = 0; i < 10; ++i) {
-        VERIFY((reinterpret_cast<unsigned long>(&a[i]) & mask) == 0);
+        VERIFY((reinterpret_cast<std::uintptr_t>(&a[i]) & mask) == 0);
     }
     const char *data = reinterpret_cast<const char *>(&a[0]);
     for (int i = 0; i < 10; ++i) {
@@ -372,30 +294,110 @@
 
     a = Vc::malloc<int_v, Vc::AlignOnCacheline>(10);
     mask = CpuId::cacheLineSize() - 1;
-    COMPARE((reinterpret_cast<unsigned long>(&a[0]) & mask), 0ul);
+    COMPARE((reinterpret_cast<std::uintptr_t>(&a[0]) & mask), 0ul);
 
     // I don't know how to properly check page alignment. So we check for 4 KiB alignment as this is
     // the minimum page size on x86
     a = Vc::malloc<int_v, Vc::AlignOnPage>(10);
     mask = 4096 - 1;
-    COMPARE((reinterpret_cast<unsigned long>(&a[0]) & mask), 0ul);
+    COMPARE((reinterpret_cast<std::uintptr_t>(&a[0]) & mask), 0ul);
 }
 
-int main()
+// testIif{{{1
+template <typename A, typename B, typename C,
+          typename = decltype(Vc::iif(std::declval<A>(), std::declval<B>(),
+                                      std::declval<C>()))>
+inline void sfinaeIifIsNotCallable(A &&, B &&, C &&, int)
 {
-    testAllTypes(testCall);
-    testAllTypes(testForeachBit);
-    testAllTypes(testSort);
-    testRealTypes(copySign);
+    FAIL() << "iif(" << UnitTest::typeToString<A>() << UnitTest::typeToString<B>()
+           << UnitTest::typeToString<C>() << ") appears to be callable.";
+}
 
-    testAllTypes(shifted);
-    testAllTypes(rotated);
-    testAllTypes(Random);
+template <typename A, typename B, typename C>
+inline void sfinaeIifIsNotCallable(A &&, B &&, C &&, ...)
+{
+    // passes
+}
 
-    testAllTypes(applyAndCall);
-    testAllTypes(fill);
+TEST_TYPES(V, testIif,
+           (ALL_VECTORS, SIMD_ODD_ARRAYS(31), Vc::SimdArray<float, 8, Vc::Scalar::float_v>))
+{
+    typedef typename V::EntryType T;
+    const T one = T(1);
+    const T two = T(2);
 
-    runTest(testMallocAlignment);
+    for (int i = 0; i < 10000; ++i) {
+        const V x = V::Random();
+        const V y = V::Random();
+        V reference = y;
+        V reference2 = two;
+        for (size_t j = 0; j < V::Size; ++j) {
+            if (x[j] > y[j]) {
+                reference[j] = x[j];
+                reference2[j] = one;
+            }
+        }
+        COMPARE(iif (x > y, x, y), reference);
+        COMPARE(iif (x > y, V(one), V(two)), reference2);
+        sfinaeIifIsNotCallable(
+            x > y, int(), float(),
+            int());  // mismatching true/false value types should never work
+        sfinaeIifIsNotCallable(
+            x > y, int(), int(),
+            int());  // iif(mask, scalar, scalar) should not appear usable
+    }
+}
 
-    return 0;
+// testIifBuiltin{{{1
+TEST(testIifBuiltin)
+{
+    COMPARE(Vc::iif(true, 1, 2), true ? 1 : 2);
+    COMPARE(Vc::iif(false, 1, 2), false ? 1 : 2);
+    sfinaeIifIsNotCallable(bool(), int(), float(), int());
 }
+
+// testNonMemberInterleave{{{1
+TEST_TYPES(V, testNonMemberInterleave, (ALL_VECTORS, SIMD_ARRAYS(1), SIMD_ARRAYS(2), SIMD_ARRAYS(3), SIMD_ARRAYS(9), SIMD_ARRAYS(8)))
+{
+    using T = typename V::EntryType;
+    for (int repeat = 0; repeat < 10; ++repeat) {
+        std::array<V, 2> testValues = {V::IndexesFromZero(), V::IndexesFromZero() + int(V::Size)};
+        std::array<V, 2> references;
+        for (size_t i = 0; i < V::Size; ++i) {
+            size_t ii = 2 * i;
+            references[ii / V::Size][ii % V::Size] = T(i);
+            ++ii;
+            references[ii / V::Size][ii % V::Size] = T(i + V::Size);
+        }
+        std::tie(testValues[0], testValues[1]) = interleave(testValues[0], testValues[1]);
+        COMPARE(testValues[0], references[0]);
+        COMPARE(testValues[1], references[1]);
+    }
+}
+
+// reinterpret_components_cast {{{1
+using CastTypes = Typelist<
+#if Vc_FLOAT_V_SIZE == Vc_INT_V_SIZE
+    Typelist<float_v, int_v>,
+    Typelist<float_v, uint_v>
+#endif
+    >;
+TEST_TYPES(P, reinterpret_components_cast, (CastTypes))
+{
+    using From = typename P::template at<0>;
+    using To = typename P::template at<1>;
+    //using To = SimdArray<unsigned int, From::size()>;
+    From x(IndexesFromZero);
+    const auto test = reinterpret_components_cast<To>(x);
+    std::size_t i = 0;
+    for (; i < From::size(); ++i) {
+        union {
+            typename From::EntryType f;
+            typename To::EntryType u;
+        } cvt;
+        cvt.f = i;
+        COMPARE(test[i], cvt.u);
+    }
+}
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/tests/vectormemoryhelper.h vc-1.3.0/tests/vectormemoryhelper.h
--- vc-0.7.4/tests/vectormemoryhelper.h	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/tests/vectormemoryhelper.h	2016-10-27 02:05:02.000000000 -0500
@@ -1,21 +1,29 @@
-/*  This file is part of the Vc library.
+/*  This file is part of the Vc library. {{{
+Copyright © 2009-2014 Matthias Kretz <kretz@kde.org>
 
-    Copyright (C) 2009 Matthias Kretz <kretz@kde.org>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-    Vc is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as
-    published by the Free Software Foundation, either version 3 of
-    the License, or (at your option) any later version.
-
-    Vc is distributed in the hope that it will be useful, but
-    WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with Vc.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+}}}*/
 
 #ifndef VECTORMEMORYHELPER_H
 #define VECTORMEMORYHELPER_H
@@ -30,7 +38,7 @@
     public:
         VectorMemoryHelper(int count)
             : mem(new char[count * sizeof(Vec) + Vc::VectorAlignment]),
-            aligned(mem + (Vc::VectorAlignment - (reinterpret_cast<unsigned long>( mem ) & ( Vc::VectorAlignment - 1 ))))
+            aligned(mem + (Vc::VectorAlignment - (reinterpret_cast<std::uintptr_t>( mem ) & ( Vc::VectorAlignment - 1 ))))
         {
         }
         ~VectorMemoryHelper() { delete[] mem; }
diff -Nru vc-0.7.4/Test_vc.sh vc-1.3.0/Test_vc.sh
--- vc-0.7.4/Test_vc.sh	2014-05-15 06:38:24.000000000 -0500
+++ vc-1.3.0/Test_vc.sh	2016-10-27 02:05:02.000000000 -0500
@@ -19,4 +19,4 @@
       ;;
 esac
 
-ctest -S "`dirname $0`/test.cmake" 2>&1 | grep -v 'Error in read script:'
+ctest -S "`dirname $0`/test.cmake"
diff -Nru vc-0.7.4/traits/decay.h vc-1.3.0/traits/decay.h
--- vc-0.7.4/traits/decay.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/decay.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,41 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_DECAY_H_
+#define VC_TRAITS_DECAY_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+template <typename T> using decay = typename std::decay<T>::type;
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_DECAY_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/entry_type_of.h vc-1.3.0/traits/entry_type_of.h
--- vc-0.7.4/traits/entry_type_of.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/entry_type_of.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,60 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_ENTRY_TYPE_OF_H_
+#define VC_TRAITS_ENTRY_TYPE_OF_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+namespace entry_type_of_internal
+{
+template <typename T, bool = Traits::is_simd_vector<T>::value> struct entry_type;
+
+template <typename T> struct entry_type<T, true>
+{
+    using type = typename decay<T>::EntryType;
+};
+
+template <typename T> struct entry_type<T, false>
+{
+    using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+};
+}  // namespace entry_type_of_internal
+
+/**
+ * Resolves to T::EntryType if \p T is a SIMD type, otherwise it resolves to \p T itself.
+ */
+template <typename T> using entry_type_of = typename entry_type_of_internal::entry_type<T>::type;
+
+}  // namespace Traits
+}  // namespace Vc_VERSIONED_NAMESPACE
+
+#endif  // VC_TRAITS_ENTRY_TYPE_OF_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/has_addition_operator.h vc-1.3.0/traits/has_addition_operator.h
--- vc-0.7.4/traits/has_addition_operator.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_addition_operator.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,44 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_ADDITION_OPERATOR_H_
+#define VC_TRAITS_HAS_ADDITION_OPERATOR_H_
+
+namespace has_addition_operator_impl
+{
+
+template <typename T, typename U, typename = decltype(std::declval<T>() + std::declval<U>())> std::true_type test(int);
+template <typename T, typename U> std::false_type test(...);
+
+}  // namespace has_addition_operator_impl
+
+template <typename T, typename U = T>
+struct has_addition_operator : public decltype(has_addition_operator_impl::test<T, U>(1))
+{
+};
+
+#endif // VC_TRAITS_HAS_ADDITION_OPERATOR_H_
diff -Nru vc-0.7.4/traits/has_contiguous_storage.h vc-1.3.0/traits/has_contiguous_storage.h
--- vc-0.7.4/traits/has_contiguous_storage.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_contiguous_storage.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,95 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_CONTIGUOUS_STORAGE_H_
+#define VC_TRAITS_HAS_CONTIGUOUS_STORAGE_H_
+
+#include <initializer_list>
+#include <memory>
+
+#ifdef _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_STD
+#else
+namespace std
+{
+#endif
+#ifdef _WIN32
+template <typename T, size_t N> class array;
+#else
+template <typename T, size_t N> struct array;
+#endif
+template <typename T, typename Allocator> class vector;
+#ifdef _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_END_NAMESPACE_STD
+#else
+}  // namespace std
+#endif
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+namespace has_contiguous_storage_detail
+{
+template <typename T, typename It = typename T::iterator>
+std::is_base_of<std::random_access_iterator_tag,
+                typename It::iterator_category>
+test(int);  // this is only a heuristic. Having a RandomAccessIterator does not guarantee
+            // contiguous storage
+template <typename T>
+std::is_base_of<std::random_access_iterator_tag,
+                typename T::iterator_category>
+test(long);  // this is only a heuristic. Having a RandomAccessIterator does not guarantee
+             // contiguous storage
+template <typename T> std::false_type test(...);
+}  // namespace has_contiguous_storage_detail
+
+template <typename T>
+struct has_contiguous_storage_impl
+    : public decltype(has_contiguous_storage_detail::test<T>(int())) {
+};
+
+template <typename T>
+struct has_contiguous_storage
+    : public has_contiguous_storage_impl<
+          typename std::remove_cv<typename std::remove_reference<T>::type>::type>
+{
+};
+
+// spezializations:
+template <typename T> struct has_contiguous_storage_impl<const T *> : public std::true_type {};
+template <typename T> struct has_contiguous_storage_impl<T *> : public std::true_type {};
+template <typename T> struct has_contiguous_storage_impl<std::unique_ptr<T[]>> : public std::true_type {};
+template <typename T> struct has_contiguous_storage_impl<std::initializer_list<T>> : public std::true_type {};
+template <typename T, std::size_t N> struct has_contiguous_storage_impl<T[N]> : public std::true_type {};
+template <typename T, std::size_t N> struct has_contiguous_storage_impl<std::array<T, N>> : public std::true_type {};
+template <typename T, typename A> struct has_contiguous_storage_impl<std::vector<T, A>> : public std::true_type {};
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif // VC_TRAITS_HAS_CONTIGUOUS_STORAGE_H_
diff -Nru vc-0.7.4/traits/has_equality_operator.h vc-1.3.0/traits/has_equality_operator.h
--- vc-0.7.4/traits/has_equality_operator.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_equality_operator.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,53 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_EQUALITY_OPERATOR_H_
+#define VC_TRAITS_HAS_EQUALITY_OPERATOR_H_
+
+namespace has_equality_operator_impl
+{
+
+template <typename T, typename U,
+          typename = enable_if<!std::is_same<void, decltype(std::declval<T>() == std::declval<U>())>::value>>
+std::true_type test(int);
+template <typename T, typename U> std::false_type test(...);
+
+}  // namespace has_equality_operator_impl
+
+template <typename T, typename U = T>
+struct has_equality_operator : public decltype(has_equality_operator_impl::test<T, U>(1))
+{
+};
+
+static_assert(has_equality_operator<int>::value, "has_equality_operator fails");
+namespace
+{
+class Foobar {};
+static_assert(!has_equality_operator<Foobar>::value, "has_equality_operator fails");
+} // unnamed namespace
+
+#endif  // VC_TRAITS_HAS_EQUALITY_OPERATOR_H_
diff -Nru vc-0.7.4/traits/has_multiply_operator.h vc-1.3.0/traits/has_multiply_operator.h
--- vc-0.7.4/traits/has_multiply_operator.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_multiply_operator.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,44 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_MULTIPLY_OPERATOR_H_
+#define VC_TRAITS_HAS_MULTIPLY_OPERATOR_H_
+
+namespace has_multiply_operator_impl
+{
+
+template <typename T, typename U, typename = decltype(std::declval<T>() * std::declval<U>())> std::true_type test(int);
+template <typename T, typename U> std::false_type test(...);
+
+}  // namespace has_multiply_operator_impl
+
+template <typename T, typename U = T>
+struct has_multiply_operator : public decltype(has_multiply_operator_impl::test<T, U>(1))
+{
+};
+
+#endif // VC_TRAITS_HAS_MULTIPLY_OPERATOR_H_
diff -Nru vc-0.7.4/traits/has_no_allocated_data.h vc-1.3.0/traits/has_no_allocated_data.h
--- vc-0.7.4/traits/has_no_allocated_data.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_no_allocated_data.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,106 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_NO_ALLOCATED_DATA_H_
+#define VC_TRAITS_HAS_NO_ALLOCATED_DATA_H_
+
+#include <array>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+
+/**
+ * Implements the has_no_allocated_data trait.
+ *
+ * Specialize this type for your container class if you need to make it usable with SIMD
+ * gathers/scatters. Example:
+ * \code
+ * namespace Vc
+ * {
+ * namespace Traits
+ * {
+ * template<typename T> struct has_no_allocated_data_impl<MyContainer<T>> : public std::true_type {};
+ * }
+ * }
+ * \endcode
+ *
+ * \see has_no_allocated_data
+ */
+template<typename T> struct has_no_allocated_data_impl : public std::false_type {};
+
+/**
+ * Type trait that tells whether a container stores its data inside the object or inside allocated
+ * memory outside of the object.
+ *
+ * Per default the trait assumes any type to store its data outside, on the heap. The only types
+ * where it knows that the storage is inside the object are std::array, Vc::array, and T[] (builtin
+ * arrays).
+ *
+ * The trait forwards the actual decision to has_no_allocated_data_impl, but removes const/volatile
+ * and references from the type \p T to make the number of required specializations of
+ * has_no_allocated_data_impl minimal.
+ */
+template <typename T>
+struct has_no_allocated_data
+    : public has_no_allocated_data_impl<
+          typename std::remove_cv<typename std::remove_reference<T>::type>::type>
+{
+};
+
+// spezializations:
+template<typename T, std::size_t N> struct has_no_allocated_data_impl<std::array<T, N>> : public std::true_type {};
+template<typename T, std::size_t N> struct has_no_allocated_data_impl<T[N]> : public std::true_type {};
+template<typename T> struct has_no_allocated_data_impl<T[]> : public std::true_type {};
+
+// tests:
+static_assert(has_no_allocated_data<int[256]>::value, "");
+static_assert(has_no_allocated_data<const int[256]>::value, "");
+static_assert(has_no_allocated_data<volatile int[256]>::value, "");
+static_assert(has_no_allocated_data<const volatile int[256]>::value, "");
+
+static_assert(has_no_allocated_data<int[]>::value, "");
+static_assert(has_no_allocated_data<int[2][2]>::value, "");
+
+static_assert(has_no_allocated_data<const volatile std::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<const volatile std::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<volatile std::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<volatile std::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<const std::array<int, 256> &>::value, "");
+static_assert(has_no_allocated_data<const std::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<std::array<int, 256>>::value, "");
+static_assert(has_no_allocated_data<std::array<int, 256> &&>::value, "");
+static_assert(!has_no_allocated_data<int*>::value, "");
+static_assert(!has_no_allocated_data<const int*>::value, "");
+static_assert(!has_no_allocated_data<const int *const>::value, "");
+static_assert(!has_no_allocated_data<int *const>::value, "");
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif // VC_TRAITS_HAS_NO_ALLOCATED_DATA_H_
diff -Nru vc-0.7.4/traits/has_subscript_operator.h vc-1.3.0/traits/has_subscript_operator.h
--- vc-0.7.4/traits/has_subscript_operator.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/has_subscript_operator.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,48 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_HAS_SUBSCRIPT_OPERATOR_H_
+#define VC_TRAITS_HAS_SUBSCRIPT_OPERATOR_H_
+
+namespace has_subscript_operator_impl
+{
+
+template <typename T, typename I, typename = decltype(std::declval<T &>()[std::declval<I>()])> std::true_type test(int);
+template <typename T, typename I> std::false_type test(float);
+
+}  // namespace has_subscript_operator_impl
+
+template <typename T, typename I = std::size_t>
+struct has_subscript_operator : public decltype(has_subscript_operator_impl::test<T, I>(1))
+{
+};
+
+static_assert(has_subscript_operator<int[]>::value, "");
+static_assert(has_subscript_operator<int[], int>::value, "");
+static_assert(!has_subscript_operator<int[], void *>::value, "");
+
+#endif // VC_TRAITS_HAS_SUBSCRIPT_OPERATOR_H_
diff -Nru vc-0.7.4/traits/is_functor_argument_immutable.h vc-1.3.0/traits/is_functor_argument_immutable.h
--- vc-0.7.4/traits/is_functor_argument_immutable.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_functor_argument_immutable.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,101 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014-2016 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
+#define VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+namespace is_functor_argument_immutable_impl
+{
+template <typename F, typename A> std::true_type   test(void (F::*)(A));
+template <typename F, typename A> std::true_type   test(void (F::*)(A) const);
+template <typename F, typename A> std::is_const<A> test(void (F::*)(A &));
+template <typename F, typename A> std::is_const<A> test(void (F::*)(A &) const);
+template <typename F, typename A> std::is_const<A> test(void (F::*)(A &&));
+template <typename F, typename A> std::is_const<A> test(void (F::*)(A &&) const);
+
+struct dummy {};
+
+// generate a true_type for template operator() members in F that are callable with a
+// 'const A &' argument even if the template parameter to operator() is fixed to 'A'.
+template <
+    typename F, typename A
+#ifdef Vc_ICC
+    // this ensures that F is a generic lambda. We can be pretty sure that noone wrote a
+    // lambda with Vc::Traits::is_functor_argument_immutable_impl::dummy parameter
+    // type. In theory, this is not needed because the return type fails with a
+    // substitution failure in that case. Only ICC generates and error instead of doing
+    // SFINAE.
+    ,
+    typename = decltype(std::declval<F &>()(std::declval<dummy &>()))
+#endif
+    ,
+#ifdef Vc_MSVC
+// MSVC fails if the template keyword is used to *correctly* tell the compiler that <A> is
+// an explicit template instantiation of operator()
+#define Vc_TEMPLATE_
+#else
+#define Vc_TEMPLATE_ template
+#endif
+    typename MemberPtr = decltype(&F::Vc_TEMPLATE_ operator()<A>)>
+decltype(is_functor_argument_immutable_impl::test(std::declval<MemberPtr>())) test2(int);
+#undef Vc_TEMPLATE_
+
+// generate a true_type for non-template operator() members in F that are callable with a
+// 'const A &' argument.
+template <typename F, typename A>
+decltype(
+    is_functor_argument_immutable_impl::test(std::declval<decltype(&F::operator())>()))
+test2(float);
+
+template <typename A> std::true_type   test3(void(*)(A));
+template <typename A> std::is_const<A> test3(void(*)(A &));
+template <typename A> std::is_const<A> test3(void(*)(A &&));
+
+}  // namespace is_functor_argument_immutable_impl
+
+template <typename F, typename A, bool = std::is_function<F>::value>
+struct is_functor_argument_immutable;
+template <typename F, typename A>
+struct is_functor_argument_immutable<F, A, false>
+    : public decltype(is_functor_argument_immutable_impl::test2<
+                      typename std::remove_reference<F>::type, A>(int())) {
+};
+template <typename F, typename A>
+struct is_functor_argument_immutable<F, A, true>
+    : public decltype(is_functor_argument_immutable_impl::test3(std::declval<F>())) {
+};
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/is_gather_signature.h vc-1.3.0/traits/is_gather_signature.h
--- vc-0.7.4/traits/is_gather_signature.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_gather_signature.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,38 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+template <std::size_t, typename... Args> struct is_gather_signature_impl;
+template <std::size_t N_, typename Arg0, typename Arg1, typename... MoreArguments>
+struct is_gather_signature_impl<N_, Arg0, Arg1, MoreArguments...>
+    : public std::integral_constant<bool, has_subscript_operator<Arg0>::value &&
+                                              !is_loadstoreflag_internal<Arg1>::value &&
+                                              has_subscript_operator<Arg1>::value> {
+};
+template<typename... Args> struct is_gather_signature_impl<0, Args...> : public std::false_type {};
+template<typename... Args> struct is_gather_signature_impl<1, Args...> : public std::false_type {};
+
+template <typename... Args> struct is_gather_signature : public is_gather_signature_impl<sizeof...(Args), decay<Args>...> {};
diff -Nru vc-0.7.4/traits/is_implicit_cast_allowed.h vc-1.3.0/traits/is_implicit_cast_allowed.h
--- vc-0.7.4/traits/is_implicit_cast_allowed.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_implicit_cast_allowed.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,68 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_IS_IMPLICIT_CAST_ALLOWED_H_
+#define VC_TRAITS_IS_IMPLICIT_CAST_ALLOWED_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+template <typename From, typename To, bool = std::is_integral<From>::value>
+struct is_implicit_cast_allowed
+    : public std::integral_constant<
+          bool, std::is_same<From, To>::value ||
+                    (std::is_integral<To>::value &&
+                     (std::is_same<typename std::make_unsigned<From>::type, To>::value ||
+                      std::is_same<typename std::make_signed<From>::type, To>::value))> {
+};
+
+template <typename From, typename To>
+struct is_implicit_cast_allowed<From, To, false> : public std::is_same<From, To>::type {
+};
+
+template <typename From, typename To>
+struct is_implicit_cast_allowed_mask : public is_implicit_cast_allowed<From, To> {
+};
+
+static_assert(is_implicit_cast_allowed<float, float>::value, "");
+static_assert(!is_implicit_cast_allowed<float, double>::value, "");
+static_assert(is_implicit_cast_allowed< int64_t, uint64_t>::value, "");
+static_assert(is_implicit_cast_allowed<uint64_t,  int64_t>::value, "");
+static_assert(is_implicit_cast_allowed< int32_t, uint32_t>::value, "");
+static_assert(is_implicit_cast_allowed<uint32_t,  int32_t>::value, "");
+static_assert(is_implicit_cast_allowed< int16_t, uint16_t>::value, "");
+static_assert(is_implicit_cast_allowed<uint16_t,  int16_t>::value, "");
+static_assert(is_implicit_cast_allowed<  int8_t,  uint8_t>::value, "");
+static_assert(is_implicit_cast_allowed< uint8_t,   int8_t>::value, "");
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_IS_IMPLICIT_CAST_ALLOWED_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/is_index_sequence.h vc-1.3.0/traits/is_index_sequence.h
--- vc-0.7.4/traits/is_index_sequence.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_index_sequence.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_IS_INDEX_SEQUENCE_H_
+#define VC_IS_INDEX_SEQUENCE_H_
+
+#include "../common/indexsequence.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+
+template <typename T> struct is_index_sequence : public std::false_type {};
+template <std::size_t... I>
+struct is_index_sequence<Vc::index_sequence<I...>> : public std::true_type {};
+
+static_assert(!is_index_sequence<int>::value, "");
+static_assert(is_index_sequence<make_index_sequence<2>>::value, "");
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_IS_INDEX_SEQUENCE_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/is_initializer_list.h vc-1.3.0/traits/is_initializer_list.h
--- vc-0.7.4/traits/is_initializer_list.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_initializer_list.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,58 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_IS_INITIALIZER_LIST_H_
+#define VC_TRAITS_IS_INITIALIZER_LIST_H_
+
+#include <initializer_list>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+namespace is_initializer_list_impl
+{
+template <typename... Args> struct test : public std::false_type {};
+template <typename I> struct test<std::initializer_list<I>> : public std::true_type {};
+}  // namespace is_initializer_list_impl
+
+/**
+ * \internal
+ *
+ * Trait that tests whether \p Args is a single type and of std::initializer_list.
+ */
+template <typename... Args>
+struct is_initializer_list
+    : public is_initializer_list_impl::test<decay<Args>...>
+{
+};
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_IS_INITIALIZER_LIST_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/is_load_arguments.h vc-1.3.0/traits/is_load_arguments.h
--- vc-0.7.4/traits/is_load_arguments.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_load_arguments.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,50 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2014 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_IS_LOAD_ARGUMENTS_H_
+#define VC_TRAITS_IS_LOAD_ARGUMENTS_H_
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+template <typename T> struct is_load_store_flag;
+
+template <typename... Args> struct is_load_arguments : public std::false_type {};
+template <typename U> struct is_load_arguments<U> : public std::is_pointer<U> {};
+template <typename U, typename F>
+struct is_load_arguments<U, F> : public std::integral_constant<
+                                     bool,
+                                     std::is_pointer<U>::value&& is_load_store_flag<F>::value>
+{
+};
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_IS_LOAD_ARGUMENTS_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/is_output_iterator.h vc-1.3.0/traits/is_output_iterator.h
--- vc-0.7.4/traits/is_output_iterator.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/is_output_iterator.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,66 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_IS_OUTPUT_ITERATOR_H_
+#define VC_TRAITS_IS_OUTPUT_ITERATOR_H_
+
+#include <iterator>
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+namespace Traits
+{
+namespace is_output_iterator_impl
+{
+template <typename T, typename ValueType = typename std::iterator_traits<T>::value_type,
+          typename = decltype(*std::declval<T &>() = std::declval<
+                                  ValueType>())  // tests that assignment to a
+                                                 // dereferenced iterator is possible, if
+                                                 // yes, T is an OutputIterator
+          >
+std::true_type test(int);
+template <typename T> std::false_type test(...);
+}  // namespace is_output_iterator_impl
+
+template <typename T>
+struct is_output_iterator
+    : public std::conditional<
+          std::is_void<typename std::iterator_traits<T>::value_type>::value,
+          std::true_type, decltype(is_output_iterator_impl::test<T>(int()))>::type
+{
+};
+
+static_assert(!std::is_void<std::iterator_traits<int *>::value_type>::value, "");
+static_assert(is_output_iterator<int *>::value, "");
+static_assert(!is_output_iterator<const int *>::value, "");
+
+}  // namespace Traits
+}  // namespace Vc
+
+#endif  // VC_TRAITS_IS_OUTPUT_ITERATOR_H_
+
+// vim: foldmethod=marker
diff -Nru vc-0.7.4/traits/type_traits.h vc-1.3.0/traits/type_traits.h
--- vc-0.7.4/traits/type_traits.h	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/traits/type_traits.h	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,188 @@
+/*  This file is part of the Vc library. {{{
+Copyright © 2013-2015 Matthias Kretz <kretz@kde.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of contributing organizations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+}}}*/
+
+#ifndef VC_TRAITS_TYPE_TRAITS_H_
+#define VC_TRAITS_TYPE_TRAITS_H_
+
+#include <type_traits>
+#include "decay.h"
+#include "has_no_allocated_data.h"
+#include "has_contiguous_storage.h"
+#include "is_initializer_list.h"
+#include "is_load_arguments.h"
+#include "is_functor_argument_immutable.h"
+#include "is_output_iterator.h"
+#include "is_index_sequence.h"
+#include "is_implicit_cast_allowed.h"
+
+namespace Vc_VERSIONED_NAMESPACE
+{
+// meta-programming helpers
+struct enable_if_default_type
+{
+    constexpr enable_if_default_type() {}
+};
+static constexpr enable_if_default_type nullarg;
+template <bool Test, typename T = enable_if_default_type> using enable_if = typename std::enable_if<Test, T>::type;
+
+namespace Traits
+{
+#include "has_subscript_operator.h"
+#include "has_multiply_operator.h"
+#include "has_addition_operator.h"
+#include "has_equality_operator.h"
+
+template<typename T> struct is_simd_mask_internal : public std::false_type {};
+template<typename T> struct is_simd_vector_internal : public std::false_type {};
+template<typename T> struct is_subscript_operation_internal : public std::false_type {};
+template<typename T> struct is_simdarray_internal : public std::false_type {};
+template<typename T> struct is_simd_mask_array_internal : public std::false_type {};
+template<typename T> struct is_loadstoreflag_internal : public std::false_type {};
+
+#include "is_gather_signature.h"
+
+template <std::size_t, typename... Args> struct is_cast_arguments_internal : public std::false_type {};
+template <typename Arg>
+struct is_cast_arguments_internal<1, Arg> : public std::integral_constant<
+                                                bool,
+                                                is_simdarray_internal<Arg>::value ||
+                                                    is_simd_vector_internal<Arg>::value>
+{
+};
+
+template <typename T, bool = is_simd_vector_internal<T>::value> struct is_integral_internal;
+template <typename T, bool = is_simd_vector_internal<T>::value> struct is_floating_point_internal;
+template <typename T, bool = is_simd_vector_internal<T>::value> struct is_signed_internal;
+template <typename T, bool = is_simd_vector_internal<T>::value> struct is_unsigned_internal;
+
+template <typename T> struct is_integral_internal      <T, false> : public std::is_integral      <T> {};
+template <typename T> struct is_floating_point_internal<T, false> : public std::is_floating_point<T> {};
+template <typename T> struct is_signed_internal        <T, false> : public std::is_signed        <T> {};
+template <typename T> struct is_unsigned_internal      <T, false> : public std::is_unsigned      <T> {};
+
+template <typename V> struct is_integral_internal      <V, true> : public std::is_integral      <typename V::EntryType> {};
+template <typename V> struct is_floating_point_internal<V, true> : public std::is_floating_point<typename V::EntryType> {};
+template <typename V> struct is_signed_internal        <V, true> : public std::is_signed        <typename V::EntryType> {};
+template <typename V> struct is_unsigned_internal      <V, true> : public std::is_unsigned      <typename V::EntryType> {};
+
+template <typename T>
+struct is_arithmetic_internal
+    : public std::integral_constant<
+          bool,
+          (is_floating_point_internal<T>::value || is_integral_internal<T>::value)>
+{
+};
+
+template <typename T,
+          bool = (is_simd_vector_internal<T>::value || is_simd_mask_internal<T>::value ||
+                  is_simdarray_internal<T>::value ||
+                  is_simd_mask_array_internal<T>::value)>
+struct vector_size_internal;
+
+template <typename T>
+struct vector_size_internal<T, true> : public std::integral_constant<std::size_t, T::Size>
+{
+};
+template <typename T>
+struct vector_size_internal<T, false> : public std::integral_constant<std::size_t, 0>
+{
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Identifies any SIMD mask type (independent of implementation or whether it's
+ * SimdMaskArray<T, N>).
+ */
+template <typename T>
+struct is_simd_mask : public std::integral_constant<bool,
+                                                    (is_simd_mask_internal<decay<T>>::value ||
+                                                     is_simd_mask_array_internal<decay<T>>::value)>
+{
+};
+
+/**
+ * Identifies any SIMD vector type (independent of implementation or whether it's
+ * SimdArray<T, N>).
+ */
+template <typename T>
+struct is_simd_vector
+    : public std::integral_constant<bool,
+                                    (is_simd_vector_internal<decay<T>>::value ||
+                                     is_simdarray_internal<decay<T>>::value)>
+{
+};
+
+/// Identifies any possible SimdArray<T, N> type (independent of const/volatile or reference)
+template <typename T>
+struct isSimdArray : public is_simdarray_internal<decay<T>>
+{
+};
+
+/// Identifies any possible SimdMaskArray<T, N> type (independent of const/volatile or reference)
+template <typename T>
+struct isSimdMaskArray : public is_simd_mask_array_internal<decay<T>>
+{
+};
+
+/// \internal Identifies SubscriptOperation types
+template <typename T> struct is_subscript_operation : public is_subscript_operation_internal<decay<T>> {};
+/// \internal Identifies LoadStoreFlag types
+template <typename T> struct is_load_store_flag : public is_loadstoreflag_internal<decay<T>> {};
+/// \internal Identifies the function signature of a cast
+template <typename... Args> struct is_cast_arguments : public is_cast_arguments_internal<sizeof...(Args), decay<Args>...> {};
+
+/// \internal Identifies a SimdArray type with a single Vector member
+template <typename T> struct is_atomic_simdarray_internal : public std::false_type {};
+template <typename T> using isAtomicSimdArray = is_atomic_simdarray_internal<decay<T>>;
+
+/// \internal Identifies a SimdMaskArray type with a single Mask member
+template <typename T> struct is_atomic_simd_mask_array_internal : public std::false_type {};
+template <typename T> using isAtomicSimdMaskArray = is_atomic_simd_mask_array_internal<decay<T>>;
+
+/**
+ * The \p value member will either be the number of SIMD vector entries or 0 if \p T is not a SIMD
+ * type.
+ */
+template <typename T> struct simd_vector_size : public vector_size_internal<decay<T>> {};
+
+template <typename T> struct is_integral : public is_integral_internal<decay<T>> {};
+template <typename T> struct is_floating_point : public is_floating_point_internal<decay<T>> {};
+template <typename T> struct is_arithmetic : public is_arithmetic_internal<decay<T>> {};
+template <typename T> struct is_signed : public is_signed_internal<decay<T>> {};
+template <typename T> struct is_unsigned : public is_unsigned_internal<decay<T>> {};
+
+template <typename T, bool IsSimdVector> struct scalar_type_internal { using type = T; };
+template <typename T> struct scalar_type_internal<T, true> { using type = typename T::EntryType; };
+template <typename T> using scalar_type = typename scalar_type_internal<decay<T>, is_simd_vector<T>::value>::type;
+
+}  // namespace Traits
+}  // namespace Vc
+
+#include "entry_type_of.h"
+
+#endif // VC_TRAITS_TYPE_TRAITS_H_
diff -Nru vc-0.7.4/.travis.yml vc-1.3.0/.travis.yml
--- vc-0.7.4/.travis.yml	1969-12-31 18:00:00.000000000 -0600
+++ vc-1.3.0/.travis.yml	2016-10-27 02:05:02.000000000 -0500
@@ -0,0 +1,77 @@
+language: cpp
+
+cache: ccache
+
+env:
+    - GCC_VERSION=5
+    - GCC_VERSION=default
+
+os:
+    - linux
+    - osx
+
+compiler:
+    - gcc
+    - clang
+
+matrix:
+    exclude:
+        - env: GCC_VERSION=5
+          os: osx
+          compiler: clang
+        - env: GCC_VERSION=5
+          os: linux
+          compiler: clang
+
+# The following gives us Ubuntu 14.04 LTS instead of 12.04 LTS
+sudo: required
+dist: trusty
+
+install:
+    - if test "$TRAVIS_OS_NAME" = "osx" -a "$CXX" = "g++"; then
+        brew update &&
+        if test $GCC_VERSION = 5; then
+          brew install gcc5 && export CXX=g++-5 CC=gcc-5;
+        else
+          brew install coreutils && export CXX=g++-4.9 CC=gcc-4.9;
+        fi
+      fi
+    - if test "$TRAVIS_OS_NAME" = "osx" -a "$CXX" = "clang++"; then
+        brew update &&
+        brew install llvm &&
+        export CXX=/usr/local/opt/llvm/bin/clang++ CC=/usr/local/opt/llvm/bin/clang &&
+        export LDFLAGS="-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib" &&
+        export CPPFLAGS=-I/usr/local/opt/llvm/include;
+      fi
+    - if test "$TRAVIS_OS_NAME" = "linux" -a "$GCC_VERSION" = "5"; then
+        sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y &&
+        sudo apt-get update -q &&
+        sudo apt-get install g++-5 -y &&
+        export CXX=g++-5 CC=gcc-5;
+      fi
+    - if test "$TRAVIS_OS_NAME" = "linux" -a "$CXX" = "clang++"; then
+        sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y &&
+        sudo apt-get update -q &&
+        sudo apt-get install clang-3.8 libstdc++-6-dev libc++-dev libc++abi-dev -y;
+        export CXX=clang++-3.8 CC=clang-3.8;
+      fi
+
+before_script:
+    - $CXX --version
+    - cmake --version
+    - export dashboard_model=Experimental
+    - export build_type=Release
+    - export NUMBER_OF_PROCESSORS=2
+
+script:
+    - ctest -V -S test.cmake
+
+notifications:
+    email: false
+    irc:
+        channels:
+            - "chat.freenode.net##Vc"
+        on_success: change # [always|never|change] # default: always
+        on_failure: always # [always|never|change] # default: always
+        use_notice: true
+        skip_join: true