diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_array b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_array
new file mode 100644
index 00000000..41f686b1
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_array
@@ -0,0 +1,308 @@
+//===-- metal_array -------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_ARRAY
+#define __METAL_ARRAY
+
+#include <metal_assert>
+
+#if defined(__HAVE_ARRAY__)
+namespace metal {
+
+template <typename T, size_t N>
+struct array {
+  // Use implicitly declared constructors and equality member functions as array
+  // is an aggregate type.
+
+  METAL_FUNC constexpr size_t size() const thread { return N; }
+  METAL_FUNC constexpr size_t max_size() const thread { return N; }
+  METAL_FUNC constexpr bool empty() const thread { return N == 0; }
+
+  METAL_FUNC thread T &front() thread {
+    assert(!empty());
+    return __elems[0];
+  }
+  METAL_FUNC constexpr const thread T &front() const thread {
+    assert(!empty());
+    return __elems[0];
+  }
+
+  METAL_FUNC thread T &back() thread {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+  METAL_FUNC constexpr const thread T &back() const thread {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+
+  METAL_FUNC thread T &operator[](size_t pos) thread {
+    assert(pos < size());
+    return __elems[pos];
+  }
+  METAL_FUNC constexpr const thread T &operator[](size_t pos) const thread {
+    assert(pos < size());
+    return __elems[pos];
+  }
+
+  METAL_FUNC thread T *data() thread { return __elems; }
+  METAL_FUNC constexpr const thread T *data() const thread { return __elems; }
+
+  METAL_FUNC constexpr size_t size() const device { return N; }
+  METAL_FUNC constexpr size_t max_size() const device { return N; }
+  METAL_FUNC constexpr bool empty() const device { return N == 0; }
+
+  METAL_FUNC device T &front() device {
+    assert(!empty());
+    return __elems[0];
+  }
+  METAL_FUNC constexpr const device T &front() const device {
+    assert(!empty());
+    return __elems[0];
+  }
+
+  METAL_FUNC device T &back() device {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+  METAL_FUNC constexpr const device T &back() const device {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+
+  METAL_FUNC device T &operator[](size_t pos) device {
+    assert(pos < size());
+    return __elems[pos];
+  }
+  METAL_FUNC constexpr const device T &operator[](size_t pos) const device {
+    assert(pos < size());
+    return __elems[pos];
+  }
+
+  METAL_FUNC device T *data() device { return __elems; }
+  METAL_FUNC constexpr const device T *data() const device { return __elems; }
+
+  METAL_FUNC constexpr size_t size() const constant { return N; }
+  METAL_FUNC constexpr size_t max_size() const constant { return N; }
+  METAL_FUNC constexpr bool empty() const constant { return N == 0; }
+
+  METAL_FUNC constexpr const constant T &front() const constant {
+    assert(!empty());
+    return __elems[0];
+  }
+
+  METAL_FUNC constexpr const constant T &back() const constant {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+
+  METAL_FUNC constexpr const constant T &operator[](size_t pos) const constant {
+    assert(pos < size());
+    return __elems[pos];
+  }
+
+  METAL_FUNC constexpr const constant T *data() const constant { return __elems; }
+
+  METAL_FUNC constexpr size_t size() const threadgroup { return N; }
+  METAL_FUNC constexpr size_t max_size() const threadgroup { return N; }
+  METAL_FUNC constexpr bool empty() const threadgroup { return N == 0; }
+
+  METAL_FUNC threadgroup T &front() threadgroup {
+    assert(!empty());
+    return __elems[0];
+  }
+  METAL_FUNC constexpr const threadgroup T &front() const threadgroup {
+    assert(!empty());
+    return __elems[0];
+  }
+
+  METAL_FUNC threadgroup T &back() threadgroup {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+  METAL_FUNC constexpr const threadgroup T &back() const threadgroup {
+    assert(!empty());
+    return __elems[N - (N != 0)];
+  }
+
+  METAL_FUNC threadgroup T &operator[](size_t pos) threadgroup {
+    assert(pos < size());
+    return __elems[pos];
+  }
+  METAL_FUNC constexpr const threadgroup T &operator[](size_t pos) const threadgroup {
+    assert(pos < size());
+    return __elems[pos];
+  }
+
+  METAL_FUNC threadgroup T *data() threadgroup { return __elems; }
+  METAL_FUNC constexpr const threadgroup T *data() const threadgroup { return __elems; }
+
+
+
+  T __elems[N ? N : 1];
+};
+
+template <typename T>
+struct array_ref {
+  METAL_FUNC constexpr array_ref() thread : d(nullptr), sz(0) {}
+  METAL_FUNC constexpr array_ref(const thread T &elt) thread : d(&elt), sz(1) {}
+  METAL_FUNC constexpr array_ref(const thread T *data, size_t size) thread : d(data), sz(size) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const thread T (&data)[N]) thread : d(data), sz(N) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const thread array<T, N> &data) thread : d(data.data()), sz(data.size()) {}
+
+  METAL_FUNC constexpr size_t size() const thread { return sz; }
+  METAL_FUNC constexpr bool empty() const thread { return sz == 0; }
+
+  METAL_FUNC constexpr const thread T &front() const thread {
+    assert(!empty());
+    return d[0];
+  }
+  METAL_FUNC constexpr const thread T &back() const thread {
+    assert(!empty());
+    return d[sz - 1];
+  }
+  METAL_FUNC constexpr const thread T &operator[](size_t pos) const thread {
+    assert(pos < size());
+    return d[pos];
+  }
+  METAL_FUNC constexpr const thread T *data() const thread { return d; }
+
+private:
+  const thread T *d;
+  size_t sz;
+};
+
+template <typename T>
+struct array_ref<device T> {
+  METAL_FUNC constexpr array_ref() thread : d(nullptr), sz(0) {}
+  METAL_FUNC constexpr array_ref(const device T &elt) thread : d(&elt), sz(1) {}
+  METAL_FUNC constexpr array_ref(const device T *data, size_t size) thread : d(data), sz(size) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const device T (&data)[N]) thread : d(data), sz(N) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const device array<T, N> &data) thread : d(data.data()), sz(data.size()) {}
+
+  METAL_FUNC constexpr size_t size() const thread { return sz; }
+  METAL_FUNC constexpr bool empty() const thread { return sz == 0; }
+
+  METAL_FUNC constexpr const device T &front() const thread {
+    assert(!empty());
+    return d[0];
+  }
+  METAL_FUNC constexpr const device T &back() const thread {
+    assert(!empty());
+    return d[sz - 1];
+  }
+  METAL_FUNC constexpr const device T &operator[](size_t pos) const thread {
+    assert(pos < size());
+    return d[pos];
+  }
+  METAL_FUNC constexpr const device T *data() const thread { return d; }
+
+private:
+  const device T *d;
+  size_t sz;
+};
+
+template <typename T>
+struct array_ref<constant T> {
+  METAL_FUNC constexpr array_ref() thread : d(nullptr), sz(0) {}
+  METAL_FUNC constexpr array_ref(const constant T &elt) thread : d(&elt), sz(1) {}
+  METAL_FUNC constexpr array_ref(const constant T *data, size_t size) thread : d(data), sz(size) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const constant T (&data)[N]) thread : d(data), sz(N) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const constant array<T, N> &data) thread : d(data.data()), sz(data.size()) {}
+
+  METAL_FUNC constexpr size_t size() const thread { return sz; }
+  METAL_FUNC constexpr bool empty() const thread { return sz == 0; }
+
+  METAL_FUNC constexpr const constant T &front() const thread {
+    assert(!empty());
+    return d[0];
+  }
+  METAL_FUNC constexpr const constant T &back() const thread {
+    assert(!empty());
+    return d[sz - 1];
+  }
+  METAL_FUNC constexpr const constant T &operator[](size_t pos) const thread {
+    assert(pos < size());
+    return d[pos];
+  }
+  METAL_FUNC constexpr const constant T *data() const thread { return d; }
+
+private:
+  const constant T *d;
+  size_t sz;
+};
+
+template <typename T>
+struct array_ref<threadgroup T> {
+  METAL_FUNC constexpr array_ref() thread : d(nullptr), sz(0) {}
+  METAL_FUNC constexpr array_ref(const threadgroup T &elt) thread : d(&elt), sz(1) {}
+  METAL_FUNC constexpr array_ref(const threadgroup T *data, size_t size) thread : d(data), sz(size) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const threadgroup T (&data)[N]) thread : d(data), sz(N) {}
+  template <size_t N> METAL_FUNC constexpr array_ref(const threadgroup array<T, N> &data) thread : d(data.data()), sz(data.size()) {}
+
+  METAL_FUNC constexpr size_t size() const thread { return sz; }
+  METAL_FUNC constexpr bool empty() const thread { return sz == 0; }
+
+  METAL_FUNC constexpr const threadgroup T &front() const thread {
+    assert(!empty());
+    return d[0];
+  }
+  METAL_FUNC constexpr const threadgroup T &back() const thread {
+    assert(!empty());
+    return d[sz - 1];
+  }
+  METAL_FUNC constexpr const threadgroup T &operator[](size_t pos) const thread {
+    assert(pos < size());
+    return d[pos];
+  }
+  METAL_FUNC constexpr const threadgroup T *data() const thread { return d; }
+
+private:
+  const threadgroup T *d;
+  size_t sz;
+};
+
+
+template <typename T>
+METAL_FUNC constexpr array_ref<thread T> make_array_ref(const thread T &elt) { return array_ref<thread T>(elt); }
+template <typename T>
+METAL_FUNC constexpr array_ref<thread T> make_array_ref(const thread T *data, size_t size) { return array_ref<thread T>(data, size); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<thread T> make_array_ref(const thread T (&data)[N]) { return array_ref<thread T>(data); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<thread T> make_array_ref(const thread array<T, N> &data) { return array_ref<thread T>(data); }
+
+template <typename T>
+METAL_FUNC constexpr array_ref<device T> make_array_ref(const device T &elt) { return array_ref<device T>(elt); }
+template <typename T>
+METAL_FUNC constexpr array_ref<device T> make_array_ref(const device T *data, size_t size) { return array_ref<device T>(data, size); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<device T> make_array_ref(const device T (&data)[N]) { return array_ref<device T>(data); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<device T> make_array_ref(const device array<T, N> &data) { return array_ref<device T>(data); }
+
+template <typename T>
+METAL_FUNC constexpr array_ref<constant T> make_array_ref(const constant T &elt) { return array_ref<constant T>(elt); }
+template <typename T>
+METAL_FUNC constexpr array_ref<constant T> make_array_ref(const constant T *data, size_t size) { return array_ref<constant T>(data, size); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<constant T> make_array_ref(const constant T (&data)[N]) { return array_ref<constant T>(data); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<constant T> make_array_ref(const constant array<T, N> &data) { return array_ref<constant T>(data); }
+
+template <typename T>
+METAL_FUNC constexpr array_ref<threadgroup T> make_array_ref(const threadgroup T &elt) { return array_ref<threadgroup T>(elt); }
+template <typename T>
+METAL_FUNC constexpr array_ref<threadgroup T> make_array_ref(const threadgroup T *data, size_t size) { return array_ref<threadgroup T>(data, size); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<threadgroup T> make_array_ref(const threadgroup T (&data)[N]) { return array_ref<threadgroup T>(data); }
+template <typename T, size_t N>
+METAL_FUNC constexpr array_ref<threadgroup T> make_array_ref(const threadgroup array<T, N> &data) { return array_ref<threadgroup T>(data); }
+
+
+
+}
+#endif // defined(__HAVE_ARRAY__)
+
+#endif // __METAL_ARRAY
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_assert b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_assert
new file mode 100644
index 00000000..83867ff1
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_assert
@@ -0,0 +1,18 @@
+//===-- metal_assert ------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_ASSERT
+#define __METAL_ASSERT
+
+// TODO: This header is intended for internal use only and it is subject to
+// changes -- seet <rdar://problem/23180072>
+
+#if defined(NDEBUG) || !defined(__HAVE_ASSERT__)
+#define assert(condition) ((void) 0)
+#else
+// TODO: To be implemented -- see <rdar://problem/23180072>
+#define assert(condition) ((void) 0)
+#endif
+
+#endif // __METAL_ASSERT
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_atomic b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_atomic
new file mode 100644
index 00000000..aacd093e
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_atomic
@@ -0,0 +1,198 @@
+//===-- metal_atomic ------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_ATOMIC
+#define __METAL_ATOMIC
+
+#include <metal_compute>
+
+namespace metal
+{
+// Metal 1.1 s2.3: Atomic Data Types.
+
+template <typename T, typename _E = void>
+struct _atomic
+{
+  _atomic() threadgroup = default;
+  _atomic() device = delete;
+  _atomic(const threadgroup _atomic &) threadgroup = delete;
+  _atomic(const device _atomic &) threadgroup = delete;
+  _atomic(const threadgroup _atomic &) device = delete;
+  _atomic(const device _atomic &) device = delete;
+  threadgroup _atomic &operator=(const threadgroup _atomic &) threadgroup = delete;
+  threadgroup _atomic &operator=(const device _atomic &) threadgroup = delete;
+  device _atomic &operator=(const threadgroup _atomic &) device = delete;
+  device _atomic &operator=(const device _atomic &) device = delete;
+};
+
+template <typename T>
+struct _atomic<T, typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value>::type>
+{
+  _atomic() threadgroup = default;
+  _atomic() device = delete;
+  _atomic(const threadgroup _atomic &) threadgroup = delete;
+  _atomic(const device _atomic &) threadgroup = delete;
+  _atomic(const threadgroup _atomic &) device = delete;
+  _atomic(const device _atomic &) device = delete;
+  threadgroup _atomic &operator=(const threadgroup _atomic &) threadgroup = delete;
+  threadgroup _atomic &operator=(const device _atomic &) threadgroup = delete;
+  device _atomic &operator=(const threadgroup _atomic &) device = delete;
+  device _atomic &operator=(const device _atomic &) device = delete;
+
+  T __s;
+};
+typedef _atomic<int> atomic_int;
+typedef _atomic<uint> atomic_uint;
+
+
+// TODO: Add section number and title -- see <rdar://problem/35223499>.
+// Metal 2.0 sX.Y: Title.
+
+
+// Metal 1.1 s5.12.1: Atomic Store Functions.
+
+#if defined(__HAVE_RELAXED_ORDER_ATOMIC__)
+#define METAL_VALID_STORE_ORDER(O)
+#endif
+
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC void atomic_store_explicit(volatile threadgroup _atomic<T> *object, U desired, memory_order order) METAL_CONST_ARG(order) METAL_VALID_STORE_ORDER(order)
+{
+  __metal_atomic_store_explicit(&object->__s, decltype(object->__s)(desired), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC void atomic_store_explicit(volatile device _atomic<T> *object, U desired, memory_order order) METAL_CONST_ARG(order) METAL_VALID_STORE_ORDER(order)
+{
+  __metal_atomic_store_explicit(&object->__s, decltype(object->__s)(desired), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+
+#if defined(__HAVE_RELAXED_ORDER_ATOMIC__)
+#define METAL_VALID_LOAD_ORDER(O)
+#endif
+
+// Metal 1.1 s5.12.2: Atomic Load Functions.
+
+template <typename T>
+METAL_FUNC T atomic_load_explicit(const volatile threadgroup _atomic<T> *object, memory_order order) METAL_CONST_ARG(order) METAL_VALID_LOAD_ORDER(order)
+{
+  return T(__metal_atomic_load_explicit(&object->__s, int(order), __METAL_MEMORY_SCOPE_THREADGROUP__));
+}
+template <typename T>
+METAL_FUNC T atomic_load_explicit(const volatile device _atomic<T> *object, memory_order order) METAL_CONST_ARG(order) METAL_VALID_LOAD_ORDER(order)
+{
+  return T(__metal_atomic_load_explicit(&object->__s, int(order), __METAL_MEMORY_SCOPE_DEVICE__));
+}
+
+// Metal 1.1 s5.12.3: Atomic Exchange Functions.
+
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_exchange_explicit(volatile threadgroup _atomic<T> *object, U desired, memory_order order) METAL_CONST_ARG(order)
+{
+  return T(__metal_atomic_exchange_explicit(&object->__s, decltype(object->__s)(desired), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__));
+}
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_exchange_explicit(volatile device _atomic<T> *object, U desired, memory_order order) METAL_CONST_ARG(order)
+{
+  return T(__metal_atomic_exchange_explicit(&object->__s , decltype(object->__s)(desired), int(order), __METAL_MEMORY_SCOPE_DEVICE__));
+}
+
+// Metal 1.1 s5.12.4: Atomic Compare and Exchange Functions.
+
+#if defined(__HAVE_RELAXED_ORDER_ATOMIC__)
+#define METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER(O)
+#define METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS(S, F)
+#endif
+
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC bool atomic_compare_exchange_weak_explicit(volatile threadgroup _atomic<T> *object, thread T *expected, U desired, memory_order success, memory_order failure) METAL_CONST_ARG(success) METAL_CONST_ARG(failure) METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER(failure) METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS(success, failure)
+{
+  decltype(object->__s) next_expected(*expected);
+  bool swapped = __metal_atomic_compare_exchange_weak_explicit(&object->__s, &next_expected, decltype(object->__s)(desired), int(success), int(failure), __METAL_MEMORY_SCOPE_THREADGROUP__);
+  *expected = T(next_expected);
+  return swapped;
+}
+template <typename T, typename U, typename _E = typename enable_if<is_convertible<T, U>::value>::type>
+METAL_FUNC bool atomic_compare_exchange_weak_explicit(volatile device _atomic<T> *object, thread T *expected, U desired, memory_order success, memory_order failure) METAL_CONST_ARG(success) METAL_CONST_ARG(failure) METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER(failure) METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS(success, failure)
+{
+  decltype(object->__s) next_expected(*expected);
+  bool swapped = __metal_atomic_compare_exchange_weak_explicit(&object->__s, &next_expected, decltype(object->__s)(desired), int(success), int(failure), __METAL_MEMORY_SCOPE_DEVICE__);
+  *expected = T(next_expected);
+  return swapped;
+}
+
+// Metal 1.1 s5.12.5: Atomic Fetch and Modify Functions.
+
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_add_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_add_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_add_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_add_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_and_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_and_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_and_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_and_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_max_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_max_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_max_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_max_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_min_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_min_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_min_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_min_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_or_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_or_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_or_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_or_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_sub_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_sub_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_sub_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_sub_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_xor_explicit(volatile threadgroup _atomic<T> *object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_xor_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+METAL_FUNC T atomic_fetch_xor_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_xor_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+} // namespace metal
+
+#endif // __METAL_ATOMIC
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_common b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_common
new file mode 100644
index 00000000..e4dea906
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_common
@@ -0,0 +1,86 @@
+//===-- metal_common ------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_COMMON
+#define __METAL_COMMON
+
+#include <metal_math_utils>
+
+// Metal 1.1 s5.2: Common Functions.
+
+namespace metal
+{
+
+namespace fast
+{
+template <typename T, typename U, typename V, typename _O = typename enable_if<_math_fast_or_precise_ternary_func_enable<T, U, V>::value, _math_fast_or_precise_ternary_func_operand_type_t<T, U, V>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O clamp(T x, U minval, V maxval)
+{
+  return __metal_clamp(_O(x), _O(minval), _O(maxval), _METAL_FAST_MATH);
+}
+
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T saturate(T x)
+{
+  return __metal_saturate(x, _METAL_FAST_MATH);
+}
+}  // namespace fast
+
+namespace precise
+{
+template <typename T, typename U, typename V, typename _O = typename enable_if<_math_fast_or_precise_ternary_func_enable<T, U, V>::value, _math_fast_or_precise_ternary_func_operand_type_t<T, U, V>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O clamp(T x, U minval, V maxval)
+{
+  return __metal_clamp(_O(x), _O(minval), _O(maxval), _METAL_PRECISE_MATH);
+}
+
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T saturate(T x)
+{
+  return __metal_saturate(x, _METAL_PRECISE_MATH);
+}
+}  // namespace precise
+
+template <typename T, typename U, typename V, typename _O = typename enable_if<_math_ternary_func_enable<T, U, V>::value, _math_ternary_func_operand_type_t<T, U, V>>::type>
+METAL_FUNC _O clamp(T x, U minval, V maxval)
+{
+  return __metal_clamp(_O(x), _O(minval), _O(maxval), _METAL_MAYBE_FAST_MATH);
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T saturate(T x)
+{
+  return __metal_saturate(x, _METAL_MAYBE_FAST_MATH);
+}
+} // namespace metal
+
+namespace metal
+{
+template <typename T, typename U, typename V, typename _O = typename enable_if<_math_ternary_func_enable<T, U, V>::value, _math_ternary_func_operand_type_t<T, U, V>>::type>
+METAL_FUNC _O mix(T x, U y, V a)
+{
+  return __metal_mix(_O(x), _O(y), _O(a));
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T sign(T x)
+{
+  return __metal_sign(x);
+}
+
+template <typename T, typename U, typename V, typename _O = typename enable_if<_math_ternary_func_enable<T, U, V>::value, _math_ternary_func_operand_type_t<T, U, V>>::type>
+METAL_FUNC _O smoothstep(T edge0, U edge1, V x)
+{
+  _O t = clamp((_O(x) - _O(edge0)) / (_O(edge1) - _O(edge0)), _O(0), _O(1));
+  return t * t * (_O(3) - _O(2) * t);
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O step(T edge, U x)
+{
+  return _O(_O(x) >= _O(edge));
+}
+} // namespace metal
+
+#endif // __METAL_COMMON
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_compute b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_compute
new file mode 100644
index 00000000..620814de
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_compute
@@ -0,0 +1,80 @@
+//===-- metal_compute -----------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_COMPUTE
+#define __METAL_COMPUTE
+
+namespace metal
+{
+// Metal 1.1 s5.8: Compute Functions.
+
+enum class mem_flags
+{
+  mem_none = 0,
+  mem_device = 1,
+  mem_threadgroup = 2,
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  mem_texture = 4,
+#endif
+  mem_device_and_threadgroup METAL_DEPRECATED("use mem_device or mem_threadgroup instead") = mem_device | mem_threadgroup
+};
+
+#if defined(__HAVE_MEMFLAG_OPERATORS__)
+METAL_FUNC constexpr mem_flags operator|(mem_flags x, mem_flags y)
+{
+  return static_cast<mem_flags>(static_cast<int>(x) | static_cast<int>(y));
+}
+
+METAL_FUNC constexpr mem_flags operator&(mem_flags x, mem_flags y)
+{
+  return static_cast<mem_flags>(static_cast<int>(x) & static_cast<int>(y));
+}
+
+METAL_FUNC constexpr mem_flags operator^(mem_flags x, mem_flags y)
+{
+  return static_cast<mem_flags>(static_cast<int>(x) ^ static_cast<int>(y));
+}
+
+METAL_FUNC constexpr mem_flags operator~(mem_flags x)
+{
+  return static_cast<mem_flags>(~static_cast<int>(x));
+}
+#endif
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+template <>
+struct _constarg_traits<mem_flags>
+{
+  constexpr static METAL_INTERNAL bool check(mem_flags flags)
+  {
+    return flags == flags;
+  }
+};
+#pragma clang diagnostic pop
+
+METAL_FUNC void threadgroup_barrier(mem_flags flags)
+{
+  __metal_wg_barrier(int(flags), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+
+#if defined(__HAVE_SIMDGROUP_BARRIER__)
+METAL_FUNC void simdgroup_barrier(mem_flags flags)
+{
+  // TODO: We should be using _METAL_MEM_SCOPE_WORKGROUP -- see <rdar://problem/32740236>.
+  __metal_simdgroup_barrier(int(flags), __METAL_MEMORY_SCOPE_THREADGROUP__);
+}
+#endif // defined(__HAVE_SIMDGROUP_BARRIER__)
+
+#if defined(__HAVE_DRAW_INDIRECT__)
+struct MTLDispatchThreadgroupsIndirectArguments
+{
+  uint threadgroupsPerGrid[3];
+};
+#endif
+
+
+} // namespace metal
+
+#endif // __METAL_COMPUTE
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_config b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_config
new file mode 100644
index 00000000..78e26576
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_config
@@ -0,0 +1,323 @@
+#ifndef __METAL_CONFIG
+#define __METAL_CONFIG
+
+#if __METAL_VERSION__ == 100
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_IGNORE_ATTRIBUTE_INCOMPATIBLE_TYPE__ 1
+#define __HAVE_NO_ADDR_SPACE_REF__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_VECTOR_CONVERSION_IN_ARRAY_INIT__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __METAL_VERSION__ == 110
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_IGNORE_ATTRIBUTE_INCOMPATIBLE_TYPE__ 1
+#define __HAVE_NO_ADDR_SPACE_REF__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_VECTOR_CONVERSION_IN_ARRAY_INIT__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __METAL_VERSION__ == 120
+#define __HAVE_16B_COORDS__ 1
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_BORDER_COLOR__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_EARLY_FRAGMENT_TEST__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_FUNCTION_CONSTANTS__ 1
+#define __HAVE_IGNORE_ATTRIBUTE_INCOMPATIBLE_TYPE__ 1
+#define __HAVE_INTEGER_BIT_EDIT_FUNCTIONS__ 1
+#define __HAVE_MEMFLAG_OPERATORS__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_TESSELLATION__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TEXTURE_READWRITE__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_FRAGMENT__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_VERTEX__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_UNIONS__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __METAL_VERSION__ == 200
+#define __HAVE_16B_COORDS__ 1
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_ANISOTROPY_LOD_MIN_MAX__ 1
+#define __HAVE_ARBITRARY_GRID_SIZE__ 1
+#define __HAVE_ARRAY__ 1
+#define __HAVE_ARRAYS_OF_SAMPLERS__ 1
+#define __HAVE_ARRAYS_OF_TEXTURES__ 1
+#define __HAVE_BORDER_COLOR__ 1
+#define __HAVE_COPY_ASSIGNABLE_TEXTURE__ 1
+#define __HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__ 1
+#define __HAVE_DEPENDENT_BUFFER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_COLOR_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_SAMPLER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_TEXTURE_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_THREADGROUP_ATTRIBUTE__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_EARLY_FRAGMENT_TEST__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_FUNCTION_CONSTANTS__ 1
+#define __HAVE_INDIRECT_ARGUMENT_BUFFER__ 1
+#define __HAVE_INDIRECT_WRITABLE_TEXTURES__ 1
+#define __HAVE_INTEGER_BIT_EDIT_FUNCTIONS__ 1
+#define __HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__ 1
+#define __HAVE_MEMFLAG_OPERATORS__ 1
+#define __HAVE_NON_CONSTEXPR_ATTRIBUTE_INDICES__ 1
+#define __HAVE_NULL_TEXTURE__ 1
+#define __HAVE_QUADGROUP__ 1
+#define __HAVE_RASTER_ORDER_GROUP__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_SIMDGROUP__ 1
+#define __HAVE_SIMDGROUP_BARRIER__ 1
+#define __HAVE_TESSELLATION__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TEXTURE_READWRITE__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_FRAGMENT__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_VERTEX__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_UNIFORM__ 1
+#define __HAVE_UNIONS__ 1
+#define __HAVE_VIEWPORT_ARRAY_INDEX__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __METAL_VERSION__ == 210
+#define __HAVE_16B_COORDS__ 1
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_ANISOTROPY_LOD_MIN_MAX__ 1
+#define __HAVE_ARBITRARY_GRID_SIZE__ 1
+#define __HAVE_ARRAY__ 1
+#define __HAVE_ARRAYS_OF_SAMPLERS__ 1
+#define __HAVE_ARRAYS_OF_TEXTURES__ 1
+#define __HAVE_BORDER_COLOR__ 1
+#define __HAVE_COPY_ASSIGNABLE_TEXTURE__ 1
+#define __HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__ 1
+#define __HAVE_DEPENDENT_BUFFER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_COLOR_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_SAMPLER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_TEXTURE_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_THREADGROUP_ATTRIBUTE__ 1
+#define __HAVE_DEPTH_2D_MS_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DISCARD_FRAGMENT_NORETURN__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_EARLY_FRAGMENT_TEST__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_FMAX3__ 1
+#define __HAVE_FMEDIAN3__ 1
+#define __HAVE_FMIN3__ 1
+#define __HAVE_FUNCTION_CONSTANTS__ 1
+#define __HAVE_INDIRECT_ARGUMENT_BUFFER__ 1
+#define __HAVE_INDIRECT_NON_STRUCT_BUFFERS__ 1
+#define __HAVE_INDIRECT_WRITABLE_TEXTURES__ 1
+#define __HAVE_INHERITANCE__ 1
+#define __HAVE_INTEGER_BIT_EDIT_FUNCTIONS__ 1
+#define __HAVE_MAD24__ 1
+#define __HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__ 1
+#define __HAVE_MAX3__ 1
+#define __HAVE_MAX_TOTAL_THREADS_PER_THREADGROUP__ 1
+#define __HAVE_MEDIAN3__ 1
+#define __HAVE_MEMFLAG_OPERATORS__ 1
+#define __HAVE_MIN3__ 1
+#define __HAVE_MUL24__ 1
+#define __HAVE_NON_CONSTEXPR_ATTRIBUTE_INDICES__ 1
+#define __HAVE_NULL_TEXTURE__ 1
+#define __HAVE_PACKED_VECTOR_COMPONENTS__ 1
+#define __HAVE_PROHIBIT_CXX11_DECL_SPEC_ATTRS__ 1
+#define __HAVE_QUADGROUP__ 1
+#define __HAVE_QUADGROUP_BALLOT__ 1
+#define __HAVE_QUADGROUP_BROADCAST_FIRST__ 1
+#define __HAVE_QUADGROUP_ONCE__ 1
+#define __HAVE_QUADGROUP_REDUCTION__ 1
+#define __HAVE_QUADGROUP_SHUFFLE_ROTATE_DOWN__ 1
+#define __HAVE_QUADGROUP_SHUFFLE_ROTATE_UP__ 1
+#define __HAVE_RASTER_ORDER_GROUP__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_SAMPLER_REDUCTION__ 1
+#define __HAVE_SIMDGROUP__ 1
+#define __HAVE_SIMDGROUP_BALLOT__ 1
+#define __HAVE_SIMDGROUP_BARRIER__ 1
+#define __HAVE_SIMDGROUP_BROADCAST_FIRST__ 1
+#define __HAVE_SIMDGROUP_ONCE__ 1
+#define __HAVE_SIMDGROUP_REDUCTION__ 1
+#define __HAVE_SIMDGROUP_SHUFFLE_ROTATE_DOWN__ 1
+#define __HAVE_SIMDGROUP_SHUFFLE_ROTATE_UP__ 1
+#define __HAVE_STENCIL_FEEDBACK__ 1
+#define __HAVE_TESSELLATION__ 1
+#define __HAVE_TEXTURE_2D_MS_ARRAY__ 1
+#define __HAVE_TEXTURE_BUFFER__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TEXTURE_READWRITE__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_FRAGMENT__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_VERTEX__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_UNBOXED_PACKED_VECTORS__ 1
+#define __HAVE_UNIFORM__ 1
+#define __HAVE_UNIONS__ 1
+#define __HAVE_VIEWPORT_ARRAY_INDEX__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __METAL_VERSION__ == 220
+#define __HAVE_16B_COORDS__ 1
+#define __HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__ 1
+#define __HAVE_ANISOTROPY_LOD_MIN_MAX__ 1
+#define __HAVE_ARBITRARY_GRID_SIZE__ 1
+#define __HAVE_ARRAY__ 1
+#define __HAVE_ARRAYS_OF_SAMPLERS__ 1
+#define __HAVE_ARRAYS_OF_TEXTURES__ 1
+#define __HAVE_BORDER_COLOR__ 1
+#define __HAVE_COPY_ASSIGNABLE_TEXTURE__ 1
+#define __HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__ 1
+#define __HAVE_DEPENDENT_BUFFER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_COLOR_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_SAMPLER_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_TEXTURE_ATTRIBUTE__ 1
+#define __HAVE_DEPENDENT_THREADGROUP_ATTRIBUTE__ 1
+#define __HAVE_DEPTH_2D_MS_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_ARRAY__ 1
+#define __HAVE_DEPTH_CUBE_READ__ 1
+#define __HAVE_DISCARD_FRAGMENT_NORETURN__ 1
+#define __HAVE_DRAW_INDIRECT__ 1
+#define __HAVE_EARLY_FRAGMENT_TEST__ 1
+#define __HAVE_FMA__ 1
+#define __HAVE_FMAX3__ 1
+#define __HAVE_FMEDIAN3__ 1
+#define __HAVE_FMIN3__ 1
+#define __HAVE_FUNCTION_CONSTANTS__ 1
+#define __HAVE_INDIRECT_ARGUMENT_BUFFER__ 1
+#define __HAVE_INDIRECT_COMMAND_BUFFER__ 1
+#define __HAVE_INDIRECT_NON_STRUCT_BUFFERS__ 1
+#define __HAVE_INDIRECT_WRITABLE_TEXTURES__ 1
+#define __HAVE_INHERITANCE__ 1
+#define __HAVE_INTEGER_BIT_EDIT_FUNCTIONS__ 1
+#define __HAVE_MAD24__ 1
+#define __HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__ 1
+#define __HAVE_MAX3__ 1
+#define __HAVE_MAX_TOTAL_THREADS_PER_THREADGROUP__ 1
+#define __HAVE_MEDIAN3__ 1
+#define __HAVE_MEMFLAG_OPERATORS__ 1
+#define __HAVE_MIN3__ 1
+#define __HAVE_MIN_LOD_CLAMP__ 1
+#define __HAVE_MUL24__ 1
+#define __HAVE_NON_CONSTEXPR_ATTRIBUTE_INDICES__ 1
+#define __HAVE_NULL_TEXTURE__ 1
+#define __HAVE_PACKED_VECTOR_COMPONENTS__ 1
+#define __HAVE_PROHIBIT_CXX11_DECL_SPEC_ATTRS__ 1
+#define __HAVE_QUADGROUP__ 1
+#define __HAVE_QUADGROUP_BALLOT__ 1
+#define __HAVE_QUADGROUP_BROADCAST_FIRST__ 1
+#define __HAVE_QUADGROUP_ONCE__ 1
+#define __HAVE_QUADGROUP_REDUCTION__ 1
+#define __HAVE_QUADGROUP_SHUFFLE_ROTATE_DOWN__ 1
+#define __HAVE_QUADGROUP_SHUFFLE_ROTATE_UP__ 1
+#define __HAVE_RASTER_ORDER_GROUP__ 1
+#define __HAVE_RELAXED_ORDER_ATOMIC__ 1
+#define __HAVE_RENDER_TARGET_ARRAY_INDEX__ 1
+#define __HAVE_SAMPLER_REDUCTION__ 1
+#define __HAVE_SIMDGROUP__ 1
+#define __HAVE_SIMDGROUP_BALLOT__ 1
+#define __HAVE_SIMDGROUP_BARRIER__ 1
+#define __HAVE_SIMDGROUP_BROADCAST_FIRST__ 1
+#define __HAVE_SIMDGROUP_ONCE__ 1
+#define __HAVE_SIMDGROUP_REDUCTION__ 1
+#define __HAVE_SIMDGROUP_SHUFFLE_ROTATE_DOWN__ 1
+#define __HAVE_SIMDGROUP_SHUFFLE_ROTATE_UP__ 1
+#define __HAVE_SPARSE_TEXTURES__ 1
+#define __HAVE_STENCIL_FEEDBACK__ 1
+#define __HAVE_TESSELLATION__ 1
+#define __HAVE_TEXTURE_2D_MS_ARRAY__ 1
+#define __HAVE_TEXTURE_BUFFER__ 1
+#define __HAVE_TEXTURE_CUBE_ARRAY__ 1
+#define __HAVE_TEXTURE_CUBE_READ__ 1
+#define __HAVE_TEXTURE_CUBE_WRITE__ 1
+#define __HAVE_TEXTURE_READWRITE__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_FRAGMENT__ 1
+#define __HAVE_TEXTURE_WRITABLE_FROM_VERTEX__ 1
+#define __HAVE_TRACING__ 1
+#define __HAVE_TRIG_PI__ 1
+#define __HAVE_UNBOXED_PACKED_VECTORS__ 1
+#define __HAVE_UNIFORM__ 1
+#define __HAVE_UNIONS__ 1
+#define __HAVE_VIEWPORT_ARRAY_INDEX__ 1
+#define __HAVE_ZERO_LOD_ARG__ 1
+#endif
+
+#if __AIR_VERSION__ == 10800
+#define __HAVE_AIR_FRACT__ 1
+#define __HAVE_AIR_LDEXP__ 1
+#define __HAVE_CLZ_ZERO_UNDEF__ 1
+#define __HAVE_CTZ_ZERO_UNDEF__ 1
+#endif
+
+#if __AIR_VERSION__ == 11100
+#define __HAVE_AIR_FRACT__ 1
+#define __HAVE_AIR_LDEXP__ 1
+#define __HAVE_CLZ_ZERO_UNDEF__ 1
+#define __HAVE_CTZ_ZERO_UNDEF__ 1
+#endif
+
+#if __AIR_VERSION__ == 20000
+#define __HAVE_AIR_FRACT__ 1
+#define __HAVE_AIR_LDEXP__ 1
+#define __HAVE_CLZ_ZERO_UNDEF__ 1
+#define __HAVE_CTZ_ZERO_UNDEF__ 1
+#endif
+
+#if __AIR_VERSION__ == 20100
+#define __HAVE_AIR_FRACT__ 1
+#define __HAVE_AIR_LDEXP__ 1
+#define __HAVE_CLZ_ZERO_UNDEF__ 1
+#define __HAVE_CTZ_ZERO_UNDEF__ 1
+#endif
+
+#if __AIR_VERSION__ == 20200
+#define __HAVE_AIR_FRACT__ 1
+#define __HAVE_AIR_LDEXP__ 1
+#define __HAVE_CLZ_ZERO_UNDEF__ 1
+#define __HAVE_CTZ_ZERO_UNDEF__ 1
+#endif
+
+
+#endif // __METAL_CONFIG
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_extended_vector b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_extended_vector
new file mode 100644
index 00000000..22afbd93
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_extended_vector
@@ -0,0 +1,278 @@
+//===-- metal_extended_vector ---------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_EXTENDED_VECTOR
+#define __METAL_EXTENDED_VECTOR
+
+typedef __attribute__((__ext_vector_type__(2))) bool bool2;
+typedef __attribute__((__ext_vector_type__(3))) bool bool3;
+typedef __attribute__((__ext_vector_type__(4))) bool bool4;
+typedef struct __Reserved_Name__Do_not_use_bool8 bool8;
+typedef struct __Reserved_Name__Do_not_use_bool16 bool16;
+
+typedef __attribute__((__ext_vector_type__(2))) char char2;
+typedef __attribute__((__ext_vector_type__(3))) char char3;
+typedef __attribute__((__ext_vector_type__(4))) char char4;
+typedef struct __Reserved_Name__Do_not_use_char8 char8;
+typedef struct __Reserved_Name__Do_not_use_char16 char16;
+
+typedef __attribute__((__ext_vector_type__(2))) unsigned char uchar2;
+typedef __attribute__((__ext_vector_type__(3))) unsigned char uchar3;
+typedef __attribute__((__ext_vector_type__(4))) unsigned char uchar4;
+typedef struct __Reserved_Name__Do_not_use_uchar16 uchar8;
+typedef struct __Reserved_Name__Do_not_use_uchar16 uchar16;
+
+typedef __attribute__((__ext_vector_type__(2))) short short2;
+typedef __attribute__((__ext_vector_type__(3))) short short3;
+typedef __attribute__((__ext_vector_type__(4))) short short4;
+typedef struct __Reserved_Name__Do_not_use_short8 short8;
+typedef struct __Reserved_Name__Do_not_use_short16 short16;
+
+typedef __attribute__((__ext_vector_type__(2))) unsigned short ushort2;
+typedef __attribute__((__ext_vector_type__(3))) unsigned short ushort3;
+typedef __attribute__((__ext_vector_type__(4))) unsigned short ushort4;
+typedef struct __Reserved_Name__Do_not_use_ushort8 ushort8;
+typedef struct __Reserved_Name__Do_not_use_ushort16 ushort16;
+
+typedef __attribute__((__ext_vector_type__(2))) int int2;
+typedef __attribute__((__ext_vector_type__(3))) int int3;
+typedef __attribute__((__ext_vector_type__(4))) int int4;
+typedef struct __Reserved_Name__Do_not_use_int8 int8;
+typedef struct __Reserved_Name__Do_not_use_int16 int16;
+
+typedef __attribute__((__ext_vector_type__(2))) unsigned int uint2;
+typedef __attribute__((__ext_vector_type__(3))) unsigned int uint3;
+typedef __attribute__((__ext_vector_type__(4))) unsigned int uint4;
+typedef struct __Reserved_Name__Do_not_use_uint8 uint8;
+typedef struct __Reserved_Name__Do_not_use_uint16 uint16;
+
+typedef struct __Reserved_Name__Do_not_use_long2 long2;
+typedef struct __Reserved_Name__Do_not_use_long3 long3;
+typedef struct __Reserved_Name__Do_not_use_long4 long4;
+typedef struct __Reserved_Name__Do_not_use_long8 long8;
+typedef struct __Reserved_Name__Do_not_use_long16 long16;
+
+typedef struct __Reserved_Name__Do_not_use_ulong2 ulong2;
+typedef struct __Reserved_Name__Do_not_use_ulong3 ulong3;
+typedef struct __Reserved_Name__Do_not_use_ulong4 ulong4;
+typedef struct __Reserved_Name__Do_not_use_ulong8 ulong8;
+typedef struct __Reserved_Name__Do_not_use_ulong16 ulong16;
+
+typedef struct __Reserved_Name__Do_not_use_llong2 llong2;
+typedef struct __Reserved_Name__Do_not_use_llong3 llong3;
+typedef struct __Reserved_Name__Do_not_use_llong4 llong4;
+typedef struct __Reserved_Name__Do_not_use_llong8 llong8;
+typedef struct __Reserved_Name__Do_not_use_llong16 llong16;
+
+typedef struct __Reserved_Name__Do_not_use_ullong2 ullong2;
+typedef struct __Reserved_Name__Do_not_use_ullong3 ullong3;
+typedef struct __Reserved_Name__Do_not_use_ullong4 ullong4;
+typedef struct __Reserved_Name__Do_not_use_ullong8 ullong8;
+typedef struct __Reserved_Name__Do_not_use_ullong16 ullong16;
+
+typedef __attribute__((__ext_vector_type__(2))) half half2;
+typedef __attribute__((__ext_vector_type__(3))) half half3;
+typedef __attribute__((__ext_vector_type__(4))) half half4;
+typedef struct __Reserved_Name__Do_not_use_half8 half8;
+typedef struct __Reserved_Name__Do_not_use_half16 half16;
+
+typedef __attribute__((__ext_vector_type__(2))) float float2;
+typedef __attribute__((__ext_vector_type__(3))) float float3;
+typedef __attribute__((__ext_vector_type__(4))) float float4;
+typedef struct __Reserved_Name__Do_not_use_float8 float8;
+typedef struct __Reserved_Name__Do_not_use_float16 float16;
+
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef __attribute__((__ext_vector_type__(2))) double double2;
+typedef __attribute__((__ext_vector_type__(3))) double double3;
+typedef __attribute__((__ext_vector_type__(4))) double double4;
+#else
+typedef struct __Reserved_Name__Do_not_use_double2 double2;
+typedef struct __Reserved_Name__Do_not_use_double3 double3;
+typedef struct __Reserved_Name__Do_not_use_double4 double4;
+#endif
+typedef struct __Reserved_Name__Do_not_use_double8 double8;
+typedef struct __Reserved_Name__Do_not_use_double16 double16;
+
+typedef struct __Reserved_Name__Do_not_use_quad2 quad2;
+typedef struct __Reserved_Name__Do_not_use_quad3 quad3;
+typedef struct __Reserved_Name__Do_not_use_quad4 quad4;
+typedef struct __Reserved_Name__Do_not_use_quad8 quad8;
+typedef struct __Reserved_Name__Do_not_use_quad16 quad16;
+
+typedef bool2 vector_bool2;
+typedef bool3 vector_bool3;
+typedef bool4 vector_bool4;
+typedef bool8 vector_bool8;
+typedef bool16 vector_bool16;
+
+typedef char2 vector_char2;
+typedef char3 vector_char3;
+typedef char4 vector_char4;
+typedef char8 vector_char8;
+typedef char16 vector_char16;
+
+typedef uchar2 vector_uchar2;
+typedef uchar3 vector_uchar3;
+typedef uchar4 vector_uchar4;
+typedef uchar8 vector_uchar8;
+typedef uchar16 vector_uchar16;
+
+typedef short2 vector_short2;
+typedef short3 vector_short3;
+typedef short4 vector_short4;
+typedef short8 vector_short8;
+typedef short16 vector_short16;
+
+typedef ushort2 vector_ushort2;
+typedef ushort3 vector_ushort3;
+typedef ushort4 vector_ushort4;
+typedef ushort8 vector_ushort8;
+typedef ushort16 vector_ushort16;
+
+typedef int2 vector_int2;
+typedef int3 vector_int3;
+typedef int4 vector_int4;
+typedef int8 vector_int8;
+typedef int16 vector_int16;
+
+typedef uint2 vector_uint2;
+typedef uint3 vector_uint3;
+typedef uint4 vector_uint4;
+typedef uint8 vector_uint8;
+typedef uint16 vector_uint16;
+
+typedef long2 vector_long2;
+typedef long3 vector_long3;
+typedef long4 vector_long4;
+typedef long8 vector_long8;
+typedef long16 vector_long16;
+
+typedef ulong2 vector_ulong2;
+typedef ulong3 vector_ulong3;
+typedef ulong4 vector_ulong4;
+typedef ulong8 vector_ulong8;
+typedef ulong16 vector_ulong16;
+
+typedef half2 vector_half2;
+typedef half3 vector_half3;
+typedef half4 vector_half4;
+typedef half8 vector_half8;
+typedef half16 vector_half16;
+
+typedef float2 vector_float2;
+typedef float3 vector_float3;
+typedef float4 vector_float4;
+typedef float8 vector_float8;
+typedef float16 vector_float16;
+
+typedef double2 vector_double2;
+typedef double3 vector_double3;
+typedef double4 vector_double4;
+typedef double8 vector_double8;
+typedef double16 vector_double16;
+
+typedef quad2 vector_quad2;
+typedef quad3 vector_quad3;
+typedef quad4 vector_quad4;
+typedef quad8 vector_quad8;
+typedef quad16 vector_quad16;
+
+namespace metal
+{
+typedef ::bool2 bool2;
+typedef ::bool3 bool3;
+typedef ::bool4 bool4;
+typedef ::bool8 bool8;
+typedef ::bool16 bool16;
+
+typedef ::char2 char2;
+typedef ::char3 char3;
+typedef ::char4 char4;
+typedef ::char8 char8;
+typedef ::char16 char16;
+
+typedef ::uchar2 uchar2;
+typedef ::uchar3 uchar3;
+typedef ::uchar4 uchar4;
+typedef ::uchar8 uchar8;
+typedef ::uchar16 uchar16;
+
+typedef ::short2 short2;
+typedef ::short3 short3;
+typedef ::short4 short4;
+typedef ::short8 short8;
+typedef ::short16 short16;
+
+typedef ::ushort2 ushort2;
+typedef ::ushort3 ushort3;
+typedef ::ushort4 ushort4;
+typedef ::ushort8 ushort8;
+typedef ::ushort16 ushort16;
+
+typedef ::int2 int2;
+typedef ::int3 int3;
+typedef ::int4 int4;
+typedef ::int8 int8;
+typedef ::int16 int16;
+
+typedef ::uint2 uint2;
+typedef ::uint3 uint3;
+typedef ::uint4 uint4;
+typedef ::uint8 uint8;
+typedef ::uint16 uint16;
+
+typedef ::long2 long2;
+typedef ::long3 long3;
+typedef ::long4 long4;
+typedef ::long8 long8;
+typedef ::long16 long16;
+
+typedef ::ulong2 ulong2;
+typedef ::ulong3 ulong3;
+typedef ::ulong4 ulong4;
+typedef ::ulong8 ulong8;
+typedef ::ulong16 ulong16;
+
+typedef ::llong2 llong2;
+typedef ::llong3 llong3;
+typedef ::llong4 llong4;
+typedef ::llong8 llong8;
+typedef ::llong16 llong16;
+
+typedef ::ullong2 ullong2;
+typedef ::ullong3 ullong3;
+typedef ::ullong4 ullong4;
+typedef ::ullong8 ullong8;
+typedef ::ullong16 ullong16;
+
+typedef ::half2 half2;
+typedef ::half3 half3;
+typedef ::half4 half4;
+typedef ::half8 half8;
+typedef ::half16 half16;
+
+typedef ::float2 float2;
+typedef ::float3 float3;
+typedef ::float4 float4;
+typedef ::float8 float8;
+typedef ::float16 float16;
+
+typedef ::double2 double2;
+typedef ::double3 double3;
+typedef ::double4 double4;
+typedef ::double8 double8;
+typedef ::double16 double16;
+
+typedef ::quad2 quad2;
+typedef ::quad3 quad3;
+typedef ::quad4 quad4;
+typedef ::quad8 quad8;
+typedef ::quad16 quad16;
+
+template <typename T, int N>
+using vec = T __attribute__((__ext_vector_type__(N)));
+}
+
+#endif // __METAL_EXTENDED_VECTOR
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_functional b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_functional
new file mode 100644
index 00000000..3d2add29
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_functional
@@ -0,0 +1,230 @@
+//===-- metal_functional --------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_FUNCTIONAL
+#define __METAL_FUNCTIONAL
+
+namespace metal
+{
+template <typename T>
+struct plus
+{
+  typedef T first_argument_type;
+  typedef T second_argument_type;
+  typedef T result_type;
+
+  T operator()(const thread T &a, const thread T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const thread T &a, const device T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const thread T &a, const constant T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const thread T &a, const threadgroup T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const device T &a, const thread T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const device T &a, const device T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const device T &a, const constant T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const device T &a, const threadgroup T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const constant T &a, const thread T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const constant T &a, const device T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const constant T &a, const constant T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const constant T &a, const threadgroup T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const threadgroup T &a, const thread T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const threadgroup T &a, const device T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const threadgroup T &a, const constant T &b) const thread
+  {
+    return a + b;
+  }
+  T operator()(const threadgroup T &a, const threadgroup T &b) const thread
+  {
+    return a + b;
+  }
+};
+
+template <typename T>
+struct minus
+{
+  typedef T first_argument_type;
+  typedef T second_argument_type;
+  typedef T result_type;
+
+  T operator()(const thread T &a, const thread T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const thread T &a, const device T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const thread T &a, const constant T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const thread T &a, const threadgroup T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const device T &a, const thread T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const device T &a, const device T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const device T &a, const constant T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const device T &a, const threadgroup T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const constant T &a, const thread T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const constant T &a, const device T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const constant T &a, const constant T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const constant T &a, const threadgroup T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const threadgroup T &a, const thread T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const threadgroup T &a, const device T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const threadgroup T &a, const constant T &b) const thread
+  {
+    return a - b;
+  }
+  T operator()(const threadgroup T &a, const threadgroup T &b) const thread
+  {
+    return a - b;
+  }
+};
+
+template <typename T>
+struct multiplies
+{
+  typedef T first_argument_type;
+  typedef T second_argument_type;
+  typedef T result_type;
+
+  T operator()(const thread T &a, const thread T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const thread T &a, const device T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const thread T &a, const constant T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const thread T &a, const threadgroup T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const device T &a, const thread T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const device T &a, const device T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const device T &a, const constant T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const device T &a, const threadgroup T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const constant T &a, const thread T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const constant T &a, const device T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const constant T &a, const constant T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const constant T &a, const threadgroup T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const threadgroup T &a, const thread T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const threadgroup T &a, const device T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const threadgroup T &a, const constant T &b) const thread
+  {
+    return a * b;
+  }
+  T operator()(const threadgroup T &a, const threadgroup T &b) const thread
+  {
+    return a * b;
+  }
+};
+} // namespace metal
+
+#endif // __METAL_FUNCTIONAL
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_geometric b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_geometric
new file mode 100644
index 00000000..bdfc5b8e
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_geometric
@@ -0,0 +1,378 @@
+//===-- metal_geometric ---------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_GEOMETRIC
+#define __METAL_GEOMETRIC
+
+#include <metal_limits>
+#include <metal_math>
+
+#pragma METAL internals : enable
+namespace metal
+{
+// Metal 1.1 s5.7: Geometric Functions.
+
+template <typename T>
+struct _fp_range_traits_impl;
+
+template <>
+struct _fp_range_traits_impl<half>
+{
+  constexpr static constant half scale_down = 0x1.0p-10;
+  constexpr static constant half scale_down_inv = 0x1.0p+10;
+  constexpr static constant half scale_up = 0x1.0p+8;
+  constexpr static constant half scale_up_inv = 0x1.0p-8;
+};
+template <>
+struct _fp_range_traits_impl<float>
+{
+  constexpr static constant float scale_down = 0x1.0p-66;
+  constexpr static constant float scale_down_inv = 0x1.0p+66;
+  constexpr static constant float scale_up = 0x1.0p+64;
+  constexpr static constant float scale_up_inv = 0x1.0p-64;
+};
+#if defined(__HAVE_NATIVE_DOUBLE__)
+template <>
+struct _fp_range_traits_impl<double>
+{
+  constexpr static constant double scale_down = 0x1.0p-514;
+  constexpr static constant double scale_down_inv = 0x1.0p+514;
+  constexpr static constant double scale_up = 0x1.0p+512;
+  constexpr static constant double scale_up_inv = 0x1.0p-512;
+};
+#endif
+
+template <typename T>
+struct _fp_range_traits : _fp_range_traits_impl<remove_cv_t<T>>
+{
+};
+
+template <typename T, typename U, typename _E = void>
+struct _geometric_binary_func_operand_type
+{
+  using type = void;
+};
+
+// We shipped a version of Metal using overloded functions to implement binary
+// functions instead of template functions. For any pair of scalar or vector
+// types T, U for which a call to the overloaded version of foo
+// `foo(T(x), U(y))` was valid (including via implicit conversion sequences),
+// the call to the templated version must also be valid.
+//
+// The general form of the binary geometric function is `O foo(T, U)`; O is the
+// floating-point vector arithmetic type the function operates with. The
+// arguments (of type T and U) are cast to O before being passed to the
+// builtin. The rules to deduce O from the pair <T, U> are as follows:
+//
+// 1) If T and U are both the same floating-point vector type, identity
+//    conversion is triggered.
+template <typename T>
+struct _geometric_binary_func_operand_type<T, T, typename enable_if<_is_fp_vector<T>::value>::type>
+{
+  using type = T;
+};
+
+// 2) If T or U is a floating-point vector type, and the other is a
+//    floating-point or integral scalar type, then O is the floating-point
+//    vector type.
+template <typename T, typename U>
+struct _geometric_binary_func_operand_type<T, U, typename enable_if<(_is_fp_vector<T>::value ^ _is_fp_vector<U>::value) && (_is_scalar<T>::value ^ _is_scalar<U>::value)>::type>
+{
+  using type = typename conditional<_is_fp_vector<T>::value, T, U>::type;
+};
+
+template <typename T, typename U>
+using _geometric_binary_func_operand_type_t = typename _geometric_binary_func_operand_type<T, U>::type;
+template <typename T, typename U>
+struct _geometric_binary_func_enable : bool_constant<!is_same<void, _geometric_binary_func_operand_type_t<T, U>>::value>
+{
+};
+
+template <typename T, typename U, typename V, typename _E = void>
+struct _geometric_ternary_func_operand_type
+{
+  using type = void;
+};
+
+// Something similar happens for ternary functions in the form O foo(T, U, V):
+//
+// 1) If T, U, and V are the same floating-point vector type, identify
+//    conversion is triggered.
+template <typename T>
+struct _geometric_ternary_func_operand_type<T, T, T, typename enable_if<_is_fp_vector<T>::value>::type>
+{
+  using type = T;
+};
+
+// 2) If T, U, V are three different type, one of them is a floating-point
+//    vector type and the others are floating-point or scalar types, then O is
+//    the floating-point vector type.
+template <typename T, typename U, typename V>
+struct _geometric_ternary_func_operand_type<T, U, V, typename enable_if<(_is_fp_vector<T>::value + _is_fp_vector<U>::value + _is_fp_vector<V>::value) == 1 && (_is_scalar<T>::value + _is_scalar<U>::value + _is_scalar<V>::value) == 2 && (!is_same<T, U>::value && !is_same<T, V>::value && !is_same<U, V>::value)>::type>
+{
+  using type = typename conditional<_is_fp_vector<T>::value, T, U>::type;
+};
+
+// 3) If T has the same type of U, or T has the same type of V, or U has the
+//    same type of V, then the rules for geometric binary functions are applied
+//    to the two different types.
+template <typename T, typename V>
+struct _geometric_ternary_func_operand_type<T, T, V, typename enable_if<!is_same<T, V>::value>::type> : _geometric_binary_func_operand_type<T, V>
+{
+};
+template <typename T, typename U>
+struct _geometric_ternary_func_operand_type<T, U, T, typename enable_if<!is_same<T, U>::value>::type> : _geometric_binary_func_operand_type<T, U>
+{
+};
+template <typename T, typename U>
+struct _geometric_ternary_func_operand_type<T, U, U, typename enable_if<!is_same<T, U>::value>::type> : _geometric_binary_func_operand_type<T, U>
+{
+};
+
+template <typename T, typename U, typename V>
+using _geometric_ternary_func_operand_type_t = typename _geometric_ternary_func_operand_type<T, U, V>::type;
+template <typename T, typename U, typename V>
+struct _geometric_ternary_func_enable : bool_constant<!is_same<void, _geometric_ternary_func_operand_type_t<T, U, V>>::value>
+{
+};
+
+// The geometric cross function operands rules are an extension of the
+// geometric binary function rules. An extra restriction applies: the O vector
+// type must be 3-elements wide.
+template <typename T, typename U, typename _E = void>
+struct _geometric_cross_func_operand_type : _geometric_binary_func_operand_type<T, U>
+{
+};
+
+template <typename T, typename U>
+using _geometric_cross_func_operand_type_t = typename _geometric_cross_func_operand_type<T, U>::type;
+template <typename T, typename U>
+struct _geometric_cross_func_enable : bool_constant<!is_same<void, _geometric_cross_func_operand_type_t<T, U>>::value && vec_elements<_geometric_cross_func_operand_type_t<T, U>>::value == 3>
+{
+};
+
+// The geometric refraction function operand rules are an extension of the
+// geometric binary function rules. An extra restriction applies: the second
+// operand must be a scalar type.
+template <typename T, typename U, typename V, typename _E = void>
+struct _geometric_refract_func_operand_type : _geometric_binary_func_operand_type<T, U>
+{
+};
+
+template <typename T, typename U, typename V>
+using _geometric_refract_func_operand_type_t = typename _geometric_refract_func_operand_type<T, U, V>::type;
+template <typename T, typename U, typename V>
+struct _geometric_refract_func_enable : bool_constant<!is_same<void, _geometric_cross_func_operand_type_t<T, U>>::value && is_scalar<V>::value>
+{
+};
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC make_scalar_t<_O> dot(T x, U y)
+{
+  return __metal_dot(_O(x), _O(y));
+}
+
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value>::type>
+METAL_FUNC make_scalar_t<T> length_squared(T x)
+{
+  return dot(x, x);
+}
+
+namespace fast
+{
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value && is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC make_scalar_t<T> length(T x)
+{
+  return fast::sqrt(length_squared(x));
+}
+
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value && is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T normalize(T x)
+{
+  return x * fast::rsqrt(length_squared(x));
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC make_scalar_t<_O> distance(T x, U y)
+{
+  return fast::length(_O(x) - _O(y));
+}
+} // namespace fast
+
+namespace precise
+{
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value && is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC make_scalar_t<T> length(T x)
+{
+  using R = make_scalar_t<T>;
+
+  R len_sq = length_squared(x);
+  if (isinf(len_sq))
+  {
+    len_sq = length_squared(x * _fp_range_traits<R>::scale_down);
+    return _fp_range_traits<R>::scale_down_inv * precise::sqrt(len_sq);
+  }
+  if (len_sq < numeric_limits<R>::min() / numeric_limits<R>::epsilon())
+  {
+    len_sq = length_squared(x * _fp_range_traits<R>::scale_up);
+    return _fp_range_traits<R>::scale_up_inv * precise::sqrt(len_sq);
+  }
+  return precise::sqrt(len_sq);
+}
+
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value && is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T normalize(T x)
+{
+  using R = make_scalar_t<T>;
+
+  if (any(isinf(x)))
+    return numeric_limits<R>::quiet_NaN();
+
+  R len_sq = length_squared(x);
+  if (isinf(len_sq))
+  {
+    x *= _fp_range_traits<R>::scale_down;
+    len_sq = length_squared(x);
+    if (isinf(len_sq))
+      return copysign(select(T(0), T(1), isinf(x)), x);
+  }
+  else if (len_sq < numeric_limits<R>::min() / numeric_limits<R>::epsilon())
+  {
+    x *= _fp_range_traits<R>::scale_up;
+    len_sq = length_squared(x);
+    if (len_sq == R(0))
+      return x;
+  }
+  return x * precise::rsqrt(len_sq);
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC make_scalar_t<_O> distance(T x, U y)
+{
+  return precise::length(_O(x) - _O(y));
+}
+} // namespace precise
+
+template <typename T, typename _E = void>
+struct _length_impl
+{
+  METAL_FUNC make_scalar_t<T> operator()(T x) const thread
+  {
+    return sqrt(length_squared(x));
+  }
+};
+
+template <typename T>
+struct _length_impl<T, typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+{
+  METAL_FUNC make_scalar_t<T> operator()(T x) const thread
+  {
+#if defined(__FAST_MATH__)
+    return fast::length(x);
+#else
+    return precise::length(x);
+#endif
+  }
+};
+
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value>::type>
+METAL_FUNC make_scalar_t<T> length(T x)
+{
+  return _length_impl<T>()(x);
+}
+
+template <typename T, typename _E = void>
+struct _normalize_impl
+{
+  METAL_FUNC T operator()(T x) const thread
+  {
+    return x * rsqrt(length_squared(x));
+  }
+};
+
+template <typename T>
+struct _normalize_impl<T, typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+{
+  METAL_FUNC T operator()(T x) const thread
+  {
+#if defined(__FAST_MATH__)
+    return fast::normalize(x);
+#else
+    return precise::normalize(x);
+#endif
+  }
+};
+
+template <typename T, typename _E = typename enable_if<_is_fp_vector<T>::value>::type>
+METAL_FUNC T normalize(T x)
+{
+  return _normalize_impl<T>()(x);
+}
+
+template <typename T, typename _E = void>
+struct _distance_impl
+{
+  METAL_FUNC make_scalar_t<T> operator()(T x, T y) const thread
+  {
+    return length(x - y);
+  }
+};
+
+template <typename T>
+struct _distance_impl<T, typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+{
+  METAL_FUNC make_scalar_t<T> operator()(T x, T y) const thread
+  {
+#if defined(__FAST_MATH__)
+    return fast::distance(x, y);
+#else
+    return precise::distance(x, y);
+#endif
+  }
+};
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC make_scalar_t<_O> distance(T x, U y)
+{
+  return _distance_impl<_O>()(_O(x), _O(y));
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC make_scalar_t<_O> distance_squared(T x, U y)
+{
+  return length_squared(_O(x) - _O(y));
+}
+
+template <typename T, typename U, typename V, typename _O = typename enable_if<_geometric_ternary_func_enable<T, U, V>::value, _geometric_ternary_func_operand_type_t<T, U, V>>::type>
+METAL_FUNC _O faceforward(T n, U i, V nref)
+{
+  return dot(_O(nref), _O(i)) < make_scalar_t<_O>(0) ? _O(n) : _O(-n);
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_binary_func_enable<T, U>::value, _geometric_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O reflect(T i, U n)
+{
+  return _O(i) - make_scalar_t<_O>(2) * dot(_O(n), _O(i)) * _O(n);
+}
+
+template <typename T, typename U, typename V, typename _O = typename enable_if<_geometric_refract_func_enable<T, U, V>::value, _geometric_refract_func_operand_type_t<T, U, V>>::type>
+METAL_FUNC _O refract(T i, U n, V eta)
+{
+  using R = make_scalar_t<_O>;
+
+  R k = R(1) - R(eta) * R(eta) * (R(1) - dot(_O(n), _O(i)) * dot(_O(n), _O(i)));
+  if (k < R(0))
+    return {0};
+  return R(eta) * _O(i) - (R(eta) * dot(_O(n), _O(i)) + sqrt(k)) * _O(n);
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_geometric_cross_func_enable<T, U>::value, _geometric_cross_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O cross(T x, U y)
+{
+  return {(_O(x)[1] * _O(y)[2]) - (_O(y)[1] * _O(x)[2]), (_O(x)[2] * _O(y)[0]) - (_O(y)[2] * _O(x)[0]), (_O(x)[0] * _O(y)[1]) - (_O(y)[0] * _O(x)[1])};
+}
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_GEOMETRIC
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_graphics b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_graphics
new file mode 100644
index 00000000..462f63fa
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_graphics
@@ -0,0 +1,100 @@
+//===-- metal_graphics ----------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_GRAPHICS
+#define __METAL_GRAPHICS
+
+#include <metal_type_traits>
+
+namespace metal
+{
+// Metal 1.1 s5.9: Graphics Functions.
+
+// Metal 1.1 s5.9.1.1: Fragment Functions -- Derivatives.
+
+template <typename T, typename _E = typename enable_if<_disjunction<is_same<make_scalar_t<T>, half>, is_same<make_scalar_t<T>, float>>::value>::type>
+METAL_FUNC T dfdx(T p)
+{
+  return __metal_dfdx(p);
+}
+
+template <typename T, typename _E = typename enable_if<_disjunction<is_same<make_scalar_t<T>, half>, is_same<make_scalar_t<T>, float>>::value>::type>
+METAL_FUNC T dfdy(T p)
+{
+  return __metal_dfdy(p);
+}
+
+template <typename T, typename _E = typename enable_if<_disjunction<is_same<make_scalar_t<T>, half>, is_same<make_scalar_t<T>, float>>::value>::type>
+METAL_FUNC T fwidth(T p)
+{
+  return __metal_fwidth(p);
+}
+
+#if defined(__HAVE_SEPARATE_SHADING_RATES__)
+// TODO: Metal X.Y sZ.W Fragment Functions – Samples -- update version and
+// section number, see <rdar://problem/32963258>.
+
+enum class fragment_rate
+{
+  raster = 0,
+  color = 1
+};
+
+METAL_FUNC uint get_num_samples(fragment_rate rate = fragment_rate::raster)
+{
+  return __metal_get_num_samples(int(rate));
+}
+
+METAL_FUNC float2 get_sample_position(uint indx, fragment_rate rate = fragment_rate::raster)
+{
+  return __metal_get_sample_position(indx, int(rate));
+}
+
+#else
+// Metal 1.1 s5.9.1.2 Fragment Functions – Samples
+
+METAL_FUNC uint get_num_samples()
+{
+  return __metal_get_num_samples(0);
+}
+
+METAL_FUNC float2 get_sample_position(uint indx)
+{
+  return __metal_get_sample_position(indx, 0);
+}
+#endif
+
+// Metal 1.1 s5.9.1.3: Fragment Functions -- Flow Control.
+
+#if defined(__HAVE_DISCARD_FRAGMENT_NORETURN__)
+METAL_FUNC METAL_NORETURN void discard_fragment()
+#else
+METAL_FUNC void discard_fragment()
+#endif
+{
+  __metal_discard_fragment();
+}
+
+#if defined(__HAVE_DRAW_INDIRECT__)
+typedef struct
+{
+  uint vertexCount;
+  uint instanceCount;
+  uint vertexStart;
+  uint baseInstance;
+} MTLDrawPrimitivesIndirectArguments;
+
+typedef struct
+{
+  uint indexCount;
+  uint instanceCount;
+  uint indexStart;
+  uint baseVertex;
+  uint baseInstance;
+} MTLDrawIndexedPrimitivesIndirectArguments;
+#endif
+
+} // namespace metal
+
+#endif // __METAL_GRAPHICS
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_indirect_command_buffer b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_indirect_command_buffer
new file mode 100644
index 00000000..5e1ce93e
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_indirect_command_buffer
@@ -0,0 +1,267 @@
+//===-- metal_indirect_command_buffer -------------------------------------===//
+// Copyright (c) 2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_INDIRECT_COMMAND_BUFFER
+#define __METAL_INDIRECT_COMMAND_BUFFER
+
+namespace metal
+{
+
+#if defined(__HAVE_INDIRECT_COMMAND_BUFFER__)
+// TODO: Fix comment for the section and title.
+// Metal 2.2 <section>: Indirect Command Buffers
+
+#pragma METAL internals : enable
+
+template <typename T>
+struct _is_metal_buffer_pointee_impl : bool_constant<__is_metal_buffer_pointee(T)>
+{
+};
+
+template <typename T>
+struct is_metal_buffer_pointee : _is_metal_buffer_pointee_impl<remove_cv_t<T>>
+{
+};
+
+struct compute_command;
+
+struct compute_command_buffer
+{
+private:
+  compute_command_buffer_t t;
+  friend struct compute_command;
+};
+
+struct compute_pipeline_state
+{
+private:
+  compute_pipeline_state_t t;
+  friend struct compute_command;
+};
+
+struct compute_command
+{
+  METAL_FUNC compute_command(thread compute_command_buffer &cmd_buf, uint index) thread
+      : buf(cmd_buf.t), index(index)
+  {
+    __metal_acquire_compute_command(buf, index);
+  }
+
+  METAL_FUNC compute_command(const thread compute_command &that) thread = delete;
+
+  METAL_FUNC ~compute_command() thread
+  {
+    __metal_release_compute_command(buf, index);
+  }
+
+  METAL_FUNC thread compute_command &operator=(const thread compute_command &that) thread = delete;
+
+  const thread compute_command &operator,(const thread compute_command &that) const thread = delete;
+
+  METAL_FUNC void set_compute_pipeline_state(compute_pipeline_state pipeline_state) thread
+  {
+    __metal_set_pipeline_state_compute_command(buf, index, pipeline_state.t);
+  }
+
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_kernel_buffer(device T *buffer, uint bind_point) thread
+  {
+    __metal_set_kernel_buffer_compute_command(buf, index, static_cast<device void *>(buffer), bind_point);
+  }
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_kernel_buffer(constant T *buffer, uint bind_point) thread
+  {
+    __metal_set_kernel_buffer_compute_command(buf, index, static_cast<constant void *>(buffer), bind_point);
+  }
+
+  METAL_FUNC void dispatch_threadgroups(uint3 threadgroups, uint3 threads_per_threadgroup) thread
+  {
+    __metal_dispatch_threadgroups_compute_command(buf, index, threadgroups, threads_per_threadgroup);
+  }
+
+  METAL_FUNC void concurrent_dispatch_threadgroups(uint3 threadgroups, uint3 threads_per_threadgroup) thread
+  {
+    __metal_concurrent_dispatch_threadgroups_compute_command(buf, index, threadgroups, threads_per_threadgroup);
+  }
+
+  METAL_FUNC void nop() thread
+  {
+    __metal_nop_compute_command(buf, index);
+  }
+
+  METAL_FUNC void stop() thread
+  {
+    __metal_stop_compute_command(buf, index);
+  }
+
+private:
+  compute_command_buffer_t buf;
+  uint index;
+};
+
+struct render_command;
+
+struct render_command_buffer
+{
+private:
+  render_command_buffer_t t;
+  friend struct render_command;
+};
+
+struct render_pipeline_state
+{
+private:
+  render_pipeline_state_t t;
+  friend struct render_command;
+};
+
+enum class primitive_type
+{
+  point,
+  line,
+  line_strip,
+  triangle,
+  triangle_strip
+};
+
+struct render_command
+{
+  METAL_FUNC render_command(thread render_command_buffer &cmd_buf, uint index) thread
+      : buf(cmd_buf.t), index(index)
+  {
+    __metal_acquire_render_command(buf, index);
+  }
+
+  METAL_FUNC render_command(const thread render_command &that) thread = delete;
+
+  METAL_FUNC ~render_command() thread
+  {
+    __metal_release_render_command(buf, index);
+  }
+
+  METAL_FUNC thread render_command &operator=(const thread render_command &that) thread = delete;
+
+  const thread render_command &operator,(const thread render_command &that) const thread = delete;
+
+  METAL_FUNC void set_render_pipeline_state(render_pipeline_state pipeline_state) thread
+  {
+    __metal_set_pipeline_state_render_command(buf, index, pipeline_state.t);
+  }
+
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_vertex_buffer(device T *buffer, uint bind_point) thread
+  {
+    __metal_set_vertex_buffer_render_command(buf, index, static_cast<device void *>(buffer), bind_point);
+  }
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_vertex_buffer(constant T *buffer, uint bind_point) thread
+  {
+    __metal_set_vertex_buffer_render_command(buf, index, static_cast<constant void *>(buffer), bind_point);
+  }
+
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_fragment_buffer(device T *buffer, uint bind_point) thread
+  {
+    __metal_set_fragment_buffer_render_command(buf, index, static_cast<device void *>(buffer), bind_point);
+  }
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_fragment_buffer(constant T *buffer, uint bind_point) thread
+  {
+    __metal_set_fragment_buffer_render_command(buf, index, static_cast<constant void *>(buffer), bind_point);
+  }
+
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_tile_buffer(device T *buffer, uint bind_point) thread
+  {
+    __metal_set_tile_buffer_render_command(buf, index, static_cast<device void *>(buffer), bind_point);
+  }
+  template <typename T, typename _E = typename enable_if<is_metal_buffer_pointee<T>::value>::type>
+  METAL_FUNC void set_tile_buffer(constant T *buffer, uint bind_point) thread
+  {
+    __metal_set_tile_buffer_render_command(buf, index, static_cast<constant void *>(buffer), bind_point);
+  }
+
+  METAL_FUNC void draw_primitives(primitive_type type, uint vertex_start, uint vertex_count, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_primitives_render_command(buf, index, uint(type), vertex_start, vertex_count, instance_count, base_instance);
+  }
+
+  template <typename T, typename _E = typename enable_if<disjunction_v<is_same<T, ushort>, is_same<T, uint>>>::type>
+  METAL_FUNC void draw_indexed_primitives(primitive_type type, uint index_count, device T *index_buffer, uint index_start, uint instance_count, uint base_vertex, uint base_instance) thread
+  {
+    __metal_draw_indexed_primitives_render_command(buf, index, uint(type), index_count, static_cast<device void *>(index_buffer), index_start, instance_count, base_vertex, base_instance);
+  }
+  template <typename T, typename _E = typename enable_if<disjunction_v<is_same<T, ushort>, is_same<T, uint>>>::type>
+  METAL_FUNC void draw_indexed_primitives(primitive_type type, uint index_count, constant T *index_buffer, uint index_start, uint instance_count, uint base_vertex, uint base_instance) thread
+  {
+    __metal_draw_indexed_primitives_render_command(buf, index, uint(type), index_count, static_cast<constant void *>(index_buffer), index_start, instance_count, base_vertex, base_instance);
+  }
+
+  template <typename T, typename _E = typename enable_if<disjunction_v<is_same<T, MTLQuadTessellationFactorsHalf>, is_same<T, MTLTriangleTessellationFactorsHalf>>>::type>
+  METAL_FUNC void set_tessellation_factor_buffer(device T *buffer, uint offset, uint instance_stride) thread
+  {
+    __metal_set_tessellation_factor_buffer_render_command(buf, index, static_cast<device void *>(buffer), offset, instance_stride);
+  }
+  template <typename T, typename _E = typename enable_if<disjunction_v<is_same<T, MTLQuadTessellationFactorsHalf>, is_same<T, MTLTriangleTessellationFactorsHalf>>>::type>
+  METAL_FUNC void set_tessellation_factor_buffer(constant T *buffer, uint offset, uint instance_stride) thread
+  {
+    __metal_set_tessellation_factor_buffer_render_command(buf, index, static_cast<constant void *>(buffer), offset, instance_stride);
+  }
+
+  METAL_FUNC void set_tessellation_factor_scale(half scale) thread
+  {
+    __metal_set_tessellation_factor_scale_render_command(buf, index, scale);
+  }
+
+  METAL_FUNC void draw_patches(uint num_patch_control_points, uint patch_start, uint patch_count, device uint *patch_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<device void *>(patch_index_buffer), instance_count, base_instance);
+  }
+  METAL_FUNC void draw_patches(uint num_patch_control_points, uint patch_start, uint patch_count, constant uint *patch_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<constant void *>(patch_index_buffer), instance_count, base_instance);
+  }
+
+  METAL_FUNC void draw_indexed_patches(uint num_patch_control_points, uint patch_start, uint patch_count, device uint *patch_index_buffer, device void *control_point_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_indexed_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<device void *>(patch_index_buffer), control_point_index_buffer, instance_count, base_instance);
+  }
+  METAL_FUNC void draw_indexed_patches(uint num_patch_control_points, uint patch_start, uint patch_count, device uint *patch_index_buffer, constant void *control_point_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_indexed_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<device void *>(patch_index_buffer), control_point_index_buffer, instance_count, base_instance);
+  }
+  METAL_FUNC void draw_indexed_patches(uint num_patch_control_points, uint patch_start, uint patch_count, constant uint *patch_index_buffer, device void *control_point_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_indexed_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<constant void *>(patch_index_buffer), control_point_index_buffer, instance_count, base_instance);
+  }
+  METAL_FUNC void draw_indexed_patches(uint num_patch_control_points, uint patch_start, uint patch_count, constant uint *patch_index_buffer, constant void *control_point_index_buffer, uint instance_count, uint base_instance) thread
+  {
+    __metal_draw_indexed_patches_render_command(buf, index, num_patch_control_points, patch_start, patch_count, static_cast<constant void *>(patch_index_buffer), control_point_index_buffer, instance_count, base_instance);
+  }
+
+  METAL_FUNC void dispatch_threads_per_tile(uint2 threads_per_tile) thread
+  {
+    __metal_dispatch_threads_per_tile_render_command(buf, index, threads_per_tile);
+  }
+
+  METAL_FUNC void nop() thread
+  {
+    __metal_nop_render_command(buf, index);
+  }
+
+  METAL_FUNC void stop() thread
+  {
+    __metal_stop_render_command(buf, index);
+  }
+
+private:
+  render_command_buffer_t buf;
+  uint index;
+};
+
+#endif // defined (__HAVE_INDIRECT_COMMAND_BUFFER__)
+
+} // namespace metal
+
+#endif // __METAL_INDIRECT_COMMAND_BUFFER
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_initializer_list b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_initializer_list
new file mode 100644
index 00000000..2dbe1ba3
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_initializer_list
@@ -0,0 +1,47 @@
+//===-- metal_initializer_list --------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_INITIALIZER_LIST
+#define __METAL_INITIALIZER_LIST
+
+namespace metal
+{
+template <typename T>
+struct initializer_list
+{
+  typedef T value_type;
+  typedef const thread T& reference;
+  typedef const thread T& const_reference;
+  typedef size_t size_type;
+
+  typedef const thread T *iterator;
+  typedef const thread T *const_iterator;
+
+  constexpr initializer_list() thread
+      : elems(nullptr), count(0)
+  {
+  }
+
+  size_type size() const thread
+  {
+    return count;
+  }
+
+  const_iterator begin() const thread
+  {
+    return elems;
+  }
+
+  const_iterator end() const thread
+  {
+    return elems + count;
+  }
+
+private:
+  const thread value_type *elems;
+  size_type count;
+};
+} // namespace metal
+
+#endif // __METAL_INITIALIZER_LIST
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer
new file mode 100644
index 00000000..c0452dec
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer
@@ -0,0 +1,1497 @@
+//===-- metal_integer -----------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_INTEGER
+#define __METAL_INTEGER
+
+#include <metal_integer_math>
+
+#pragma METAL internals : enable
+namespace metal
+{
+// Metal 1.1 s5.3: Integer Functions.
+
+#if defined(__HAVE_MAD24__)
+template <typename T, typename _E = typename enable_if<_disjunction<is_same<make_scalar_t<T>, int>, is_same<make_scalar_t<T>, uint>>::value>::type>
+METAL_FUNC T mad24(T x, T y, T z)
+{
+  return __metal_mad24(x, y, z);
+}
+#endif
+
+#if defined(__HAVE_MUL24__)
+template <typename T, typename _E = typename enable_if<_disjunction<is_same<make_scalar_t<T>, int>, is_same<make_scalar_t<T>, uint>>::value>::type>
+METAL_FUNC T mul24(T x, T y)
+{
+  return __metal_mul24(x, y);
+}
+#endif
+} // namespace metal
+#pragma METAL internals : disable
+
+// TODO: The following is old code about to be rewritten by Alex.
+namespace metal {
+  // 5.4 Integer Functions
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL uchar _air_clz_i8(uchar x, bool is_zero_undef) __asm("air.clz.i8");
+#else
+  METAL_INTERNAL uchar _air_clz_i8(uchar x) __asm("air.clz.i8");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL uchar _air_ctz_i8(uchar x, bool is_zero_undef) __asm("air.ctz.i8");
+#else
+  METAL_INTERNAL uchar _air_ctz_i8(uchar x) __asm("air.ctz.i8");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL ushort _air_clz_i16(ushort x, bool is_zero_undef) __asm("air.clz.i16");
+#else
+  METAL_INTERNAL ushort _air_clz_i16(ushort x) __asm("air.clz.i16");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL ushort _air_ctz_i16(ushort x, bool is_zero_undef) __asm("air.ctz.i16");
+#else
+  METAL_INTERNAL ushort _air_ctz_i16(ushort x) __asm("air.ctz.i16");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL uint _air_clz_i32(uint x, bool is_zero_undef) __asm("air.clz.i32");
+#else
+  METAL_INTERNAL uint _air_clz_i32(uint x) __asm("air.clz.i32");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL uint _air_ctz_i32(uint x, bool is_zero_undef) __asm("air.ctz.i32");
+#else
+  METAL_INTERNAL uint _air_ctz_i32(uint x) __asm("air.ctz.i32");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,2> _air_clz_v2i8(vec<uchar,2> x, bool is_zero_undef) __asm("air.clz.v2i8");
+#else
+  METAL_INTERNAL vec<uchar,2> _air_clz_v2i8(vec<uchar,2> x) __asm("air.clz.v2i8");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,2> _air_ctz_v2i8(vec<uchar,2> x, bool is_zero_undef) __asm("air.ctz.v2i8");
+#else
+  METAL_INTERNAL vec<uchar,2> _air_ctz_v2i8(vec<uchar,2> x) __asm("air.ctz.v2i8");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,2> _air_clz_v2i16(vec<ushort,2> x, bool is_zero_undef) __asm("air.clz.v2i16");
+#else
+  METAL_INTERNAL vec<ushort,2> _air_clz_v2i16(vec<ushort,2> x) __asm("air.clz.v2i16");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,2> _air_ctz_v2i16(vec<ushort,2> x, bool is_zero_undef) __asm("air.ctz.v2i16");
+#else
+  METAL_INTERNAL vec<ushort,2> _air_ctz_v2i16(vec<ushort,2> x) __asm("air.ctz.v2i16");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,2> _air_clz_v2i32(vec<uint,2> x, bool is_zero_undef) __asm("air.clz.v2i32");
+#else
+  METAL_INTERNAL vec<uint,2> _air_clz_v2i32(vec<uint,2> x) __asm("air.clz.v2i32");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,2> _air_ctz_v2i32(vec<uint,2> x, bool is_zero_undef) __asm("air.ctz.v2i32");
+#else
+  METAL_INTERNAL vec<uint,2> _air_ctz_v2i32(vec<uint,2> x) __asm("air.ctz.v2i32");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,3> _air_clz_v3i8(vec<uchar,3> x, bool is_zero_undef) __asm("air.clz.v3i8");
+#else
+  METAL_INTERNAL vec<uchar,3> _air_clz_v3i8(vec<uchar,3> x) __asm("air.clz.v3i8");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,3> _air_ctz_v3i8(vec<uchar,3> x, bool is_zero_undef) __asm("air.ctz.v3i8");
+#else
+  METAL_INTERNAL vec<uchar,3> _air_ctz_v3i8(vec<uchar,3> x) __asm("air.ctz.v3i8");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,3> _air_clz_v3i16(vec<ushort,3> x, bool is_zero_undef) __asm("air.clz.v3i16");
+#else
+  METAL_INTERNAL vec<ushort,3> _air_clz_v3i16(vec<ushort,3> x) __asm("air.clz.v3i16");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,3> _air_ctz_v3i16(vec<ushort,3> x, bool is_zero_undef) __asm("air.ctz.v3i16");
+#else
+  METAL_INTERNAL vec<ushort,3> _air_ctz_v3i16(vec<ushort,3> x) __asm("air.ctz.v3i16");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,3> _air_clz_v3i32(vec<uint,3> x, bool is_zero_undef) __asm("air.clz.v3i32");
+#else
+  METAL_INTERNAL vec<uint,3> _air_clz_v3i32(vec<uint,3> x) __asm("air.clz.v3i32");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,3> _air_ctz_v3i32(vec<uint,3> x, bool is_zero_undef) __asm("air.ctz.v3i32");
+#else
+  METAL_INTERNAL vec<uint,3> _air_ctz_v3i32(vec<uint,3> x) __asm("air.ctz.v3i32");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,4> _air_clz_v4i8(vec<uchar,4> x, bool is_zero_undef) __asm("air.clz.v4i8");
+#else
+  METAL_INTERNAL vec<uchar,4> _air_clz_v4i8(vec<uchar,4> x) __asm("air.clz.v4i8");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uchar,4> _air_ctz_v4i8(vec<uchar,4> x, bool is_zero_undef) __asm("air.ctz.v4i8");
+#else
+  METAL_INTERNAL vec<uchar,4> _air_ctz_v4i8(vec<uchar,4> x) __asm("air.ctz.v4i8");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,4> _air_clz_v4i16(vec<ushort,4> x, bool is_zero_undef) __asm("air.clz.v4i16");
+#else
+  METAL_INTERNAL vec<ushort,4> _air_clz_v4i16(vec<ushort,4> x) __asm("air.clz.v4i16");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<ushort,4> _air_ctz_v4i16(vec<ushort,4> x, bool is_zero_undef) __asm("air.ctz.v4i16");
+#else
+  METAL_INTERNAL vec<ushort,4> _air_ctz_v4i16(vec<ushort,4> x) __asm("air.ctz.v4i16");
+#endif
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,4> _air_clz_v4i32(vec<uint,4> x, bool is_zero_undef) __asm("air.clz.v4i32");
+#else
+  METAL_INTERNAL vec<uint,4> _air_clz_v4i32(vec<uint,4> x) __asm("air.clz.v4i32");
+#endif
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+  METAL_INTERNAL vec<uint,4> _air_ctz_v4i32(vec<uint,4> x, bool is_zero_undef) __asm("air.ctz.v4i32");
+#else
+  METAL_INTERNAL vec<uint,4> _air_ctz_v4i32(vec<uint,4> x) __asm("air.ctz.v4i32");
+#endif
+
+  METAL_ASM char abs(char x) __asm("air.abs.s.i8");
+  METAL_ASM uchar absdiff(char x, char y) __asm("air.abs_diff.s.i8");
+  METAL_ASM char addsat(char x, char y) __asm("air.add_sat.s.i8");
+  METAL_ASM char hadd(char x, char y) __asm("air.hadd.s.i8");
+  METAL_ASM char rhadd(char x, char y) __asm("air.rhadd.s.i8");
+  METAL_ASM char clamp(char x, char minval, char maxval) __asm("air.clamp.s.i8");
+  METAL_FUNC char clz(char x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<char>(_air_clz_i8(as_type<uchar>(x), false));
+#else
+    return static_cast<char>(_air_clz_i8(as_type<uchar>(x)));
+#endif
+  }
+  METAL_FUNC char ctz(char x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<char>(_air_ctz_i8(as_type<uchar>(x), false));
+#else
+   return static_cast<char>(_air_ctz_i8(as_type<uchar>(x)));
+#endif
+  }
+  METAL_ASM char madhi(char a, char b, char c) __asm("air.mad_hi.s.i8");
+  METAL_ASM char madsat(char a, char b, char c) __asm("air.mad_sat.s.i8");
+  METAL_ASM char max(char x, char y) __asm("air.max.s.i8");
+  METAL_ASM char min(char x, char y) __asm("air.min.s.i8");
+  METAL_ASM char mulhi(char x, char y) __asm("air.mul_hi.s.i8");
+  METAL_ASM char rotate(char v, char i) __asm("air.rotate.i8");
+  METAL_ASM char subsat(char x, char y) __asm("air.sub_sat.s.i8");
+  METAL_ASM char popcount(char x) __asm("air.popcount.i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC char extract_bits(char x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    uchar xu = as_type<uchar>(x) >> offset;
+    uchar signmask = uchar(1) << (bits - 1);
+    uchar mask1 = ((~xu & signmask) << 1) - 1;
+    uchar mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<char>(xu);
+  }
+  METAL_FUNC uchar insert_bits(uchar base, uchar insert, uint offset, uint bits);
+  METAL_FUNC char insert_bits(char base, char insert, uint offset, uint bits) {
+    return as_type<char>(insert_bits(as_type<uchar>(base), as_type<uchar>(insert), offset, bits));
+  }
+  METAL_FUNC uchar reverse_bits(uchar x);
+  METAL_FUNC char reverse_bits(char x) {
+    return as_type<char>(reverse_bits(as_type<uchar>(x)));
+  }
+#else
+  METAL_ASM char extract_bits(char x, uint offset, uint bits) __asm("air.extract_bits.s.i8");
+  METAL_ASM char insert_bits(char base, char insert, uint offset, uint bits) __asm("air.insert_bits.s.i8");
+  METAL_ASM char reverse_bits(char x) __asm("air.reverse_bits.i8");
+#endif
+#endif
+  METAL_ASM uchar abs(uchar x) __asm("air.abs.u.i8");
+  METAL_ASM uchar absdiff(uchar x, uchar y) __asm("air.abs_diff.u.i8");
+  METAL_ASM uchar addsat(uchar x, uchar y) __asm("air.add_sat.u.i8");
+  METAL_ASM uchar hadd(uchar x, uchar y) __asm("air.hadd.u.i8");
+  METAL_ASM uchar rhadd(uchar x, uchar y) __asm("air.rhadd.u.i8");
+  METAL_ASM uchar clamp(uchar x, uchar minval, uchar maxval) __asm("air.clamp.u.i8");
+  METAL_FUNC uchar clz(uchar x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<uchar>(_air_clz_i8(as_type<uchar>(x), false));
+#else
+    return static_cast<uchar>(_air_clz_i8(as_type<uchar>(x)));
+#endif
+  }
+  METAL_FUNC uchar ctz(uchar x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<uchar>(_air_ctz_i8(as_type<uchar>(x), false));
+#else
+   return static_cast<uchar>(_air_ctz_i8(as_type<uchar>(x)));
+#endif
+  }
+  METAL_ASM uchar madhi(uchar a, uchar b, uchar c) __asm("air.mad_hi.u.i8");
+  METAL_ASM uchar madsat(uchar a, uchar b, uchar c) __asm("air.mad_sat.u.i8");
+  METAL_ASM uchar max(uchar x, uchar y) __asm("air.max.u.i8");
+  METAL_ASM uchar min(uchar x, uchar y) __asm("air.min.u.i8");
+  METAL_ASM uchar mulhi(uchar x, uchar y) __asm("air.mul_hi.u.i8");
+  METAL_ASM uchar rotate(uchar v, uchar i) __asm("air.rotate.i8");
+  METAL_ASM uchar subsat(uchar x, uchar y) __asm("air.sub_sat.u.i8");
+  METAL_ASM uchar popcount(uchar x) __asm("air.popcount.i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC uchar extract_bits(uchar x, uint offset, uint bits) {
+    if (bits == 8)
+      return x;
+    return (x >> offset) & ((uchar(1) << bits) - uchar(1));
+  }
+  METAL_FUNC uchar insert_bits(uchar base, uchar insert, uint offset, uint bits) {
+    if (bits == 8)
+      return insert;
+    uchar mask = ((uchar(1) << bits) - uchar(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC uchar reverse_bits(uchar x) {
+    x = ((x & uchar(0x55)) << 1) | ((x & uchar(0xAA)) >> 1);
+    x = ((x & uchar(0x33)) << 2) | ((x & uchar(0xCC)) >> 2);
+    return (x << 4) | (x >> 4);
+  }
+#else
+  METAL_ASM uchar extract_bits(uchar x, uint offset, uint bits) __asm("air.extract_bits.u.i8");
+  METAL_ASM uchar insert_bits(uchar base, uchar insert, uint offset, uint bits) __asm("air.insert_bits.u.i8");
+  METAL_ASM uchar reverse_bits(uchar x) __asm("air.reverse_bits.i8");
+#endif
+#endif
+  METAL_ASM short abs(short x) __asm("air.abs.s.i16");
+  METAL_ASM ushort absdiff(short x, short y) __asm("air.abs_diff.s.i16");
+  METAL_ASM short addsat(short x, short y) __asm("air.add_sat.s.i16");
+  METAL_ASM short hadd(short x, short y) __asm("air.hadd.s.i16");
+  METAL_ASM short rhadd(short x, short y) __asm("air.rhadd.s.i16");
+  METAL_ASM short clamp(short x, short minval, short maxval) __asm("air.clamp.s.i16");
+  METAL_FUNC short clz(short x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<short>(_air_clz_i16(as_type<ushort>(x), false));
+#else
+    return static_cast<short>(_air_clz_i16(as_type<ushort>(x)));
+#endif
+  }
+  METAL_FUNC short ctz(short x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<short>(_air_ctz_i16(as_type<ushort>(x), false));
+#else
+   return static_cast<short>(_air_ctz_i16(as_type<ushort>(x)));
+#endif
+  }
+  METAL_ASM short madhi(short a, short b, short c) __asm("air.mad_hi.s.i16");
+  METAL_ASM short madsat(short a, short b, short c) __asm("air.mad_sat.s.i16");
+  METAL_ASM short max(short x, short y) __asm("air.max.s.i16");
+  METAL_ASM short min(short x, short y) __asm("air.min.s.i16");
+  METAL_ASM short mulhi(short x, short y) __asm("air.mul_hi.s.i16");
+  METAL_ASM short rotate(short v, short i) __asm("air.rotate.i16");
+  METAL_ASM short subsat(short x, short y) __asm("air.sub_sat.s.i16");
+  METAL_ASM short popcount(short x) __asm("air.popcount.i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC short extract_bits(short x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    ushort xu = as_type<ushort>(x) >> offset;
+    ushort signmask = ushort(1) << (bits - 1);
+    ushort mask1 = ((~xu & signmask) << 1) - 1;
+    ushort mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<short>(xu);
+  }
+  METAL_FUNC ushort insert_bits(ushort base, ushort insert, uint offset, uint bits);
+  METAL_FUNC short insert_bits(short base, short insert, uint offset, uint bits) {
+    return as_type<short>(insert_bits(as_type<ushort>(base), as_type<ushort>(insert), offset, bits));
+  }
+  METAL_FUNC ushort reverse_bits(ushort x);
+  METAL_FUNC short reverse_bits(short x) {
+    return as_type<short>(reverse_bits(as_type<ushort>(x)));
+  }
+#else
+  METAL_ASM short extract_bits(short x, uint offset, uint bits) __asm("air.extract_bits.s.i16");
+  METAL_ASM short insert_bits(short base, short insert, uint offset, uint bits) __asm("air.insert_bits.s.i16");
+  METAL_ASM short reverse_bits(short x) __asm("air.reverse_bits.i16");
+#endif
+#endif
+  METAL_ASM ushort abs(ushort x) __asm("air.abs.u.i16");
+  METAL_ASM ushort absdiff(ushort x, ushort y) __asm("air.abs_diff.u.i16");
+  METAL_ASM ushort addsat(ushort x, ushort y) __asm("air.add_sat.u.i16");
+  METAL_ASM ushort hadd(ushort x, ushort y) __asm("air.hadd.u.i16");
+  METAL_ASM ushort rhadd(ushort x, ushort y) __asm("air.rhadd.u.i16");
+  METAL_ASM ushort clamp(ushort x, ushort minval, ushort maxval) __asm("air.clamp.u.i16");
+  METAL_FUNC ushort clz(ushort x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<ushort>(_air_clz_i16(as_type<ushort>(x), false));
+#else
+    return static_cast<ushort>(_air_clz_i16(as_type<ushort>(x)));
+#endif
+  }
+  METAL_FUNC ushort ctz(ushort x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<ushort>(_air_ctz_i16(as_type<ushort>(x), false));
+#else
+   return static_cast<ushort>(_air_ctz_i16(as_type<ushort>(x)));
+#endif
+  }
+  METAL_ASM ushort madhi(ushort a, ushort b, ushort c) __asm("air.mad_hi.u.i16");
+  METAL_ASM ushort madsat(ushort a, ushort b, ushort c) __asm("air.mad_sat.u.i16");
+  METAL_ASM ushort max(ushort x, ushort y) __asm("air.max.u.i16");
+  METAL_ASM ushort min(ushort x, ushort y) __asm("air.min.u.i16");
+  METAL_ASM ushort mulhi(ushort x, ushort y) __asm("air.mul_hi.u.i16");
+  METAL_ASM ushort rotate(ushort v, ushort i) __asm("air.rotate.i16");
+  METAL_ASM ushort subsat(ushort x, ushort y) __asm("air.sub_sat.u.i16");
+  METAL_ASM ushort popcount(ushort x) __asm("air.popcount.i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC ushort extract_bits(ushort x, uint offset, uint bits) {
+    if (bits == 16)
+      return x;
+    return (x >> offset) & ((ushort(1) << bits) - ushort(1));
+  }
+  METAL_FUNC ushort insert_bits(ushort base, ushort insert, uint offset, uint bits) {
+    if (bits == 16)
+      return insert;
+    ushort mask = ((ushort(1) << bits) - ushort(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC ushort reverse_bits(ushort x) {
+    x = ((x & ushort(0x5555)) << 1) | ((x & ushort(0xAAAA)) >> 1);
+    x = ((x & ushort(0x3333)) << 2) | ((x & ushort(0xCCCC)) >> 2);
+    x = ((x & ushort(0x0F0F)) << 4) | ((x & ushort(0xF0F0)) >> 4);
+    return (x << 8) | (x >> 8);
+  }
+#else
+  METAL_ASM ushort extract_bits(ushort x, uint offset, uint bits) __asm("air.extract_bits.u.i16");
+  METAL_ASM ushort insert_bits(ushort base, ushort insert, uint offset, uint bits) __asm("air.insert_bits.u.i16");
+  METAL_ASM ushort reverse_bits(ushort x) __asm("air.reverse_bits.i16");
+#endif
+#endif
+  METAL_ASM int abs(int x) __asm("air.abs.s.i32");
+  METAL_ASM uint absdiff(int x, int y) __asm("air.abs_diff.s.i32");
+  METAL_ASM int addsat(int x, int y) __asm("air.add_sat.s.i32");
+  METAL_ASM int hadd(int x, int y) __asm("air.hadd.s.i32");
+  METAL_ASM int rhadd(int x, int y) __asm("air.rhadd.s.i32");
+  METAL_ASM int clamp(int x, int minval, int maxval) __asm("air.clamp.s.i32");
+  METAL_FUNC int clz(int x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<int>(_air_clz_i32(as_type<uint>(x), false));
+#else
+    return static_cast<int>(_air_clz_i32(as_type<uint>(x)));
+#endif
+  }
+  METAL_FUNC int ctz(int x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<int>(_air_ctz_i32(as_type<uint>(x), false));
+#else
+   return static_cast<int>(_air_ctz_i32(as_type<uint>(x)));
+#endif
+  }
+  METAL_ASM int madhi(int a, int b, int c) __asm("air.mad_hi.s.i32");
+  METAL_ASM int madsat(int a, int b, int c) __asm("air.mad_sat.s.i32");
+  METAL_ASM int max(int x, int y) __asm("air.max.s.i32");
+  METAL_ASM int min(int x, int y) __asm("air.min.s.i32");
+  METAL_ASM int mulhi(int x, int y) __asm("air.mul_hi.s.i32");
+  METAL_ASM int rotate(int v, int i) __asm("air.rotate.i32");
+  METAL_ASM int subsat(int x, int y) __asm("air.sub_sat.s.i32");
+  METAL_ASM int popcount(int x) __asm("air.popcount.i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC int extract_bits(int x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    uint xu = as_type<uint>(x) >> offset;
+    uint signmask = uint(1) << (bits - 1);
+    uint mask1 = ((~xu & signmask) << 1) - 1;
+    uint mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<int>(xu);
+  }
+  METAL_FUNC uint insert_bits(uint base, uint insert, uint offset, uint bits);
+  METAL_FUNC int insert_bits(int base, int insert, uint offset, uint bits) {
+    return as_type<int>(insert_bits(as_type<uint>(base), as_type<uint>(insert), offset, bits));
+  }
+  METAL_FUNC uint reverse_bits(uint x);
+  METAL_FUNC int reverse_bits(int x) {
+    return as_type<int>(reverse_bits(as_type<uint>(x)));
+  }
+#else
+  METAL_ASM int extract_bits(int x, uint offset, uint bits) __asm("air.extract_bits.s.i32");
+  METAL_ASM int insert_bits(int base, int insert, uint offset, uint bits) __asm("air.insert_bits.s.i32");
+  METAL_ASM int reverse_bits(int x) __asm("air.reverse_bits.i32");
+#endif
+#endif
+  METAL_ASM uint abs(uint x) __asm("air.abs.u.i32");
+  METAL_ASM uint absdiff(uint x, uint y) __asm("air.abs_diff.u.i32");
+  METAL_ASM uint addsat(uint x, uint y) __asm("air.add_sat.u.i32");
+  METAL_ASM uint hadd(uint x, uint y) __asm("air.hadd.u.i32");
+  METAL_ASM uint rhadd(uint x, uint y) __asm("air.rhadd.u.i32");
+  METAL_ASM uint clamp(uint x, uint minval, uint maxval) __asm("air.clamp.u.i32");
+  METAL_FUNC uint clz(uint x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<uint>(_air_clz_i32(as_type<uint>(x), false));
+#else
+    return static_cast<uint>(_air_clz_i32(as_type<uint>(x)));
+#endif
+  }
+  METAL_FUNC uint ctz(uint x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<uint>(_air_ctz_i32(as_type<uint>(x), false));
+#else
+   return static_cast<uint>(_air_ctz_i32(as_type<uint>(x)));
+#endif
+  }
+  METAL_ASM uint madhi(uint a, uint b, uint c) __asm("air.mad_hi.u.i32");
+  METAL_ASM uint madsat(uint a, uint b, uint c) __asm("air.mad_sat.u.i32");
+  METAL_ASM uint max(uint x, uint y) __asm("air.max.u.i32");
+  METAL_ASM uint min(uint x, uint y) __asm("air.min.u.i32");
+  METAL_ASM uint mulhi(uint x, uint y) __asm("air.mul_hi.u.i32");
+  METAL_ASM uint rotate(uint v, uint i) __asm("air.rotate.i32");
+  METAL_ASM uint subsat(uint x, uint y) __asm("air.sub_sat.u.i32");
+  METAL_ASM uint popcount(uint x) __asm("air.popcount.i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC uint extract_bits(uint x, uint offset, uint bits) {
+    if (bits == 32)
+      return x;
+    return (x >> offset) & ((uint(1) << bits) - uint(1));
+  }
+  METAL_FUNC uint insert_bits(uint base, uint insert, uint offset, uint bits) {
+    if (bits == 32)
+      return insert;
+    uint mask = ((uint(1) << bits) - uint(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC uint reverse_bits(uint x) {
+    x = ((x & uint(0x55555555)) << 1) | ((x & uint(0xAAAAAAAA)) >> 1);
+    x = ((x & uint(0x33333333)) << 2) | ((x & uint(0xCCCCCCCC)) >> 2);
+    x = ((x & uint(0x0F0F0F0F)) << 4) | ((x & uint(0xF0F0F0F0)) >> 4);
+    x = ((x & uint(0x00FF00FF)) << 8) | ((x & uint(0xFF00FF00)) >> 8);
+    return (x << 16) | (x >> 16);
+  }
+#else
+  METAL_ASM uint extract_bits(uint x, uint offset, uint bits) __asm("air.extract_bits.u.i32");
+  METAL_ASM uint insert_bits(uint base, uint insert, uint offset, uint bits) __asm("air.insert_bits.u.i32");
+  METAL_ASM uint reverse_bits(uint x) __asm("air.reverse_bits.i32");
+#endif
+#endif
+  METAL_ASM vec<char,2> abs(vec<char,2> x) __asm("air.abs.s.v2i8");
+  METAL_ASM vec<uchar,2> absdiff(vec<char,2> x, vec<char,2> y) __asm("air.abs_diff.s.v2i8");
+  METAL_ASM vec<char,2> addsat(vec<char,2> x, vec<char,2> y) __asm("air.add_sat.s.v2i8");
+  METAL_ASM vec<char,2> hadd(vec<char,2> x, vec<char,2> y) __asm("air.hadd.s.v2i8");
+  METAL_ASM vec<char,2> rhadd(vec<char,2> x, vec<char,2> y) __asm("air.rhadd.s.v2i8");
+  METAL_ASM vec<char,2> clamp(vec<char,2> x, vec<char,2> minval, vec<char,2> maxval) __asm("air.clamp.s.v2i8");
+  METAL_FUNC vec<char,2> clamp(vec<char,2> x, char minval, char maxval) { return clamp(x,vec<char,2>(minval),vec<char,2>(maxval)); }
+  METAL_FUNC vec<char,2> clz(vec<char,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<char,2>>(_air_clz_v2i8(as_type<vec<uchar,2>>(x), false));
+#else
+    return static_cast<vec<char,2>>(_air_clz_v2i8(as_type<vec<uchar,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<char,2> ctz(vec<char,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<char,2>>(_air_ctz_v2i8(as_type<vec<uchar,2>>(x), false));
+#else
+   return static_cast<vec<char,2>>(_air_ctz_v2i8(as_type<vec<uchar,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<char,2> madhi(vec<char,2> a, vec<char,2> b, vec<char,2> c) __asm("air.mad_hi.s.v2i8");
+  METAL_ASM vec<char,2> madsat(vec<char,2> a, vec<char,2> b, vec<char,2> c) __asm("air.mad_sat.s.v2i8");
+  METAL_ASM vec<char,2> max(vec<char,2> x, vec<char,2> y) __asm("air.max.s.v2i8");
+  METAL_FUNC vec<char,2> max(vec<char,2> x, char y) { return max(x,vec<char,2>(y)); }
+  METAL_ASM vec<char,2> min(vec<char,2> x, vec<char,2> y) __asm("air.min.s.v2i8");
+  METAL_FUNC vec<char,2> min(vec<char,2> x, char y) { return min(x,vec<char,2>(y)); }
+  METAL_ASM vec<char,2> mulhi(vec<char,2> x, vec<char,2> y) __asm("air.mul_hi.s.v2i8");
+  METAL_ASM vec<char,2> rotate(vec<char,2> v, vec<char,2> i) __asm("air.rotate.v2i8");
+  METAL_ASM vec<char,2> subsat(vec<char,2> x, vec<char,2> y) __asm("air.sub_sat.s.v2i8");
+  METAL_ASM vec<char,2> popcount(vec<char,2> x) __asm("air.popcount.v2i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<char,2> extract_bits(vec<char,2> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uchar,2> xu = as_type<vec<uchar,2>>(x) >> offset;
+    vec<uchar,2> signmask = vec<uchar,2>(1) << (bits - 1);
+    vec<uchar,2> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uchar,2> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<char,2>>(xu);
+  }
+  METAL_FUNC vec<uchar,2> insert_bits(vec<uchar,2> base, vec<uchar,2> insert, uint offset, uint bits);
+  METAL_FUNC vec<char,2> insert_bits(vec<char,2> base, vec<char,2> insert, uint offset, uint bits) {
+    return as_type<vec<char,2>>(insert_bits(as_type<vec<uchar,2>>(base), as_type<vec<uchar,2>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uchar,2> reverse_bits(vec<uchar,2> x);
+  METAL_FUNC vec<char,2> reverse_bits(vec<char,2> x) {
+    return as_type<vec<char,2>>(reverse_bits(as_type<vec<uchar,2>>(x)));
+  }
+#else
+  METAL_ASM vec<char,2> extract_bits(vec<char,2> x, uint offset, uint bits) __asm("air.extract_bits.s.v2i8");
+  METAL_ASM vec<char,2> insert_bits(vec<char,2> base, vec<char,2> insert, uint offset, uint bits) __asm("air.insert_bits.s.v2i8");
+  METAL_ASM vec<char,2> reverse_bits(vec<char,2> x) __asm("air.reverse_bits.v2i8");
+#endif
+#endif
+  METAL_ASM vec<uchar,2> abs(vec<uchar,2> x) __asm("air.abs.u.v2i8");
+  METAL_ASM vec<uchar,2> absdiff(vec<uchar,2> x, vec<uchar,2> y) __asm("air.abs_diff.u.v2i8");
+  METAL_ASM vec<uchar,2> addsat(vec<uchar,2> x, vec<uchar,2> y) __asm("air.add_sat.u.v2i8");
+  METAL_ASM vec<uchar,2> hadd(vec<uchar,2> x, vec<uchar,2> y) __asm("air.hadd.u.v2i8");
+  METAL_ASM vec<uchar,2> rhadd(vec<uchar,2> x, vec<uchar,2> y) __asm("air.rhadd.u.v2i8");
+  METAL_ASM vec<uchar,2> clamp(vec<uchar,2> x, vec<uchar,2> minval, vec<uchar,2> maxval) __asm("air.clamp.u.v2i8");
+  METAL_FUNC vec<uchar,2> clamp(vec<uchar,2> x, uchar minval, uchar maxval) { return clamp(x,vec<uchar,2>(minval),vec<uchar,2>(maxval)); }
+  METAL_FUNC vec<uchar,2> clz(vec<uchar,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uchar,2>>(_air_clz_v2i8(as_type<vec<uchar,2>>(x), false));
+#else
+    return static_cast<vec<uchar,2>>(_air_clz_v2i8(as_type<vec<uchar,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uchar,2> ctz(vec<uchar,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uchar,2>>(_air_ctz_v2i8(as_type<vec<uchar,2>>(x), false));
+#else
+   return static_cast<vec<uchar,2>>(_air_ctz_v2i8(as_type<vec<uchar,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<uchar,2> madhi(vec<uchar,2> a, vec<uchar,2> b, vec<uchar,2> c) __asm("air.mad_hi.u.v2i8");
+  METAL_ASM vec<uchar,2> madsat(vec<uchar,2> a, vec<uchar,2> b, vec<uchar,2> c) __asm("air.mad_sat.u.v2i8");
+  METAL_ASM vec<uchar,2> max(vec<uchar,2> x, vec<uchar,2> y) __asm("air.max.u.v2i8");
+  METAL_FUNC vec<uchar,2> max(vec<uchar,2> x, uchar y) { return max(x,vec<uchar,2>(y)); }
+  METAL_ASM vec<uchar,2> min(vec<uchar,2> x, vec<uchar,2> y) __asm("air.min.u.v2i8");
+  METAL_FUNC vec<uchar,2> min(vec<uchar,2> x, uchar y) { return min(x,vec<uchar,2>(y)); }
+  METAL_ASM vec<uchar,2> mulhi(vec<uchar,2> x, vec<uchar,2> y) __asm("air.mul_hi.u.v2i8");
+  METAL_ASM vec<uchar,2> rotate(vec<uchar,2> v, vec<uchar,2> i) __asm("air.rotate.v2i8");
+  METAL_ASM vec<uchar,2> subsat(vec<uchar,2> x, vec<uchar,2> y) __asm("air.sub_sat.u.v2i8");
+  METAL_ASM vec<uchar,2> popcount(vec<uchar,2> x) __asm("air.popcount.v2i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uchar,2> extract_bits(vec<uchar,2> x, uint offset, uint bits) {
+    if (bits == 8)
+      return x;
+    return (x >> offset) & ((vec<uchar,2>(1) << bits) - vec<uchar,2>(1));
+  }
+  METAL_FUNC vec<uchar,2> insert_bits(vec<uchar,2> base, vec<uchar,2> insert, uint offset, uint bits) {
+    if (bits == 8)
+      return insert;
+    vec<uchar,2> mask = ((vec<uchar,2>(1) << bits) - vec<uchar,2>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uchar,2> reverse_bits(vec<uchar,2> x) {
+    x = ((x & vec<uchar,2>(0x55)) << 1) | ((x & vec<uchar,2>(0xAA)) >> 1);
+    x = ((x & vec<uchar,2>(0x33)) << 2) | ((x & vec<uchar,2>(0xCC)) >> 2);
+    return (x << 4) | (x >> 4);
+  }
+#else
+  METAL_ASM vec<uchar,2> extract_bits(vec<uchar,2> x, uint offset, uint bits) __asm("air.extract_bits.u.v2i8");
+  METAL_ASM vec<uchar,2> insert_bits(vec<uchar,2> base, vec<uchar,2> insert, uint offset, uint bits) __asm("air.insert_bits.u.v2i8");
+  METAL_ASM vec<uchar,2> reverse_bits(vec<uchar,2> x) __asm("air.reverse_bits.v2i8");
+#endif
+#endif
+  METAL_ASM vec<short,2> abs(vec<short,2> x) __asm("air.abs.s.v2i16");
+  METAL_ASM vec<ushort,2> absdiff(vec<short,2> x, vec<short,2> y) __asm("air.abs_diff.s.v2i16");
+  METAL_ASM vec<short,2> addsat(vec<short,2> x, vec<short,2> y) __asm("air.add_sat.s.v2i16");
+  METAL_ASM vec<short,2> hadd(vec<short,2> x, vec<short,2> y) __asm("air.hadd.s.v2i16");
+  METAL_ASM vec<short,2> rhadd(vec<short,2> x, vec<short,2> y) __asm("air.rhadd.s.v2i16");
+  METAL_ASM vec<short,2> clamp(vec<short,2> x, vec<short,2> minval, vec<short,2> maxval) __asm("air.clamp.s.v2i16");
+  METAL_FUNC vec<short,2> clamp(vec<short,2> x, short minval, short maxval) { return clamp(x,vec<short,2>(minval),vec<short,2>(maxval)); }
+  METAL_FUNC vec<short,2> clz(vec<short,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<short,2>>(_air_clz_v2i16(as_type<vec<ushort,2>>(x), false));
+#else
+    return static_cast<vec<short,2>>(_air_clz_v2i16(as_type<vec<ushort,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<short,2> ctz(vec<short,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<short,2>>(_air_ctz_v2i16(as_type<vec<ushort,2>>(x), false));
+#else
+   return static_cast<vec<short,2>>(_air_ctz_v2i16(as_type<vec<ushort,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<short,2> madhi(vec<short,2> a, vec<short,2> b, vec<short,2> c) __asm("air.mad_hi.s.v2i16");
+  METAL_ASM vec<short,2> madsat(vec<short,2> a, vec<short,2> b, vec<short,2> c) __asm("air.mad_sat.s.v2i16");
+  METAL_ASM vec<short,2> max(vec<short,2> x, vec<short,2> y) __asm("air.max.s.v2i16");
+  METAL_FUNC vec<short,2> max(vec<short,2> x, short y) { return max(x,vec<short,2>(y)); }
+  METAL_ASM vec<short,2> min(vec<short,2> x, vec<short,2> y) __asm("air.min.s.v2i16");
+  METAL_FUNC vec<short,2> min(vec<short,2> x, short y) { return min(x,vec<short,2>(y)); }
+  METAL_ASM vec<short,2> mulhi(vec<short,2> x, vec<short,2> y) __asm("air.mul_hi.s.v2i16");
+  METAL_ASM vec<short,2> rotate(vec<short,2> v, vec<short,2> i) __asm("air.rotate.v2i16");
+  METAL_ASM vec<short,2> subsat(vec<short,2> x, vec<short,2> y) __asm("air.sub_sat.s.v2i16");
+  METAL_ASM vec<short,2> popcount(vec<short,2> x) __asm("air.popcount.v2i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<short,2> extract_bits(vec<short,2> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<ushort,2> xu = as_type<vec<ushort,2>>(x) >> offset;
+    vec<ushort,2> signmask = vec<ushort,2>(1) << (bits - 1);
+    vec<ushort,2> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<ushort,2> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<short,2>>(xu);
+  }
+  METAL_FUNC vec<ushort,2> insert_bits(vec<ushort,2> base, vec<ushort,2> insert, uint offset, uint bits);
+  METAL_FUNC vec<short,2> insert_bits(vec<short,2> base, vec<short,2> insert, uint offset, uint bits) {
+    return as_type<vec<short,2>>(insert_bits(as_type<vec<ushort,2>>(base), as_type<vec<ushort,2>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<ushort,2> reverse_bits(vec<ushort,2> x);
+  METAL_FUNC vec<short,2> reverse_bits(vec<short,2> x) {
+    return as_type<vec<short,2>>(reverse_bits(as_type<vec<ushort,2>>(x)));
+  }
+#else
+  METAL_ASM vec<short,2> extract_bits(vec<short,2> x, uint offset, uint bits) __asm("air.extract_bits.s.v2i16");
+  METAL_ASM vec<short,2> insert_bits(vec<short,2> base, vec<short,2> insert, uint offset, uint bits) __asm("air.insert_bits.s.v2i16");
+  METAL_ASM vec<short,2> reverse_bits(vec<short,2> x) __asm("air.reverse_bits.v2i16");
+#endif
+#endif
+  METAL_ASM vec<ushort,2> abs(vec<ushort,2> x) __asm("air.abs.u.v2i16");
+  METAL_ASM vec<ushort,2> absdiff(vec<ushort,2> x, vec<ushort,2> y) __asm("air.abs_diff.u.v2i16");
+  METAL_ASM vec<ushort,2> addsat(vec<ushort,2> x, vec<ushort,2> y) __asm("air.add_sat.u.v2i16");
+  METAL_ASM vec<ushort,2> hadd(vec<ushort,2> x, vec<ushort,2> y) __asm("air.hadd.u.v2i16");
+  METAL_ASM vec<ushort,2> rhadd(vec<ushort,2> x, vec<ushort,2> y) __asm("air.rhadd.u.v2i16");
+  METAL_ASM vec<ushort,2> clamp(vec<ushort,2> x, vec<ushort,2> minval, vec<ushort,2> maxval) __asm("air.clamp.u.v2i16");
+  METAL_FUNC vec<ushort,2> clamp(vec<ushort,2> x, ushort minval, ushort maxval) { return clamp(x,vec<ushort,2>(minval),vec<ushort,2>(maxval)); }
+  METAL_FUNC vec<ushort,2> clz(vec<ushort,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<ushort,2>>(_air_clz_v2i16(as_type<vec<ushort,2>>(x), false));
+#else
+    return static_cast<vec<ushort,2>>(_air_clz_v2i16(as_type<vec<ushort,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<ushort,2> ctz(vec<ushort,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<ushort,2>>(_air_ctz_v2i16(as_type<vec<ushort,2>>(x), false));
+#else
+   return static_cast<vec<ushort,2>>(_air_ctz_v2i16(as_type<vec<ushort,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<ushort,2> madhi(vec<ushort,2> a, vec<ushort,2> b, vec<ushort,2> c) __asm("air.mad_hi.u.v2i16");
+  METAL_ASM vec<ushort,2> madsat(vec<ushort,2> a, vec<ushort,2> b, vec<ushort,2> c) __asm("air.mad_sat.u.v2i16");
+  METAL_ASM vec<ushort,2> max(vec<ushort,2> x, vec<ushort,2> y) __asm("air.max.u.v2i16");
+  METAL_FUNC vec<ushort,2> max(vec<ushort,2> x, ushort y) { return max(x,vec<ushort,2>(y)); }
+  METAL_ASM vec<ushort,2> min(vec<ushort,2> x, vec<ushort,2> y) __asm("air.min.u.v2i16");
+  METAL_FUNC vec<ushort,2> min(vec<ushort,2> x, ushort y) { return min(x,vec<ushort,2>(y)); }
+  METAL_ASM vec<ushort,2> mulhi(vec<ushort,2> x, vec<ushort,2> y) __asm("air.mul_hi.u.v2i16");
+  METAL_ASM vec<ushort,2> rotate(vec<ushort,2> v, vec<ushort,2> i) __asm("air.rotate.v2i16");
+  METAL_ASM vec<ushort,2> subsat(vec<ushort,2> x, vec<ushort,2> y) __asm("air.sub_sat.u.v2i16");
+  METAL_ASM vec<ushort,2> popcount(vec<ushort,2> x) __asm("air.popcount.v2i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<ushort,2> extract_bits(vec<ushort,2> x, uint offset, uint bits) {
+    if (bits == 16)
+      return x;
+    return (x >> offset) & ((vec<ushort,2>(1) << bits) - vec<ushort,2>(1));
+  }
+  METAL_FUNC vec<ushort,2> insert_bits(vec<ushort,2> base, vec<ushort,2> insert, uint offset, uint bits) {
+    if (bits == 16)
+      return insert;
+    vec<ushort,2> mask = ((vec<ushort,2>(1) << bits) - vec<ushort,2>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<ushort,2> reverse_bits(vec<ushort,2> x) {
+    x = ((x & vec<ushort,2>(0x5555)) << 1) | ((x & vec<ushort,2>(0xAAAA)) >> 1);
+    x = ((x & vec<ushort,2>(0x3333)) << 2) | ((x & vec<ushort,2>(0xCCCC)) >> 2);
+    x = ((x & vec<ushort,2>(0x0F0F)) << 4) | ((x & vec<ushort,2>(0xF0F0)) >> 4);
+    return (x << 8) | (x >> 8);
+  }
+#else
+  METAL_ASM vec<ushort,2> extract_bits(vec<ushort,2> x, uint offset, uint bits) __asm("air.extract_bits.u.v2i16");
+  METAL_ASM vec<ushort,2> insert_bits(vec<ushort,2> base, vec<ushort,2> insert, uint offset, uint bits) __asm("air.insert_bits.u.v2i16");
+  METAL_ASM vec<ushort,2> reverse_bits(vec<ushort,2> x) __asm("air.reverse_bits.v2i16");
+#endif
+#endif
+  METAL_ASM vec<int,2> abs(vec<int,2> x) __asm("air.abs.s.v2i32");
+  METAL_ASM vec<uint,2> absdiff(vec<int,2> x, vec<int,2> y) __asm("air.abs_diff.s.v2i32");
+  METAL_ASM vec<int,2> addsat(vec<int,2> x, vec<int,2> y) __asm("air.add_sat.s.v2i32");
+  METAL_ASM vec<int,2> hadd(vec<int,2> x, vec<int,2> y) __asm("air.hadd.s.v2i32");
+  METAL_ASM vec<int,2> rhadd(vec<int,2> x, vec<int,2> y) __asm("air.rhadd.s.v2i32");
+  METAL_ASM vec<int,2> clamp(vec<int,2> x, vec<int,2> minval, vec<int,2> maxval) __asm("air.clamp.s.v2i32");
+  METAL_FUNC vec<int,2> clamp(vec<int,2> x, int minval, int maxval) { return clamp(x,vec<int,2>(minval),vec<int,2>(maxval)); }
+  METAL_FUNC vec<int,2> clz(vec<int,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<int,2>>(_air_clz_v2i32(as_type<vec<uint,2>>(x), false));
+#else
+    return static_cast<vec<int,2>>(_air_clz_v2i32(as_type<vec<uint,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<int,2> ctz(vec<int,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<int,2>>(_air_ctz_v2i32(as_type<vec<uint,2>>(x), false));
+#else
+   return static_cast<vec<int,2>>(_air_ctz_v2i32(as_type<vec<uint,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<int,2> madhi(vec<int,2> a, vec<int,2> b, vec<int,2> c) __asm("air.mad_hi.s.v2i32");
+  METAL_ASM vec<int,2> madsat(vec<int,2> a, vec<int,2> b, vec<int,2> c) __asm("air.mad_sat.s.v2i32");
+  METAL_ASM vec<int,2> max(vec<int,2> x, vec<int,2> y) __asm("air.max.s.v2i32");
+  METAL_FUNC vec<int,2> max(vec<int,2> x, int y) { return max(x,vec<int,2>(y)); }
+  METAL_ASM vec<int,2> min(vec<int,2> x, vec<int,2> y) __asm("air.min.s.v2i32");
+  METAL_FUNC vec<int,2> min(vec<int,2> x, int y) { return min(x,vec<int,2>(y)); }
+  METAL_ASM vec<int,2> mulhi(vec<int,2> x, vec<int,2> y) __asm("air.mul_hi.s.v2i32");
+  METAL_ASM vec<int,2> rotate(vec<int,2> v, vec<int,2> i) __asm("air.rotate.v2i32");
+  METAL_ASM vec<int,2> subsat(vec<int,2> x, vec<int,2> y) __asm("air.sub_sat.s.v2i32");
+  METAL_ASM vec<int,2> popcount(vec<int,2> x) __asm("air.popcount.v2i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<int,2> extract_bits(vec<int,2> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uint,2> xu = as_type<vec<uint,2>>(x) >> offset;
+    vec<uint,2> signmask = vec<uint,2>(1) << (bits - 1);
+    vec<uint,2> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uint,2> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<int,2>>(xu);
+  }
+  METAL_FUNC vec<uint,2> insert_bits(vec<uint,2> base, vec<uint,2> insert, uint offset, uint bits);
+  METAL_FUNC vec<int,2> insert_bits(vec<int,2> base, vec<int,2> insert, uint offset, uint bits) {
+    return as_type<vec<int,2>>(insert_bits(as_type<vec<uint,2>>(base), as_type<vec<uint,2>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uint,2> reverse_bits(vec<uint,2> x);
+  METAL_FUNC vec<int,2> reverse_bits(vec<int,2> x) {
+    return as_type<vec<int,2>>(reverse_bits(as_type<vec<uint,2>>(x)));
+  }
+#else
+  METAL_ASM vec<int,2> extract_bits(vec<int,2> x, uint offset, uint bits) __asm("air.extract_bits.s.v2i32");
+  METAL_ASM vec<int,2> insert_bits(vec<int,2> base, vec<int,2> insert, uint offset, uint bits) __asm("air.insert_bits.s.v2i32");
+  METAL_ASM vec<int,2> reverse_bits(vec<int,2> x) __asm("air.reverse_bits.v2i32");
+#endif
+#endif
+  METAL_ASM vec<uint,2> abs(vec<uint,2> x) __asm("air.abs.u.v2i32");
+  METAL_ASM vec<uint,2> absdiff(vec<uint,2> x, vec<uint,2> y) __asm("air.abs_diff.u.v2i32");
+  METAL_ASM vec<uint,2> addsat(vec<uint,2> x, vec<uint,2> y) __asm("air.add_sat.u.v2i32");
+  METAL_ASM vec<uint,2> hadd(vec<uint,2> x, vec<uint,2> y) __asm("air.hadd.u.v2i32");
+  METAL_ASM vec<uint,2> rhadd(vec<uint,2> x, vec<uint,2> y) __asm("air.rhadd.u.v2i32");
+  METAL_ASM vec<uint,2> clamp(vec<uint,2> x, vec<uint,2> minval, vec<uint,2> maxval) __asm("air.clamp.u.v2i32");
+  METAL_FUNC vec<uint,2> clamp(vec<uint,2> x, uint minval, uint maxval) { return clamp(x,vec<uint,2>(minval),vec<uint,2>(maxval)); }
+  METAL_FUNC vec<uint,2> clz(vec<uint,2> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uint,2>>(_air_clz_v2i32(as_type<vec<uint,2>>(x), false));
+#else
+    return static_cast<vec<uint,2>>(_air_clz_v2i32(as_type<vec<uint,2>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uint,2> ctz(vec<uint,2> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uint,2>>(_air_ctz_v2i32(as_type<vec<uint,2>>(x), false));
+#else
+   return static_cast<vec<uint,2>>(_air_ctz_v2i32(as_type<vec<uint,2>>(x)));
+#endif
+  }
+  METAL_ASM vec<uint,2> madhi(vec<uint,2> a, vec<uint,2> b, vec<uint,2> c) __asm("air.mad_hi.u.v2i32");
+  METAL_ASM vec<uint,2> madsat(vec<uint,2> a, vec<uint,2> b, vec<uint,2> c) __asm("air.mad_sat.u.v2i32");
+  METAL_ASM vec<uint,2> max(vec<uint,2> x, vec<uint,2> y) __asm("air.max.u.v2i32");
+  METAL_FUNC vec<uint,2> max(vec<uint,2> x, uint y) { return max(x,vec<uint,2>(y)); }
+  METAL_ASM vec<uint,2> min(vec<uint,2> x, vec<uint,2> y) __asm("air.min.u.v2i32");
+  METAL_FUNC vec<uint,2> min(vec<uint,2> x, uint y) { return min(x,vec<uint,2>(y)); }
+  METAL_ASM vec<uint,2> mulhi(vec<uint,2> x, vec<uint,2> y) __asm("air.mul_hi.u.v2i32");
+  METAL_ASM vec<uint,2> rotate(vec<uint,2> v, vec<uint,2> i) __asm("air.rotate.v2i32");
+  METAL_ASM vec<uint,2> subsat(vec<uint,2> x, vec<uint,2> y) __asm("air.sub_sat.u.v2i32");
+  METAL_ASM vec<uint,2> popcount(vec<uint,2> x) __asm("air.popcount.v2i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uint,2> extract_bits(vec<uint,2> x, uint offset, uint bits) {
+    if (bits == 32)
+      return x;
+    return (x >> offset) & ((vec<uint,2>(1) << bits) - vec<uint,2>(1));
+  }
+  METAL_FUNC vec<uint,2> insert_bits(vec<uint,2> base, vec<uint,2> insert, uint offset, uint bits) {
+    if (bits == 32)
+      return insert;
+    vec<uint,2> mask = ((vec<uint,2>(1) << bits) - vec<uint,2>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uint,2> reverse_bits(vec<uint,2> x) {
+    x = ((x & vec<uint,2>(0x55555555)) << 1) | ((x & vec<uint,2>(0xAAAAAAAA)) >> 1);
+    x = ((x & vec<uint,2>(0x33333333)) << 2) | ((x & vec<uint,2>(0xCCCCCCCC)) >> 2);
+    x = ((x & vec<uint,2>(0x0F0F0F0F)) << 4) | ((x & vec<uint,2>(0xF0F0F0F0)) >> 4);
+    x = ((x & vec<uint,2>(0x00FF00FF)) << 8) | ((x & vec<uint,2>(0xFF00FF00)) >> 8);
+    return (x << 16) | (x >> 16);
+  }
+#else
+  METAL_ASM vec<uint,2> extract_bits(vec<uint,2> x, uint offset, uint bits) __asm("air.extract_bits.u.v2i32");
+  METAL_ASM vec<uint,2> insert_bits(vec<uint,2> base, vec<uint,2> insert, uint offset, uint bits) __asm("air.insert_bits.u.v2i32");
+  METAL_ASM vec<uint,2> reverse_bits(vec<uint,2> x) __asm("air.reverse_bits.v2i32");
+#endif
+#endif
+  METAL_ASM vec<char,3> abs(vec<char,3> x) __asm("air.abs.s.v3i8");
+  METAL_ASM vec<uchar,3> absdiff(vec<char,3> x, vec<char,3> y) __asm("air.abs_diff.s.v3i8");
+  METAL_ASM vec<char,3> addsat(vec<char,3> x, vec<char,3> y) __asm("air.add_sat.s.v3i8");
+  METAL_ASM vec<char,3> hadd(vec<char,3> x, vec<char,3> y) __asm("air.hadd.s.v3i8");
+  METAL_ASM vec<char,3> rhadd(vec<char,3> x, vec<char,3> y) __asm("air.rhadd.s.v3i8");
+  METAL_ASM vec<char,3> clamp(vec<char,3> x, vec<char,3> minval, vec<char,3> maxval) __asm("air.clamp.s.v3i8");
+  METAL_FUNC vec<char,3> clamp(vec<char,3> x, char minval, char maxval) { return clamp(x,vec<char,3>(minval),vec<char,3>(maxval)); }
+  METAL_FUNC vec<char,3> clz(vec<char,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<char,3>>(_air_clz_v3i8(as_type<vec<uchar,3>>(x), false));
+#else
+    return static_cast<vec<char,3>>(_air_clz_v3i8(as_type<vec<uchar,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<char,3> ctz(vec<char,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<char,3>>(_air_ctz_v3i8(as_type<vec<uchar,3>>(x), false));
+#else
+   return static_cast<vec<char,3>>(_air_ctz_v3i8(as_type<vec<uchar,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<char,3> madhi(vec<char,3> a, vec<char,3> b, vec<char,3> c) __asm("air.mad_hi.s.v3i8");
+  METAL_ASM vec<char,3> madsat(vec<char,3> a, vec<char,3> b, vec<char,3> c) __asm("air.mad_sat.s.v3i8");
+  METAL_ASM vec<char,3> max(vec<char,3> x, vec<char,3> y) __asm("air.max.s.v3i8");
+  METAL_FUNC vec<char,3> max(vec<char,3> x, char y) { return max(x,vec<char,3>(y)); }
+  METAL_ASM vec<char,3> min(vec<char,3> x, vec<char,3> y) __asm("air.min.s.v3i8");
+  METAL_FUNC vec<char,3> min(vec<char,3> x, char y) { return min(x,vec<char,3>(y)); }
+  METAL_ASM vec<char,3> mulhi(vec<char,3> x, vec<char,3> y) __asm("air.mul_hi.s.v3i8");
+  METAL_ASM vec<char,3> rotate(vec<char,3> v, vec<char,3> i) __asm("air.rotate.v3i8");
+  METAL_ASM vec<char,3> subsat(vec<char,3> x, vec<char,3> y) __asm("air.sub_sat.s.v3i8");
+  METAL_ASM vec<char,3> popcount(vec<char,3> x) __asm("air.popcount.v3i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<char,3> extract_bits(vec<char,3> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uchar,3> xu = as_type<vec<uchar,3>>(x) >> offset;
+    vec<uchar,3> signmask = vec<uchar,3>(1) << (bits - 1);
+    vec<uchar,3> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uchar,3> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<char,3>>(xu);
+  }
+  METAL_FUNC vec<uchar,3> insert_bits(vec<uchar,3> base, vec<uchar,3> insert, uint offset, uint bits);
+  METAL_FUNC vec<char,3> insert_bits(vec<char,3> base, vec<char,3> insert, uint offset, uint bits) {
+    return as_type<vec<char,3>>(insert_bits(as_type<vec<uchar,3>>(base), as_type<vec<uchar,3>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uchar,3> reverse_bits(vec<uchar,3> x);
+  METAL_FUNC vec<char,3> reverse_bits(vec<char,3> x) {
+    return as_type<vec<char,3>>(reverse_bits(as_type<vec<uchar,3>>(x)));
+  }
+#else
+  METAL_ASM vec<char,3> extract_bits(vec<char,3> x, uint offset, uint bits) __asm("air.extract_bits.s.v3i8");
+  METAL_ASM vec<char,3> insert_bits(vec<char,3> base, vec<char,3> insert, uint offset, uint bits) __asm("air.insert_bits.s.v3i8");
+  METAL_ASM vec<char,3> reverse_bits(vec<char,3> x) __asm("air.reverse_bits.v3i8");
+#endif
+#endif
+  METAL_ASM vec<uchar,3> abs(vec<uchar,3> x) __asm("air.abs.u.v3i8");
+  METAL_ASM vec<uchar,3> absdiff(vec<uchar,3> x, vec<uchar,3> y) __asm("air.abs_diff.u.v3i8");
+  METAL_ASM vec<uchar,3> addsat(vec<uchar,3> x, vec<uchar,3> y) __asm("air.add_sat.u.v3i8");
+  METAL_ASM vec<uchar,3> hadd(vec<uchar,3> x, vec<uchar,3> y) __asm("air.hadd.u.v3i8");
+  METAL_ASM vec<uchar,3> rhadd(vec<uchar,3> x, vec<uchar,3> y) __asm("air.rhadd.u.v3i8");
+  METAL_ASM vec<uchar,3> clamp(vec<uchar,3> x, vec<uchar,3> minval, vec<uchar,3> maxval) __asm("air.clamp.u.v3i8");
+  METAL_FUNC vec<uchar,3> clamp(vec<uchar,3> x, uchar minval, uchar maxval) { return clamp(x,vec<uchar,3>(minval),vec<uchar,3>(maxval)); }
+  METAL_FUNC vec<uchar,3> clz(vec<uchar,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uchar,3>>(_air_clz_v3i8(as_type<vec<uchar,3>>(x), false));
+#else
+    return static_cast<vec<uchar,3>>(_air_clz_v3i8(as_type<vec<uchar,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uchar,3> ctz(vec<uchar,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uchar,3>>(_air_ctz_v3i8(as_type<vec<uchar,3>>(x), false));
+#else
+   return static_cast<vec<uchar,3>>(_air_ctz_v3i8(as_type<vec<uchar,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<uchar,3> madhi(vec<uchar,3> a, vec<uchar,3> b, vec<uchar,3> c) __asm("air.mad_hi.u.v3i8");
+  METAL_ASM vec<uchar,3> madsat(vec<uchar,3> a, vec<uchar,3> b, vec<uchar,3> c) __asm("air.mad_sat.u.v3i8");
+  METAL_ASM vec<uchar,3> max(vec<uchar,3> x, vec<uchar,3> y) __asm("air.max.u.v3i8");
+  METAL_FUNC vec<uchar,3> max(vec<uchar,3> x, uchar y) { return max(x,vec<uchar,3>(y)); }
+  METAL_ASM vec<uchar,3> min(vec<uchar,3> x, vec<uchar,3> y) __asm("air.min.u.v3i8");
+  METAL_FUNC vec<uchar,3> min(vec<uchar,3> x, uchar y) { return min(x,vec<uchar,3>(y)); }
+  METAL_ASM vec<uchar,3> mulhi(vec<uchar,3> x, vec<uchar,3> y) __asm("air.mul_hi.u.v3i8");
+  METAL_ASM vec<uchar,3> rotate(vec<uchar,3> v, vec<uchar,3> i) __asm("air.rotate.v3i8");
+  METAL_ASM vec<uchar,3> subsat(vec<uchar,3> x, vec<uchar,3> y) __asm("air.sub_sat.u.v3i8");
+  METAL_ASM vec<uchar,3> popcount(vec<uchar,3> x) __asm("air.popcount.v3i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uchar,3> extract_bits(vec<uchar,3> x, uint offset, uint bits) {
+    if (bits == 8)
+      return x;
+    return (x >> offset) & ((vec<uchar,3>(1) << bits) - vec<uchar,3>(1));
+  }
+  METAL_FUNC vec<uchar,3> insert_bits(vec<uchar,3> base, vec<uchar,3> insert, uint offset, uint bits) {
+    if (bits == 8)
+      return insert;
+    vec<uchar,3> mask = ((vec<uchar,3>(1) << bits) - vec<uchar,3>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uchar,3> reverse_bits(vec<uchar,3> x) {
+    x = ((x & vec<uchar,3>(0x55)) << 1) | ((x & vec<uchar,3>(0xAA)) >> 1);
+    x = ((x & vec<uchar,3>(0x33)) << 2) | ((x & vec<uchar,3>(0xCC)) >> 2);
+    return (x << 4) | (x >> 4);
+  }
+#else
+  METAL_ASM vec<uchar,3> extract_bits(vec<uchar,3> x, uint offset, uint bits) __asm("air.extract_bits.u.v3i8");
+  METAL_ASM vec<uchar,3> insert_bits(vec<uchar,3> base, vec<uchar,3> insert, uint offset, uint bits) __asm("air.insert_bits.u.v3i8");
+  METAL_ASM vec<uchar,3> reverse_bits(vec<uchar,3> x) __asm("air.reverse_bits.v3i8");
+#endif
+#endif
+  METAL_ASM vec<short,3> abs(vec<short,3> x) __asm("air.abs.s.v3i16");
+  METAL_ASM vec<ushort,3> absdiff(vec<short,3> x, vec<short,3> y) __asm("air.abs_diff.s.v3i16");
+  METAL_ASM vec<short,3> addsat(vec<short,3> x, vec<short,3> y) __asm("air.add_sat.s.v3i16");
+  METAL_ASM vec<short,3> hadd(vec<short,3> x, vec<short,3> y) __asm("air.hadd.s.v3i16");
+  METAL_ASM vec<short,3> rhadd(vec<short,3> x, vec<short,3> y) __asm("air.rhadd.s.v3i16");
+  METAL_ASM vec<short,3> clamp(vec<short,3> x, vec<short,3> minval, vec<short,3> maxval) __asm("air.clamp.s.v3i16");
+  METAL_FUNC vec<short,3> clamp(vec<short,3> x, short minval, short maxval) { return clamp(x,vec<short,3>(minval),vec<short,3>(maxval)); }
+  METAL_FUNC vec<short,3> clz(vec<short,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<short,3>>(_air_clz_v3i16(as_type<vec<ushort,3>>(x), false));
+#else
+    return static_cast<vec<short,3>>(_air_clz_v3i16(as_type<vec<ushort,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<short,3> ctz(vec<short,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<short,3>>(_air_ctz_v3i16(as_type<vec<ushort,3>>(x), false));
+#else
+   return static_cast<vec<short,3>>(_air_ctz_v3i16(as_type<vec<ushort,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<short,3> madhi(vec<short,3> a, vec<short,3> b, vec<short,3> c) __asm("air.mad_hi.s.v3i16");
+  METAL_ASM vec<short,3> madsat(vec<short,3> a, vec<short,3> b, vec<short,3> c) __asm("air.mad_sat.s.v3i16");
+  METAL_ASM vec<short,3> max(vec<short,3> x, vec<short,3> y) __asm("air.max.s.v3i16");
+  METAL_FUNC vec<short,3> max(vec<short,3> x, short y) { return max(x,vec<short,3>(y)); }
+  METAL_ASM vec<short,3> min(vec<short,3> x, vec<short,3> y) __asm("air.min.s.v3i16");
+  METAL_FUNC vec<short,3> min(vec<short,3> x, short y) { return min(x,vec<short,3>(y)); }
+  METAL_ASM vec<short,3> mulhi(vec<short,3> x, vec<short,3> y) __asm("air.mul_hi.s.v3i16");
+  METAL_ASM vec<short,3> rotate(vec<short,3> v, vec<short,3> i) __asm("air.rotate.v3i16");
+  METAL_ASM vec<short,3> subsat(vec<short,3> x, vec<short,3> y) __asm("air.sub_sat.s.v3i16");
+  METAL_ASM vec<short,3> popcount(vec<short,3> x) __asm("air.popcount.v3i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<short,3> extract_bits(vec<short,3> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<ushort,3> xu = as_type<vec<ushort,3>>(x) >> offset;
+    vec<ushort,3> signmask = vec<ushort,3>(1) << (bits - 1);
+    vec<ushort,3> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<ushort,3> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<short,3>>(xu);
+  }
+  METAL_FUNC vec<ushort,3> insert_bits(vec<ushort,3> base, vec<ushort,3> insert, uint offset, uint bits);
+  METAL_FUNC vec<short,3> insert_bits(vec<short,3> base, vec<short,3> insert, uint offset, uint bits) {
+    return as_type<vec<short,3>>(insert_bits(as_type<vec<ushort,3>>(base), as_type<vec<ushort,3>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<ushort,3> reverse_bits(vec<ushort,3> x);
+  METAL_FUNC vec<short,3> reverse_bits(vec<short,3> x) {
+    return as_type<vec<short,3>>(reverse_bits(as_type<vec<ushort,3>>(x)));
+  }
+#else
+  METAL_ASM vec<short,3> extract_bits(vec<short,3> x, uint offset, uint bits) __asm("air.extract_bits.s.v3i16");
+  METAL_ASM vec<short,3> insert_bits(vec<short,3> base, vec<short,3> insert, uint offset, uint bits) __asm("air.insert_bits.s.v3i16");
+  METAL_ASM vec<short,3> reverse_bits(vec<short,3> x) __asm("air.reverse_bits.v3i16");
+#endif
+#endif
+  METAL_ASM vec<ushort,3> abs(vec<ushort,3> x) __asm("air.abs.u.v3i16");
+  METAL_ASM vec<ushort,3> absdiff(vec<ushort,3> x, vec<ushort,3> y) __asm("air.abs_diff.u.v3i16");
+  METAL_ASM vec<ushort,3> addsat(vec<ushort,3> x, vec<ushort,3> y) __asm("air.add_sat.u.v3i16");
+  METAL_ASM vec<ushort,3> hadd(vec<ushort,3> x, vec<ushort,3> y) __asm("air.hadd.u.v3i16");
+  METAL_ASM vec<ushort,3> rhadd(vec<ushort,3> x, vec<ushort,3> y) __asm("air.rhadd.u.v3i16");
+  METAL_ASM vec<ushort,3> clamp(vec<ushort,3> x, vec<ushort,3> minval, vec<ushort,3> maxval) __asm("air.clamp.u.v3i16");
+  METAL_FUNC vec<ushort,3> clamp(vec<ushort,3> x, ushort minval, ushort maxval) { return clamp(x,vec<ushort,3>(minval),vec<ushort,3>(maxval)); }
+  METAL_FUNC vec<ushort,3> clz(vec<ushort,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<ushort,3>>(_air_clz_v3i16(as_type<vec<ushort,3>>(x), false));
+#else
+    return static_cast<vec<ushort,3>>(_air_clz_v3i16(as_type<vec<ushort,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<ushort,3> ctz(vec<ushort,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<ushort,3>>(_air_ctz_v3i16(as_type<vec<ushort,3>>(x), false));
+#else
+   return static_cast<vec<ushort,3>>(_air_ctz_v3i16(as_type<vec<ushort,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<ushort,3> madhi(vec<ushort,3> a, vec<ushort,3> b, vec<ushort,3> c) __asm("air.mad_hi.u.v3i16");
+  METAL_ASM vec<ushort,3> madsat(vec<ushort,3> a, vec<ushort,3> b, vec<ushort,3> c) __asm("air.mad_sat.u.v3i16");
+  METAL_ASM vec<ushort,3> max(vec<ushort,3> x, vec<ushort,3> y) __asm("air.max.u.v3i16");
+  METAL_FUNC vec<ushort,3> max(vec<ushort,3> x, ushort y) { return max(x,vec<ushort,3>(y)); }
+  METAL_ASM vec<ushort,3> min(vec<ushort,3> x, vec<ushort,3> y) __asm("air.min.u.v3i16");
+  METAL_FUNC vec<ushort,3> min(vec<ushort,3> x, ushort y) { return min(x,vec<ushort,3>(y)); }
+  METAL_ASM vec<ushort,3> mulhi(vec<ushort,3> x, vec<ushort,3> y) __asm("air.mul_hi.u.v3i16");
+  METAL_ASM vec<ushort,3> rotate(vec<ushort,3> v, vec<ushort,3> i) __asm("air.rotate.v3i16");
+  METAL_ASM vec<ushort,3> subsat(vec<ushort,3> x, vec<ushort,3> y) __asm("air.sub_sat.u.v3i16");
+  METAL_ASM vec<ushort,3> popcount(vec<ushort,3> x) __asm("air.popcount.v3i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<ushort,3> extract_bits(vec<ushort,3> x, uint offset, uint bits) {
+    if (bits == 16)
+      return x;
+    return (x >> offset) & ((vec<ushort,3>(1) << bits) - vec<ushort,3>(1));
+  }
+  METAL_FUNC vec<ushort,3> insert_bits(vec<ushort,3> base, vec<ushort,3> insert, uint offset, uint bits) {
+    if (bits == 16)
+      return insert;
+    vec<ushort,3> mask = ((vec<ushort,3>(1) << bits) - vec<ushort,3>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<ushort,3> reverse_bits(vec<ushort,3> x) {
+    x = ((x & vec<ushort,3>(0x5555)) << 1) | ((x & vec<ushort,3>(0xAAAA)) >> 1);
+    x = ((x & vec<ushort,3>(0x3333)) << 2) | ((x & vec<ushort,3>(0xCCCC)) >> 2);
+    x = ((x & vec<ushort,3>(0x0F0F)) << 4) | ((x & vec<ushort,3>(0xF0F0)) >> 4);
+    return (x << 8) | (x >> 8);
+  }
+#else
+  METAL_ASM vec<ushort,3> extract_bits(vec<ushort,3> x, uint offset, uint bits) __asm("air.extract_bits.u.v3i16");
+  METAL_ASM vec<ushort,3> insert_bits(vec<ushort,3> base, vec<ushort,3> insert, uint offset, uint bits) __asm("air.insert_bits.u.v3i16");
+  METAL_ASM vec<ushort,3> reverse_bits(vec<ushort,3> x) __asm("air.reverse_bits.v3i16");
+#endif
+#endif
+  METAL_ASM vec<int,3> abs(vec<int,3> x) __asm("air.abs.s.v3i32");
+  METAL_ASM vec<uint,3> absdiff(vec<int,3> x, vec<int,3> y) __asm("air.abs_diff.s.v3i32");
+  METAL_ASM vec<int,3> addsat(vec<int,3> x, vec<int,3> y) __asm("air.add_sat.s.v3i32");
+  METAL_ASM vec<int,3> hadd(vec<int,3> x, vec<int,3> y) __asm("air.hadd.s.v3i32");
+  METAL_ASM vec<int,3> rhadd(vec<int,3> x, vec<int,3> y) __asm("air.rhadd.s.v3i32");
+  METAL_ASM vec<int,3> clamp(vec<int,3> x, vec<int,3> minval, vec<int,3> maxval) __asm("air.clamp.s.v3i32");
+  METAL_FUNC vec<int,3> clamp(vec<int,3> x, int minval, int maxval) { return clamp(x,vec<int,3>(minval),vec<int,3>(maxval)); }
+  METAL_FUNC vec<int,3> clz(vec<int,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<int,3>>(_air_clz_v3i32(as_type<vec<uint,3>>(x), false));
+#else
+    return static_cast<vec<int,3>>(_air_clz_v3i32(as_type<vec<uint,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<int,3> ctz(vec<int,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<int,3>>(_air_ctz_v3i32(as_type<vec<uint,3>>(x), false));
+#else
+   return static_cast<vec<int,3>>(_air_ctz_v3i32(as_type<vec<uint,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<int,3> madhi(vec<int,3> a, vec<int,3> b, vec<int,3> c) __asm("air.mad_hi.s.v3i32");
+  METAL_ASM vec<int,3> madsat(vec<int,3> a, vec<int,3> b, vec<int,3> c) __asm("air.mad_sat.s.v3i32");
+  METAL_ASM vec<int,3> max(vec<int,3> x, vec<int,3> y) __asm("air.max.s.v3i32");
+  METAL_FUNC vec<int,3> max(vec<int,3> x, int y) { return max(x,vec<int,3>(y)); }
+  METAL_ASM vec<int,3> min(vec<int,3> x, vec<int,3> y) __asm("air.min.s.v3i32");
+  METAL_FUNC vec<int,3> min(vec<int,3> x, int y) { return min(x,vec<int,3>(y)); }
+  METAL_ASM vec<int,3> mulhi(vec<int,3> x, vec<int,3> y) __asm("air.mul_hi.s.v3i32");
+  METAL_ASM vec<int,3> rotate(vec<int,3> v, vec<int,3> i) __asm("air.rotate.v3i32");
+  METAL_ASM vec<int,3> subsat(vec<int,3> x, vec<int,3> y) __asm("air.sub_sat.s.v3i32");
+  METAL_ASM vec<int,3> popcount(vec<int,3> x) __asm("air.popcount.v3i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<int,3> extract_bits(vec<int,3> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uint,3> xu = as_type<vec<uint,3>>(x) >> offset;
+    vec<uint,3> signmask = vec<uint,3>(1) << (bits - 1);
+    vec<uint,3> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uint,3> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<int,3>>(xu);
+  }
+  METAL_FUNC vec<uint,3> insert_bits(vec<uint,3> base, vec<uint,3> insert, uint offset, uint bits);
+  METAL_FUNC vec<int,3> insert_bits(vec<int,3> base, vec<int,3> insert, uint offset, uint bits) {
+    return as_type<vec<int,3>>(insert_bits(as_type<vec<uint,3>>(base), as_type<vec<uint,3>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uint,3> reverse_bits(vec<uint,3> x);
+  METAL_FUNC vec<int,3> reverse_bits(vec<int,3> x) {
+    return as_type<vec<int,3>>(reverse_bits(as_type<vec<uint,3>>(x)));
+  }
+#else
+  METAL_ASM vec<int,3> extract_bits(vec<int,3> x, uint offset, uint bits) __asm("air.extract_bits.s.v3i32");
+  METAL_ASM vec<int,3> insert_bits(vec<int,3> base, vec<int,3> insert, uint offset, uint bits) __asm("air.insert_bits.s.v3i32");
+  METAL_ASM vec<int,3> reverse_bits(vec<int,3> x) __asm("air.reverse_bits.v3i32");
+#endif
+#endif
+  METAL_ASM vec<uint,3> abs(vec<uint,3> x) __asm("air.abs.u.v3i32");
+  METAL_ASM vec<uint,3> absdiff(vec<uint,3> x, vec<uint,3> y) __asm("air.abs_diff.u.v3i32");
+  METAL_ASM vec<uint,3> addsat(vec<uint,3> x, vec<uint,3> y) __asm("air.add_sat.u.v3i32");
+  METAL_ASM vec<uint,3> hadd(vec<uint,3> x, vec<uint,3> y) __asm("air.hadd.u.v3i32");
+  METAL_ASM vec<uint,3> rhadd(vec<uint,3> x, vec<uint,3> y) __asm("air.rhadd.u.v3i32");
+  METAL_ASM vec<uint,3> clamp(vec<uint,3> x, vec<uint,3> minval, vec<uint,3> maxval) __asm("air.clamp.u.v3i32");
+  METAL_FUNC vec<uint,3> clamp(vec<uint,3> x, uint minval, uint maxval) { return clamp(x,vec<uint,3>(minval),vec<uint,3>(maxval)); }
+  METAL_FUNC vec<uint,3> clz(vec<uint,3> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uint,3>>(_air_clz_v3i32(as_type<vec<uint,3>>(x), false));
+#else
+    return static_cast<vec<uint,3>>(_air_clz_v3i32(as_type<vec<uint,3>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uint,3> ctz(vec<uint,3> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uint,3>>(_air_ctz_v3i32(as_type<vec<uint,3>>(x), false));
+#else
+   return static_cast<vec<uint,3>>(_air_ctz_v3i32(as_type<vec<uint,3>>(x)));
+#endif
+  }
+  METAL_ASM vec<uint,3> madhi(vec<uint,3> a, vec<uint,3> b, vec<uint,3> c) __asm("air.mad_hi.u.v3i32");
+  METAL_ASM vec<uint,3> madsat(vec<uint,3> a, vec<uint,3> b, vec<uint,3> c) __asm("air.mad_sat.u.v3i32");
+  METAL_ASM vec<uint,3> max(vec<uint,3> x, vec<uint,3> y) __asm("air.max.u.v3i32");
+  METAL_FUNC vec<uint,3> max(vec<uint,3> x, uint y) { return max(x,vec<uint,3>(y)); }
+  METAL_ASM vec<uint,3> min(vec<uint,3> x, vec<uint,3> y) __asm("air.min.u.v3i32");
+  METAL_FUNC vec<uint,3> min(vec<uint,3> x, uint y) { return min(x,vec<uint,3>(y)); }
+  METAL_ASM vec<uint,3> mulhi(vec<uint,3> x, vec<uint,3> y) __asm("air.mul_hi.u.v3i32");
+  METAL_ASM vec<uint,3> rotate(vec<uint,3> v, vec<uint,3> i) __asm("air.rotate.v3i32");
+  METAL_ASM vec<uint,3> subsat(vec<uint,3> x, vec<uint,3> y) __asm("air.sub_sat.u.v3i32");
+  METAL_ASM vec<uint,3> popcount(vec<uint,3> x) __asm("air.popcount.v3i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uint,3> extract_bits(vec<uint,3> x, uint offset, uint bits) {
+    if (bits == 32)
+      return x;
+    return (x >> offset) & ((vec<uint,3>(1) << bits) - vec<uint,3>(1));
+  }
+  METAL_FUNC vec<uint,3> insert_bits(vec<uint,3> base, vec<uint,3> insert, uint offset, uint bits) {
+    if (bits == 32)
+      return insert;
+    vec<uint,3> mask = ((vec<uint,3>(1) << bits) - vec<uint,3>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uint,3> reverse_bits(vec<uint,3> x) {
+    x = ((x & vec<uint,3>(0x55555555)) << 1) | ((x & vec<uint,3>(0xAAAAAAAA)) >> 1);
+    x = ((x & vec<uint,3>(0x33333333)) << 2) | ((x & vec<uint,3>(0xCCCCCCCC)) >> 2);
+    x = ((x & vec<uint,3>(0x0F0F0F0F)) << 4) | ((x & vec<uint,3>(0xF0F0F0F0)) >> 4);
+    x = ((x & vec<uint,3>(0x00FF00FF)) << 8) | ((x & vec<uint,3>(0xFF00FF00)) >> 8);
+    return (x << 16) | (x >> 16);
+  }
+#else
+  METAL_ASM vec<uint,3> extract_bits(vec<uint,3> x, uint offset, uint bits) __asm("air.extract_bits.u.v3i32");
+  METAL_ASM vec<uint,3> insert_bits(vec<uint,3> base, vec<uint,3> insert, uint offset, uint bits) __asm("air.insert_bits.u.v3i32");
+  METAL_ASM vec<uint,3> reverse_bits(vec<uint,3> x) __asm("air.reverse_bits.v3i32");
+#endif
+#endif
+  METAL_ASM vec<char,4> abs(vec<char,4> x) __asm("air.abs.s.v4i8");
+  METAL_ASM vec<uchar,4> absdiff(vec<char,4> x, vec<char,4> y) __asm("air.abs_diff.s.v4i8");
+  METAL_ASM vec<char,4> addsat(vec<char,4> x, vec<char,4> y) __asm("air.add_sat.s.v4i8");
+  METAL_ASM vec<char,4> hadd(vec<char,4> x, vec<char,4> y) __asm("air.hadd.s.v4i8");
+  METAL_ASM vec<char,4> rhadd(vec<char,4> x, vec<char,4> y) __asm("air.rhadd.s.v4i8");
+  METAL_ASM vec<char,4> clamp(vec<char,4> x, vec<char,4> minval, vec<char,4> maxval) __asm("air.clamp.s.v4i8");
+  METAL_FUNC vec<char,4> clamp(vec<char,4> x, char minval, char maxval) { return clamp(x,vec<char,4>(minval),vec<char,4>(maxval)); }
+  METAL_FUNC vec<char,4> clz(vec<char,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<char,4>>(_air_clz_v4i8(as_type<vec<uchar,4>>(x), false));
+#else
+    return static_cast<vec<char,4>>(_air_clz_v4i8(as_type<vec<uchar,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<char,4> ctz(vec<char,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<char,4>>(_air_ctz_v4i8(as_type<vec<uchar,4>>(x), false));
+#else
+   return static_cast<vec<char,4>>(_air_ctz_v4i8(as_type<vec<uchar,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<char,4> madhi(vec<char,4> a, vec<char,4> b, vec<char,4> c) __asm("air.mad_hi.s.v4i8");
+  METAL_ASM vec<char,4> madsat(vec<char,4> a, vec<char,4> b, vec<char,4> c) __asm("air.mad_sat.s.v4i8");
+  METAL_ASM vec<char,4> max(vec<char,4> x, vec<char,4> y) __asm("air.max.s.v4i8");
+  METAL_FUNC vec<char,4> max(vec<char,4> x, char y) { return max(x,vec<char,4>(y)); }
+  METAL_ASM vec<char,4> min(vec<char,4> x, vec<char,4> y) __asm("air.min.s.v4i8");
+  METAL_FUNC vec<char,4> min(vec<char,4> x, char y) { return min(x,vec<char,4>(y)); }
+  METAL_ASM vec<char,4> mulhi(vec<char,4> x, vec<char,4> y) __asm("air.mul_hi.s.v4i8");
+  METAL_ASM vec<char,4> rotate(vec<char,4> v, vec<char,4> i) __asm("air.rotate.v4i8");
+  METAL_ASM vec<char,4> subsat(vec<char,4> x, vec<char,4> y) __asm("air.sub_sat.s.v4i8");
+  METAL_ASM vec<char,4> popcount(vec<char,4> x) __asm("air.popcount.v4i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<char,4> extract_bits(vec<char,4> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uchar,4> xu = as_type<vec<uchar,4>>(x) >> offset;
+    vec<uchar,4> signmask = vec<uchar,4>(1) << (bits - 1);
+    vec<uchar,4> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uchar,4> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<char,4>>(xu);
+  }
+  METAL_FUNC vec<uchar,4> insert_bits(vec<uchar,4> base, vec<uchar,4> insert, uint offset, uint bits);
+  METAL_FUNC vec<char,4> insert_bits(vec<char,4> base, vec<char,4> insert, uint offset, uint bits) {
+    return as_type<vec<char,4>>(insert_bits(as_type<vec<uchar,4>>(base), as_type<vec<uchar,4>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uchar,4> reverse_bits(vec<uchar,4> x);
+  METAL_FUNC vec<char,4> reverse_bits(vec<char,4> x) {
+    return as_type<vec<char,4>>(reverse_bits(as_type<vec<uchar,4>>(x)));
+  }
+#else
+  METAL_ASM vec<char,4> extract_bits(vec<char,4> x, uint offset, uint bits) __asm("air.extract_bits.s.v4i8");
+  METAL_ASM vec<char,4> insert_bits(vec<char,4> base, vec<char,4> insert, uint offset, uint bits) __asm("air.insert_bits.s.v4i8");
+  METAL_ASM vec<char,4> reverse_bits(vec<char,4> x) __asm("air.reverse_bits.v4i8");
+#endif
+#endif
+  METAL_ASM vec<uchar,4> abs(vec<uchar,4> x) __asm("air.abs.u.v4i8");
+  METAL_ASM vec<uchar,4> absdiff(vec<uchar,4> x, vec<uchar,4> y) __asm("air.abs_diff.u.v4i8");
+  METAL_ASM vec<uchar,4> addsat(vec<uchar,4> x, vec<uchar,4> y) __asm("air.add_sat.u.v4i8");
+  METAL_ASM vec<uchar,4> hadd(vec<uchar,4> x, vec<uchar,4> y) __asm("air.hadd.u.v4i8");
+  METAL_ASM vec<uchar,4> rhadd(vec<uchar,4> x, vec<uchar,4> y) __asm("air.rhadd.u.v4i8");
+  METAL_ASM vec<uchar,4> clamp(vec<uchar,4> x, vec<uchar,4> minval, vec<uchar,4> maxval) __asm("air.clamp.u.v4i8");
+  METAL_FUNC vec<uchar,4> clamp(vec<uchar,4> x, uchar minval, uchar maxval) { return clamp(x,vec<uchar,4>(minval),vec<uchar,4>(maxval)); }
+  METAL_FUNC vec<uchar,4> clz(vec<uchar,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uchar,4>>(_air_clz_v4i8(as_type<vec<uchar,4>>(x), false));
+#else
+    return static_cast<vec<uchar,4>>(_air_clz_v4i8(as_type<vec<uchar,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uchar,4> ctz(vec<uchar,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uchar,4>>(_air_ctz_v4i8(as_type<vec<uchar,4>>(x), false));
+#else
+   return static_cast<vec<uchar,4>>(_air_ctz_v4i8(as_type<vec<uchar,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<uchar,4> madhi(vec<uchar,4> a, vec<uchar,4> b, vec<uchar,4> c) __asm("air.mad_hi.u.v4i8");
+  METAL_ASM vec<uchar,4> madsat(vec<uchar,4> a, vec<uchar,4> b, vec<uchar,4> c) __asm("air.mad_sat.u.v4i8");
+  METAL_ASM vec<uchar,4> max(vec<uchar,4> x, vec<uchar,4> y) __asm("air.max.u.v4i8");
+  METAL_FUNC vec<uchar,4> max(vec<uchar,4> x, uchar y) { return max(x,vec<uchar,4>(y)); }
+  METAL_ASM vec<uchar,4> min(vec<uchar,4> x, vec<uchar,4> y) __asm("air.min.u.v4i8");
+  METAL_FUNC vec<uchar,4> min(vec<uchar,4> x, uchar y) { return min(x,vec<uchar,4>(y)); }
+  METAL_ASM vec<uchar,4> mulhi(vec<uchar,4> x, vec<uchar,4> y) __asm("air.mul_hi.u.v4i8");
+  METAL_ASM vec<uchar,4> rotate(vec<uchar,4> v, vec<uchar,4> i) __asm("air.rotate.v4i8");
+  METAL_ASM vec<uchar,4> subsat(vec<uchar,4> x, vec<uchar,4> y) __asm("air.sub_sat.u.v4i8");
+  METAL_ASM vec<uchar,4> popcount(vec<uchar,4> x) __asm("air.popcount.v4i8");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uchar,4> extract_bits(vec<uchar,4> x, uint offset, uint bits) {
+    if (bits == 8)
+      return x;
+    return (x >> offset) & ((vec<uchar,4>(1) << bits) - vec<uchar,4>(1));
+  }
+  METAL_FUNC vec<uchar,4> insert_bits(vec<uchar,4> base, vec<uchar,4> insert, uint offset, uint bits) {
+    if (bits == 8)
+      return insert;
+    vec<uchar,4> mask = ((vec<uchar,4>(1) << bits) - vec<uchar,4>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uchar,4> reverse_bits(vec<uchar,4> x) {
+    x = ((x & vec<uchar,4>(0x55)) << 1) | ((x & vec<uchar,4>(0xAA)) >> 1);
+    x = ((x & vec<uchar,4>(0x33)) << 2) | ((x & vec<uchar,4>(0xCC)) >> 2);
+    return (x << 4) | (x >> 4);
+  }
+#else
+  METAL_ASM vec<uchar,4> extract_bits(vec<uchar,4> x, uint offset, uint bits) __asm("air.extract_bits.u.v4i8");
+  METAL_ASM vec<uchar,4> insert_bits(vec<uchar,4> base, vec<uchar,4> insert, uint offset, uint bits) __asm("air.insert_bits.u.v4i8");
+  METAL_ASM vec<uchar,4> reverse_bits(vec<uchar,4> x) __asm("air.reverse_bits.v4i8");
+#endif
+#endif
+  METAL_ASM vec<short,4> abs(vec<short,4> x) __asm("air.abs.s.v4i16");
+  METAL_ASM vec<ushort,4> absdiff(vec<short,4> x, vec<short,4> y) __asm("air.abs_diff.s.v4i16");
+  METAL_ASM vec<short,4> addsat(vec<short,4> x, vec<short,4> y) __asm("air.add_sat.s.v4i16");
+  METAL_ASM vec<short,4> hadd(vec<short,4> x, vec<short,4> y) __asm("air.hadd.s.v4i16");
+  METAL_ASM vec<short,4> rhadd(vec<short,4> x, vec<short,4> y) __asm("air.rhadd.s.v4i16");
+  METAL_ASM vec<short,4> clamp(vec<short,4> x, vec<short,4> minval, vec<short,4> maxval) __asm("air.clamp.s.v4i16");
+  METAL_FUNC vec<short,4> clamp(vec<short,4> x, short minval, short maxval) { return clamp(x,vec<short,4>(minval),vec<short,4>(maxval)); }
+  METAL_FUNC vec<short,4> clz(vec<short,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<short,4>>(_air_clz_v4i16(as_type<vec<ushort,4>>(x), false));
+#else
+    return static_cast<vec<short,4>>(_air_clz_v4i16(as_type<vec<ushort,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<short,4> ctz(vec<short,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<short,4>>(_air_ctz_v4i16(as_type<vec<ushort,4>>(x), false));
+#else
+   return static_cast<vec<short,4>>(_air_ctz_v4i16(as_type<vec<ushort,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<short,4> madhi(vec<short,4> a, vec<short,4> b, vec<short,4> c) __asm("air.mad_hi.s.v4i16");
+  METAL_ASM vec<short,4> madsat(vec<short,4> a, vec<short,4> b, vec<short,4> c) __asm("air.mad_sat.s.v4i16");
+  METAL_ASM vec<short,4> max(vec<short,4> x, vec<short,4> y) __asm("air.max.s.v4i16");
+  METAL_FUNC vec<short,4> max(vec<short,4> x, short y) { return max(x,vec<short,4>(y)); }
+  METAL_ASM vec<short,4> min(vec<short,4> x, vec<short,4> y) __asm("air.min.s.v4i16");
+  METAL_FUNC vec<short,4> min(vec<short,4> x, short y) { return min(x,vec<short,4>(y)); }
+  METAL_ASM vec<short,4> mulhi(vec<short,4> x, vec<short,4> y) __asm("air.mul_hi.s.v4i16");
+  METAL_ASM vec<short,4> rotate(vec<short,4> v, vec<short,4> i) __asm("air.rotate.v4i16");
+  METAL_ASM vec<short,4> subsat(vec<short,4> x, vec<short,4> y) __asm("air.sub_sat.s.v4i16");
+  METAL_ASM vec<short,4> popcount(vec<short,4> x) __asm("air.popcount.v4i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<short,4> extract_bits(vec<short,4> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<ushort,4> xu = as_type<vec<ushort,4>>(x) >> offset;
+    vec<ushort,4> signmask = vec<ushort,4>(1) << (bits - 1);
+    vec<ushort,4> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<ushort,4> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<short,4>>(xu);
+  }
+  METAL_FUNC vec<ushort,4> insert_bits(vec<ushort,4> base, vec<ushort,4> insert, uint offset, uint bits);
+  METAL_FUNC vec<short,4> insert_bits(vec<short,4> base, vec<short,4> insert, uint offset, uint bits) {
+    return as_type<vec<short,4>>(insert_bits(as_type<vec<ushort,4>>(base), as_type<vec<ushort,4>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<ushort,4> reverse_bits(vec<ushort,4> x);
+  METAL_FUNC vec<short,4> reverse_bits(vec<short,4> x) {
+    return as_type<vec<short,4>>(reverse_bits(as_type<vec<ushort,4>>(x)));
+  }
+#else
+  METAL_ASM vec<short,4> extract_bits(vec<short,4> x, uint offset, uint bits) __asm("air.extract_bits.s.v4i16");
+  METAL_ASM vec<short,4> insert_bits(vec<short,4> base, vec<short,4> insert, uint offset, uint bits) __asm("air.insert_bits.s.v4i16");
+  METAL_ASM vec<short,4> reverse_bits(vec<short,4> x) __asm("air.reverse_bits.v4i16");
+#endif
+#endif
+  METAL_ASM vec<ushort,4> abs(vec<ushort,4> x) __asm("air.abs.u.v4i16");
+  METAL_ASM vec<ushort,4> absdiff(vec<ushort,4> x, vec<ushort,4> y) __asm("air.abs_diff.u.v4i16");
+  METAL_ASM vec<ushort,4> addsat(vec<ushort,4> x, vec<ushort,4> y) __asm("air.add_sat.u.v4i16");
+  METAL_ASM vec<ushort,4> hadd(vec<ushort,4> x, vec<ushort,4> y) __asm("air.hadd.u.v4i16");
+  METAL_ASM vec<ushort,4> rhadd(vec<ushort,4> x, vec<ushort,4> y) __asm("air.rhadd.u.v4i16");
+  METAL_ASM vec<ushort,4> clamp(vec<ushort,4> x, vec<ushort,4> minval, vec<ushort,4> maxval) __asm("air.clamp.u.v4i16");
+  METAL_FUNC vec<ushort,4> clamp(vec<ushort,4> x, ushort minval, ushort maxval) { return clamp(x,vec<ushort,4>(minval),vec<ushort,4>(maxval)); }
+  METAL_FUNC vec<ushort,4> clz(vec<ushort,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<ushort,4>>(_air_clz_v4i16(as_type<vec<ushort,4>>(x), false));
+#else
+    return static_cast<vec<ushort,4>>(_air_clz_v4i16(as_type<vec<ushort,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<ushort,4> ctz(vec<ushort,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<ushort,4>>(_air_ctz_v4i16(as_type<vec<ushort,4>>(x), false));
+#else
+   return static_cast<vec<ushort,4>>(_air_ctz_v4i16(as_type<vec<ushort,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<ushort,4> madhi(vec<ushort,4> a, vec<ushort,4> b, vec<ushort,4> c) __asm("air.mad_hi.u.v4i16");
+  METAL_ASM vec<ushort,4> madsat(vec<ushort,4> a, vec<ushort,4> b, vec<ushort,4> c) __asm("air.mad_sat.u.v4i16");
+  METAL_ASM vec<ushort,4> max(vec<ushort,4> x, vec<ushort,4> y) __asm("air.max.u.v4i16");
+  METAL_FUNC vec<ushort,4> max(vec<ushort,4> x, ushort y) { return max(x,vec<ushort,4>(y)); }
+  METAL_ASM vec<ushort,4> min(vec<ushort,4> x, vec<ushort,4> y) __asm("air.min.u.v4i16");
+  METAL_FUNC vec<ushort,4> min(vec<ushort,4> x, ushort y) { return min(x,vec<ushort,4>(y)); }
+  METAL_ASM vec<ushort,4> mulhi(vec<ushort,4> x, vec<ushort,4> y) __asm("air.mul_hi.u.v4i16");
+  METAL_ASM vec<ushort,4> rotate(vec<ushort,4> v, vec<ushort,4> i) __asm("air.rotate.v4i16");
+  METAL_ASM vec<ushort,4> subsat(vec<ushort,4> x, vec<ushort,4> y) __asm("air.sub_sat.u.v4i16");
+  METAL_ASM vec<ushort,4> popcount(vec<ushort,4> x) __asm("air.popcount.v4i16");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<ushort,4> extract_bits(vec<ushort,4> x, uint offset, uint bits) {
+    if (bits == 16)
+      return x;
+    return (x >> offset) & ((vec<ushort,4>(1) << bits) - vec<ushort,4>(1));
+  }
+  METAL_FUNC vec<ushort,4> insert_bits(vec<ushort,4> base, vec<ushort,4> insert, uint offset, uint bits) {
+    if (bits == 16)
+      return insert;
+    vec<ushort,4> mask = ((vec<ushort,4>(1) << bits) - vec<ushort,4>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<ushort,4> reverse_bits(vec<ushort,4> x) {
+    x = ((x & vec<ushort,4>(0x5555)) << 1) | ((x & vec<ushort,4>(0xAAAA)) >> 1);
+    x = ((x & vec<ushort,4>(0x3333)) << 2) | ((x & vec<ushort,4>(0xCCCC)) >> 2);
+    x = ((x & vec<ushort,4>(0x0F0F)) << 4) | ((x & vec<ushort,4>(0xF0F0)) >> 4);
+    return (x << 8) | (x >> 8);
+  }
+#else
+  METAL_ASM vec<ushort,4> extract_bits(vec<ushort,4> x, uint offset, uint bits) __asm("air.extract_bits.u.v4i16");
+  METAL_ASM vec<ushort,4> insert_bits(vec<ushort,4> base, vec<ushort,4> insert, uint offset, uint bits) __asm("air.insert_bits.u.v4i16");
+  METAL_ASM vec<ushort,4> reverse_bits(vec<ushort,4> x) __asm("air.reverse_bits.v4i16");
+#endif
+#endif
+  METAL_ASM vec<int,4> abs(vec<int,4> x) __asm("air.abs.s.v4i32");
+  METAL_ASM vec<uint,4> absdiff(vec<int,4> x, vec<int,4> y) __asm("air.abs_diff.s.v4i32");
+  METAL_ASM vec<int,4> addsat(vec<int,4> x, vec<int,4> y) __asm("air.add_sat.s.v4i32");
+  METAL_ASM vec<int,4> hadd(vec<int,4> x, vec<int,4> y) __asm("air.hadd.s.v4i32");
+  METAL_ASM vec<int,4> rhadd(vec<int,4> x, vec<int,4> y) __asm("air.rhadd.s.v4i32");
+  METAL_ASM vec<int,4> clamp(vec<int,4> x, vec<int,4> minval, vec<int,4> maxval) __asm("air.clamp.s.v4i32");
+  METAL_FUNC vec<int,4> clamp(vec<int,4> x, int minval, int maxval) { return clamp(x,vec<int,4>(minval),vec<int,4>(maxval)); }
+  METAL_FUNC vec<int,4> clz(vec<int,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<int,4>>(_air_clz_v4i32(as_type<vec<uint,4>>(x), false));
+#else
+    return static_cast<vec<int,4>>(_air_clz_v4i32(as_type<vec<uint,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<int,4> ctz(vec<int,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<int,4>>(_air_ctz_v4i32(as_type<vec<uint,4>>(x), false));
+#else
+   return static_cast<vec<int,4>>(_air_ctz_v4i32(as_type<vec<uint,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<int,4> madhi(vec<int,4> a, vec<int,4> b, vec<int,4> c) __asm("air.mad_hi.s.v4i32");
+  METAL_ASM vec<int,4> madsat(vec<int,4> a, vec<int,4> b, vec<int,4> c) __asm("air.mad_sat.s.v4i32");
+  METAL_ASM vec<int,4> max(vec<int,4> x, vec<int,4> y) __asm("air.max.s.v4i32");
+  METAL_FUNC vec<int,4> max(vec<int,4> x, int y) { return max(x,vec<int,4>(y)); }
+  METAL_ASM vec<int,4> min(vec<int,4> x, vec<int,4> y) __asm("air.min.s.v4i32");
+  METAL_FUNC vec<int,4> min(vec<int,4> x, int y) { return min(x,vec<int,4>(y)); }
+  METAL_ASM vec<int,4> mulhi(vec<int,4> x, vec<int,4> y) __asm("air.mul_hi.s.v4i32");
+  METAL_ASM vec<int,4> rotate(vec<int,4> v, vec<int,4> i) __asm("air.rotate.v4i32");
+  METAL_ASM vec<int,4> subsat(vec<int,4> x, vec<int,4> y) __asm("air.sub_sat.s.v4i32");
+  METAL_ASM vec<int,4> popcount(vec<int,4> x) __asm("air.popcount.v4i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<int,4> extract_bits(vec<int,4> x, uint offset, uint bits) {
+    if (bits == 0)
+      return 0;
+    vec<uint,4> xu = as_type<vec<uint,4>>(x) >> offset;
+    vec<uint,4> signmask = vec<uint,4>(1) << (bits - 1);
+    vec<uint,4> mask1 = ((~xu & signmask) << 1) - 1;
+    vec<uint,4> mask2 = ~(((xu & signmask) << 1) - 1);
+    xu = (xu & mask1) | mask2;
+    return as_type<vec<int,4>>(xu);
+  }
+  METAL_FUNC vec<uint,4> insert_bits(vec<uint,4> base, vec<uint,4> insert, uint offset, uint bits);
+  METAL_FUNC vec<int,4> insert_bits(vec<int,4> base, vec<int,4> insert, uint offset, uint bits) {
+    return as_type<vec<int,4>>(insert_bits(as_type<vec<uint,4>>(base), as_type<vec<uint,4>>(insert), offset, bits));
+  }
+  METAL_FUNC vec<uint,4> reverse_bits(vec<uint,4> x);
+  METAL_FUNC vec<int,4> reverse_bits(vec<int,4> x) {
+    return as_type<vec<int,4>>(reverse_bits(as_type<vec<uint,4>>(x)));
+  }
+#else
+  METAL_ASM vec<int,4> extract_bits(vec<int,4> x, uint offset, uint bits) __asm("air.extract_bits.s.v4i32");
+  METAL_ASM vec<int,4> insert_bits(vec<int,4> base, vec<int,4> insert, uint offset, uint bits) __asm("air.insert_bits.s.v4i32");
+  METAL_ASM vec<int,4> reverse_bits(vec<int,4> x) __asm("air.reverse_bits.v4i32");
+#endif
+#endif
+  METAL_ASM vec<uint,4> abs(vec<uint,4> x) __asm("air.abs.u.v4i32");
+  METAL_ASM vec<uint,4> absdiff(vec<uint,4> x, vec<uint,4> y) __asm("air.abs_diff.u.v4i32");
+  METAL_ASM vec<uint,4> addsat(vec<uint,4> x, vec<uint,4> y) __asm("air.add_sat.u.v4i32");
+  METAL_ASM vec<uint,4> hadd(vec<uint,4> x, vec<uint,4> y) __asm("air.hadd.u.v4i32");
+  METAL_ASM vec<uint,4> rhadd(vec<uint,4> x, vec<uint,4> y) __asm("air.rhadd.u.v4i32");
+  METAL_ASM vec<uint,4> clamp(vec<uint,4> x, vec<uint,4> minval, vec<uint,4> maxval) __asm("air.clamp.u.v4i32");
+  METAL_FUNC vec<uint,4> clamp(vec<uint,4> x, uint minval, uint maxval) { return clamp(x,vec<uint,4>(minval),vec<uint,4>(maxval)); }
+  METAL_FUNC vec<uint,4> clz(vec<uint,4> x) {
+#if defined(__HAVE_CLZ_ZERO_UNDEF__)
+    return static_cast<vec<uint,4>>(_air_clz_v4i32(as_type<vec<uint,4>>(x), false));
+#else
+    return static_cast<vec<uint,4>>(_air_clz_v4i32(as_type<vec<uint,4>>(x)));
+#endif
+  }
+  METAL_FUNC vec<uint,4> ctz(vec<uint,4> x) {
+#if defined(__HAVE_CTZ_ZERO_UNDEF__)
+   return static_cast<vec<uint,4>>(_air_ctz_v4i32(as_type<vec<uint,4>>(x), false));
+#else
+   return static_cast<vec<uint,4>>(_air_ctz_v4i32(as_type<vec<uint,4>>(x)));
+#endif
+  }
+  METAL_ASM vec<uint,4> madhi(vec<uint,4> a, vec<uint,4> b, vec<uint,4> c) __asm("air.mad_hi.u.v4i32");
+  METAL_ASM vec<uint,4> madsat(vec<uint,4> a, vec<uint,4> b, vec<uint,4> c) __asm("air.mad_sat.u.v4i32");
+  METAL_ASM vec<uint,4> max(vec<uint,4> x, vec<uint,4> y) __asm("air.max.u.v4i32");
+  METAL_FUNC vec<uint,4> max(vec<uint,4> x, uint y) { return max(x,vec<uint,4>(y)); }
+  METAL_ASM vec<uint,4> min(vec<uint,4> x, vec<uint,4> y) __asm("air.min.u.v4i32");
+  METAL_FUNC vec<uint,4> min(vec<uint,4> x, uint y) { return min(x,vec<uint,4>(y)); }
+  METAL_ASM vec<uint,4> mulhi(vec<uint,4> x, vec<uint,4> y) __asm("air.mul_hi.u.v4i32");
+  METAL_ASM vec<uint,4> rotate(vec<uint,4> v, vec<uint,4> i) __asm("air.rotate.v4i32");
+  METAL_ASM vec<uint,4> subsat(vec<uint,4> x, vec<uint,4> y) __asm("air.sub_sat.u.v4i32");
+  METAL_ASM vec<uint,4> popcount(vec<uint,4> x) __asm("air.popcount.v4i32");
+#if defined(__HAVE_INTEGER_BIT_EDIT_FUNCTIONS__)
+#if !defined(__HAVE_INTEGER_BIT_EDIT_AIR_FUNCTIONS__)
+  METAL_FUNC vec<uint,4> extract_bits(vec<uint,4> x, uint offset, uint bits) {
+    if (bits == 32)
+      return x;
+    return (x >> offset) & ((vec<uint,4>(1) << bits) - vec<uint,4>(1));
+  }
+  METAL_FUNC vec<uint,4> insert_bits(vec<uint,4> base, vec<uint,4> insert, uint offset, uint bits) {
+    if (bits == 32)
+      return insert;
+    vec<uint,4> mask = ((vec<uint,4>(1) << bits) - vec<uint,4>(1)) << offset;
+    return (base & ~mask) | ((insert << offset) & mask);
+  }
+  METAL_FUNC vec<uint,4> reverse_bits(vec<uint,4> x) {
+    x = ((x & vec<uint,4>(0x55555555)) << 1) | ((x & vec<uint,4>(0xAAAAAAAA)) >> 1);
+    x = ((x & vec<uint,4>(0x33333333)) << 2) | ((x & vec<uint,4>(0xCCCCCCCC)) >> 2);
+    x = ((x & vec<uint,4>(0x0F0F0F0F)) << 4) | ((x & vec<uint,4>(0xF0F0F0F0)) >> 4);
+    x = ((x & vec<uint,4>(0x00FF00FF)) << 8) | ((x & vec<uint,4>(0xFF00FF00)) >> 8);
+    return (x << 16) | (x >> 16);
+  }
+#else
+  METAL_ASM vec<uint,4> extract_bits(vec<uint,4> x, uint offset, uint bits) __asm("air.extract_bits.u.v4i32");
+  METAL_ASM vec<uint,4> insert_bits(vec<uint,4> base, vec<uint,4> insert, uint offset, uint bits) __asm("air.insert_bits.u.v4i32");
+  METAL_ASM vec<uint,4> reverse_bits(vec<uint,4> x) __asm("air.reverse_bits.v4i32");
+#endif
+#endif
+} // namespace metal
+
+#endif // __METAL_INTEGER
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer_math b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer_math
new file mode 100644
index 00000000..70babf10
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_integer_math
@@ -0,0 +1,141 @@
+//===-- metal_integer_math ------------------------------------------------===//
+// Copyright (c) 2015-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_INTEGER_MATH
+#define __METAL_INTEGER_MATH
+
+#include <metal_math_utils>
+#include <metal_type_traits>
+
+#pragma METAL internals : enable
+namespace metal
+{
+template <typename T>
+struct _integer_ternary_func_enable : false_type
+{
+};
+
+template <>
+struct _integer_ternary_func_enable<char> : true_type
+{
+};
+template <>
+struct _integer_ternary_func_enable<uchar> : true_type
+{
+};
+template <>
+struct _integer_ternary_func_enable<short> : true_type
+{
+};
+template <>
+struct _integer_ternary_func_enable<ushort> : true_type
+{
+};
+template <>
+struct _integer_ternary_func_enable<int> : true_type
+{
+};
+template <>
+struct _integer_ternary_func_enable<uint> : true_type
+{
+};
+template <typename T, int N>
+struct _integer_ternary_func_enable<T __attribute__((ext_vector_type(N)))> : _integer_ternary_func_enable<T>
+{
+};
+template <typename T, int N>
+struct _integer_ternary_func_enable<T __attribute__((packed_vector_type(N)))> : _integer_ternary_func_enable<T>
+{
+};
+
+#if defined(__HAVE_MAX3__)
+template <typename T, typename _E = void>
+struct _max3_impl;
+
+template <typename T>
+struct _max3_impl<T, typename enable_if<_integer_ternary_func_enable<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_max3(x, y, z);
+  }
+};
+
+template <typename T>
+struct _max3_impl<T, typename enable_if<is_floating_point<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_fmax3(x, y, z, _METAL_MAYBE_FAST_MATH);
+  }
+};
+
+template <typename T, typename _E = typename enable_if<_integer_ternary_func_enable<T>::value || is_floating_point<T>::value>::type>
+METAL_FUNC T max3(T x, T y, T z)
+{
+  return _max3_impl<T>()(x, y, z);
+}
+#endif
+
+#if defined(__HAVE_MEDIAN3__)
+template <typename T, typename _E = void>
+struct _median3_impl;
+
+template <typename T>
+struct _median3_impl<T, typename enable_if<_integer_ternary_func_enable<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_median3(x, y, z);
+  }
+};
+
+template <typename T>
+struct _median3_impl<T, typename enable_if<is_floating_point<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_fmedian3(x, y, z, _METAL_MAYBE_FAST_MATH);
+  }
+};
+
+template <typename T, typename _E = typename enable_if<_integer_ternary_func_enable<T>::value || is_floating_point<T>::value>::type>
+METAL_FUNC T median3(T x, T y, T z)
+{
+  return _median3_impl<T>()(x, y, z);
+}
+#endif
+
+#if defined(__HAVE_MIN3__)
+template <typename T, typename _E = void>
+struct _min3_impl;
+
+template <typename T>
+struct _min3_impl<T, typename enable_if<_integer_ternary_func_enable<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_min3(x, y, z);
+  }
+};
+
+template <typename T>
+struct _min3_impl<T, typename enable_if<is_floating_point<T>::value>::type>
+{
+  METAL_FUNC T operator()(T x, T y, T z) const thread
+  {
+    return __metal_fmin3(x, y, z, _METAL_MAYBE_FAST_MATH);
+  }
+};
+
+template <typename T, typename _E = typename enable_if<_integer_ternary_func_enable<T>::value || is_floating_point<T>::value>::type>
+METAL_FUNC T min3(T x, T y, T z)
+{
+  return _min3_impl<T>()(x, y, z);
+}
+#endif
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_INTEGER_MATH
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_limits b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_limits
new file mode 100644
index 00000000..24efee26
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_limits
@@ -0,0 +1,174 @@
+//===-- metal_limits ------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_LIMITS
+#define __METAL_LIMITS
+
+#pragma METAL internals : enable
+namespace metal
+{
+enum float_round_style
+{
+  round_indeterminate = -1,
+  round_toward_zero = 0,
+  round_to_nearest = 1,
+  round_toward_infinity = 2,
+  round_toward_neg_infinity = 3
+};
+
+enum float_denorm_style
+{
+  denorm_indeterminate = -1,
+  denorm_absent = 0,
+  denorm_present = 1
+};
+
+template <typename T>
+struct _numeric_limits_impl
+{
+  static constexpr constant bool is_specialized = false;
+  static constexpr constant bool is_signed = false;
+  static constexpr constant bool is_integer = false;
+  static constexpr constant bool is_exact = false;
+  static constexpr constant bool has_infinity = false;
+  static constexpr constant bool has_quiet_NaN = false;
+  static constexpr constant bool has_signaling_NaN = false;
+  static constexpr constant float_denorm_style has_denorm = denorm_absent;
+  static constexpr constant bool has_denorm_loss = false;
+  static constexpr constant float_round_style round_style = round_toward_zero;
+  static constexpr constant bool is_iec559 = false;
+  static constexpr constant bool is_bounded = false;
+  static constexpr constant bool is_modulo = false;
+  static constexpr constant int digits = 0;
+  static constexpr constant int digits10 = 0;
+  static constexpr constant int max_digits10 = 0;
+  static constexpr constant int radix = 0;
+  static constexpr constant int min_exponent = 0;
+  static constexpr constant int min_exponent10 = 0;
+  static constexpr constant int max_exponent = 0;
+  static constexpr constant int max_exponent10 = 0;
+  static constexpr constant bool traps = false;
+  static constexpr constant bool tinyness_before = false;
+
+  static constexpr T min()
+  {
+    return T();
+  }
+  static constexpr T lowest()
+  {
+    return T();
+  }
+  static constexpr T max()
+  {
+    return T();
+  }
+  static constexpr T epsilon()
+  {
+    return T();
+  }
+  static constexpr T round_error()
+  {
+    return T();
+  }
+  static constexpr T infinity()
+  {
+    return T();
+  }
+  static constexpr T quiet_NaN()
+  {
+    return T();
+  }
+  static constexpr T signaling_NaN()
+  {
+    return T();
+  }
+  static constexpr T denorm_min()
+  {
+    return T();
+  }
+};
+
+// TODO: Implement all the other members -- see <rdar://problem/36141588>.
+template <>
+struct _numeric_limits_impl<half>
+{
+  static constexpr constant bool has_quiet_NaN = true;
+
+  static constexpr half min()
+  {
+    return HALF_MIN;
+  }
+  static constexpr half max()
+  {
+    return HALF_MAX;
+  }
+  static constexpr half epsilon()
+  {
+    return HALF_EPSILON;
+  }
+  static constexpr half quiet_NaN()
+  {
+    return __builtin_nanh("");
+  }
+};
+
+// TODO: Implement all the other members -- see <rdar://problem/36141588>.
+template <>
+struct _numeric_limits_impl<float>
+{
+  static constexpr constant bool has_quiet_NaN = true;
+
+  static constexpr float min()
+  {
+    return FLT_MIN;
+  }
+  static constexpr float max()
+  {
+    return FLT_MAX;
+  }
+  static constexpr float epsilon()
+  {
+    return FLT_EPSILON;
+  }
+  static constexpr float quiet_NaN()
+  {
+    return __builtin_nanf("");
+  }
+};
+
+#if defined(__HAVE_NATIVE_DOUBLE__)
+// TODO: Implement all the other members -- see <rdar://problem/36141588>.
+template <>
+struct _numeric_limits_impl<double>
+{
+  static constexpr constant bool has_quiet_NaN = true;
+
+  static constexpr double min()
+  {
+    return DBL_MIN;
+  }
+  static constexpr double max()
+  {
+    return DBL_MAX;
+  }
+  static constexpr double epsilon()
+  {
+    return DBL_EPSILON;
+  }
+  static constexpr double quiet_NaN()
+  {
+    return __builtin_nan("");
+  }
+};
+#endif
+
+template <typename T>
+struct numeric_limits : _numeric_limits_impl<remove_cv_t<T>>
+{
+};
+
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_LIMITS
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math
new file mode 100644
index 00000000..74b482e3
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math
@@ -0,0 +1,2304 @@
+//===-- metal_math --------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_MATH
+#define __METAL_MATH
+
+#include <metal_integer_math>
+#include <metal_math_utils>
+#include <metal_relational>
+
+namespace metal {
+// Metal 1.1 s5.5: Math Functions.
+
+
+namespace fast
+{
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T abs(T x)
+{
+  return __metal_fabs(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T acos(T x)
+{
+  return __metal_acos(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T acosh(T x)
+{
+  return __metal_acosh(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T asin(T x)
+{
+  return __metal_asin(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T asinh(T x)
+{
+  return __metal_asinh(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T atan(T y_over_x)
+{
+  return __metal_atan(y_over_x, _METAL_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O atan2(T y, U x)
+{
+  return __metal_atan2(_O(y), _O(x), _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T atanh(T x)
+{
+  return __metal_atanh(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T ceil(T x)
+{
+  return __metal_ceil(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cos(T x)
+{
+  return __metal_cos(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cosh(T x)
+{
+  return __metal_cosh(x, _METAL_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cospi(T x)
+{
+  return __metal_cospi(x, _METAL_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp(T x)
+{
+  return __metal_exp(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp10(T x)
+{
+  return __metal_exp10(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp2(T x)
+{
+  return __metal_exp2(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fabs(T x)
+{
+  return __metal_fabs(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T floor(T x)
+{
+  return __metal_floor(x, _METAL_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmax(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_FAST_MATH);
+}
+#if defined(__HAVE_FMAX3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmax3(T x, T y, T z)
+{
+  return __metal_fmax3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+#if defined(__HAVE_FMEDIAN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmedian3(T x, T y, T z)
+{
+  return __metal_fmedian3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmin(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_FAST_MATH);
+}
+#if defined(__HAVE_FMIN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmin3(T x, T y, T z)
+{
+  return __metal_fmin3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmod(T x, U y)
+{
+  return __metal_fmod(_O(x), _O(y), _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T log(T x)
+{
+  return __metal_log(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T log2(T x)
+{
+  return __metal_log2(x, _METAL_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O max(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_FAST_MATH);
+}
+#if defined(__HAVE_MAX3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T max3(T x, T y, T z)
+{
+  return __metal_fmax3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+#if defined(__HAVE_MEDIAN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T median3(T x, T y, T z)
+{
+  return __metal_fmedian3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O min(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_FAST_MATH);
+}
+#if defined(__HAVE_MIN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T min3(T x, T y, T z)
+{
+  return __metal_fmin3(x, y, z, _METAL_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O pow(T x, U y)
+{
+  return __metal_pow(_O(x), _O(y), _METAL_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O powr(T x, U y)
+{
+  return __metal_powr(_O(x), _O(y), _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T rint(T x)
+{
+  return __metal_rint(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T round(T x)
+{
+  return __metal_round(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T rsqrt(T x)
+{
+  return __metal_rsqrt(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sin(T x)
+{
+  return __metal_sin(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sinh(T x)
+{
+  return __metal_sinh(x, _METAL_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sinpi(T x)
+{
+  return __metal_sinpi(x, _METAL_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sqrt(T x)
+{
+  return __metal_sqrt(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tan(T x)
+{
+  return __metal_tan(x, _METAL_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tanh(T x)
+{
+  return __metal_tanh(x, _METAL_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tanpi(T x)
+{
+  return __metal_tanpi(x, _METAL_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T trunc(T x)
+{
+  return __metal_trunc(x, _METAL_FAST_MATH);
+}
+}  // namespace fast
+
+namespace precise
+{
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T abs(T x)
+{
+  return __metal_fabs(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T acos(T x)
+{
+  return __metal_acos(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T acosh(T x)
+{
+  return __metal_acosh(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T asin(T x)
+{
+  return __metal_asin(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T asinh(T x)
+{
+  return __metal_asinh(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T atan(T y_over_x)
+{
+  return __metal_atan(y_over_x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O atan2(T y, U x)
+{
+  return __metal_atan2(_O(y), _O(x), _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T atanh(T x)
+{
+  return __metal_atanh(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T ceil(T x)
+{
+  return __metal_ceil(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cos(T x)
+{
+  return __metal_cos(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cosh(T x)
+{
+  return __metal_cosh(x, _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T cospi(T x)
+{
+  return __metal_cospi(x, _METAL_PRECISE_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp(T x)
+{
+  return __metal_exp(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp10(T x)
+{
+  return __metal_exp10(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T exp2(T x)
+{
+  return __metal_exp2(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fabs(T x)
+{
+  return __metal_fabs(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T floor(T x)
+{
+  return __metal_floor(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmax(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_FMAX3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmax3(T x, T y, T z)
+{
+  return __metal_fmax3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+#if defined(__HAVE_FMEDIAN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmedian3(T x, T y, T z)
+{
+  return __metal_fmedian3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmin(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_FMIN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T fmin3(T x, T y, T z)
+{
+  return __metal_fmin3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O fmod(T x, U y)
+{
+  return __metal_fmod(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T log(T x)
+{
+  return __metal_log(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T log2(T x)
+{
+  return __metal_log2(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O max(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_MAX3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T max3(T x, T y, T z)
+{
+  return __metal_fmax3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+#if defined(__HAVE_MEDIAN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T median3(T x, T y, T z)
+{
+  return __metal_fmedian3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O min(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_MIN3__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T min3(T x, T y, T z)
+{
+  return __metal_fmin3(x, y, z, _METAL_PRECISE_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O pow(T x, U y)
+{
+  return __metal_pow(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_fast_or_precise_binary_func_enable<T, U>::value, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::type, typename _E = typename enable_if<is_same<float, make_scalar_t<_O>>::value>::type>
+METAL_FUNC _O powr(T x, U y)
+{
+  return __metal_powr(_O(x), _O(y), _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T rint(T x)
+{
+  return __metal_rint(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T round(T x)
+{
+  return __metal_round(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T rsqrt(T x)
+{
+  return __metal_rsqrt(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sin(T x)
+{
+  return __metal_sin(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sinh(T x)
+{
+  return __metal_sinh(x, _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sinpi(T x)
+{
+  return __metal_sinpi(x, _METAL_PRECISE_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T sqrt(T x)
+{
+  return __metal_sqrt(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tan(T x)
+{
+  return __metal_tan(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tanh(T x)
+{
+  return __metal_tanh(x, _METAL_PRECISE_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T tanpi(T x)
+{
+  return __metal_tanpi(x, _METAL_PRECISE_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_same<float, make_scalar_t<T>>::value>::type>
+METAL_FUNC T trunc(T x)
+{
+  return __metal_trunc(x, _METAL_PRECISE_MATH);
+}
+}  // namespace precise
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T abs(T x)
+{
+  return __metal_fabs(x, _METAL_PRECISE_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T acos(T x)
+{
+  return __metal_acos(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T acosh(T x)
+{
+  return __metal_acosh(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T asin(T x)
+{
+  return __metal_asin(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T asinh(T x)
+{
+  return __metal_asinh(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T atan(T y_over_x)
+{
+  return __metal_atan(y_over_x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O atan2(T y, U x)
+{
+  return __metal_atan2(_O(y), _O(x), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T atanh(T x)
+{
+  return __metal_atanh(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T ceil(T x)
+{
+  return __metal_ceil(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T cos(T x)
+{
+  return __metal_cos(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T cosh(T x)
+{
+  return __metal_cosh(x, _METAL_MAYBE_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T cospi(T x)
+{
+  return __metal_cospi(x, _METAL_MAYBE_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T exp(T x)
+{
+  return __metal_exp(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T exp10(T x)
+{
+  return __metal_exp10(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T exp2(T x)
+{
+  return __metal_exp2(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T fabs(T x)
+{
+  return __metal_fabs(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T floor(T x)
+{
+  return __metal_floor(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O fmax(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+#if defined(__HAVE_FMAX3__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T fmax3(T x, T y, T z)
+{
+  return __metal_fmax3(x, y, z, _METAL_MAYBE_FAST_MATH);
+}
+#endif
+#if defined(__HAVE_FMEDIAN3__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T fmedian3(T x, T y, T z)
+{
+  return __metal_fmedian3(x, y, z, _METAL_MAYBE_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O fmin(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+#if defined(__HAVE_FMIN3__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T fmin3(T x, T y, T z)
+{
+  return __metal_fmin3(x, y, z, _METAL_MAYBE_FAST_MATH);
+}
+#endif
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O fmod(T x, U y)
+{
+  return __metal_fmod(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T log(T x)
+{
+  return __metal_log(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T log2(T x)
+{
+  return __metal_log2(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O max(T x, U y)
+{
+  return __metal_fmax(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O min(T x, U y)
+{
+  return __metal_fmin(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O pow(T x, U y)
+{
+  return __metal_pow(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename U, typename _O = typename enable_if<_math_binary_func_enable<T, U>::value, _math_binary_func_operand_type_t<T, U>>::type>
+METAL_FUNC _O powr(T x, U y)
+{
+  return __metal_powr(_O(x), _O(y), _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T rint(T x)
+{
+  return __metal_rint(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T round(T x)
+{
+  return __metal_round(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T rsqrt(T x)
+{
+  return __metal_rsqrt(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T sin(T x)
+{
+  return __metal_sin(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T sinh(T x)
+{
+  return __metal_sinh(x, _METAL_MAYBE_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T sinpi(T x)
+{
+  return __metal_sinpi(x, _METAL_MAYBE_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T sqrt(T x)
+{
+  return __metal_sqrt(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T tan(T x)
+{
+  return __metal_tan(x, _METAL_MAYBE_FAST_MATH);
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T tanh(T x)
+{
+  return __metal_tanh(x, _METAL_MAYBE_FAST_MATH);
+}
+#if defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T tanpi(T x)
+{
+  return __metal_tanpi(x, _METAL_MAYBE_FAST_MATH);
+}
+#endif  // defined(__HAVE_TRIG_PI__)
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC T trunc(T x)
+{
+  return __metal_trunc(x, _METAL_MAYBE_FAST_MATH);
+}
+
+#define _AIR_PREFIX_half ""
+#if defined(__FAST_MATH__)
+#define _AIR_PREFIX_float "fast_"
+#else
+#define _AIR_PREFIX_float ""
+#endif
+#define _AIR_PREFIX_double ""
+
+  // Forward declaration of some functions implemented in metal
+  // namespace and called directly by corresponding functions in
+  // fast and precise namespaces directly i.e. copysign in fast
+  // and precise namespaces call metal::copysign.
+  METAL_FUNC half copysign(half, half);
+  METAL_FUNC half fdim(half, half);
+  METAL_FUNC half frexp(half, thread int&);
+  METAL_FUNC int ilogb(half);
+  METAL_FUNC half ldexp(half, int);
+  METAL_FUNC half modf(half, thread half&);
+  METAL_FUNC float copysign(float, float);
+  METAL_FUNC float fdim(float, float);
+  METAL_FUNC float frexp(float, thread int&);
+  METAL_FUNC int ilogb(float);
+  METAL_FUNC float ldexp(float, int);
+  METAL_FUNC float modf(float, thread float&);
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  METAL_FUNC double copysign(double, double);
+  METAL_FUNC double fdim(double, double);
+  METAL_FUNC double frexp(double, thread int&);
+  METAL_FUNC int ilogb(double);
+  METAL_FUNC double ldexp(double, int);
+  METAL_FUNC double modf(double, thread double&);
+#endif
+  METAL_FUNC vec<half,2> copysign(vec<half,2>, vec<half,2>);
+  METAL_FUNC vec<half,2> fdim(vec<half,2>, vec<half,2>);
+  METAL_FUNC vec<half,2> frexp(vec<half,2>, thread vec<int,2>&);
+  METAL_FUNC vec<int,2> ilogb(vec<half,2>);
+  METAL_FUNC vec<half,2> ldexp(vec<half,2>, vec<int,2>);
+  METAL_FUNC vec<half,2> modf(vec<half,2>, thread vec<half,2>&);
+  METAL_FUNC vec<float,2> copysign(vec<float,2>, vec<float,2>);
+  METAL_FUNC vec<float,2> fdim(vec<float,2>, vec<float,2>);
+  METAL_FUNC vec<float,2> frexp(vec<float,2>, thread vec<int,2>&);
+  METAL_FUNC vec<int,2> ilogb(vec<float,2>);
+  METAL_FUNC vec<float,2> ldexp(vec<float,2>, vec<int,2>);
+  METAL_FUNC vec<float,2> modf(vec<float,2>, thread vec<float,2>&);
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  METAL_FUNC vec<double,2> copysign(vec<double,2>, vec<double,2>);
+  METAL_FUNC vec<double,2> fdim(vec<double,2>, vec<double,2>);
+  METAL_FUNC vec<double,2> frexp(vec<double,2>, thread vec<int,2>&);
+  METAL_FUNC vec<int,2> ilogb(vec<double,2>);
+  METAL_FUNC vec<double,2> ldexp(vec<double,2>, vec<int,2>);
+  METAL_FUNC vec<double,2> modf(vec<double,2>, thread vec<double,2>&);
+#endif
+  METAL_FUNC vec<half,3> copysign(vec<half,3>, vec<half,3>);
+  METAL_FUNC vec<half,3> fdim(vec<half,3>, vec<half,3>);
+  METAL_FUNC vec<half,3> frexp(vec<half,3>, thread vec<int,3>&);
+  METAL_FUNC vec<int,3> ilogb(vec<half,3>);
+  METAL_FUNC vec<half,3> ldexp(vec<half,3>, vec<int,3>);
+  METAL_FUNC vec<half,3> modf(vec<half,3>, thread vec<half,3>&);
+  METAL_FUNC vec<float,3> copysign(vec<float,3>, vec<float,3>);
+  METAL_FUNC vec<float,3> fdim(vec<float,3>, vec<float,3>);
+  METAL_FUNC vec<float,3> frexp(vec<float,3>, thread vec<int,3>&);
+  METAL_FUNC vec<int,3> ilogb(vec<float,3>);
+  METAL_FUNC vec<float,3> ldexp(vec<float,3>, vec<int,3>);
+  METAL_FUNC vec<float,3> modf(vec<float,3>, thread vec<float,3>&);
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  METAL_FUNC vec<double,3> copysign(vec<double,3>, vec<double,3>);
+  METAL_FUNC vec<double,3> fdim(vec<double,3>, vec<double,3>);
+  METAL_FUNC vec<double,3> frexp(vec<double,3>, thread vec<int,3>&);
+  METAL_FUNC vec<int,3> ilogb(vec<double,3>);
+  METAL_FUNC vec<double,3> ldexp(vec<double,3>, vec<int,3>);
+  METAL_FUNC vec<double,3> modf(vec<double,3>, thread vec<double,3>&);
+#endif
+  METAL_FUNC vec<half,4> copysign(vec<half,4>, vec<half,4>);
+  METAL_FUNC vec<half,4> fdim(vec<half,4>, vec<half,4>);
+  METAL_FUNC vec<half,4> frexp(vec<half,4>, thread vec<int,4>&);
+  METAL_FUNC vec<int,4> ilogb(vec<half,4>);
+  METAL_FUNC vec<half,4> ldexp(vec<half,4>, vec<int,4>);
+  METAL_FUNC vec<half,4> modf(vec<half,4>, thread vec<half,4>&);
+  METAL_FUNC vec<float,4> copysign(vec<float,4>, vec<float,4>);
+  METAL_FUNC vec<float,4> fdim(vec<float,4>, vec<float,4>);
+  METAL_FUNC vec<float,4> frexp(vec<float,4>, thread vec<int,4>&);
+  METAL_FUNC vec<int,4> ilogb(vec<float,4>);
+  METAL_FUNC vec<float,4> ldexp(vec<float,4>, vec<int,4>);
+  METAL_FUNC vec<float,4> modf(vec<float,4>, thread vec<float,4>&);
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  METAL_FUNC vec<double,4> copysign(vec<double,4>, vec<double,4>);
+  METAL_FUNC vec<double,4> fdim(vec<double,4>, vec<double,4>);
+  METAL_FUNC vec<double,4> frexp(vec<double,4>, thread vec<int,4>&);
+  METAL_FUNC vec<int,4> ilogb(vec<double,4>);
+  METAL_FUNC vec<double,4> ldexp(vec<double,4>, vec<int,4>);
+  METAL_FUNC vec<double,4> modf(vec<double,4>, thread vec<double,4>&);
+#endif
+
+namespace fast {
+  // Forward declarations
+  METAL_FUNC float copysign(float x, float y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM float fma(float a, float b, float c) __asm("air.fma.f32");
+#endif
+
+  METAL_ASM float fract(float x) __asm("air.fast_fract.f32");
+
+  METAL_FUNC float frexp(float x, thread int &exp) {
+    return metal::frexp(x, exp);
+  }
+  METAL_FUNC int ilogb(float x) {
+    return metal::ilogb(x);
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM float ldexp(float x, int k) __asm("air.fast_ldexp.f32");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC float ldexp(float x, int k) {
+    return metal::ldexp(x, k);
+  }
+#endif
+  METAL_FUNC float fdim(float x, float y) {
+    return metal::fdim(x, y);
+  }
+  METAL_ASM float log10(float x) __asm("air.fast_log10.f32");
+
+  METAL_FUNC float modf(float x, thread float &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM float sincos(float x, thread float &cosval) __asm("air.fast_sincos.f32");
+
+  //METAL_ASM float trunc(float x) __asm("air.fast_trunc.f32");
+  // Forward declarations
+  METAL_FUNC vec<float,2> copysign(vec<float,2> x, vec<float,2> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,2> fma(vec<float,2> a, vec<float,2> b, vec<float,2> c) __asm("air.fma.v2f32");
+#endif
+
+  METAL_FUNC vec<float,2> frexp(vec<float,2> x, thread vec<int,2> &exponent) {
+    int temp_exponent;
+    vec<float,2> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,2> ilogb(vec<float,2> x) {
+    vec<int,2> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) __asm("air.fast_ldexp.v2f32");
+#else
+  METAL_FUNC vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) {
+    vec<float,2> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,2> fdim(vec<float,2> x, vec<float,2> y) {
+    vec<float,2> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,2> fract(vec<float,2> x) __asm("air.fast_fract.v2f32");
+#else
+  METAL_FUNC vec<float,2> fract(vec<float,2> x) {
+    vec<float,2> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,2> log10(vec<float,2> x) __asm("air.fast_log10.v2f32");
+
+  METAL_FUNC vec<float,2> modf(vec<float,2> x, thread vec<float,2> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,2> sincos(vec<float,2> x, thread vec<float,2> &cosval) __asm("air.fast_sincos.v2f32");
+
+  //METAL_ASM vec<float,2> trunc(vec<float,2> x) __asm("air.fast_trunc.v2f32");
+  // Forward declarations
+  METAL_FUNC vec<float,3> copysign(vec<float,3> x, vec<float,3> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,3> fma(vec<float,3> a, vec<float,3> b, vec<float,3> c) __asm("air.fma.v3f32");
+#endif
+
+  METAL_FUNC vec<float,3> frexp(vec<float,3> x, thread vec<int,3> &exponent) {
+    int temp_exponent;
+    vec<float,3> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,3> ilogb(vec<float,3> x) {
+    vec<int,3> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) __asm("air.fast_ldexp.v3f32");
+#else
+  METAL_FUNC vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) {
+    vec<float,3> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,3> fdim(vec<float,3> x, vec<float,3> y) {
+    vec<float,3> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,3> fract(vec<float,3> x) __asm("air.fast_fract.v3f32");
+#else
+  METAL_FUNC vec<float,3> fract(vec<float,3> x) {
+    vec<float,3> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,3> log10(vec<float,3> x) __asm("air.fast_log10.v3f32");
+
+  METAL_FUNC vec<float,3> modf(vec<float,3> x, thread vec<float,3> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,3> sincos(vec<float,3> x, thread vec<float,3> &cosval) __asm("air.fast_sincos.v3f32");
+
+  //METAL_ASM vec<float,3> trunc(vec<float,3> x) __asm("air.fast_trunc.v3f32");
+  // Forward declarations
+  METAL_FUNC vec<float,4> copysign(vec<float,4> x, vec<float,4> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,4> fma(vec<float,4> a, vec<float,4> b, vec<float,4> c) __asm("air.fma.v4f32");
+#endif
+
+  METAL_FUNC vec<float,4> frexp(vec<float,4> x, thread vec<int,4> &exponent) {
+    int temp_exponent;
+    vec<float,4> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    ret_val[3] = frexp(x[3], temp_exponent);
+    exponent[3] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,4> ilogb(vec<float,4> x) {
+    vec<int,4> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    ret_val[3] = ilogb(x[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) __asm("air.fast_ldexp.v4f32");
+#else
+  METAL_FUNC vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) {
+    vec<float,4> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    ret_val[3] = ldexp(x[3], k[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,4> fdim(vec<float,4> x, vec<float,4> y) {
+    vec<float,4> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    ret_val[3] = fdim(x[3], y[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,4> fract(vec<float,4> x) __asm("air.fast_fract.v4f32");
+#else
+  METAL_FUNC vec<float,4> fract(vec<float,4> x) {
+    vec<float,4> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    ret_val[3] = fract(x[3]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,4> log10(vec<float,4> x) __asm("air.fast_log10.v4f32");
+
+  METAL_FUNC vec<float,4> modf(vec<float,4> x, thread vec<float,4> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,4> sincos(vec<float,4> x, thread vec<float,4> &cosval) __asm("air.fast_sincos.v4f32");
+
+  //METAL_ASM vec<float,4> trunc(vec<float,4> x) __asm("air.fast_trunc.v4f32");
+} // namespace fast
+
+namespace precise {
+  // Forward declarations
+  METAL_FUNC float copysign(float x, float y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM float fma(float a, float b, float c) __asm("air.fma.f32");
+#endif
+
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM float fract(float x) __asm("air.fract.f32");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC float fract(float x) {
+    if (metal::isinf(x))
+      return float(0);
+    if (metal::isnan(x))
+      return x;
+    return fmin(x - floor(x), float(0x1.fffffep-1));
+  }
+#endif
+
+  METAL_FUNC float frexp(float x, thread int &exp) {
+    return metal::frexp(x, exp);
+  }
+  METAL_FUNC int ilogb(float x) {
+    return metal::ilogb(x);
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM float ldexp(float x, int k) __asm("air.ldexp.f32");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC float ldexp(float x, int k) {
+    return metal::ldexp(x, k);
+  }
+#endif
+  METAL_FUNC float fdim(float x, float y) {
+    return metal::fdim(x, y);
+  }
+  METAL_ASM float log10(float x) __asm("air.log10.f32");
+
+  METAL_FUNC float modf(float x, thread float &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM float sincos(float x, thread float &cosval) __asm("air.sincos.f32");
+
+  //METAL_ASM float trunc(float x) __asm("air.trunc.f32");
+  // Forward declarations
+  METAL_FUNC vec<float,2> copysign(vec<float,2> x, vec<float,2> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,2> fma(vec<float,2> a, vec<float,2> b, vec<float,2> c) __asm("air.fma.v2f32");
+#endif
+
+  METAL_FUNC vec<float,2> frexp(vec<float,2> x, thread vec<int,2> &exponent) {
+    int temp_exponent;
+    vec<float,2> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,2> ilogb(vec<float,2> x) {
+    vec<int,2> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) __asm("air.ldexp.v2f32");
+#else
+  METAL_FUNC vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) {
+    vec<float,2> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,2> fdim(vec<float,2> x, vec<float,2> y) {
+    vec<float,2> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,2> fract(vec<float,2> x) __asm("air.fract.v2f32");
+#else
+  METAL_FUNC vec<float,2> fract(vec<float,2> x) {
+    vec<float,2> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,2> log10(vec<float,2> x) __asm("air.log10.v2f32");
+
+  METAL_FUNC vec<float,2> modf(vec<float,2> x, thread vec<float,2> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,2> sincos(vec<float,2> x, thread vec<float,2> &cosval) __asm("air.sincos.v2f32");
+
+  //METAL_ASM vec<float,2> trunc(vec<float,2> x) __asm("air.trunc.v2f32");
+  // Forward declarations
+  METAL_FUNC vec<float,3> copysign(vec<float,3> x, vec<float,3> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,3> fma(vec<float,3> a, vec<float,3> b, vec<float,3> c) __asm("air.fma.v3f32");
+#endif
+
+  METAL_FUNC vec<float,3> frexp(vec<float,3> x, thread vec<int,3> &exponent) {
+    int temp_exponent;
+    vec<float,3> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,3> ilogb(vec<float,3> x) {
+    vec<int,3> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) __asm("air.ldexp.v3f32");
+#else
+  METAL_FUNC vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) {
+    vec<float,3> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,3> fdim(vec<float,3> x, vec<float,3> y) {
+    vec<float,3> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,3> fract(vec<float,3> x) __asm("air.fract.v3f32");
+#else
+  METAL_FUNC vec<float,3> fract(vec<float,3> x) {
+    vec<float,3> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,3> log10(vec<float,3> x) __asm("air.log10.v3f32");
+
+  METAL_FUNC vec<float,3> modf(vec<float,3> x, thread vec<float,3> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,3> sincos(vec<float,3> x, thread vec<float,3> &cosval) __asm("air.sincos.v3f32");
+
+  //METAL_ASM vec<float,3> trunc(vec<float,3> x) __asm("air.trunc.v3f32");
+  // Forward declarations
+  METAL_FUNC vec<float,4> copysign(vec<float,4> x, vec<float,4> y) {
+    return metal::copysign(x, y);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,4> fma(vec<float,4> a, vec<float,4> b, vec<float,4> c) __asm("air.fma.v4f32");
+#endif
+
+  METAL_FUNC vec<float,4> frexp(vec<float,4> x, thread vec<int,4> &exponent) {
+    int temp_exponent;
+    vec<float,4> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    ret_val[3] = frexp(x[3], temp_exponent);
+    exponent[3] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,4> ilogb(vec<float,4> x) {
+    vec<int,4> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    ret_val[3] = ilogb(x[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) __asm("air.ldexp.v4f32");
+#else
+  METAL_FUNC vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) {
+    vec<float,4> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    ret_val[3] = ldexp(x[3], k[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,4> fdim(vec<float,4> x, vec<float,4> y) {
+    vec<float,4> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    ret_val[3] = fdim(x[3], y[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,4> fract(vec<float,4> x) __asm("air.fract.v4f32");
+#else
+  METAL_FUNC vec<float,4> fract(vec<float,4> x) {
+    vec<float,4> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    ret_val[3] = fract(x[3]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<float,4> log10(vec<float,4> x) __asm("air.log10.v4f32");
+
+  METAL_FUNC vec<float,4> modf(vec<float,4> x, thread vec<float,4> &intval) {
+    return metal::modf(x, intval);
+  }
+  METAL_ASM vec<float,4> sincos(vec<float,4> x, thread vec<float,4> &cosval) __asm("air.sincos.v4f32");
+
+  //METAL_ASM vec<float,4> trunc(vec<float,4> x) __asm("air.trunc.v4f32");
+} // namespace precise
+
+  // Forward declarations
+  METAL_FUNC half copysign(half x, half y) {
+    ushort iy = as_type<ushort>(y) & (ushort)(0x8000);
+    ushort ret = (as_type<ushort>(x) & (ushort)(0x8000 - 1ULL)) | iy;
+    return as_type<half>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM half fma(half a, half b, half c) __asm("air.fma.f16");
+#endif
+
+  METAL_ASM half fract(half x) __asm("air.fract.f16");
+
+  METAL_FUNC half frexp(half x, thread int &exp) {
+  if ((as_type<ushort>(x) & (ushort)(0x7c00)) == (ushort)(0x7c00)) {
+    exp = 0;
+    return x;
+  }
+
+  // This will evaluate to true on G3 for denorms
+  if (x == 0.0f) {
+    exp = 0;
+    return 0.0f;
+  }
+
+  ushort xi = as_type<ushort>(x);
+  int e = (xi & 0x7c00) >> 10;
+  // subnormal
+  if (e == 0) {
+    // subnormal mantissa + 1.0f
+    half t = as_type<half>((ushort)((xi & (ushort)0x03ff) | (ushort)0x3c00));
+    t = t - 1.0f;
+    xi = as_type<ushort>(copysign(t, x));
+    e = -14 + ((xi & 0x7c00) >> 10);
+  }
+
+  e -= 14;
+  exp = e;
+  return as_type<half>((ushort)((xi & (0x8000 | 0x03ff)) | 0x3800));
+  }
+  METAL_FUNC int ilogb(half x) {
+    ushort ux = as_type<ushort>(x) & (ushort)(0x7fff);
+    short exp = ux >> (ushort)(10);
+
+    if(((uint)(exp) - (uint)(1)) >= (uint)(30)) {
+      // +-0, +-denormal, +-inf, NaN
+      if(x == half(0))
+        return FP_ILOGB0;
+
+      if(metal::isnan(x))
+        return FP_ILOGBNAN;
+
+      if(ux == (ushort)(0x7c00))
+        return INT_MAX;
+
+      ux |= (ushort)(0x3c00);
+      half f = as_type<half>(ux) - half(1);
+      exp = as_type<ushort>(f) >> (ushort)(10);
+
+      return exp - short(15 + 14);
+    }
+
+    return exp - short(15);
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM half ldexp(half x, int k) __asm("air." _AIR_PREFIX_half "ldexp.f16");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC half ldexp(half x, int k) {
+    if (x==0.0f) return 0.0f;
+    ushort ux = as_type<ushort>(x);
+    int exp = (ux & (ushort)(0x7c00)) >> 10;
+    ushort sign = ux & (ushort)(0x8000);
+    ushort m = ux & (~(ushort)(0x7c00));
+
+    // If inf or nan
+    if (exp == ((ushort)(0x7c00) >> 10))
+    return x;
+
+  // if k > (power of minimum subnormal + max exponent), simply return inf of same sign
+  if (k > (30 + 10 + 14))
+    return as_type<half>((ushort)(0x7c00 | sign));
+
+  // subnormal
+  if (exp == 0) {
+    half t = as_type<half>((ushort)(m | 0x3c00));
+    x = t - copysign(half(1), x);
+    ux = as_type<ushort>(x);
+    exp = ((ux & (ushort)(0x7c00)) >> 10) - (14);
+    m = ux & (~(ushort)(0x7c00));
+  }
+
+  int e = (int)(exp) + k;
+  if (e >= (30+1)) // return inf of same sign as x
+    return as_type<half>((ushort)((ushort)(0x7c00) | sign));
+
+  if (e <= 0) // return 0.0f of same sign as x
+    return as_type<half>((ushort)((ushort)(0) | sign));
+
+  return as_type<half>((ushort)(m | ((ushort)(e) << 10)));
+  }
+#endif
+  METAL_FUNC half fdim(half x, half y) {
+    bool xNan = x != x;
+    bool yNan = y != y;
+    if (xNan || yNan)
+      return as_type<half>((ushort)0x7e00);
+
+    half t = x - y;
+
+    // When either x or y are nan, t is nan and t < 0 evaluate to false
+    // When x == y == +/-INFINITY, t is nan but x == y evaluate to true.
+    return select(t, half(0), bool(t < half(0)) || bool(x == y));
+  }
+  METAL_ASM half log10(half x) __asm("air.log10.f16");
+
+  METAL_FUNC half modf(half x, thread half &intval) {
+    intval = trunc(x);
+    bool isinf_x = isinf(x);
+    return copysign(select(x - intval, half(0), isinf_x), x);
+  }
+  METAL_ASM half sincos(half x, thread half &cosval) __asm("air." _AIR_PREFIX_half "sincos.f16");
+
+  //METAL_ASM half trunc(half x) __asm("air." _AIR_PREFIX_half "trunc.f16");
+  // Forward declarations
+  METAL_FUNC float copysign(float x, float y) {
+    uint iy = as_type<uint>(y) & (uint)(0x80000000);
+    uint ret = (as_type<uint>(x) & (uint)(0x80000000 - 1ULL)) | iy;
+    return as_type<float>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM float fma(float a, float b, float c) __asm("air.fma.f32");
+#endif
+
+  METAL_FUNC float fract(float x) {
+#if defined(__FAST_MATH__)
+    return fast::fract(x);
+#else
+    return precise::fract(x);
+#endif
+  }
+
+  METAL_FUNC float frexp(float x, thread int &exp) {
+  if ((as_type<uint>(x) & (uint)(0x7f800000)) == (uint)(0x7f800000)) {
+    exp = 0;
+    return x;
+  }
+
+  // This will evaluate to true on G3 for denorms
+  if (x == 0.0f) {
+    exp = 0;
+    return 0.0f;
+  }
+
+  uint xi = as_type<uint>(x);
+  int e = (xi & 0x7f800000) >> 23;
+  // subnormal
+  if (e == 0) {
+    // subnormal mantissa + 1.0f
+    float t = as_type<float>((uint)((xi & (uint)0x007fffff) | (uint)0x3f800000));
+    t = t - 1.0f;
+    xi = as_type<uint>(copysign(t, x));
+    e = -126 + ((xi & 0x7f800000) >> 23);
+  }
+
+  e -= 126;
+  exp = e;
+  return as_type<float>((uint)((xi & (0x80000000 | 0x007fffff)) | 0x3f000000));
+  }
+  METAL_FUNC int ilogb(float x) {
+    uint ux = as_type<uint>(x) & (uint)(0x7fffffff);
+    int exp = ux >> (uint)(23);
+
+    if(((uint)(exp) - (uint)(1)) >= (uint)(254)) {
+      // +-0, +-denormal, +-inf, NaN
+      if(x == float(0))
+        return FP_ILOGB0;
+
+      if(metal::isnan(x))
+        return FP_ILOGBNAN;
+
+      if(ux == (uint)(0x7f800000))
+        return INT_MAX;
+
+      ux |= (uint)(0x3f800000);
+      float f = as_type<float>(ux) - float(1);
+      exp = as_type<uint>(f) >> (uint)(23);
+
+      return exp - int(127 + 126);
+    }
+
+    return exp - int(127);
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM float ldexp(float x, int k) __asm("air." _AIR_PREFIX_float "ldexp.f32");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC float ldexp(float x, int k) {
+    if (x==0.0f) return 0.0f;
+    uint ux = as_type<uint>(x);
+    int exp = (ux & (uint)(0x7f800000)) >> 23;
+    uint sign = ux & (uint)(0x80000000);
+    uint m = ux & (~(uint)(0x7f800000));
+
+    // If inf or nan
+    if (exp == ((uint)(0x7f800000) >> 23))
+    return x;
+
+  // if k > (power of minimum subnormal + max exponent), simply return inf of same sign
+  if (k > (254 + 23 + 126))
+    return as_type<float>((uint)(0x7f800000 | sign));
+
+  // subnormal
+  if (exp == 0) {
+    float t = as_type<float>((uint)(m | 0x3f800000));
+    x = t - copysign(float(1), x);
+    ux = as_type<uint>(x);
+    exp = ((ux & (uint)(0x7f800000)) >> 23) - (126);
+    m = ux & (~(uint)(0x7f800000));
+  }
+
+  int e = (int)(exp) + k;
+  if (e >= (254+1)) // return inf of same sign as x
+    return as_type<float>((uint)((uint)(0x7f800000) | sign));
+
+  if (e <= 0) // return 0.0f of same sign as x
+    return as_type<float>((uint)((uint)(0) | sign));
+
+  return as_type<float>((uint)(m | ((uint)(e) << 23)));
+  }
+#endif
+  METAL_FUNC float fdim(float x, float y) {
+    bool xNan = x != x;
+    bool yNan = y != y;
+    if (xNan || yNan)
+      return as_type<float>(0x7fc00000);
+
+    float t = x - y;
+
+    // When either x or y are nan, t is nan and t < 0 evaluate to false
+    // When x == y == +/-INFINITY, t is nan but x == y evaluate to true.
+    return select(t, float(0), bool(t < float(0)) || bool(x == y));
+  }
+  METAL_FUNC float log10(float x) {
+#if defined(__FAST_MATH__)
+    return fast::log10(x);
+#else
+    return precise::log10(x);
+#endif
+  }
+
+  METAL_FUNC float modf(float x, thread float &intval) {
+    intval = trunc(x);
+    bool isinf_x = isinf(x);
+    return copysign(select(x - intval, float(0), isinf_x), x);
+  }
+  METAL_ASM float sincos(float x, thread float &cosval) __asm("air." _AIR_PREFIX_float "sincos.f32");
+
+  //METAL_ASM float trunc(float x) __asm("air." _AIR_PREFIX_float "trunc.f32");
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  // Forward declarations
+  METAL_FUNC double copysign(double x, double y) {
+    unsigned __metal_internal_int64_t iy = as_type<unsigned __metal_internal_int64_t>(y) & (unsigned __metal_internal_int64_t)(0x8000000000000000);
+    unsigned __metal_internal_int64_t ret = (as_type<unsigned __metal_internal_int64_t>(x) & (unsigned __metal_internal_int64_t)(0x8000000000000000 - 1ULL)) | iy;
+    return as_type<double>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM double fma(double a, double b, double c) __asm("air.fma.f64");
+#endif
+
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM double fract(double x) __asm("air." _AIR_PREFIX_double "fract.f64");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC double fract(double x) {
+    if (metal::isinf(x))
+      return double(0);
+    if (metal::isnan(x))
+      return x;
+    return fmin(x - floor(x), double(0x1.fffffep-1));
+  }
+#endif
+
+  METAL_FUNC double frexp(double x, thread int &exp) {
+  if ((as_type<unsigned __metal_internal_int64_t>(x) & (unsigned __metal_internal_int64_t)(0x7ff0000000000000)) == (unsigned __metal_internal_int64_t)(0x7ff0000000000000)) {
+    exp = 0;
+    return x;
+  }
+
+  // This will evaluate to true on G3 for denorms
+  if (x == 0.0f) {
+    exp = 0;
+    return 0.0f;
+  }
+
+  unsigned __metal_internal_int64_t xi = as_type<unsigned __metal_internal_int64_t>(x);
+  int e = (xi & 0x7ff0000000000000) >> 52;
+  // subnormal
+  if (e == 0) {
+    // subnormal mantissa + 1.0f
+    double t = as_type<double>((unsigned __metal_internal_int64_t)((xi & (unsigned __metal_internal_int64_t)0x000fffffffffffff) | (unsigned __metal_internal_int64_t)0x3ff0000000000000));
+    t = t - 1.0f;
+    xi = as_type<unsigned __metal_internal_int64_t>(copysign(t, x));
+    e = -1022 + ((xi & 0x7ff0000000000000) >> 52);
+  }
+
+  e -= 1022;
+  exp = e;
+  return as_type<double>((unsigned __metal_internal_int64_t)((xi & (0x8000000000000000 | 0x000fffffffffffff)) | 0x3fe0000000000000));
+  }
+  METAL_FUNC int ilogb(double x) {
+    unsigned __metal_internal_int64_t ux = as_type<unsigned __metal_internal_int64_t>(x) & (unsigned __metal_internal_int64_t)(0x7fffffffffffffff);
+    __metal_internal_int64_t exp = ux >> (unsigned __metal_internal_int64_t)(52);
+
+    if(((unsigned __metal_internal_int64_t)(exp) - (unsigned __metal_internal_int64_t)(1)) >= (unsigned __metal_internal_int64_t)(2046)) {
+      // +-0, +-denormal, +-inf, NaN
+      if(x == double(0))
+        return FP_ILOGB0;
+
+      if(metal::isnan(x))
+        return FP_ILOGBNAN;
+
+      if(ux == (unsigned __metal_internal_int64_t)(0x7ff0000000000000))
+        return INT_MAX;
+
+      ux |= (unsigned __metal_internal_int64_t)(0x3ff0000000000000);
+      double f = as_type<double>(ux) - double(1);
+      exp = as_type<unsigned __metal_internal_int64_t>(f) >> (unsigned __metal_internal_int64_t)(52);
+
+      return exp - __metal_internal_int64_t(1023 + 1022);
+    }
+
+    return exp - __metal_internal_int64_t(1023);
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM double ldexp(double x, int k) __asm("air." _AIR_PREFIX_double "ldexp.f64");
+#else
+  //TODO: <rdar://problem/20022019> fract and ldexp should call air function/builtins
+  METAL_FUNC double ldexp(double x, int k) {
+    if (x==0.0f) return 0.0f;
+    unsigned __metal_internal_int64_t ux = as_type<unsigned __metal_internal_int64_t>(x);
+    int exp = (ux & (unsigned __metal_internal_int64_t)(0x7ff0000000000000)) >> 52;
+    unsigned __metal_internal_int64_t sign = ux & (unsigned __metal_internal_int64_t)(0x8000000000000000);
+    unsigned __metal_internal_int64_t m = ux & (~(unsigned __metal_internal_int64_t)(0x7ff0000000000000));
+
+    // If inf or nan
+    if (exp == ((unsigned __metal_internal_int64_t)(0x7ff0000000000000) >> 52))
+    return x;
+
+  // if k > (power of minimum subnormal + max exponent), simply return inf of same sign
+  if (k > (2046 + 52 + 1022))
+    return as_type<double>((unsigned __metal_internal_int64_t)(0x7ff0000000000000 | sign));
+
+  // subnormal
+  if (exp == 0) {
+    double t = as_type<double>((unsigned __metal_internal_int64_t)(m | 0x3ff0000000000000));
+    x = t - copysign(double(1), x);
+    ux = as_type<unsigned __metal_internal_int64_t>(x);
+    exp = ((ux & (unsigned __metal_internal_int64_t)(0x7ff0000000000000)) >> 52) - (1022);
+    m = ux & (~(unsigned __metal_internal_int64_t)(0x7ff0000000000000));
+  }
+
+  int e = (int)(exp) + k;
+  if (e >= (2046+1)) // return inf of same sign as x
+    return as_type<double>((unsigned __metal_internal_int64_t)((unsigned __metal_internal_int64_t)(0x7ff0000000000000) | sign));
+
+  if (e <= 0) // return 0.0f of same sign as x
+    return as_type<double>((unsigned __metal_internal_int64_t)((unsigned __metal_internal_int64_t)(0) | sign));
+
+  return as_type<double>((unsigned __metal_internal_int64_t)(m | ((unsigned __metal_internal_int64_t)(e) << 52)));
+  }
+#endif
+  METAL_FUNC double fdim(double x, double y) {
+    bool xNan = x != x;
+    bool yNan = y != y;
+    if (xNan || yNan)
+      return as_type<double>(0x7ff8000000000000);
+
+    double t = x - y;
+
+    // When either x or y are nan, t is nan and t < 0 evaluate to false
+    // When x == y == +/-INFINITY, t is nan but x == y evaluate to true.
+    return select(t, double(0), bool(t < double(0)) || bool(x == y));
+  }
+  METAL_ASM double log10(double x) __asm("air.log10.f64");
+
+  METAL_FUNC double modf(double x, thread double &intval) {
+    intval = trunc(x);
+    bool isinf_x = isinf(x);
+    return copysign(select(x - intval, double(0), isinf_x), x);
+  }
+  METAL_ASM double sincos(double x, thread double &cosval) __asm("air." _AIR_PREFIX_double "sincos.f64");
+
+  //METAL_ASM double trunc(double x) __asm("air." _AIR_PREFIX_double "trunc.f64");
+#endif
+  // Forward declarations
+  METAL_FUNC vec<half,2> copysign(vec<half,2> x, vec<half,2> y) {
+    vec<ushort,2> iy = as_type<vec<ushort,2>>(y) & (vec<ushort,2>)(0x8000);
+    vec<ushort,2> ret = (as_type<vec<ushort,2>>(x) & (vec<ushort,2>)(0x8000 - 1ULL)) | iy;
+    return as_type<vec<half,2>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<half,2> fma(vec<half,2> a, vec<half,2> b, vec<half,2> c) __asm("air.fma.v2f16");
+#endif
+
+  METAL_FUNC vec<half,2> frexp(vec<half,2> x, thread vec<int,2> &exponent) {
+    int temp_exponent;
+    vec<half,2> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,2> ilogb(vec<half,2> x) {
+    vec<int,2> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<half,2> ldexp(vec<half,2> x, vec<int,2> k) __asm("air." _AIR_PREFIX_half "ldexp.v2f16");
+#else
+  METAL_FUNC vec<half,2> ldexp(vec<half,2> x, vec<int,2> k) {
+    vec<half,2> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<half,2> fdim(vec<half,2> x, vec<half,2> y) {
+    vec<half,2> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<half,2> fract(vec<half,2> x) __asm("air." _AIR_PREFIX_half "fract.v2f16");
+#else
+  METAL_FUNC vec<half,2> fract(vec<half,2> x) {
+    vec<half,2> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<half,2> log10(vec<half,2> x) __asm("air.log10.v2f16");
+
+  METAL_FUNC vec<half,2> modf(vec<half,2> x, thread vec<half,2> &intval) {
+    intval = trunc(x);
+    vec<bool,2> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<half,2>(0), isinf_x), x);
+  }
+  METAL_ASM vec<half,2> sincos(vec<half,2> x, thread vec<half,2> &cosval) __asm("air." _AIR_PREFIX_half "sincos.v2f16");
+
+  //METAL_ASM vec<half,2> trunc(vec<half,2> x) __asm("air." _AIR_PREFIX_half "trunc.v2f16");
+  // Forward declarations
+  METAL_FUNC vec<float,2> copysign(vec<float,2> x, vec<float,2> y) {
+    vec<uint,2> iy = as_type<vec<uint,2>>(y) & (vec<uint,2>)(0x80000000);
+    vec<uint,2> ret = (as_type<vec<uint,2>>(x) & (vec<uint,2>)(0x80000000 - 1ULL)) | iy;
+    return as_type<vec<float,2>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,2> fma(vec<float,2> a, vec<float,2> b, vec<float,2> c) __asm("air.fma.v2f32");
+#endif
+
+  METAL_FUNC vec<float,2> frexp(vec<float,2> x, thread vec<int,2> &exponent) {
+    int temp_exponent;
+    vec<float,2> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,2> ilogb(vec<float,2> x) {
+    vec<int,2> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) __asm("air." _AIR_PREFIX_float "ldexp.v2f32");
+#else
+  METAL_FUNC vec<float,2> ldexp(vec<float,2> x, vec<int,2> k) {
+    vec<float,2> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,2> fdim(vec<float,2> x, vec<float,2> y) {
+    vec<float,2> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,2> fract(vec<float,2> x) __asm("air." _AIR_PREFIX_float "fract.v2f32");
+#else
+  METAL_FUNC vec<float,2> fract(vec<float,2> x) {
+    vec<float,2> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,2> log10(vec<float,2> x) {
+#if defined(__FAST_MATH__)
+    return fast::log10(x);
+#else
+    return precise::log10(x);
+#endif
+  }
+
+  METAL_FUNC vec<float,2> modf(vec<float,2> x, thread vec<float,2> &intval) {
+    intval = trunc(x);
+    vec<bool,2> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<float,2>(0), isinf_x), x);
+  }
+  METAL_ASM vec<float,2> sincos(vec<float,2> x, thread vec<float,2> &cosval) __asm("air." _AIR_PREFIX_float "sincos.v2f32");
+
+  //METAL_ASM vec<float,2> trunc(vec<float,2> x) __asm("air." _AIR_PREFIX_float "trunc.v2f32");
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  // Forward declarations
+  METAL_FUNC vec<double,2> copysign(vec<double,2> x, vec<double,2> y) {
+    vec<unsigned __metal_internal_int64_t,2> iy = as_type<vec<unsigned __metal_internal_int64_t,2>>(y) & (vec<unsigned __metal_internal_int64_t,2>)(0x8000000000000000);
+    vec<unsigned __metal_internal_int64_t,2> ret = (as_type<vec<unsigned __metal_internal_int64_t,2>>(x) & (vec<unsigned __metal_internal_int64_t,2>)(0x8000000000000000 - 1ULL)) | iy;
+    return as_type<vec<double,2>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<double,2> fma(vec<double,2> a, vec<double,2> b, vec<double,2> c) __asm("air.fma.v2f64");
+#endif
+
+  METAL_FUNC vec<double,2> frexp(vec<double,2> x, thread vec<int,2> &exponent) {
+    int temp_exponent;
+    vec<double,2> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,2> ilogb(vec<double,2> x) {
+    vec<int,2> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<double,2> ldexp(vec<double,2> x, vec<int,2> k) __asm("air." _AIR_PREFIX_double "ldexp.v2f64");
+#else
+  METAL_FUNC vec<double,2> ldexp(vec<double,2> x, vec<int,2> k) {
+    vec<double,2> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<double,2> fdim(vec<double,2> x, vec<double,2> y) {
+    vec<double,2> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<double,2> fract(vec<double,2> x) __asm("air." _AIR_PREFIX_double "fract.v2f64");
+#else
+  METAL_FUNC vec<double,2> fract(vec<double,2> x) {
+    vec<double,2> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<double,2> log10(vec<double,2> x) __asm("air.log10.v2f64");
+
+  METAL_FUNC vec<double,2> modf(vec<double,2> x, thread vec<double,2> &intval) {
+    intval = trunc(x);
+    vec<bool,2> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<double,2>(0), isinf_x), x);
+  }
+  METAL_ASM vec<double,2> sincos(vec<double,2> x, thread vec<double,2> &cosval) __asm("air." _AIR_PREFIX_double "sincos.v2f64");
+
+  //METAL_ASM vec<double,2> trunc(vec<double,2> x) __asm("air." _AIR_PREFIX_double "trunc.v2f64");
+#endif
+  // Forward declarations
+  METAL_FUNC vec<half,3> copysign(vec<half,3> x, vec<half,3> y) {
+    vec<ushort,3> iy = as_type<vec<ushort,3>>(y) & (vec<ushort,3>)(0x8000);
+    vec<ushort,3> ret = (as_type<vec<ushort,3>>(x) & (vec<ushort,3>)(0x8000 - 1ULL)) | iy;
+    return as_type<vec<half,3>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<half,3> fma(vec<half,3> a, vec<half,3> b, vec<half,3> c) __asm("air.fma.v3f16");
+#endif
+
+  METAL_FUNC vec<half,3> frexp(vec<half,3> x, thread vec<int,3> &exponent) {
+    int temp_exponent;
+    vec<half,3> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,3> ilogb(vec<half,3> x) {
+    vec<int,3> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<half,3> ldexp(vec<half,3> x, vec<int,3> k) __asm("air." _AIR_PREFIX_half "ldexp.v3f16");
+#else
+  METAL_FUNC vec<half,3> ldexp(vec<half,3> x, vec<int,3> k) {
+    vec<half,3> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<half,3> fdim(vec<half,3> x, vec<half,3> y) {
+    vec<half,3> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<half,3> fract(vec<half,3> x) __asm("air." _AIR_PREFIX_half "fract.v3f16");
+#else
+  METAL_FUNC vec<half,3> fract(vec<half,3> x) {
+    vec<half,3> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<half,3> log10(vec<half,3> x) __asm("air.log10.v3f16");
+
+  METAL_FUNC vec<half,3> modf(vec<half,3> x, thread vec<half,3> &intval) {
+    intval = trunc(x);
+    vec<bool,3> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<half,3>(0), isinf_x), x);
+  }
+  METAL_ASM vec<half,3> sincos(vec<half,3> x, thread vec<half,3> &cosval) __asm("air." _AIR_PREFIX_half "sincos.v3f16");
+
+  //METAL_ASM vec<half,3> trunc(vec<half,3> x) __asm("air." _AIR_PREFIX_half "trunc.v3f16");
+  // Forward declarations
+  METAL_FUNC vec<float,3> copysign(vec<float,3> x, vec<float,3> y) {
+    vec<uint,3> iy = as_type<vec<uint,3>>(y) & (vec<uint,3>)(0x80000000);
+    vec<uint,3> ret = (as_type<vec<uint,3>>(x) & (vec<uint,3>)(0x80000000 - 1ULL)) | iy;
+    return as_type<vec<float,3>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,3> fma(vec<float,3> a, vec<float,3> b, vec<float,3> c) __asm("air.fma.v3f32");
+#endif
+
+  METAL_FUNC vec<float,3> frexp(vec<float,3> x, thread vec<int,3> &exponent) {
+    int temp_exponent;
+    vec<float,3> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,3> ilogb(vec<float,3> x) {
+    vec<int,3> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) __asm("air." _AIR_PREFIX_float "ldexp.v3f32");
+#else
+  METAL_FUNC vec<float,3> ldexp(vec<float,3> x, vec<int,3> k) {
+    vec<float,3> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,3> fdim(vec<float,3> x, vec<float,3> y) {
+    vec<float,3> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,3> fract(vec<float,3> x) __asm("air." _AIR_PREFIX_float "fract.v3f32");
+#else
+  METAL_FUNC vec<float,3> fract(vec<float,3> x) {
+    vec<float,3> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,3> log10(vec<float,3> x) {
+#if defined(__FAST_MATH__)
+    return fast::log10(x);
+#else
+    return precise::log10(x);
+#endif
+  }
+
+  METAL_FUNC vec<float,3> modf(vec<float,3> x, thread vec<float,3> &intval) {
+    intval = trunc(x);
+    vec<bool,3> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<float,3>(0), isinf_x), x);
+  }
+  METAL_ASM vec<float,3> sincos(vec<float,3> x, thread vec<float,3> &cosval) __asm("air." _AIR_PREFIX_float "sincos.v3f32");
+
+  //METAL_ASM vec<float,3> trunc(vec<float,3> x) __asm("air." _AIR_PREFIX_float "trunc.v3f32");
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  // Forward declarations
+  METAL_FUNC vec<double,3> copysign(vec<double,3> x, vec<double,3> y) {
+    vec<unsigned __metal_internal_int64_t,3> iy = as_type<vec<unsigned __metal_internal_int64_t,3>>(y) & (vec<unsigned __metal_internal_int64_t,3>)(0x8000000000000000);
+    vec<unsigned __metal_internal_int64_t,3> ret = (as_type<vec<unsigned __metal_internal_int64_t,3>>(x) & (vec<unsigned __metal_internal_int64_t,3>)(0x8000000000000000 - 1ULL)) | iy;
+    return as_type<vec<double,3>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<double,3> fma(vec<double,3> a, vec<double,3> b, vec<double,3> c) __asm("air.fma.v3f64");
+#endif
+
+  METAL_FUNC vec<double,3> frexp(vec<double,3> x, thread vec<int,3> &exponent) {
+    int temp_exponent;
+    vec<double,3> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,3> ilogb(vec<double,3> x) {
+    vec<int,3> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<double,3> ldexp(vec<double,3> x, vec<int,3> k) __asm("air." _AIR_PREFIX_double "ldexp.v3f64");
+#else
+  METAL_FUNC vec<double,3> ldexp(vec<double,3> x, vec<int,3> k) {
+    vec<double,3> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<double,3> fdim(vec<double,3> x, vec<double,3> y) {
+    vec<double,3> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<double,3> fract(vec<double,3> x) __asm("air." _AIR_PREFIX_double "fract.v3f64");
+#else
+  METAL_FUNC vec<double,3> fract(vec<double,3> x) {
+    vec<double,3> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<double,3> log10(vec<double,3> x) __asm("air.log10.v3f64");
+
+  METAL_FUNC vec<double,3> modf(vec<double,3> x, thread vec<double,3> &intval) {
+    intval = trunc(x);
+    vec<bool,3> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<double,3>(0), isinf_x), x);
+  }
+  METAL_ASM vec<double,3> sincos(vec<double,3> x, thread vec<double,3> &cosval) __asm("air." _AIR_PREFIX_double "sincos.v3f64");
+
+  //METAL_ASM vec<double,3> trunc(vec<double,3> x) __asm("air." _AIR_PREFIX_double "trunc.v3f64");
+#endif
+  // Forward declarations
+  METAL_FUNC vec<half,4> copysign(vec<half,4> x, vec<half,4> y) {
+    vec<ushort,4> iy = as_type<vec<ushort,4>>(y) & (vec<ushort,4>)(0x8000);
+    vec<ushort,4> ret = (as_type<vec<ushort,4>>(x) & (vec<ushort,4>)(0x8000 - 1ULL)) | iy;
+    return as_type<vec<half,4>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<half,4> fma(vec<half,4> a, vec<half,4> b, vec<half,4> c) __asm("air.fma.v4f16");
+#endif
+
+  METAL_FUNC vec<half,4> frexp(vec<half,4> x, thread vec<int,4> &exponent) {
+    int temp_exponent;
+    vec<half,4> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    ret_val[3] = frexp(x[3], temp_exponent);
+    exponent[3] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,4> ilogb(vec<half,4> x) {
+    vec<int,4> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    ret_val[3] = ilogb(x[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<half,4> ldexp(vec<half,4> x, vec<int,4> k) __asm("air." _AIR_PREFIX_half "ldexp.v4f16");
+#else
+  METAL_FUNC vec<half,4> ldexp(vec<half,4> x, vec<int,4> k) {
+    vec<half,4> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    ret_val[3] = ldexp(x[3], k[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<half,4> fdim(vec<half,4> x, vec<half,4> y) {
+    vec<half,4> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    ret_val[3] = fdim(x[3], y[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<half,4> fract(vec<half,4> x) __asm("air." _AIR_PREFIX_half "fract.v4f16");
+#else
+  METAL_FUNC vec<half,4> fract(vec<half,4> x) {
+    vec<half,4> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    ret_val[3] = fract(x[3]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<half,4> log10(vec<half,4> x) __asm("air.log10.v4f16");
+
+  METAL_FUNC vec<half,4> modf(vec<half,4> x, thread vec<half,4> &intval) {
+    intval = trunc(x);
+    vec<bool,4> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<half,4>(0), isinf_x), x);
+  }
+  METAL_ASM vec<half,4> sincos(vec<half,4> x, thread vec<half,4> &cosval) __asm("air." _AIR_PREFIX_half "sincos.v4f16");
+
+  //METAL_ASM vec<half,4> trunc(vec<half,4> x) __asm("air." _AIR_PREFIX_half "trunc.v4f16");
+  // Forward declarations
+  METAL_FUNC vec<float,4> copysign(vec<float,4> x, vec<float,4> y) {
+    vec<uint,4> iy = as_type<vec<uint,4>>(y) & (vec<uint,4>)(0x80000000);
+    vec<uint,4> ret = (as_type<vec<uint,4>>(x) & (vec<uint,4>)(0x80000000 - 1ULL)) | iy;
+    return as_type<vec<float,4>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<float,4> fma(vec<float,4> a, vec<float,4> b, vec<float,4> c) __asm("air.fma.v4f32");
+#endif
+
+  METAL_FUNC vec<float,4> frexp(vec<float,4> x, thread vec<int,4> &exponent) {
+    int temp_exponent;
+    vec<float,4> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    ret_val[3] = frexp(x[3], temp_exponent);
+    exponent[3] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,4> ilogb(vec<float,4> x) {
+    vec<int,4> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    ret_val[3] = ilogb(x[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) __asm("air." _AIR_PREFIX_float "ldexp.v4f32");
+#else
+  METAL_FUNC vec<float,4> ldexp(vec<float,4> x, vec<int,4> k) {
+    vec<float,4> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    ret_val[3] = ldexp(x[3], k[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,4> fdim(vec<float,4> x, vec<float,4> y) {
+    vec<float,4> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    ret_val[3] = fdim(x[3], y[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<float,4> fract(vec<float,4> x) __asm("air." _AIR_PREFIX_float "fract.v4f32");
+#else
+  METAL_FUNC vec<float,4> fract(vec<float,4> x) {
+    vec<float,4> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    ret_val[3] = fract(x[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<float,4> log10(vec<float,4> x) {
+#if defined(__FAST_MATH__)
+    return fast::log10(x);
+#else
+    return precise::log10(x);
+#endif
+  }
+
+  METAL_FUNC vec<float,4> modf(vec<float,4> x, thread vec<float,4> &intval) {
+    intval = trunc(x);
+    vec<bool,4> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<float,4>(0), isinf_x), x);
+  }
+  METAL_ASM vec<float,4> sincos(vec<float,4> x, thread vec<float,4> &cosval) __asm("air." _AIR_PREFIX_float "sincos.v4f32");
+
+  //METAL_ASM vec<float,4> trunc(vec<float,4> x) __asm("air." _AIR_PREFIX_float "trunc.v4f32");
+#if defined(__HAVE_NATIVE_DOUBLE__)
+  // Forward declarations
+  METAL_FUNC vec<double,4> copysign(vec<double,4> x, vec<double,4> y) {
+    vec<unsigned __metal_internal_int64_t,4> iy = as_type<vec<unsigned __metal_internal_int64_t,4>>(y) & (vec<unsigned __metal_internal_int64_t,4>)(0x8000000000000000);
+    vec<unsigned __metal_internal_int64_t,4> ret = (as_type<vec<unsigned __metal_internal_int64_t,4>>(x) & (vec<unsigned __metal_internal_int64_t,4>)(0x8000000000000000 - 1ULL)) | iy;
+    return as_type<vec<double,4>>(ret);
+  }
+
+#if defined(__HAVE_FMA__)
+  METAL_ASM vec<double,4> fma(vec<double,4> a, vec<double,4> b, vec<double,4> c) __asm("air.fma.v4f64");
+#endif
+
+  METAL_FUNC vec<double,4> frexp(vec<double,4> x, thread vec<int,4> &exponent) {
+    int temp_exponent;
+    vec<double,4> ret_val;
+    ret_val[0] = frexp(x[0], temp_exponent);
+    exponent[0] = temp_exponent;
+    ret_val[1] = frexp(x[1], temp_exponent);
+    exponent[1] = temp_exponent;
+    ret_val[2] = frexp(x[2], temp_exponent);
+    exponent[2] = temp_exponent;
+    ret_val[3] = frexp(x[3], temp_exponent);
+    exponent[3] = temp_exponent;
+    return ret_val;
+  }
+  METAL_FUNC vec<int,4> ilogb(vec<double,4> x) {
+    vec<int,4> ret_val;
+    ret_val[0] = ilogb(x[0]);
+    ret_val[1] = ilogb(x[1]);
+    ret_val[2] = ilogb(x[2]);
+    ret_val[3] = ilogb(x[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_LDEXP__)
+  METAL_ASM vec<double,4> ldexp(vec<double,4> x, vec<int,4> k) __asm("air." _AIR_PREFIX_double "ldexp.v4f64");
+#else
+  METAL_FUNC vec<double,4> ldexp(vec<double,4> x, vec<int,4> k) {
+    vec<double,4> ret_val;
+    ret_val[0] = ldexp(x[0], k[0]);
+    ret_val[1] = ldexp(x[1], k[1]);
+    ret_val[2] = ldexp(x[2], k[2]);
+    ret_val[3] = ldexp(x[3], k[3]);
+    return ret_val;
+  }
+#endif
+  METAL_FUNC vec<double,4> fdim(vec<double,4> x, vec<double,4> y) {
+    vec<double,4> ret_val;
+    ret_val[0] = fdim(x[0], y[0]);
+    ret_val[1] = fdim(x[1], y[1]);
+    ret_val[2] = fdim(x[2], y[2]);
+    ret_val[3] = fdim(x[3], y[3]);
+    return ret_val;
+  }
+#if defined(__HAVE_AIR_FRACT__)
+  METAL_ASM vec<double,4> fract(vec<double,4> x) __asm("air." _AIR_PREFIX_double "fract.v4f64");
+#else
+  METAL_FUNC vec<double,4> fract(vec<double,4> x) {
+    vec<double,4> ret_val;
+    ret_val[0] = fract(x[0]);
+    ret_val[1] = fract(x[1]);
+    ret_val[2] = fract(x[2]);
+    ret_val[3] = fract(x[3]);
+    return ret_val;
+  }
+#endif
+  METAL_ASM vec<double,4> log10(vec<double,4> x) __asm("air.log10.v4f64");
+
+  METAL_FUNC vec<double,4> modf(vec<double,4> x, thread vec<double,4> &intval) {
+    intval = trunc(x);
+    vec<bool,4> isinf_x = isinf(x);
+    return copysign(select(x - intval, vec<double,4>(0), isinf_x), x);
+  }
+  METAL_ASM vec<double,4> sincos(vec<double,4> x, thread vec<double,4> &cosval) __asm("air." _AIR_PREFIX_double "sincos.v4f64");
+
+  //METAL_ASM vec<double,4> trunc(vec<double,4> x) __asm("air." _AIR_PREFIX_double "trunc.v4f64");
+#endif
+} // namespace metal
+
+#endif // __METAL_MATH
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math_utils b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math_utils
new file mode 100644
index 00000000..ace3700a
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_math_utils
@@ -0,0 +1,230 @@
+//===-- metal_math_utils --------------------------------------------------===//
+// Copyright (c) 2015-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_MATH_UTILS
+#define __METAL_MATH_UTILS
+
+#define _METAL_PRECISE_MATH false
+#define _METAL_FAST_MATH true
+#if defined(__FAST_MATH__)
+#define _METAL_MAYBE_FAST_MATH _METAL_FAST_MATH
+#else
+#define _METAL_MAYBE_FAST_MATH _METAL_PRECISE_MATH
+#endif
+
+#pragma METAL internals : enable
+namespace metal
+{
+template <typename T>
+struct _is_scalar : bool_constant<is_scalar<T>::value && is_arithmetic<T>::value>
+{
+};
+
+template <typename T>
+struct _is_fp_vector : bool_constant<is_floating_point<T>::value && is_vector<T>::value>
+{
+};
+
+template <typename T, typename U, typename _E = void>
+struct _math_binary_func_operand_type
+{
+  using type = void;
+};
+
+// We shipped a version of Metal using overloded functions to implement binary
+// functions instead of template functions. For any pair of scalar or vector
+// types T, U for which a call to the overloaded version of foo
+// `foo(T(x), U(y))` was valid (including via implicit conversion sequences),
+// the call to the templated version must also be valid.
+//
+// The general form of the binary math function is `O foo(T, U)`; O is the
+// floating-point arithmetic type the function operates with. The arguments (of
+// type T and U) are cast to O before being passed to the builtin.
+// The rules to deduce O from the pair <T, U> are as follows:
+//
+// 1) If T and U are both the same floating-point type, identity conversion is
+//    triggered.
+template <typename T>
+struct _math_binary_func_operand_type<T, T, typename enable_if<is_floating_point<T>::value>::type>
+{
+  using type = T;
+};
+
+// 2) If T or U is a floating-point vector type, and the other is a
+//    floating-point or integral scalar type, then O is the floating-point
+//    vector type.
+template <typename T, typename U>
+struct _math_binary_func_operand_type<T, U, typename enable_if<(_is_fp_vector<T>::value ^ _is_fp_vector<U>::value) && (_is_scalar<T>::value ^ _is_scalar<U>::value)>::type>
+{
+  using type = typename conditional<_is_fp_vector<T>::value, T, U>::type;
+};
+
+// 3) If T is a floating-point scalar type, and U is an integral scalar type, or
+//    reciprocally, then O is the floating-point scalar type.
+template <typename T, typename U>
+struct _math_binary_func_operand_type<T, U, typename enable_if<_is_scalar<T>::value && _is_scalar<U>::value && (is_floating_point<T>::value ^ is_floating_point<U>::value)>::type>
+{
+  using type = typename conditional<is_floating_point<T>::value, T, U>::type;
+};
+
+// The rules described above work when half, float, and potentially double
+// versions of a given binary function were available. In the precise or fast
+// namespaces, only `float` versions of functions were available, and an
+// additional rule applies.
+template <typename T, typename U, typename _E = void>
+struct _math_fast_or_precise_binary_func_operand_type : _math_binary_func_operand_type<T, U>
+{
+};
+
+// 4) In the fast or precise namespaces, when T or U is float, and the other is
+//    a scalar type, then O is float.
+template <typename T, typename U>
+struct _math_fast_or_precise_binary_func_operand_type<T, U, typename enable_if<(is_same<float, T>::value && _is_scalar<U>::value) || (is_same<float, U>::value && _is_scalar<T>::value)>::type>
+{
+  using type = float;
+};
+
+// Here are some examples:
+//     // Case 1:
+//     half x1, y1;
+//     half res = foo(x1, y1);
+//     half2 x2, y2;
+//     half2 res = foo(x2, y2);
+//
+//     // Case 2:
+//     int x3;
+//     half2 y3;
+//     half2 res = foo(x3, y3);  // equivalent to `half2 res = foo(half2(x3), y3)`
+//
+//     // Case 3:
+//     half x4;
+//     int y4;
+//     half res = foo(x4, y4);   // equivalent to `half foo(x4, half(y4))`
+//
+//     // Case 4:
+//     float x6;
+//     half y6;
+//     fast::foo(x6, y6);        // equivalent to `float foo(x6, float(y6))`
+//
+// The following are invalid:
+//     // The calls would be ambiguous:
+//     float x6;
+//     half y6;
+//     foo(x6, y6);
+//
+//     half2 x7;
+//     float2 y7;
+//     foo(x7, y7);
+//
+//     char x8;
+//     int y8;
+//     foo(x8, y8);
+//
+//     // This call was and is invalid: no implicit conversion from int2 to half2
+//     half2 x9;
+//     int2 y9;
+//     foo(x9, y9);
+
+template <typename T, typename U>
+using _math_binary_func_operand_type_t = typename _math_binary_func_operand_type<T, U>::type;
+template <typename T, typename U>
+using _math_fast_or_precise_binary_func_operand_type_t = typename _math_fast_or_precise_binary_func_operand_type<T, U>::type;
+template <typename T, typename U>
+struct _math_binary_func_enable : bool_constant<!is_same<void, _math_binary_func_operand_type_t<T, U>>::value>
+{
+};
+template <typename T, typename U>
+struct _math_fast_or_precise_binary_func_enable : bool_constant<!is_same<void, _math_fast_or_precise_binary_func_operand_type_t<T, U>>::value>
+{
+};
+
+template <typename T, typename U, typename V, typename _E = void>
+struct _math_ternary_func_operand_type
+{
+  using type = void;
+};
+
+// We shipped a version of Metal using overloded functions to implement ternary
+// functions instead of template functions. For any tria of scalar or vector
+// types T, U, V for which a call to the overloaded version of foo
+// `foo(T(x), U(y), V(z))` was valid (including via implicit conversion
+// sequences), the call to the templated version must also be valid.
+//
+// The general form of the ternary math function is `O foo(T, U, V)`; O is the
+// floating-point arithmetic type the function operates with. The arguments (of
+// type T, U, and V) are cast to O before being passed to the builtin.
+// The rules to deduce O from the triad <T, U, V> are as follows:
+//
+// 1) If T, U, and V are the same floating-point type, identity conversion is
+//    triggered.
+template <typename T>
+struct _math_ternary_func_operand_type<T, T, T, typename enable_if<is_floating_point<T>::value>::type>
+{
+  using type = T;
+};
+
+// 2) If only one of T, U, V is a floating-point vector type, and the others
+//    are integral scalar types, then O is the floating point vector type.
+template <typename T, typename U, typename V>
+struct _math_ternary_func_operand_type<T, U, V, typename enable_if<(_is_fp_vector<T>::value + _is_fp_vector<U>::value + _is_fp_vector<V>::value) == 1 && (_is_scalar<T>::value + _is_scalar<U>::value + _is_scalar<V>::value) == 2 && (!is_same<T, U>::value && !is_same<T, V>::value && !is_same<U, V>::value)>::type>
+{
+  using type = typename conditional<_is_fp_vector<T>::value, T, U>::type;
+};
+
+// 3) If only one of T, U, V is a floating-point scalar type, and the others
+//    are integral scalar types, then O is the floating point scalar type.
+template <typename T, typename U, typename V>
+struct _math_ternary_func_operand_type<T, U, V, typename enable_if<_is_scalar<T>::value && _is_scalar<U>::value && _is_scalar<V>::value && (is_floating_point<T>::value + is_floating_point<U>::value + is_floating_point<V>::value) == 1 && (!is_same<T, U>::value && !is_same<T, V>::value && !is_same<U, V>::value)>::type>
+{
+  using type = typename conditional<is_floating_point<T>::value, T, typename conditional<is_floating_point<U>::value, U, V>::type>::type;
+};
+
+// 4) If T = U, then O only depends on T and V only; if T = V or U = V, then O
+//    depends on T and U only.
+template <typename T, typename V>
+struct _math_ternary_func_operand_type<T, T, V, typename enable_if<!is_same<T, V>::value>::type> : _math_binary_func_operand_type<T, V>
+{
+};
+template <typename T, typename U>
+struct _math_ternary_func_operand_type<T, U, T, typename enable_if<!is_same<T, U>::value>::type> : _math_binary_func_operand_type<T, U>
+{
+};
+template <typename T, typename U>
+struct _math_ternary_func_operand_type<T, U, U, typename enable_if<!is_same<T, U>::value>::type> : _math_binary_func_operand_type<T, U>
+{
+};
+
+// The rules described above work when half, float, and potentially double
+// versions of a given ternary function were available. In the precise or fast
+// namespaces, only `float` versions of functions were available, and an
+// additional rule applies.
+template <typename T, typename U, typename V, typename _E = void>
+struct _math_fast_or_precise_ternary_func_operand_type : _math_ternary_func_operand_type<T, U, V>
+{
+};
+
+// 5) In the fast or precise namespaces, when at least one of T, U, or V is
+//    float, and all the others are scalar types, then O is float.
+template <typename T, typename U, typename V>
+struct _math_fast_or_precise_ternary_func_operand_type<T, U, V, typename enable_if<(is_same<float, T>::value || is_same<float, U>::value || is_same<float, V>::value) && (_is_scalar<T>::value && _is_scalar<U>::value && _is_scalar<V>::value)>::type>
+{
+  using type = float;
+};
+
+template <typename T, typename U, typename V>
+using _math_ternary_func_operand_type_t = typename _math_ternary_func_operand_type<T, U, V>::type;
+template <typename T, typename U, typename V>
+using _math_fast_or_precise_ternary_func_operand_type_t = typename _math_fast_or_precise_ternary_func_operand_type<T, U, V>::type;
+template <typename T, typename U, typename V>
+struct _math_ternary_func_enable : bool_constant<!is_same<void, _math_ternary_func_operand_type_t<T, U, V>>::value>
+{
+};
+template <typename T, typename U, typename V>
+struct _math_fast_or_precise_ternary_func_enable : bool_constant<!is_same<void, _math_fast_or_precise_ternary_func_operand_type_t<T, U, V>>::value>
+{
+};
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_MATH_UTILS
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_matrix b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_matrix
new file mode 100644
index 00000000..2d930833
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_matrix
@@ -0,0 +1,1386 @@
+//===-- metal_matrix ------------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_MATRIX_H
+#define __METAL_MATRIX_H
+
+#include <metal_functional>
+#include <metal_geometric>
+#include <metal_initializer_list>
+#include <metal_numeric>
+#include <metal_utility>
+
+#pragma METAL internals : enable
+namespace metal {
+// Metal 1.1 s2.2: Vector and Matrix Data Types.
+
+template <typename T, int Cols, int Rows = Cols, typename _E = typename enable_if<is_scalar<T>::value && is_floating_point<T>::value && Cols >=2 && Rows >= 2>::type>
+struct matrix
+{
+  vec<T, Rows> columns[Cols];
+
+private:
+  template <typename U, int... R>
+  static vec<T, Rows> build_col(initializer_list<U> col, _integer_sequence<int, R...>)
+  {
+    return {(R < col.size() ? *(col.begin() + R) : U())...};
+  }
+  template <int... R>
+  static vec<T, Rows> build_diag_col(int c, T val, _integer_sequence<int, R...>)
+  {
+    return {(c == R ? val : 0)...};
+  }
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <int... R>
+  static vec<T, Rows> build_full_col(int c, initializer_list<T> elems, _integer_sequence<int, R...>)
+  {
+    return {*(elems.begin() + c * Rows + R)...};
+  }
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+
+  struct cols_init_tag
+  {
+  };
+  struct cols_all_tag
+  {
+  };
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  struct elems_all_tag
+  {
+  };
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+
+  template <int... C>
+  METAL_FUNC explicit matrix(T val, _integer_sequence<int, C...>) thread
+      : columns{build_diag_col(C, val, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+
+  template <int... C>
+  METAL_FUNC explicit matrix(cols_init_tag, initializer_list<vec<T, Rows>> cols, _integer_sequence<int, C...>) thread
+     : columns{(C < cols.size() ? *(cols.begin() + C) : vec<T, Rows>())...}
+  {
+  }
+
+  template <typename... U, typename _G = typename enable_if<_conjunction<is_convertible<U, vec<T, Rows>>...>::value>::type>
+  METAL_FUNC explicit matrix(cols_all_tag, U... cols) thread
+      : columns{vec<T, Rows>(cols)...}
+  {
+  }
+
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <typename... U, typename _G = typename enable_if<_conjunction<is_convertible<U, T>...>::value>::type>
+  METAL_FUNC explicit matrix(elems_all_tag, U... elems) thread
+      : matrix({T(elems)...}, _make_integer_sequence<int, Cols>())
+  {
+  }
+  template <int... C>
+  METAL_FUNC explicit matrix(initializer_list<T> elems, _integer_sequence<int, C...>) thread
+      : columns{build_full_col(C, elems, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <int... C>
+  METAL_FUNC explicit matrix(T val, _integer_sequence<int, C...>) constant
+      : columns{build_diag_col(C, val, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+
+  template <int... C>
+  METAL_FUNC explicit matrix(cols_init_tag, initializer_list<vec<T, Rows>> cols, _integer_sequence<int, C...>) constant
+     : columns{(C < cols.size() ? *(cols.begin() + C) : vec<T, Rows>())...}
+  {
+  }
+
+  template <typename... U, typename _G = typename enable_if<_conjunction<is_convertible<U, vec<T, Rows>>...>::value>::type>
+  METAL_FUNC explicit matrix(cols_all_tag, U... cols) constant
+      : columns{vec<T, Rows>(cols)...}
+  {
+  }
+
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <typename... U, typename _G = typename enable_if<_conjunction<is_convertible<U, T>...>::value>::type>
+  METAL_FUNC explicit matrix(elems_all_tag, U... elems) constant
+      : matrix({T(elems)...}, _make_integer_sequence<int, Cols>())
+  {
+  }
+  template <int... C>
+  METAL_FUNC explicit matrix(initializer_list<T> elems, _integer_sequence<int, C...>) constant
+      : columns{build_full_col(C, elems, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const thread matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) thread
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const device matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) thread
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const constant matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) thread
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const threadgroup matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) thread
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const thread matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) constant
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const device matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) constant
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const constant matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) constant
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+  template <typename U, int... C>
+  METAL_FUNC explicit matrix(const threadgroup matrix<U, Cols, Rows> &that, _integer_sequence<int, C...>) constant
+      : columns{vec<T, Rows>(that.columns[C])...}
+  {
+  }
+
+public:
+  METAL_FUNC matrix() thread = default;
+
+  METAL_FUNC matrix(initializer_list<vec<T, Rows>> cols) thread
+      : matrix(cols_init_tag(), cols, _make_integer_sequence<int, Cols>())
+  {
+  }
+  template <typename... U, typename _G = typename enable_if<sizeof...(U) == Cols>::type>
+  METAL_FUNC explicit matrix(initializer_list<U>... cols) thread
+      : columns{build_col(cols, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+
+  METAL_FUNC explicit matrix(T val) thread
+      : matrix(val, _make_integer_sequence<int, Cols>())
+  {
+  }
+
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <typename... U, typename _G = typename enable_if<(sizeof...(U) == Cols) || (sizeof...(U) == Cols * Rows)>::type>
+  METAL_FUNC explicit matrix(U... vals) thread
+      : matrix(conditional_t<sizeof...(U) == Cols, cols_all_tag, elems_all_tag>(), vals...)
+  {
+  }
+#else
+  template <typename... U, typename _G = typename enable_if<(sizeof...(U) == Cols)>::type>
+  METAL_FUNC explicit matrix(U... vals) thread
+      : matrix(cols_all_tag(), vals...)
+  {
+  }
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  METAL_FUNC matrix() constant = default;
+
+  METAL_FUNC matrix(initializer_list<vec<T, Rows>> cols) constant
+      : matrix(cols_init_tag(), cols, _make_integer_sequence<int, Cols>())
+  {
+  }
+  template <typename... U, typename _G = typename enable_if<sizeof...(U) == Cols>::type>
+  METAL_FUNC explicit matrix(initializer_list<U>... cols) constant
+      : columns{build_col(cols, _make_integer_sequence<int, Rows>())...}
+  {
+  }
+
+  METAL_FUNC explicit matrix(T val) constant
+      : matrix(val, _make_integer_sequence<int, Cols>())
+  {
+  }
+
+#if defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+  template <typename... U, typename _G = typename enable_if<(sizeof...(U) == Cols) || (sizeof...(U) == Cols * Rows)>::type>
+  METAL_FUNC explicit matrix(U... vals) constant
+      : matrix(conditional_t<sizeof...(U) == Cols, cols_all_tag, elems_all_tag>(), vals...)
+  {
+  }
+#else
+  template <typename... U, typename _G = typename enable_if<(sizeof...(U) == Cols)>::type>
+  METAL_FUNC explicit matrix(U... vals) constant
+      : matrix(cols_all_tag(), vals...)
+  {
+  }
+#endif // defined(__HAVE_MATRIX_MULTIPLE_SCALAR_CONSTRUCTORS__)
+
+  METAL_FUNC matrix(const thread matrix<T, Cols, Rows> &that) thread = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const thread matrix<U, Cols, Rows> &that) thread
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const device matrix<T, Cols, Rows> &that) thread = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const device matrix<U, Cols, Rows> &that) thread
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const constant matrix<T, Cols, Rows> &that) thread = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const constant matrix<U, Cols, Rows> &that) thread
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const threadgroup matrix<T, Cols, Rows> &that) thread = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const threadgroup matrix<U, Cols, Rows> &that) thread
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const thread matrix<T, Cols, Rows> &that) constant = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const thread matrix<U, Cols, Rows> &that) constant
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const device matrix<T, Cols, Rows> &that) constant = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const device matrix<U, Cols, Rows> &that) constant
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const constant matrix<T, Cols, Rows> &that) constant = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const constant matrix<U, Cols, Rows> &that) constant
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+  METAL_FUNC matrix(const threadgroup matrix<T, Cols, Rows> &that) constant = default;
+
+  template <typename U>
+  METAL_FUNC explicit matrix(const threadgroup matrix<U, Cols, Rows> &that) constant
+      : matrix(that, _make_integer_sequence<int, Cols>())
+  {
+  }
+
+public:
+  METAL_FUNC thread vec<T, Rows> &operator[](int r) thread
+  {
+    return columns[r];
+  }
+  METAL_FUNC device vec<T, Rows> &operator[](int r) device
+  {
+    return columns[r];
+  }
+  METAL_FUNC threadgroup vec<T, Rows> &operator[](int r) threadgroup
+  {
+    return columns[r];
+  }
+
+  METAL_FUNC const thread vec<T, Rows> &operator[](int r) const thread
+  {
+    return columns[r];
+  }
+  METAL_FUNC const device vec<T, Rows> &operator[](int r) const device
+  {
+    return columns[r];
+  }
+  METAL_FUNC const constant vec<T, Rows> &operator[](int r) const constant
+  {
+    return columns[r];
+  }
+  METAL_FUNC const threadgroup vec<T, Rows> &operator[](int r) const threadgroup
+  {
+    return columns[r];
+  }
+
+private:
+  template <typename O, int... C>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, vec<T, Rows> b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b);
+  }
+
+  template <typename O, int... C>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(thread matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(device matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+  template <typename O, int... C>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, C...>)
+  {
+    a[Cols - sizeof...(C)] = op(a[Cols - sizeof...(C)], b[Cols - sizeof...(C)]);
+    _make_compound_foreach(a, b, op, _make_integer_sequence<int, sizeof...(C) - 1>());
+  }
+  template <typename O>
+  static void _make_compound_foreach(threadgroup matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b, O op, _integer_sequence<int, 0>)
+  {
+    a[Cols - 1] = op(a[Cols - 1], b[Cols - 1]);
+  }
+
+public:
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator+=(const thread matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator-=(const thread matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator+=(const device matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator-=(const device matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator+=(const constant matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator-=(const constant matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator+=(const threadgroup matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator-=(const threadgroup matrix<T, Cols, Rows> &that) thread
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator+=(const thread matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator-=(const thread matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator+=(const device matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator-=(const device matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator+=(const constant matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator-=(const constant matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator+=(const threadgroup matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator-=(const threadgroup matrix<T, Cols, Rows> &that) device
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator+=(const thread matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator-=(const thread matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator+=(const device matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator-=(const device matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator+=(const constant matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator-=(const constant matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator+=(const threadgroup matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, plus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator-=(const threadgroup matrix<T, Cols, Rows> &that) threadgroup
+  {
+    _make_compound_foreach(*this, that, minus<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+
+  METAL_FUNC thread matrix<T, Cols, Rows> &operator*=(T val) thread
+  {
+    _make_compound_foreach(*this, vec<T, Rows>(val), multiplies<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC device matrix<T, Cols, Rows> &operator*=(T val) device
+  {
+    _make_compound_foreach(*this, vec<T, Rows>(val), multiplies<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+  METAL_FUNC threadgroup matrix<T, Cols, Rows> &operator*=(T val) threadgroup
+  {
+    _make_compound_foreach(*this, vec<T, Rows>(val), multiplies<vec<T, Rows>>(), _make_integer_sequence<int, Cols>());
+    return *this;
+  }
+};
+
+typedef matrix<half, 2, 2> half2x2;
+typedef matrix<half, 2, 3> half2x3;
+typedef matrix<half, 2, 4> half2x4;
+typedef matrix<half, 3, 2> half3x2;
+typedef matrix<half, 3, 3> half3x3;
+typedef matrix<half, 3, 4> half3x4;
+typedef matrix<half, 4, 2> half4x2;
+typedef matrix<half, 4, 3> half4x3;
+typedef matrix<half, 4, 4> half4x4;
+typedef matrix<float, 2, 2> float2x2;
+typedef matrix<float, 2, 3> float2x3;
+typedef matrix<float, 2, 4> float2x4;
+typedef matrix<float, 3, 2> float3x2;
+typedef matrix<float, 3, 3> float3x3;
+typedef matrix<float, 3, 4> float3x4;
+typedef matrix<float, 4, 2> float4x2;
+typedef matrix<float, 4, 3> float4x3;
+typedef matrix<float, 4, 4> float4x4;
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 2, 2> double2x2;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 2, 3> double2x3;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 2, 4> double2x4;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 3, 2> double3x2;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 3, 3> double3x3;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 3, 4> double3x4;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 4, 2> double4x2;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 4, 3> double4x3;
+#endif
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef matrix<double, 4, 4> double4x4;
+#endif
+
+// Metal 1.1 s3.2: Matrix Operators.
+
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(T a, const thread matrix<T, Cols, Rows> &b)
+{
+  return _matrix_scalar_product_impl(b, a, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const thread matrix<T, Cols, Rows> &a, T b)
+{
+  return b * a;
+}
+template <typename T, int Cols, int K>
+METAL_FUNC vec<T, Cols> operator*(vec<T, K> a, const thread matrix<T, Cols, K> &b)
+{
+  return _vector_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> operator*(const thread matrix<T, K, Rows> &a, vec<T, K> b)
+{
+  return _matrix_vector_product_impl(vec<T, Rows>(), a, b, _make_integer_sequence<int, K>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(T a, const device matrix<T, Cols, Rows> &b)
+{
+  return _matrix_scalar_product_impl(b, a, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const device matrix<T, Cols, Rows> &a, T b)
+{
+  return b * a;
+}
+template <typename T, int Cols, int K>
+METAL_FUNC vec<T, Cols> operator*(vec<T, K> a, const device matrix<T, Cols, K> &b)
+{
+  return _vector_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> operator*(const device matrix<T, K, Rows> &a, vec<T, K> b)
+{
+  return _matrix_vector_product_impl(vec<T, Rows>(), a, b, _make_integer_sequence<int, K>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(T a, const constant matrix<T, Cols, Rows> &b)
+{
+  return _matrix_scalar_product_impl(b, a, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const constant matrix<T, Cols, Rows> &a, T b)
+{
+  return b * a;
+}
+template <typename T, int Cols, int K>
+METAL_FUNC vec<T, Cols> operator*(vec<T, K> a, const constant matrix<T, Cols, K> &b)
+{
+  return _vector_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> operator*(const constant matrix<T, K, Rows> &a, vec<T, K> b)
+{
+  return _matrix_vector_product_impl(vec<T, Rows>(), a, b, _make_integer_sequence<int, K>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(T a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  return _matrix_scalar_product_impl(b, a, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const threadgroup matrix<T, Cols, Rows> &a, T b)
+{
+  return b * a;
+}
+template <typename T, int Cols, int K>
+METAL_FUNC vec<T, Cols> operator*(vec<T, K> a, const threadgroup matrix<T, Cols, K> &b)
+{
+  return _vector_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> operator*(const threadgroup matrix<T, K, Rows> &a, vec<T, K> b)
+{
+  return _matrix_vector_product_impl(vec<T, Rows>(), a, b, _make_integer_sequence<int, K>());
+}
+
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_scalar_product_impl(const thread matrix<T, Cols, Rows> &a, T b, _integer_sequence<int, C...>)
+{
+  return {(a[C] * vec<T, Rows>(b))...};
+}
+template <typename T, int Cols, int K, int... C>
+METAL_FUNC vec<T, Cols> _vector_matrix_product_impl(vec<T, K> a, const thread matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {dot(a, b[C])...};
+}
+
+template <typename T, int K, int Rows, int... H>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const thread matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, H...>)
+{
+  return _matrix_vector_product_impl(tmp + a[K - sizeof...(H)] * b[K - sizeof...(H)], a, b, _make_integer_sequence<int, sizeof...(H) - 1>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const thread matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, 0>)
+{
+  return tmp + a[K - 1] * b[K - 1];
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_scalar_product_impl(const device matrix<T, Cols, Rows> &a, T b, _integer_sequence<int, C...>)
+{
+  return {(a[C] * vec<T, Rows>(b))...};
+}
+template <typename T, int Cols, int K, int... C>
+METAL_FUNC vec<T, Cols> _vector_matrix_product_impl(vec<T, K> a, const device matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {dot(a, b[C])...};
+}
+
+template <typename T, int K, int Rows, int... H>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const device matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, H...>)
+{
+  return _matrix_vector_product_impl(tmp + a[K - sizeof...(H)] * b[K - sizeof...(H)], a, b, _make_integer_sequence<int, sizeof...(H) - 1>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const device matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, 0>)
+{
+  return tmp + a[K - 1] * b[K - 1];
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_scalar_product_impl(const constant matrix<T, Cols, Rows> &a, T b, _integer_sequence<int, C...>)
+{
+  return {(a[C] * vec<T, Rows>(b))...};
+}
+template <typename T, int Cols, int K, int... C>
+METAL_FUNC vec<T, Cols> _vector_matrix_product_impl(vec<T, K> a, const constant matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {dot(a, b[C])...};
+}
+
+template <typename T, int K, int Rows, int... H>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const constant matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, H...>)
+{
+  return _matrix_vector_product_impl(tmp + a[K - sizeof...(H)] * b[K - sizeof...(H)], a, b, _make_integer_sequence<int, sizeof...(H) - 1>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const constant matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, 0>)
+{
+  return tmp + a[K - 1] * b[K - 1];
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_scalar_product_impl(const threadgroup matrix<T, Cols, Rows> &a, T b, _integer_sequence<int, C...>)
+{
+  return {(a[C] * vec<T, Rows>(b))...};
+}
+template <typename T, int Cols, int K, int... C>
+METAL_FUNC vec<T, Cols> _vector_matrix_product_impl(vec<T, K> a, const threadgroup matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {dot(a, b[C])...};
+}
+
+template <typename T, int K, int Rows, int... H>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const threadgroup matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, H...>)
+{
+  return _matrix_vector_product_impl(tmp + a[K - sizeof...(H)] * b[K - sizeof...(H)], a, b, _make_integer_sequence<int, sizeof...(H) - 1>());
+}
+template <typename T, int K, int Rows>
+METAL_FUNC vec<T, Rows> _matrix_vector_product_impl(vec<T, Rows> tmp, const threadgroup matrix<T, K, Rows> &a, vec<T, K> b, _integer_sequence<int, 0>)
+{
+  return tmp + a[K - 1] * b[K - 1];
+}
+
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const thread matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const thread matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const thread matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const thread matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const thread matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const thread matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const thread matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const thread matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const thread matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const thread matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const thread matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const thread matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const device matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const device matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const device matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const device matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const device matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const device matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const device matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const device matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const device matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const device matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const device matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const device matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const constant matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const constant matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const constant matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const constant matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const constant matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const constant matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const constant matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const constant matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const constant matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const constant matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const constant matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const constant matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const threadgroup matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const threadgroup matrix<T, Cols, Rows> &a, const thread matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const threadgroup matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const threadgroup matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const threadgroup matrix<T, Cols, Rows> &a, const device matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const threadgroup matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const threadgroup matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const threadgroup matrix<T, Cols, Rows> &a, const constant matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const threadgroup matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator+(const threadgroup matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp += b;
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Cols, Rows> operator-(const threadgroup matrix<T, Cols, Rows> &a, const threadgroup matrix<T, Cols, Rows> &b)
+{
+  matrix<T, Cols, Rows> tmp = a;
+  return tmp -= b;
+}
+template <typename T, int K, int Rows, int Cols>
+METAL_FUNC matrix<T, Cols, Rows> operator*(const threadgroup matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b)
+{
+  return _matrix_matrix_product_impl(a, b, _make_integer_sequence<int, Cols>());
+}
+
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const thread matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const thread matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const thread matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const thread matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const device matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const device matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const device matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const device matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const constant matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const constant matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const constant matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const constant matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const threadgroup matrix<T, K, Rows> &a, const thread matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const threadgroup matrix<T, K, Rows> &a, const device matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const threadgroup matrix<T, K, Rows> &a, const constant matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+template <typename T, int K, int Rows, int Cols, int... C>
+METAL_FUNC matrix<T, Cols, Rows> _matrix_matrix_product_impl(const threadgroup matrix<T, K, Rows> &a, const threadgroup matrix<T, Cols, K> &b, _integer_sequence<int, C...>)
+{
+  return {a * b[C]...};
+}
+
+template <typename T, int K>
+METAL_FUNC thread vec<T, K> &operator*=(thread vec<T, K> &a, const thread matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC thread vec<T, K> &operator*=(thread vec<T, K> &a, const device matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC thread vec<T, K> &operator*=(thread vec<T, K> &a, const constant matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC thread vec<T, K> &operator*=(thread vec<T, K> &a, const threadgroup matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC device vec<T, K> &operator*=(device vec<T, K> &a, const thread matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC device vec<T, K> &operator*=(device vec<T, K> &a, const device matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC device vec<T, K> &operator*=(device vec<T, K> &a, const constant matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC device vec<T, K> &operator*=(device vec<T, K> &a, const threadgroup matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC threadgroup vec<T, K> &operator*=(threadgroup vec<T, K> &a, const thread matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC threadgroup vec<T, K> &operator*=(threadgroup vec<T, K> &a, const device matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC threadgroup vec<T, K> &operator*=(threadgroup vec<T, K> &a, const constant matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+template <typename T, int K>
+METAL_FUNC threadgroup vec<T, K> &operator*=(threadgroup vec<T, K> &a, const threadgroup matrix<T, K, K> &b)
+{
+  return a = a * b;
+}
+
+// Metal 1.1 s5.6: Matrix Functions.
+
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Rows, Cols> transpose(const thread matrix<T, Cols, Rows> &a)
+{
+  return _transpose_impl(a, _make_integer_sequence<int, Rows>());
+}
+template <typename T, int K>
+METAL_FUNC T determinant(const thread matrix<T, K, K> &a)
+{
+  return _determinant_impl(a, 0, _make_determinant_rows(_make_integer_sequence<int, K>()), _make_integer_sequence<int, K>());
+}
+
+template <typename T, int Cols, int Rows, int... R>
+METAL_FUNC matrix<T, Rows, Cols> _transpose_impl(const thread matrix<T, Cols, Rows> &a, _integer_sequence<int, R...>)
+{
+  return {_transpose_row(R, a, _make_integer_sequence<int, Cols>())...};
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC vec<T, Cols> _transpose_row(int r, const thread matrix<T, Cols, Rows> &a, _integer_sequence<int, C...>)
+{
+  return {a[C][r]...};
+}
+
+template <typename T, int K, int... R>
+METAL_FUNC T _determinant_impl(const thread matrix<T, K, K> &a, int c, vec<int, sizeof...(R)> rows, _integer_sequence<int, R...>)
+{
+  return _make_accumulation(((R & 1 ? -1 : 1) * a[c][rows[R]] * _determinant_impl(a, c + 1, _remove_determinant_row(rows, R, _make_integer_sequence<int, sizeof...(R) - 1>()), _make_integer_sequence<int, sizeof...(R) - 1>()))...);
+}
+template <typename T, int K>
+METAL_FUNC T _determinant_impl(const thread matrix<T, K, K> &a, int c, vec<int, 2> rows, _integer_sequence<int, 0, 1>)
+{
+  return a[c][rows[0]] * a[c + 1][rows[1]] - a[c][rows[1]] * a[c + 1][rows[0]];
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Rows, Cols> transpose(const device matrix<T, Cols, Rows> &a)
+{
+  return _transpose_impl(a, _make_integer_sequence<int, Rows>());
+}
+template <typename T, int K>
+METAL_FUNC T determinant(const device matrix<T, K, K> &a)
+{
+  return _determinant_impl(a, 0, _make_determinant_rows(_make_integer_sequence<int, K>()), _make_integer_sequence<int, K>());
+}
+
+template <typename T, int Cols, int Rows, int... R>
+METAL_FUNC matrix<T, Rows, Cols> _transpose_impl(const device matrix<T, Cols, Rows> &a, _integer_sequence<int, R...>)
+{
+  return {_transpose_row(R, a, _make_integer_sequence<int, Cols>())...};
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC vec<T, Cols> _transpose_row(int r, const device matrix<T, Cols, Rows> &a, _integer_sequence<int, C...>)
+{
+  return {a[C][r]...};
+}
+
+template <typename T, int K, int... R>
+METAL_FUNC T _determinant_impl(const device matrix<T, K, K> &a, int c, vec<int, sizeof...(R)> rows, _integer_sequence<int, R...>)
+{
+  return _make_accumulation(((R & 1 ? -1 : 1) * a[c][rows[R]] * _determinant_impl(a, c + 1, _remove_determinant_row(rows, R, _make_integer_sequence<int, sizeof...(R) - 1>()), _make_integer_sequence<int, sizeof...(R) - 1>()))...);
+}
+template <typename T, int K>
+METAL_FUNC T _determinant_impl(const device matrix<T, K, K> &a, int c, vec<int, 2> rows, _integer_sequence<int, 0, 1>)
+{
+  return a[c][rows[0]] * a[c + 1][rows[1]] - a[c][rows[1]] * a[c + 1][rows[0]];
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Rows, Cols> transpose(const constant matrix<T, Cols, Rows> &a)
+{
+  return _transpose_impl(a, _make_integer_sequence<int, Rows>());
+}
+template <typename T, int K>
+METAL_FUNC T determinant(const constant matrix<T, K, K> &a)
+{
+  return _determinant_impl(a, 0, _make_determinant_rows(_make_integer_sequence<int, K>()), _make_integer_sequence<int, K>());
+}
+
+template <typename T, int Cols, int Rows, int... R>
+METAL_FUNC matrix<T, Rows, Cols> _transpose_impl(const constant matrix<T, Cols, Rows> &a, _integer_sequence<int, R...>)
+{
+  return {_transpose_row(R, a, _make_integer_sequence<int, Cols>())...};
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC vec<T, Cols> _transpose_row(int r, const constant matrix<T, Cols, Rows> &a, _integer_sequence<int, C...>)
+{
+  return {a[C][r]...};
+}
+
+template <typename T, int K, int... R>
+METAL_FUNC T _determinant_impl(const constant matrix<T, K, K> &a, int c, vec<int, sizeof...(R)> rows, _integer_sequence<int, R...>)
+{
+  return _make_accumulation(((R & 1 ? -1 : 1) * a[c][rows[R]] * _determinant_impl(a, c + 1, _remove_determinant_row(rows, R, _make_integer_sequence<int, sizeof...(R) - 1>()), _make_integer_sequence<int, sizeof...(R) - 1>()))...);
+}
+template <typename T, int K>
+METAL_FUNC T _determinant_impl(const constant matrix<T, K, K> &a, int c, vec<int, 2> rows, _integer_sequence<int, 0, 1>)
+{
+  return a[c][rows[0]] * a[c + 1][rows[1]] - a[c][rows[1]] * a[c + 1][rows[0]];
+}
+template <typename T, int Cols, int Rows>
+METAL_FUNC matrix<T, Rows, Cols> transpose(const threadgroup matrix<T, Cols, Rows> &a)
+{
+  return _transpose_impl(a, _make_integer_sequence<int, Rows>());
+}
+template <typename T, int K>
+METAL_FUNC T determinant(const threadgroup matrix<T, K, K> &a)
+{
+  return _determinant_impl(a, 0, _make_determinant_rows(_make_integer_sequence<int, K>()), _make_integer_sequence<int, K>());
+}
+
+template <typename T, int Cols, int Rows, int... R>
+METAL_FUNC matrix<T, Rows, Cols> _transpose_impl(const threadgroup matrix<T, Cols, Rows> &a, _integer_sequence<int, R...>)
+{
+  return {_transpose_row(R, a, _make_integer_sequence<int, Cols>())...};
+}
+template <typename T, int Cols, int Rows, int... C>
+METAL_FUNC vec<T, Cols> _transpose_row(int r, const threadgroup matrix<T, Cols, Rows> &a, _integer_sequence<int, C...>)
+{
+  return {a[C][r]...};
+}
+
+template <typename T, int K, int... R>
+METAL_FUNC T _determinant_impl(const threadgroup matrix<T, K, K> &a, int c, vec<int, sizeof...(R)> rows, _integer_sequence<int, R...>)
+{
+  return _make_accumulation(((R & 1 ? -1 : 1) * a[c][rows[R]] * _determinant_impl(a, c + 1, _remove_determinant_row(rows, R, _make_integer_sequence<int, sizeof...(R) - 1>()), _make_integer_sequence<int, sizeof...(R) - 1>()))...);
+}
+template <typename T, int K>
+METAL_FUNC T _determinant_impl(const threadgroup matrix<T, K, K> &a, int c, vec<int, 2> rows, _integer_sequence<int, 0, 1>)
+{
+  return a[c][rows[0]] * a[c + 1][rows[1]] - a[c][rows[1]] * a[c + 1][rows[0]];
+}
+
+template <int... R>
+METAL_FUNC vec<int, sizeof...(R)> _make_determinant_rows(_integer_sequence<int, R...>)
+{
+  return {R...};
+}
+template <int... R>
+METAL_FUNC vec<int, sizeof...(R)> _remove_determinant_row(vec<int, sizeof...(R) + 1> rows, int r, _integer_sequence<int, R...>)
+{
+  return {rows[R < r ? R : R + 1]...};
+}
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_MATRIX_H
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_numeric b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_numeric
new file mode 100644
index 00000000..f395f2e4
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_numeric
@@ -0,0 +1,22 @@
+//===-- metal_numeric -----------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_NUMERIC
+#define __METAL_NUMERIC
+
+namespace metal
+{
+template <typename T>
+METAL_FUNC T _make_accumulation(T val)
+{
+  return val;
+}
+template <typename T, typename... U>
+METAL_FUNC T _make_accumulation(T acc, T val, U... vals)
+{
+  return _make_accumulation(acc + val, vals...);
+}
+} // namespace metal
+
+#endif // __METAL_NUMERIC
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_pack b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_pack
new file mode 100644
index 00000000..e7cb3a44
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_pack
@@ -0,0 +1,133 @@
+//===-- metal_pack --------------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_PACK
+#define __METAL_PACK
+
+namespace metal
+{
+// Metal 1.1 s5.11: Pack and Unpack Functions.
+
+METAL_FUNC float4 unpack_unorm4x8_to_float(uint x)
+{
+  return __metal_unpack_unorm4x8(x, float4());
+}
+METAL_FUNC float4 unpack_snorm4x8_to_float(uint x)
+{
+  return __metal_unpack_snorm4x8(x, float4());
+}
+METAL_FUNC half4 unpack_unorm4x8_to_half(uint x)
+{
+  return __metal_unpack_unorm4x8(x, half4());
+}
+METAL_FUNC half4 unpack_snorm4x8_to_half(uint x)
+{
+  return __metal_unpack_snorm4x8(x, half4());
+}
+
+METAL_FUNC float4 unpack_unorm4x8_srgb_to_float(uint x)
+{
+  return __metal_unpack_unorm4x8_srgb(x, float4());
+}
+METAL_FUNC half4 unpack_unorm4x8_srgb_to_half(uint x)
+{
+  return __metal_unpack_unorm4x8_srgb(x, half4());
+}
+
+METAL_FUNC float2 unpack_unorm2x16_to_float(uint x)
+{
+  return __metal_unpack_unorm2x16(x, float2());
+}
+METAL_FUNC float2 unpack_snorm2x16_to_float(uint x)
+{
+  return __metal_unpack_snorm2x16(x, float2());
+}
+METAL_FUNC half2 unpack_unorm2x16_to_half(uint x)
+{
+  return __metal_unpack_unorm2x16(x, half2());
+}
+METAL_FUNC half2 unpack_snorm2x16_to_half(uint x)
+{
+  return __metal_unpack_snorm2x16(x, half2());
+}
+
+METAL_FUNC float4 unpack_unorm10a2_to_float(uint x)
+{
+  return __metal_unpack_unorm_rgb10a2(x, float4());
+}
+METAL_FUNC float3 unpack_unorm565_to_float(ushort x)
+{
+  return __metal_unpack_unorm_rgb565(x, float3());
+}
+METAL_FUNC half4 unpack_unorm10a2_to_half(uint x)
+{
+  return __metal_unpack_unorm_rgb10a2(x, half4());
+}
+METAL_FUNC half3 unpack_unorm565_to_half(ushort x)
+{
+  return __metal_unpack_unorm_rgb565(x, half3());
+}
+
+METAL_FUNC uint pack_float_to_unorm4x8(float4 x)
+{
+  return __metal_pack_unorm4x8(x);
+}
+METAL_FUNC uint pack_float_to_snorm4x8(float4 x)
+{
+  return __metal_pack_snorm4x8(x);
+}
+METAL_FUNC uint pack_half_to_unorm4x8(half4 x)
+{
+  return __metal_pack_unorm4x8(x);
+}
+METAL_FUNC uint pack_half_to_snorm4x8(half4 x)
+{
+  return __metal_pack_snorm4x8(x);
+}
+
+METAL_FUNC uint pack_float_to_srgb_unorm4x8(float4 x)
+{
+  return __metal_pack_unorm4x8_srgb(x);
+}
+METAL_FUNC uint pack_half_to_srgb_unorm4x8(half4 x)
+{
+  return __metal_pack_unorm4x8_srgb(x);
+}
+
+METAL_FUNC uint pack_float_to_unorm2x16(float2 x)
+{
+  return __metal_pack_unorm2x16(x);
+}
+METAL_FUNC uint pack_float_to_snorm2x16(float2 x)
+{
+  return __metal_pack_snorm2x16(x);
+}
+METAL_FUNC uint pack_half_to_unorm2x16(half2 x)
+{
+  return __metal_pack_unorm2x16(x);
+}
+METAL_FUNC uint pack_half_to_snorm2x16(half2 x)
+{
+  return __metal_pack_snorm2x16(x);
+}
+
+METAL_FUNC uint pack_float_to_unorm10a2(float4 x)
+{
+  return __metal_pack_unorm_rgb10a2(x);
+}
+METAL_FUNC ushort pack_float_to_unorm565(float3 x)
+{
+  return __metal_pack_unorm_rgb565(x);
+}
+METAL_FUNC uint pack_half_to_unorm10a2(half4 x)
+{
+  return __metal_pack_unorm_rgb10a2(x);
+}
+METAL_FUNC ushort pack_half_to_unorm565(half3 x)
+{
+  return __metal_pack_unorm_rgb565(x);
+}
+} // namespace metal
+
+#endif // __METAL_PACK
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_packed_vector b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_packed_vector
new file mode 100644
index 00000000..ef90e97a
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_packed_vector
@@ -0,0 +1,200 @@
+//===-- metal_packed_vector -----------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_PACKED_VECTOR
+#define __METAL_PACKED_VECTOR
+
+typedef __attribute__((__packed_vector_type__(2))) bool packed_bool2;
+typedef __attribute__((__packed_vector_type__(3))) bool packed_bool3;
+typedef __attribute__((__packed_vector_type__(4))) bool packed_bool4;
+typedef struct __Reserved_Name__Do_not_use_packed_bool8 packed_bool8;
+typedef struct __Reserved_Name__Do_not_use_packed_bool16 packed_bool16;
+
+typedef __attribute__((__packed_vector_type__(2))) char packed_char2;
+typedef __attribute__((__packed_vector_type__(3))) char packed_char3;
+typedef __attribute__((__packed_vector_type__(4))) char packed_char4;
+typedef struct __Reserved_Name__Do_not_use_packed_char8 packed_char8;
+typedef struct __Reserved_Name__Do_not_use_packed_char16 packed_char16;
+
+typedef __attribute__((__packed_vector_type__(2))) unsigned char packed_uchar2;
+typedef __attribute__((__packed_vector_type__(3))) unsigned char packed_uchar3;
+typedef __attribute__((__packed_vector_type__(4))) unsigned char packed_uchar4;
+typedef struct __Reserved_Name__Do_not_use_packed_uchar16 packed_uchar8;
+typedef struct __Reserved_Name__Do_not_use_packed_uchar16 packed_uchar16;
+
+typedef __attribute__((__packed_vector_type__(2))) short packed_short2;
+typedef __attribute__((__packed_vector_type__(3))) short packed_short3;
+typedef __attribute__((__packed_vector_type__(4))) short packed_short4;
+typedef struct __Reserved_Name__Do_not_use_packed_short8 packed_short8;
+typedef struct __Reserved_Name__Do_not_use_packed_short16 packed_short16;
+
+typedef __attribute__((__packed_vector_type__(2))) unsigned short packed_ushort2;
+typedef __attribute__((__packed_vector_type__(3))) unsigned short packed_ushort3;
+typedef __attribute__((__packed_vector_type__(4))) unsigned short packed_ushort4;
+typedef struct __Reserved_Name__Do_not_use_packed_ushort8 packed_ushort8;
+typedef struct __Reserved_Name__Do_not_use_packed_ushort16 packed_ushort16;
+
+typedef __attribute__((__packed_vector_type__(2))) int packed_int2;
+typedef __attribute__((__packed_vector_type__(3))) int packed_int3;
+typedef __attribute__((__packed_vector_type__(4))) int packed_int4;
+typedef struct __Reserved_Name__Do_not_use_packed_int8 packed_int8;
+typedef struct __Reserved_Name__Do_not_use_packed_int16 packed_int16;
+
+typedef __attribute__((__packed_vector_type__(2))) unsigned int packed_uint2;
+typedef __attribute__((__packed_vector_type__(3))) unsigned int packed_uint3;
+typedef __attribute__((__packed_vector_type__(4))) unsigned int packed_uint4;
+typedef struct __Reserved_Name__Do_not_use_packed_uint8 packed_uint8;
+typedef struct __Reserved_Name__Do_not_use_packed_uint16 packed_uint16;
+
+typedef struct __Reserved_Name__Do_not_use_packed_long2 packed_long2;
+typedef struct __Reserved_Name__Do_not_use_packed_long3 packed_long3;
+typedef struct __Reserved_Name__Do_not_use_packed_long4 packed_long4;
+typedef struct __Reserved_Name__Do_not_use_packed_long8 packed_long8;
+typedef struct __Reserved_Name__Do_not_use_packed_long16 packed_long16;
+
+typedef struct __Reserved_Name__Do_not_use_packed_ulong2 packed_ulong2;
+typedef struct __Reserved_Name__Do_not_use_packed_ulong3 packed_ulong3;
+typedef struct __Reserved_Name__Do_not_use_packed_ulong4 packed_ulong4;
+typedef struct __Reserved_Name__Do_not_use_packed_ulong8 packed_ulong8;
+typedef struct __Reserved_Name__Do_not_use_packed_ulong16 packed_ulong16;
+
+typedef struct __Reserved_Name__Do_not_use_packed_llong2 packed_llong2;
+typedef struct __Reserved_Name__Do_not_use_packed_llong3 packed_llong3;
+typedef struct __Reserved_Name__Do_not_use_packed_llong4 packed_llong4;
+typedef struct __Reserved_Name__Do_not_use_packed_llong8 packed_llong8;
+typedef struct __Reserved_Name__Do_not_use_packed_llong16 packed_llong16;
+
+typedef struct __Reserved_Name__Do_not_use_packed_ullong2 packed_ullong2;
+typedef struct __Reserved_Name__Do_not_use_packed_ullong3 packed_ullong3;
+typedef struct __Reserved_Name__Do_not_use_packed_ullong4 packed_ullong4;
+typedef struct __Reserved_Name__Do_not_use_packed_ullong8 packed_ullong8;
+typedef struct __Reserved_Name__Do_not_use_packed_ullong16 packed_ullong16;
+
+typedef __attribute__((__packed_vector_type__(2))) half packed_half2;
+typedef __attribute__((__packed_vector_type__(3))) half packed_half3;
+typedef __attribute__((__packed_vector_type__(4))) half packed_half4;
+typedef struct __Reserved_Name__Do_not_use_packed_half8 packed_half8;
+typedef struct __Reserved_Name__Do_not_use_packed_half16 packed_half16;
+
+typedef __attribute__((__packed_vector_type__(2))) float packed_float2;
+typedef __attribute__((__packed_vector_type__(3))) float packed_float3;
+typedef __attribute__((__packed_vector_type__(4))) float packed_float4;
+typedef struct __Reserved_Name__Do_not_use_packed_float8 packed_float8;
+typedef struct __Reserved_Name__Do_not_use_packed_float16 packed_float16;
+
+#if defined(__HAVE_NATIVE_DOUBLE__)
+typedef __attribute__((__packed_vector_type__(2))) double packed_double2;
+typedef __attribute__((__packed_vector_type__(3))) double packed_double3;
+typedef __attribute__((__packed_vector_type__(4))) double packed_double4;
+#else
+typedef struct __Reserved_Name__Do_not_use_packed_double2 packed_double2;
+typedef struct __Reserved_Name__Do_not_use_packed_double3 packed_double3;
+typedef struct __Reserved_Name__Do_not_use_packed_double4 packed_double4;
+#endif
+typedef struct __Reserved_Name__Do_not_use_packed_double8 packed_double8;
+typedef struct __Reserved_Name__Do_not_use_packed_double16 packed_double16;
+
+typedef struct __Reserved_Name__Do_not_use_packed_quad2 packed_quad2;
+typedef struct __Reserved_Name__Do_not_use_packed_quad3 packed_quad3;
+typedef struct __Reserved_Name__Do_not_use_packed_quad4 packed_quad4;
+typedef struct __Reserved_Name__Do_not_use_packed_quad8 packed_quad8;
+typedef struct __Reserved_Name__Do_not_use_packed_quad16 packed_quad16;
+
+namespace metal
+{
+typedef ::packed_bool2 packed_bool2;
+typedef ::packed_bool3 packed_bool3;
+typedef ::packed_bool4 packed_bool4;
+typedef ::packed_bool8 packed_bool8;
+typedef ::packed_bool16 packed_bool16;
+
+typedef ::packed_char2 packed_char2;
+typedef ::packed_char3 packed_char3;
+typedef ::packed_char4 packed_char4;
+typedef ::packed_char8 packed_char8;
+typedef ::packed_char16 packed_char16;
+
+typedef ::packed_uchar2 packed_uchar2;
+typedef ::packed_uchar3 packed_uchar3;
+typedef ::packed_uchar4 packed_uchar4;
+typedef ::packed_uchar8 packed_uchar8;
+typedef ::packed_uchar16 packed_uchar16;
+
+typedef ::packed_short2 packed_short2;
+typedef ::packed_short3 packed_short3;
+typedef ::packed_short4 packed_short4;
+typedef ::packed_short8 packed_short8;
+typedef ::packed_short16 packed_short16;
+
+typedef ::packed_ushort2 packed_ushort2;
+typedef ::packed_ushort3 packed_ushort3;
+typedef ::packed_ushort4 packed_ushort4;
+typedef ::packed_ushort8 packed_ushort8;
+typedef ::packed_ushort16 packed_ushort16;
+
+typedef ::packed_int2 packed_int2;
+typedef ::packed_int3 packed_int3;
+typedef ::packed_int4 packed_int4;
+typedef ::packed_int8 packed_int8;
+typedef ::packed_int16 packed_int16;
+
+typedef ::packed_uint2 packed_uint2;
+typedef ::packed_uint3 packed_uint3;
+typedef ::packed_uint4 packed_uint4;
+typedef ::packed_uint8 packed_uint8;
+typedef ::packed_uint16 packed_uint16;
+
+typedef ::packed_long2 packed_long2;
+typedef ::packed_long3 packed_long3;
+typedef ::packed_long4 packed_long4;
+typedef ::packed_long8 packed_long8;
+typedef ::packed_long16 packed_long16;
+
+typedef ::packed_ulong2 packed_ulong2;
+typedef ::packed_ulong3 packed_ulong3;
+typedef ::packed_ulong4 packed_ulong4;
+typedef ::packed_ulong8 packed_ulong8;
+typedef ::packed_ulong16 packed_ulong16;
+
+typedef ::packed_llong2 packed_llong2;
+typedef ::packed_llong3 packed_llong3;
+typedef ::packed_llong4 packed_llong4;
+typedef ::packed_llong8 packed_llong8;
+typedef ::packed_llong16 packed_llong16;
+
+typedef ::packed_ullong2 packed_ullong2;
+typedef ::packed_ullong3 packed_ullong3;
+typedef ::packed_ullong4 packed_ullong4;
+typedef ::packed_ullong8 packed_ullong8;
+typedef ::packed_ullong16 packed_ullong16;
+
+typedef ::packed_half2 packed_half2;
+typedef ::packed_half3 packed_half3;
+typedef ::packed_half4 packed_half4;
+typedef ::packed_half8 packed_half8;
+typedef ::packed_half16 packed_half16;
+
+typedef ::packed_float2 packed_float2;
+typedef ::packed_float3 packed_float3;
+typedef ::packed_float4 packed_float4;
+typedef ::packed_float8 packed_float8;
+typedef ::packed_float16 packed_float16;
+
+typedef ::packed_double2 packed_double2;
+typedef ::packed_double3 packed_double3;
+typedef ::packed_double4 packed_double4;
+typedef ::packed_double8 packed_double8;
+typedef ::packed_double16 packed_double16;
+
+typedef ::packed_quad2 packed_quad2;
+typedef ::packed_quad3 packed_quad3;
+typedef ::packed_quad4 packed_quad4;
+typedef ::packed_quad8 packed_quad8;
+typedef ::packed_quad16 packed_quad16;
+
+template <typename T, int N>
+using packed_vec = T __attribute__((__packed_vector_type__(N)));
+}
+
+#endif // __METAL_PACKED_VECTOR
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_quadgroup b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_quadgroup
new file mode 100644
index 00000000..50f49592
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_quadgroup
@@ -0,0 +1,250 @@
+//===-- metal_quadgroup ---------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_QUADGROUP
+#define __METAL_QUADGROUP
+
+#include <metal_relational>
+
+namespace metal {
+
+#if defined(__HAVE_QUADGROUP__)
+// TODO: Specify the appropriate section for quadgroups.
+// Metal 2.2 s5.<TODO>: Quadgroup Functions.
+
+#pragma METAL internals : enable
+template <typename T, typename _E = void>
+struct __is_valid_quadgroup_type : false_type
+{
+};
+
+template <typename T>
+struct __is_valid_quadgroup_type<T, typename enable_if<is_same_v<make_scalar_t<T>, half> ||
+                                                       is_same_v<make_scalar_t<T>, float> ||
+#if defined(__HAVE_NATIVE_DOUBLE__)
+                                                       is_same_v<make_scalar_t<T>, double> ||
+#endif
+                                                       is_same_v<make_scalar_t<T>, char> ||
+                                                       is_same_v<make_scalar_t<T>, uchar> ||
+                                                       is_same_v<make_scalar_t<T>, signed char> ||
+                                                       is_same_v<make_scalar_t<T>, short> ||
+                                                       is_same_v<make_scalar_t<T>, ushort> ||
+                                                       is_same_v<make_scalar_t<T>, int> ||
+                                                       is_same_v<make_scalar_t<T>, uint>>::type> : true_type
+{
+};
+
+template <typename T, typename _E = void>
+struct __is_valid_quadgroup_integral_type : false_type
+{
+};
+
+template <typename T>
+struct __is_valid_quadgroup_integral_type<T, typename enable_if<is_same_v<make_scalar_t<T>, char> ||
+                                                                is_same_v<make_scalar_t<T>, uchar> ||
+                                                                is_same_v<make_scalar_t<T>, signed char> ||
+                                                                is_same_v<make_scalar_t<T>, short> ||
+                                                                is_same_v<make_scalar_t<T>, ushort> ||
+                                                                is_same_v<make_scalar_t<T>, int> ||
+                                                                is_same_v<make_scalar_t<T>, uint>>::type> : true_type
+{
+};
+#pragma METAL internals : disable
+
+#if defined(__HAVE_QUADGROUP_BALLOT__)
+struct quad_vote {
+  typedef ushort vote_t;
+
+  METAL_FUNC explicit constexpr quad_vote(vote_t v = 0) thread : v(v & 0xf)
+  {
+  }
+
+  METAL_FUNC explicit constexpr operator vote_t() const thread
+  {
+    return v;
+  }
+
+  bool all() const thread
+  {
+    return __metal_quad_vote_all(v);
+  }
+
+  bool any() const thread
+  {
+    return __metal_quad_vote_any(v);
+  }
+
+private:
+  vote_t v;
+};
+
+METAL_FUNC quad_vote quad_active_threads_mask()
+{
+  return quad_vote(__metal_quad_active_threads_mask());
+}
+
+METAL_FUNC bool quad_all(bool expr)
+{
+  return __metal_quad_all(expr);
+}
+#endif // defined(__HAVE_QUADGROUP_BALLOT__)
+
+#if defined(__HAVE_QUADGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_integral_type<T>::value>::type>
+METAL_FUNC T quad_and(T data)
+{
+  return __metal_quad_and(data);
+}
+#endif // defined(__HAVE_QUADGROUP_REDUCTION__)
+
+#if defined(__HAVE_QUADGROUP_BALLOT__)
+METAL_FUNC bool quad_any(bool expr)
+{
+  return __metal_quad_any(expr);
+}
+#endif // defined(__HAVE_QUADGROUP_BALLOT__)
+
+#if defined(__HAVE_QUADGROUP_BALLOT__)
+METAL_FUNC quad_vote quad_ballot(bool expr)
+{
+  return quad_vote(__metal_quad_ballot(expr));
+}
+#endif // defined(__HAVE_QUADGROUP_BALLOT__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_broadcast(T data, ushort broadcast_lane_id)
+{
+  return __metal_quad_broadcast(data, broadcast_lane_id);
+}
+
+#if defined(__HAVE_QUADGROUP_BROADCAST_FIRST__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_broadcast_first(T data)
+{
+  return __metal_quad_broadcast_first(data);
+}
+#endif // defined(__HAVE_QUADGROUP_BROADCAST_FIRST__)
+
+#if defined(__HAVE_QUADGROUP_REDUCTION__)
+METAL_FUNC bool quad_is_helper_thread()
+{
+  return __metal_quad_is_helper_thread();
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_max(T data)
+{
+  return __metal_quad_max(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_min(T data)
+{
+  return __metal_quad_min(data);
+}
+#endif // defined(__HAVE_QUADGROUP_REDUCTION__)
+
+#if defined(__HAVE_QUADGROUP_ONCE__)
+METAL_FUNC bool quad_once()
+{
+  return __metal_quad_once();
+}
+#endif // defined(__HAVE_QUADGROUP_ONCE__)
+
+#if defined(__HAVE_QUADGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_integral_type<T>::value>::type>
+METAL_FUNC T quad_or(T data)
+{
+  return __metal_quad_or(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_prefix_exclusive_product(T data)
+{
+  return __metal_quad_prefix_exclusive_product(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_prefix_exclusive_sum(T data)
+{
+  return __metal_quad_prefix_exclusive_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_prefix_inclusive_product(T data)
+{
+  return __metal_quad_prefix_inclusive_product(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_prefix_inclusive_sum(T data)
+{
+  return __metal_quad_prefix_inclusive_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_product(T data)
+{
+  return __metal_quad_product(data);
+}
+#endif // defined(__HAVE_QUADGROUP_REDUCTION__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle(T data, ushort quad_lane_id)
+{
+  return __metal_quad_shuffle(data, quad_lane_id);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle_down(T data, ushort delta)
+{
+  return __metal_quad_shuffle_down(data, delta);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle_up(T data, ushort delta)
+{
+  return __metal_quad_shuffle_up(data, delta);
+}
+
+#if defined(__HAVE_QUADGROUP_SHUFFLE_ROTATE_DOWN__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle_rotate_down(T data, ushort delta)
+{
+  return __metal_quad_shuffle_rotate_down(data, delta);
+}
+#endif // defined(__HAVE_QUADGROUP_SHUFFLE_ROTATE_UP__)
+
+#if defined(__HAVE_QUADGROUP_SHUFFLE_ROTATE_UP__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle_rotate_up(T data, ushort delta)
+{
+  return __metal_quad_shuffle_rotate_up(data, delta);
+}
+#endif // defined(__HAVE_QUADGROUP_SHUFFLE_ROTATE_UP__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_shuffle_xor(T data, ushort mask)
+{
+  return __metal_quad_shuffle_xor(data, mask);
+}
+
+#if defined(__HAVE_QUADGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_type<T>::value>::type>
+METAL_FUNC T quad_sum(T data)
+{
+  return __metal_quad_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_quadgroup_integral_type<T>::value>::type>
+METAL_FUNC T quad_xor(T data)
+{
+  return __metal_quad_xor(data);
+}
+#endif // defined(__HAVE_QUADGROUP_REDUCTION__)
+#endif // defined(__HAVE_QUADGROUP__)
+
+} // namespace metal
+
+#endif // __METAL_QUADGROUP
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_relational b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_relational
new file mode 100644
index 00000000..beac830f
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_relational
@@ -0,0 +1,200 @@
+//===-- metal_relational --------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_RELATIONAL
+#define __METAL_RELATIONAL
+
+#pragma METAL internals : enable
+namespace metal
+{
+// Metal 1.1 s5.4: Relational Functions.
+
+template <typename T>
+struct _fp_encoding_traits_impl;
+
+template <typename T, int N>
+struct _fp_encoding_traits_impl<T __attribute__((ext_vector_type(N)))>
+{
+  typedef typename _fp_encoding_traits_impl<T>::encoding_type __attribute__((ext_vector_type(N))) encoding_type;
+  constexpr static constant encoding_type bit_width = sizeof(encoding_type) * CHAR_BIT;
+  constexpr static constant encoding_type sign_mask = _fp_encoding_traits_impl<T>::sign_mask;
+  constexpr static constant encoding_type inf_mask = _fp_encoding_traits_impl<T>::inf_mask;
+  constexpr static constant encoding_type min_mask = _fp_encoding_traits_impl<T>::min_mask;
+};
+template <typename T, int N>
+struct _fp_encoding_traits_impl<T __attribute__((packed_vector_type(N)))>
+{
+  typedef typename _fp_encoding_traits_impl<T>::encoding_type __attribute__((packed_vector_type(N))) encoding_type;
+  constexpr static constant encoding_type bit_width = sizeof(encoding_type) * CHAR_BIT;
+  constexpr static constant encoding_type sign_mask = _fp_encoding_traits_impl<T>::sign_mask;
+  constexpr static constant encoding_type inf_mask = _fp_encoding_traits_impl<T>::inf_mask;
+  constexpr static constant encoding_type min_mask = _fp_encoding_traits_impl<T>::min_mask;
+};
+template <>
+struct _fp_encoding_traits_impl<half>
+{
+  typedef ushort encoding_type;
+  constexpr static constant encoding_type bit_width = sizeof(encoding_type) * CHAR_BIT;
+  constexpr static constant encoding_type sign_mask = 0x8000;
+  constexpr static constant encoding_type inf_mask = 0x7c00;
+  constexpr static constant encoding_type min_mask = 0x0400;
+};
+template <>
+struct _fp_encoding_traits_impl<float>
+{
+  typedef uint encoding_type;
+  constexpr static constant encoding_type bit_width = sizeof(encoding_type) * CHAR_BIT;
+  constexpr static constant encoding_type sign_mask = 0x80000000;
+  constexpr static constant encoding_type inf_mask = 0x7f800000;
+  constexpr static constant encoding_type min_mask = 0x00800000;
+};
+#if defined(__HAVE_NATIVE_DOUBLE__)
+template <>
+struct _fp_encoding_traits_impl<double>
+{
+  typedef unsigned __metal_internal_int64_t encoding_type;
+  constexpr static constant encoding_type bit_width = sizeof(encoding_type) * CHAR_BIT;
+  constexpr static constant encoding_type sign_mask = 0x8000000000000000;
+  constexpr static constant encoding_type inf_mask = 0x7ff0000000000000;
+  constexpr static constant encoding_type min_mask = 0x0010000000000000;
+};
+#endif
+
+template <typename T>
+struct _fp_encoding_traits : _fp_encoding_traits_impl<remove_cv_t<T>>
+{
+};
+
+template <typename T, typename U, typename _E = void>
+struct _relational_select_operand_type
+{
+  typedef void type;
+};
+
+// We shipped a version of Metal using overloded functions to implement the
+// select function instead of using a single template function. For any pair of
+// scalar or vector types T, U for which a call to the overloaded version of
+// select `select(T(x), U(y), c)` was valid (including via implicit conversion
+// sequences), the call to the templated version must also be valid.
+//
+// Conversion of the third parameter into a boolean vector is not supported.
+//
+// The general form of the select function is `O select(T, U, B)`; O is the
+// arithmetic type the function operates with. The arguments of type `T` and `U`
+// are cast to `O` before being passed to the builtin. The argument of type `B`
+// is either a `bool` -- if both `T` and `U` are scalar -- or a vector which
+// length matches the length of `O`. The rules to deduce O from the pair <T, U>
+// are as follows:
+//
+// 1) If T and U are both the same arithmetic type, identity conversion is
+//    triggered.
+template <typename T>
+struct _relational_select_operand_type<T, T, typename enable_if<is_arithmetic<T>::value>::type>
+{
+  typedef T type;
+};
+
+// 2) If T or U is a vector type, and the other is an arithmetic scalar type,
+//    then O is the vector type.
+template <typename T, typename U>
+struct _relational_select_operand_type<T, U, typename enable_if<(is_vector<T>::value ^ is_vector<U>::value) && ((is_scalar<T>::value && is_arithmetic<T>::value) ^ (is_scalar<U>::value && is_arithmetic<U>::value))>::type>
+{
+  typedef conditional_t<is_vector<T>::value, T, U> type;
+};
+
+template <typename T, typename U>
+using _relational_select_operand_type_t = typename _relational_select_operand_type<T, U>::type;
+template <typename T, typename U>
+struct _relational_select_enable : bool_constant<!is_same<void, _relational_select_operand_type_t<T, U>>::value>
+{
+};
+
+template <typename T, typename _E = void>
+struct _make_bool_impl;
+
+template <typename T>
+struct _make_bool_impl<T, typename enable_if<is_arithmetic<T>::value && is_scalar<T>::value>::type>
+{
+  typedef bool type;
+};
+template <typename T, int N>
+struct _make_bool_impl<T __attribute__((ext_vector_type(N)))>
+{
+  typedef bool __attribute__((ext_vector_type(N))) type;
+};
+template <typename T, int N>
+struct _make_bool_impl<T __attribute__((packed_vector_type(N)))>
+{
+  typedef bool __attribute__((packed_vector_type(N))) type;
+};
+
+template <typename T>
+struct _make_bool : _make_bool_impl<remove_cv_t<T>>
+{
+};
+template <typename T>
+using _make_bool_t = typename _make_bool<T>::type;
+
+template <typename T, typename _E = typename enable_if<is_same<make_scalar_t<T>, bool>::value>::type>
+METAL_FUNC bool all(T x)
+{
+  return __metal_all(x);
+}
+
+template <typename T, typename _E = typename enable_if<is_same<make_scalar_t<T>, bool>::value>::type>
+METAL_FUNC bool any(T x)
+{
+  return __metal_any(x);
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isinf(T x)
+{
+  return (__builtin_astype(x, typename _fp_encoding_traits<T>::encoding_type) & ~_fp_encoding_traits<T>::sign_mask) == _fp_encoding_traits<T>::inf_mask;
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isfinite(T x)
+{
+  return (__builtin_astype(x, typename _fp_encoding_traits<T>::encoding_type) & ~_fp_encoding_traits<T>::sign_mask) < _fp_encoding_traits<T>::inf_mask;
+}
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isnan(T x)
+{
+  return (__builtin_astype(x, typename _fp_encoding_traits<T>::encoding_type) & ~_fp_encoding_traits<T>::sign_mask) > _fp_encoding_traits<T>::inf_mask;
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isnormal(T x)
+{
+  return typename _fp_encoding_traits<T>::encoding_type((__builtin_astype(x, typename _fp_encoding_traits<T>::encoding_type) & ~_fp_encoding_traits<T>::sign_mask) - _fp_encoding_traits<T>::min_mask) < typename _fp_encoding_traits<T>::encoding_type(_fp_encoding_traits<T>::inf_mask - _fp_encoding_traits<T>::min_mask);
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isunordered(T x, T y)
+{
+  return isnan(x) || isnan(y);
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> isordered(T x, T y)
+{
+  return !isunordered(x, y);
+}
+
+template <typename T, typename U, typename _O = typename enable_if<_relational_select_enable<T, U>::value, _relational_select_operand_type_t<T, U>>::type>
+METAL_FUNC _O select(T x, U y, _make_bool_t<_O> c)
+{
+  return __metal_select(_O(x), _O(y), c);
+}
+
+template <typename T, typename _E = typename enable_if<is_floating_point<T>::value>::type>
+METAL_FUNC _make_bool_t<T> signbit(T x)
+{
+  return (__builtin_astype(x, typename _fp_encoding_traits<T>::encoding_type) >> (_fp_encoding_traits<T>::bit_width - 1)) == 1;
+}
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_RELATIONAL
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_simdgroup b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_simdgroup
new file mode 100644
index 00000000..1218d2e7
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_simdgroup
@@ -0,0 +1,253 @@
+//===-- metal_simdgroup ---------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_SIMDGROUP
+#define __METAL_SIMDGROUP
+
+#include <metal_relational>
+
+namespace metal
+{
+
+#if defined(__HAVE_SIMDGROUP__)
+// Metal 2.0 s5.13: SIMD-group Functions.
+
+#pragma METAL internals : enable
+template <typename T, typename _E = void>
+struct __is_valid_simdgroup_type : false_type
+{
+};
+
+template <typename T>
+struct __is_valid_simdgroup_type<T, typename enable_if<is_same_v<make_scalar_t<T>, half> ||
+                                                       is_same_v<make_scalar_t<T>, float> ||
+#if defined(__HAVE_NATIVE_DOUBLE__)
+                                                       is_same_v<make_scalar_t<T>, double> ||
+#endif
+                                                       is_same_v<make_scalar_t<T>, char> ||
+                                                       is_same_v<make_scalar_t<T>, uchar> ||
+                                                       is_same_v<make_scalar_t<T>, signed char> ||
+                                                       is_same_v<make_scalar_t<T>, short> ||
+                                                       is_same_v<make_scalar_t<T>, ushort> ||
+                                                       is_same_v<make_scalar_t<T>, int> ||
+                                                       is_same_v<make_scalar_t<T>, uint>>::type> : true_type
+{
+};
+
+template <typename T, typename _E = void>
+struct __is_valid_simdgroup_integral_type : false_type
+{
+};
+
+template <typename T>
+struct __is_valid_simdgroup_integral_type<T, typename enable_if<is_same_v<make_scalar_t<T>, char> ||
+                                                                is_same_v<make_scalar_t<T>, uchar> ||
+                                                                is_same_v<make_scalar_t<T>, signed char> ||
+                                                                is_same_v<make_scalar_t<T>, short> ||
+                                                                is_same_v<make_scalar_t<T>, ushort> ||
+                                                                is_same_v<make_scalar_t<T>, int> ||
+                                                                is_same_v<make_scalar_t<T>, uint>>::type> : true_type
+{
+};
+#pragma METAL internals : disable
+
+#if defined(__HAVE_SIMDGROUP_BALLOT__)
+struct simd_vote {
+#if   defined(__METAL_MACOS__)
+  // TODO: Use the appropriate 64bit type. See <rdar://problem/29116680>
+  typedef unsigned __metal_internal_int64_t vote_t;
+#endif // defined(__METAL_MACOS__)
+
+  METAL_FUNC explicit constexpr simd_vote(vote_t v = 0) thread : v(v)
+  {
+  }
+
+  METAL_FUNC explicit constexpr operator vote_t() const thread
+  {
+    return v;
+  }
+
+  bool all() const thread
+  {
+    return __metal_simd_vote_all(v);
+  }
+
+  bool any() const thread
+  {
+    return __metal_simd_vote_any(v);
+  }
+
+private:
+  vote_t v;
+};
+
+METAL_FUNC simd_vote simd_active_threads_mask()
+{
+  return simd_vote(__metal_simd_active_threads_mask());
+}
+
+METAL_FUNC bool simd_all(bool expr)
+{
+  return __metal_simd_all(expr);
+}
+#endif // defined(__HAVE_SIMDGROUP_BALLOT__)
+
+#if defined(__HAVE_SIMDGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_integral_type<T>::value>::type>
+METAL_FUNC T simd_and(T data)
+{
+  return __metal_simd_and(data);
+}
+#endif // defined(__HAVE_SIMDGROUP_REDUCTION__)
+
+#if defined(__HAVE_SIMDGROUP_BALLOT__)
+METAL_FUNC bool simd_any(bool expr)
+{
+  return __metal_simd_any(expr);
+}
+#endif // defined(__HAVE_SIMDGROUP_BALLOT__)
+
+#if defined(__HAVE_SIMDGROUP_BALLOT__)
+METAL_FUNC simd_vote simd_ballot(bool expr)
+{
+  return simd_vote(__metal_simd_ballot(expr, simd_vote::vote_t(0)));
+}
+#endif // defined(__HAVE_SIMDGROUP_BALLOT__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_broadcast(T data, ushort broadcast_lane_id)
+{
+  return __metal_simd_broadcast(data, broadcast_lane_id);
+}
+
+#if defined(__HAVE_SIMDGROUP_BROADCAST_FIRST__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_broadcast_first(T data)
+{
+  return __metal_simd_broadcast_first(data);
+}
+#endif // defined(__HAVE_SIMDGROUP_BROADCAST_FIRST__)
+
+#if defined(__HAVE_SIMDGROUP_REDUCTION__)
+METAL_FUNC bool simd_is_helper_thread()
+{
+  return __metal_simd_is_helper_thread();
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_max(T data)
+{
+  return __metal_simd_max(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_min(T data)
+{
+  return __metal_simd_min(data);
+}
+#endif // defined(__HAVE_SIMDGROUP_REDUCTION__)
+
+#if defined(__HAVE_SIMDGROUP_ONCE__)
+METAL_FUNC bool simd_once()
+{
+  return __metal_simd_once();
+}
+#endif // defined(__HAVE_SIMDGROUP_ONCE__)
+
+#if defined(__HAVE_SIMDGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_integral_type<T>::value>::type>
+METAL_FUNC T simd_or(T data)
+{
+  return __metal_simd_or(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_prefix_exclusive_product(T data)
+{
+  return __metal_simd_prefix_exclusive_product(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_prefix_exclusive_sum(T data)
+{
+  return __metal_simd_prefix_exclusive_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_prefix_inclusive_product(T data)
+{
+  return __metal_simd_prefix_inclusive_product(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_prefix_inclusive_sum(T data)
+{
+  return __metal_simd_prefix_inclusive_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_product(T data)
+{
+  return __metal_simd_product(data);
+}
+#endif // defined(__HAVE_SIMDGROUP_REDUCTION__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle(T data, ushort simd_lane_id)
+{
+  return __metal_simd_shuffle(data, simd_lane_id);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle_down(T data, ushort delta)
+{
+  return __metal_simd_shuffle_down(data, delta);
+}
+
+#if defined(__HAVE_SIMDGROUP_SHUFFLE_ROTATE_DOWN__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle_rotate_down(T data, ushort delta)
+{
+  return __metal_simd_shuffle_rotate_down(data, delta);
+}
+#endif // defined(__HAVE_SIMDGROUP_SHUFFLE_ROTATE_UP__)
+
+#if defined(__HAVE_SIMDGROUP_SHUFFLE_ROTATE_UP__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle_rotate_up(T data, ushort delta)
+{
+  return __metal_simd_shuffle_rotate_up(data, delta);
+}
+#endif // defined(__HAVE_SIMDGROUP_SHUFFLE_ROTATE_UP__)
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle_up(T data, ushort delta)
+{
+  return __metal_simd_shuffle_up(data, delta);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_shuffle_xor(T data, ushort mask)
+{
+  return __metal_simd_shuffle_xor(data, mask);
+}
+
+#if defined(__HAVE_SIMDGROUP_REDUCTION__)
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_type<T>::value>::type>
+METAL_FUNC T simd_sum(T data)
+{
+  return __metal_simd_sum(data);
+}
+
+template <typename T, typename _E = typename enable_if<__is_valid_simdgroup_integral_type<T>::value>::type>
+METAL_FUNC T simd_xor(T data)
+{
+  return __metal_simd_xor(data);
+}
+#endif // defined(__HAVE_SIMDGROUP_REDUCTION__)
+#endif // defined(__HAVE_SIMDGROUP__)
+
+} // namespace metal
+
+#endif // __METAL_SIMDGROUP
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib
new file mode 100644
index 00000000..de79613e
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib
@@ -0,0 +1,26 @@
+#ifndef __METAL_STDLIB
+#define __METAL_STDLIB
+
+#include <metal_array>
+#include <metal_atomic>
+#include <metal_common>
+#include <metal_compute>
+#include <metal_functional>
+#include <metal_geometric>
+#include <metal_graphics>
+#include <metal_indirect_command_buffer>
+#include <metal_initializer_list>
+#include <metal_integer>
+#include <metal_limits>
+#include <metal_math>
+#include <metal_matrix>
+#include <metal_numeric>
+#include <metal_pack>
+#include <metal_quadgroup>
+#include <metal_relational>
+#include <metal_simdgroup>
+#include <metal_texture>
+#include <metal_uniform>
+#include <metal_utility>
+
+#endif // __METAL_STDLIB
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..02d548d8
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.no-fast-math-64.pch
new file mode 100644
index 00000000..a8987610
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_1.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..7066e0a6
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.no-fast-math-64.pch
new file mode 100644
index 00000000..73962a30
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.1_2.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..c81ca9a7
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.no-fast-math-64.pch
new file mode 100644
index 00000000..e2fafdee
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_0.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..d08aa022
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.no-fast-math-64.pch
new file mode 100644
index 00000000..d1d5669d
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_1.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..5bc09e93
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.no-fast-math-64.pch
new file mode 100644
index 00000000..c33a5bc6
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.2_2.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.fast-relaxed-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.fast-relaxed-math-64.pch
new file mode 100644
index 00000000..02d548d8
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.fast-relaxed-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.no-fast-math-64.pch b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.no-fast-math-64.pch
new file mode 100644
index 00000000..a8987610
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_stdlib.no-fast-math-64.pch differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tessellation b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tessellation
new file mode 100644
index 00000000..85bf10ba
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tessellation
@@ -0,0 +1,73 @@
+//===-- metal_tessellation ------------------------------------------------===//
+// Copyright (c) 2016 Apple Inc. All rights reserved
+//
+// This header is for internal use only. This header may disappear between
+// releases.
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_TESSELLATION
+#define __METAL_TESSELLATION
+
+#if defined(__HAVE_TESSELLATION__)
+
+namespace metal
+{
+
+template <typename T, typename = void>
+class patch_control_point;
+
+template <typename T>
+class patch_control_point<T, typename enable_if<__is_metal_patch_control_point_struct(T)>::type>
+{
+  patch_control_point() thread = default;
+
+public:
+  thread patch_control_point &operator=(const thread patch_control_point &) thread = delete;
+  thread patch_control_point &operator=(const constant patch_control_point&) thread = delete;
+  thread patch_control_point *operator&() thread = delete;
+  const thread patch_control_point *operator&() const thread = delete;
+
+  // Return number of control points.
+  size_t size() const thread
+  {
+    return __metal_get_num_patch_control_points();
+  }
+
+  T operator[](size_t pos) const thread
+  {
+    return control_point_function(static_cast<int>(pos), pcp);
+  }
+
+private:
+  // Return T for the control point at pos.
+  METAL_PURE static T control_point_function(int, patch_control_point_t);
+
+private:
+  patch_control_point_t pcp;
+};
+
+// Metal Tessellation structures
+struct MTLQuadTessellationFactorsHalf
+{
+  half edgeTessellationFactor[4];
+  half insideTessellationFactor[2];
+};
+
+struct MTLTriangleTessellationFactorsHalf
+{
+  half edgeTessellationFactor[3];
+  half insideTessellationFactor;
+};
+
+struct MTLDrawPatchIndirectArguments
+{
+  uint patchCount;
+  uint instanceCount;
+  uint patchStart;
+  uint baseInstance;
+};
+
+} // namespace metal
+
+#endif // __HAVE_TESSELLATION__
+#endif // __METAL_TESSELLATION
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_texture b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_texture
new file mode 100644
index 00000000..b3b766f7
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_texture
@@ -0,0 +1,10564 @@
+//===-- metal_texture -----------------------------------------------------===//
+// Copyright (c) 2014-2016 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_TEXTURE
+#define __METAL_TEXTURE
+
+#if defined(__HAVE_ARRAY__)
+#include <metal_array>
+#endif
+#include <metal_type_traits>
+
+#pragma METAL internals : enable
+namespace metal {
+enum class access
+{
+  sample,
+  read,
+  write,
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  read_write
+#endif
+};
+
+enum class coord
+{
+  normalized = 0,
+  pixel = 1
+};
+enum class filter
+{
+  nearest = 0,
+  linear = 1,
+};
+enum class s_address
+{
+  clamp_to_zero = 0,
+  clamp_to_edge = 1,
+  repeat = 2,
+  mirrored_repeat = 3,
+#if defined(__HAVE_BORDER_COLOR__)
+  clamp_to_border = 4
+#endif
+};
+enum class t_address
+{
+  clamp_to_zero = 0,
+  clamp_to_edge = 1,
+  repeat = 2,
+  mirrored_repeat = 3,
+#if defined(__HAVE_BORDER_COLOR__)
+  clamp_to_border = 4
+#endif
+};
+enum class r_address
+{
+  clamp_to_zero = 0,
+  clamp_to_edge = 1,
+  repeat = 2,
+  mirrored_repeat = 3,
+#if defined(__HAVE_BORDER_COLOR__)
+  clamp_to_border = 4
+#endif
+};
+enum class address
+{
+  clamp_to_zero = 0,
+  clamp_to_edge = 1,
+  repeat = 2,
+  mirrored_repeat = 3,
+#if defined(__HAVE_BORDER_COLOR__)
+  clamp_to_border = 4
+#endif
+};
+enum class mip_filter
+{
+  none = 0,
+  nearest = 1,
+  linear = 2
+};
+enum class compare_func
+{
+  less = 1,
+  less_equal = 2,
+  greater = 3,
+  greater_equal = 4,
+  equal = 5,
+  not_equal = 6,
+#if defined(__HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__)
+  always = 7,
+  never = 8
+#endif
+};
+enum class mag_filter
+{
+  nearest = 0,
+  linear = 1,
+};
+enum class min_filter
+{
+  nearest = 0,
+  linear = 1,
+};
+
+struct __max_anisotropy
+{
+  METAL_FUNC constexpr explicit __max_anisotropy(int v) thread
+      : value(v - 1) // Given value 1 to 16 is stored as 4 bits 0 to 15.
+  {
+  }
+  uchar value : 4;
+};
+struct __lod_clamp
+{
+  METAL_FUNC constexpr explicit __lod_clamp(float min, float max) thread
+      : bits((convert(max) << 16) | convert(min))
+  {
+  }
+  uint bits;
+
+private:
+  METAL_FUNC static constexpr float clamp(float x, float absmax)
+  {
+    return (x > absmax) ? absmax : (x < -absmax) ? -absmax : x;
+  }
+  METAL_FUNC static constexpr uint convert(float x)
+  {
+    return as_type<ushort>(static_cast<half>(__builtin_isfinite(x) ? clamp(x, HALF_MAX) : x));
+  }
+};
+
+#if defined(__HAVE_ANISOTROPY_LOD_MIN_MAX__)
+using max_anisotropy = __max_anisotropy;
+using lod_clamp = __lod_clamp;
+#endif
+
+#if defined(__HAVE_BORDER_COLOR__)
+enum class border_color
+{
+  transparent_black = 0,
+  opaque_black = 1,
+  opaque_white = 2
+};
+#endif
+
+#if defined(__HAVE_SAMPLER_REDUCTION__)
+enum class reduction
+{
+  weighted_average = 0,
+  minimum = 1,
+  maximum = 2
+};
+#endif
+
+// Metal 1.1 s2.6: Samplers.
+struct sampler
+{
+private:
+  using __uint64_t = unsigned __metal_internal_int64_t;
+
+public:
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread sampler& operator&() const thread = delete;
+#endif
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant sampler& operator&() const constant = delete;
+#endif
+
+  METAL_FUNC constexpr sampler() thread : val(build())
+  {
+  }
+  template <typename... Ts>
+  METAL_FUNC constexpr sampler(Ts... t) thread : val(build(t...))
+  {
+  }
+  METAL_FUNC constexpr sampler() constant : val(build())
+  {
+  }
+  template <typename... Ts>
+  METAL_FUNC constexpr sampler(Ts... t) constant : val(build(t...))
+  {
+  }
+
+  METAL_FUNC constexpr sampler(const thread sampler &) thread = default;
+  METAL_FUNC constexpr sampler(const constant sampler &) thread = default;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC constexpr sampler(const device sampler &) thread = default;
+#endif
+  METAL_FUNC constexpr sampler(const thread sampler &) constant = default;
+  METAL_FUNC constexpr sampler(const constant sampler &) constant = default;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC constexpr sampler(const device sampler &) constant = default;
+#endif
+
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC thread sampler &operator=(const thread sampler &that) thread = default;
+#else
+  thread sampler &operator=(const thread sampler&) thread = delete;
+#endif
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC thread sampler &operator=(const constant sampler &that) thread = default;
+#else
+  thread sampler &operator=(const constant sampler&) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC thread sampler &operator=(const device sampler &that) thread = default;
+#else
+  thread sampler &operator=(const device sampler&) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC device sampler &operator=(const thread sampler &that) device = default;
+#else
+  device sampler &operator=(const thread sampler&) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC device sampler &operator=(const constant sampler &that) device = default;
+#else
+  device sampler &operator=(const constant sampler&) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_ARRAYS_OF_SAMPLERS__)
+  METAL_FUNC device sampler &operator=(const device sampler &that) device = default;
+#else
+  device sampler &operator=(const device sampler&) device = delete;
+#endif
+#endif
+
+private :
+  sampler_t val;
+
+private:
+  // Values to help calculate offsets.
+  constexpr const static constant unsigned s_address_bits  =  3;   // bits[2:0]   s_address mode
+  constexpr const static constant unsigned t_address_bits  =  3;   // bits[5:3]   t_address mode
+  constexpr const static constant unsigned r_address_bits  =  3;   // bits[8:6]   r_address mode
+  constexpr const static constant unsigned mag_filter_bits =  2;   // bits[10:9]  mag filter mode
+  constexpr const static constant unsigned min_filter_bits =  2;   // bits[12:11] min filter mode
+  constexpr const static constant unsigned mip_filter_bits =  2;   // bits[14:13] mip filter mode
+  constexpr const static constant unsigned normalized_bits =  1;   // bits[15:15] normalized mode
+  constexpr const static constant unsigned compare_bits    =  4;   // bits[19:16] compare func
+  constexpr const static constant unsigned anisotropy_bits =  4;   // bits[23:20] max anisotropy level
+  constexpr const static constant unsigned lod_clamp_bits  = 32;   // bits[39:24] lod min value
+                                                                   // bits[55:40] lod max value
+  constexpr const static constant unsigned border_color_bits =  2; // bits[57:56] border_color
+  constexpr const static constant unsigned reduction_bits    =  2; // bits[59:58] reduction
+                                                                   // bits[62:60] reserved
+  constexpr const static constant unsigned marker_bit        = 63; // bits[63:63] constant sampler indicator.
+
+  constexpr const static constant unsigned s_address_base    = 0;
+  constexpr const static constant unsigned t_address_base    = s_address_base  + s_address_bits;
+  constexpr const static constant unsigned r_address_base    = t_address_base  + t_address_bits;
+  constexpr const static constant unsigned mag_filter_base   = r_address_base  + r_address_bits;
+  constexpr const static constant unsigned min_filter_base   = mag_filter_base + mag_filter_bits;
+  constexpr const static constant unsigned mip_filter_base   = min_filter_base + min_filter_bits;
+  constexpr const static constant unsigned normalized_base   = mip_filter_base + mip_filter_bits;
+  constexpr const static constant unsigned compare_base      = normalized_base + normalized_bits;
+  constexpr const static constant unsigned anisotropy_base   = compare_base    + compare_bits;
+  constexpr const static constant unsigned lod_clamp_base    = anisotropy_base + anisotropy_bits;
+  constexpr const static constant unsigned border_color_base = lod_clamp_base + lod_clamp_bits;
+  constexpr const static constant unsigned reduction_base    = border_color_base + border_color_bits;
+
+  constexpr const static constant __uint64_t s_address_mask    = ((1ULL << s_address_bits   ) - 1) << s_address_base;
+  constexpr const static constant __uint64_t t_address_mask    = ((1ULL << t_address_bits   ) - 1) << t_address_base;
+  constexpr const static constant __uint64_t r_address_mask    = ((1ULL << r_address_bits   ) - 1) << r_address_base;
+  constexpr const static constant __uint64_t mag_filter_mask   = ((1ULL << mag_filter_bits  ) - 1) << mag_filter_base;
+  constexpr const static constant __uint64_t min_filter_mask   = ((1ULL << min_filter_bits  ) - 1) << min_filter_base;
+  constexpr const static constant __uint64_t mip_filter_mask   = ((1ULL << mip_filter_bits  ) - 1) << mip_filter_base;
+  constexpr const static constant __uint64_t normalized_mask   = ((1ULL << normalized_bits  ) - 1) << normalized_base;
+  constexpr const static constant __uint64_t compare_mask      = ((1ULL << compare_bits     ) - 1) << compare_base;
+  constexpr const static constant __uint64_t anisotropy_mask   = ((1ULL << anisotropy_bits  ) - 1) << anisotropy_base;
+  constexpr const static constant __uint64_t lod_clamp_mask    = ((1ULL << lod_clamp_bits   ) - 1) << lod_clamp_base;
+  constexpr const static constant __uint64_t border_color_mask = ((1ULL << border_color_bits) - 1) << border_color_base;
+  constexpr const static constant __uint64_t reduction_mask    = ((1ULL << reduction_bits   ) - 1) << reduction_base;
+
+#if defined(__HAVE_ALWAYS_NEVER_COMPARE_FUNCTION__)
+  constexpr const static constant compare_func default_compare_func = compare_func::never;
+#else
+  constexpr const static constant compare_func default_compare_func = compare_func::none;
+#endif
+  constexpr const static constant auto default_anisotropy = __max_anisotropy(1);
+  constexpr const static constant auto default_lod_clamp = __lod_clamp(0.0, FLT_MAX);
+
+  static constexpr __uint64_t build()
+  {
+    return (__uint64_t(1) << marker_bit) |
+           (__uint64_t(default_lod_clamp.bits) << lod_clamp_base) |
+           (__uint64_t(default_anisotropy.value) << anisotropy_base) |
+           (__uint64_t(default_compare_func) << compare_base) |
+           (__uint64_t(address::clamp_to_edge) << s_address_base) |
+           (__uint64_t(address::clamp_to_edge) << t_address_base) |
+           (__uint64_t(address::clamp_to_edge) << r_address_base);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(coord mode, Ts... t)
+  {
+    return (__uint64_t(mode) << normalized_base) | (build(t...) & ~normalized_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(s_address mode, Ts... t)
+  {
+    return (__uint64_t(mode) << s_address_base) | (build(t...) & ~s_address_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(t_address mode, Ts... t)
+  {
+    return (__uint64_t(mode) << t_address_base) | (build(t...) & ~t_address_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(r_address mode, Ts... t)
+  {
+    return (__uint64_t(mode) << r_address_base) | (build(t...) & ~r_address_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(address mode, Ts... t)
+  {
+    return (__uint64_t(mode) << s_address_base) |
+           (__uint64_t(mode) << t_address_base) |
+           (__uint64_t(mode) << r_address_base) |
+           (build(t...) & ~(s_address_mask | t_address_mask | r_address_mask));
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(mag_filter mode, Ts... t)
+  {
+    return (__uint64_t(mode) << mag_filter_base) | (build(t...) & ~mag_filter_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(min_filter mode, Ts... t)
+  {
+    return (__uint64_t(mode) << min_filter_base) | (build(t...) & ~min_filter_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(filter mode, Ts... t)
+  {
+    return (__uint64_t(mode) << mag_filter_base) |
+           (__uint64_t(mode) << min_filter_base) |
+           (build(t...) & ~(mag_filter_mask | min_filter_mask));
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(mip_filter mode, Ts... t)
+  {
+    return (__uint64_t(mode) << mip_filter_base) | (build(t...) & ~mip_filter_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(compare_func mode, Ts... t)
+  {
+    return (__uint64_t(mode) << compare_base) | (build(t...) & ~compare_mask);
+  }
+
+#if defined(__HAVE_ANISOTROPY_LOD_MIN_MAX__)
+  template <typename... Ts>
+  static constexpr __uint64_t build(max_anisotropy aniso, Ts... t)
+  {
+    return (__uint64_t(aniso.value) << anisotropy_base) | (build(t...) & ~anisotropy_mask);
+  }
+
+  template <typename... Ts>
+  static constexpr __uint64_t build(lod_clamp lod, Ts... t)
+  {
+    return (__uint64_t(lod.bits) << lod_clamp_base) | (build(t...) & ~lod_clamp_mask);
+  }
+#endif
+
+#if defined(__HAVE_BORDER_COLOR__)
+  template <typename... Ts>
+  static constexpr __uint64_t build(border_color mode, Ts... t)
+  {
+    return (__uint64_t(mode) << border_color_base) | (build(t...) & ~border_color_mask);
+  }
+#endif
+
+#if defined(__HAVE_SAMPLER_REDUCTION__)
+  template <typename... Ts>
+  static constexpr __uint64_t build(reduction mode, Ts... t)
+  {
+    return (__uint64_t(mode) << reduction_base) | (build(t...) & ~reduction_mask);
+  }
+#endif
+
+private:
+  template <typename T, access a, typename _Enable>
+  friend struct texture1d;
+  template <typename T, access a, typename _Enable>
+  friend struct texture1d_array;
+  template <typename T, access a, typename _Enable>
+  friend struct texture2d;
+  template <typename T, access a, typename _Enable>
+  friend struct texture2d_array;
+  template <typename T, access a, typename _Enable>
+  friend struct texture3d;
+  template <typename T, access a, typename _Enable>
+  friend struct texturecube;
+#if defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+  template <typename T, access a, typename _Enable>
+  friend struct texturecube_array;
+#endif
+  template <typename T, access a, typename _Enable>
+  friend struct texture2d_ms;
+#if defined(__HAVE_TEXTURE_2D_MS_ARRAY__)
+  template <typename T, access a, typename _Enable>
+  friend struct texture2d_ms_array;
+#endif
+  template <typename T, access a, typename _Enable>
+  friend struct depth2d;
+  template <typename T, access a, typename _Enable>
+  friend struct depth2d_array;
+  template <typename T, access a, typename _Enable>
+  friend struct depthcube;
+#if defined(__HAVE_DEPTH_CUBE_ARRAY__)
+  template <typename T, access a, typename _Enable>
+  friend struct depthcube_array;
+#endif
+  template <typename T, access a, typename _Enable>
+  friend struct depth2d_ms;
+#if defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+  template <typename T, access a, typename _Enable>
+  friend struct depth2d_ms_array;
+#endif
+};
+
+#if defined(__HAVE_SPARSE_TEXTURES__)
+// TODO: This is not stable yet. The code related to sparse textures and
+// min_lod_clamp will change.
+template <typename T, typename _E = typename enable_if<is_arithmetic<make_scalar_t<T>>::value>::type>
+class checked_color {
+  T __value;
+  bool __status;
+
+public:
+  METAL_FUNC constexpr checked_color(T value, bool nack) thread
+      : __value(value), __status(nack)
+  {
+  }
+
+  // Indicates whether all memory addressed to retrieve the value was mapped.
+  METAL_FUNC constexpr bool resident() const thread
+  {
+    return !__status;
+  }
+  METAL_FUNC constexpr T const value() const thread
+  {
+    return __value;
+  }
+
+  METAL_FUNC constexpr operator T() const thread
+  {
+    return value();
+  }
+};
+#endif
+
+struct bias
+{
+  METAL_FUNC constexpr bias(float value) thread
+      : value(value)
+  {
+  }
+  float value;
+};
+
+struct level
+{
+  METAL_FUNC constexpr level(float lod) thread
+      : lod(lod)
+  {
+  }
+  float lod;
+};
+
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+// TODO: This is not stable yet.
+struct min_lod_clamp
+{
+  METAL_FUNC constexpr min_lod_clamp(float value) thread
+      : value(value)
+  {
+  }
+  float value;
+};
+#endif
+
+// To allow level to be used in constant argument checks.
+template <>
+struct _constarg_traits<level>
+{
+  constexpr static METAL_INTERNAL bool check(level l)
+  {
+    return _constarg_traits<float>::check(l.lod);
+  }
+};
+
+struct gradient2d
+{
+  METAL_FUNC constexpr gradient2d(float2 dPdx, float2 dPdy) thread
+      : dPdx(dPdx), dPdy(dPdy)
+  {
+  }
+  float2 dPdx;
+  float2 dPdy;
+};
+
+struct gradient3d
+{
+  METAL_FUNC constexpr gradient3d(float3 dPdx, float3 dPdy) thread
+      : dPdx(dPdx), dPdy(dPdy)
+  {
+  }
+  float3 dPdx;
+  float3 dPdy;
+};
+
+struct gradientcube
+{
+  METAL_FUNC constexpr gradientcube(float3 dPdx, float3 dPdy) thread
+      : dPdx(dPdx), dPdy(dPdy)
+  {
+  }
+  float3 dPdx;
+  float3 dPdy;
+};
+
+enum class component
+{
+  x,
+  y,
+  z,
+  w
+};
+
+METAL_INTERNAL constexpr static inline bool _is_zero(uint a)
+{
+  return a == 0;
+}
+METAL_INTERNAL constexpr static inline bool _is_zero(level a)
+{
+  return a.lod == 0;
+}
+#define METAL_ZERO_ARG(A) \
+  METAL_ENABLE_IF(_is_zero(A), "'" #A "' argument value must be 0")
+
+#if defined(__HAVE_ZERO_LOD_ARG__)
+#define METAL_VALID_LOD_ARG(A) \
+  METAL_CONST_ARG(A)           \
+  METAL_ZERO_ARG(A)
+#else
+#define METAL_VALID_LOD_ARG(A)
+#endif
+
+#if defined(__HAVE_ZERO_LOD_ARG__)
+#define METAL_VALID_LEVEL_ARG(A) \
+  METAL_CONST_ARG(A)             \
+  METAL_ZERO_ARG(A)
+#else
+#define METAL_VALID_LEVEL_ARG(A)
+#endif
+
+// Metal 1.1 s2.5: Textures.
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texture1d;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texture1d_array;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texture2d;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texture2d_array;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texture3d;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texturecube;
+#if defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+template <typename T, access a = access::sample, typename _Enable = void>
+struct texturecube_array;
+#endif
+template <typename T, access a = access::read, typename _Enable = void>
+struct texture2d_ms;
+#if defined(__HAVE_TEXTURE_2D_MS_ARRAY__)
+template <typename T, access a = access::read, typename _Enable = void>
+struct texture2d_ms_array;
+#endif
+#if defined(__HAVE_TEXTURE_BUFFER__)
+template <typename T, access a = access::read, typename _Enable = void>
+struct texture_buffer;
+#endif
+template <typename T, access a = access::sample, typename _Enable = void>
+struct depth2d;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct depth2d_array;
+template <typename T, access a = access::sample, typename _Enable = void>
+struct depthcube;
+#if defined(__HAVE_DEPTH_CUBE_ARRAY__)
+template <typename T, access a = access::sample, typename _Enable = void>
+struct depthcube_array;
+#endif
+template <typename T, access a = access::read, typename _Enable = void>
+struct depth2d_ms;
+#if defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+template <typename T, access a = access::read, typename _Enable = void>
+struct depth2d_ms_array;
+#endif
+
+#if defined(__HAVE_NULL_TEXTURE__)
+// Metal 1.2 s5.10.15: Null Texture Functions.
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture1d<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture1d_array<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture2d<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture2d_array<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture3d<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(texturecube<T, a> tex);
+#if defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+template <typename T, access a> METAL_FUNC bool is_null_texture(texturecube_array<T, a> tex);
+#endif
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture2d_ms<T, a> tex);
+#if defined(__HAVE_TEXTURE_2D_MS_ARRAY__)
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture2d_ms_array<T, a> tex);
+#endif
+#if defined(__HAVE_TEXTURE_BUFFER__)
+template <typename T, access a> METAL_FUNC bool is_null_texture(texture_buffer<T, a> tex);
+#endif
+template <typename T, access a> METAL_FUNC bool is_null_texture(depth2d<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(depth2d_array<T, a> tex);
+template <typename T, access a> METAL_FUNC bool is_null_texture(depthcube<T, a> tex);
+#if defined(__HAVE_DEPTH_CUBE_ARRAY__)
+template <typename T, access a> METAL_FUNC bool is_null_texture(depthcube_array<T, a> tex);
+#endif
+template <typename T, access a> METAL_FUNC bool is_null_texture(depth2d_ms<T, a> tex);
+#if defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+template <typename T, access a> METAL_FUNC bool is_null_texture(depth2d_ms_array<T, a> tex);
+#endif
+#endif
+
+template <typename T>
+struct _is_color_texture_channel_impl : bool_constant<__is_metal_color_texture_channel(T)>
+{
+};
+
+template <typename T>
+struct is_color_texture_channel : _is_color_texture_channel_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_color_texture_channel_v = is_color_texture_channel<T>::value;
+#endif
+
+
+template <typename T>
+struct _is_depth_texture_channel_impl : bool_constant<__is_metal_depth_texture_channel(T)>
+{
+};
+
+template <typename T>
+struct is_depth_texture_channel : _is_depth_texture_channel_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_depth_texture_channel_v = is_depth_texture_channel<T>::value;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__)
+#if !defined(__HAVE_INDIRECT_WRITABLE_TEXTURES__)
+#define _is_valid_default_construct(_a) (_a == access::read || _a == access::sample)
+#elif !defined(__HAVE_TEXTURE_READWRITE__)
+#define _is_valid_default_construct(_a) (_a == access::read || _a == access::sample || _a == access::write)
+#else
+#define _is_valid_default_construct(_a) (_a == access::read || _a == access::sample || _a == access::write || _a == access::read_write)
+#endif
+#define _err_default_construct_msg "Default constructor for textures must use access::sample or access::read as the access qualifier"
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+#if !defined(__HAVE_INDIRECT_WRITABLE_TEXTURES__)
+#define _is_valid_copy_assign(_a) (_a == access::read || _a == access::sample)
+#elif !defined(__HAVE_TEXTURE_READWRITE__)
+#define _is_valid_copy_assign(_a) (_a == access::read || _a == access::sample || _a == access::write)
+#else
+#define _is_valid_copy_assign(_a) (_a == access::read || _a == access::sample || _a == access::write || _a == access::read_write)
+#endif
+#define _err_copy_assign_msg "Assignment of textures supports only texture with access::sample or access::read access qualifier"
+#endif
+
+#define _is_valid_sample(_a) (_a == access::sample)
+#define _err_sample_access_msg "Texture sampling supports only texture with access::sample access qualifier"
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+#define _is_valid_read(_a) (_a == access::sample || _a == access::read || _a == access::read_write)
+#define _err_read_access_msg "Texture reading supports only texture with access::sample, access::read, or access::read_write as the access qualifier"
+#define _is_valid_write(_a) (_a == access::write || _a == access::read_write)
+#define _err_write_access_msg "Texture writing supports only texture with access::write or access::read_write as the access qualifier"
+#else
+#define _is_valid_read(_a) (_a == access::sample || _a == access::read)
+#define _err_read_access_msg "Texture reading supports only texture with access::read or access::sample as the access qualifier"
+#define _is_valid_write(_a) (_a == access::write)
+#define _err_write_access_msg "Texture writing supports only texture with access::write or access::read_write as the access qualifier"
+#endif
+
+#define _is_valid_gather(_a) (_a == access::sample)
+#define _err_gather_access_msg "Texture gather supports only texture with access::sample access qualifier"
+
+#define _is_valid_ms_access(_a) (_a == access::read)
+#define _err_ms_access "Multisample textures must have access qualifier access::read"
+
+#define _is_valid_texture_buffer_access(_a) (_a == access::read || _a == access::write || _a == access::read_write)
+#define _err_texture_buffer_access "Texture buffers must have access qualifier access::read, access::write, or access::read_write"
+
+#define _is_valid_depth_access(_a) (_a == access::sample || _a == access::read)
+#define _err_depth_access "Depth textures must have access qualifier access::read or access::sample"
+
+
+template <typename T, access a>
+struct texture1d<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture1d<T, a> &operator,(const thread texture1d<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d<T, a> &operator,(const device texture1d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d<T, a> &operator,(const constant texture1d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d<T, a> &operator,(const thread texture1d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d<T, a> &operator,(const device texture1d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d<T, a> &operator,(const constant texture1d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d<T, a> &operator,(const thread texture1d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d<T, a> &operator,(const device texture1d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d<T, a> &operator,(const constant texture1d<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture1d() thread : t(__metal_get_null_texture_1d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture1d() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture1d() constant : t(__metal_get_null_texture_1d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture1d() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d<T, a> &operator=(const thread texture1d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d<T, a> &operator=(const thread texture1d<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d<T, a> &operator=(const device texture1d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d<T, a> &operator=(const device texture1d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d<T, a> &operator=(const constant texture1d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d<T, a> &operator=(const constant texture1d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d<T, a> &operator=(const thread texture1d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d<T, a> &operator=(const thread texture1d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d<T, a> &operator=(const device texture1d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d<T, a> &operator=(const device texture1d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d<T, a> &operator=(const constant texture1d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d<T, a> &operator=(const constant texture1d<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_t(t, s.val, coord, false, 0, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_t(t, coord, color, lod, int(a));
+  }
+#endif
+
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_1d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_1d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_1d_t(t);
+  }
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_1d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_1d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_1d_t(t);
+  }
+#endif
+
+private:
+  texture_1d_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture1d<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct texture1d_array<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture1d_array<T, a> &operator,(const thread texture1d_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d_array<T, a> &operator,(const device texture1d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d_array<T, a> &operator,(const constant texture1d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d_array<T, a> &operator,(const thread texture1d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d_array<T, a> &operator,(const device texture1d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d_array<T, a> &operator,(const constant texture1d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture1d_array<T, a> &operator,(const thread texture1d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture1d_array<T, a> &operator,(const device texture1d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture1d_array<T, a> &operator,(const constant texture1d_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture1d_array() thread : t(__metal_get_null_texture_1d_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture1d_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture1d_array() constant : t(__metal_get_null_texture_1d_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture1d_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d_array<T, a> &operator=(const thread texture1d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d_array<T, a> &operator=(const thread texture1d_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d_array<T, a> &operator=(const device texture1d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d_array<T, a> &operator=(const device texture1d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture1d_array<T, a> &operator=(const constant texture1d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture1d_array<T, a> &operator=(const constant texture1d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d_array<T, a> &operator=(const thread texture1d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d_array<T, a> &operator=(const thread texture1d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d_array<T, a> &operator=(const device texture1d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d_array<T, a> &operator=(const device texture1d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture1d_array<T, a> &operator=(const constant texture1d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture1d_array<T, a> &operator=(const constant texture1d_array<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_1d_array_t(t, s.val, coord, array, false, 0, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort array, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort array, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint array, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint array, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort array, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort array, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint array, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint array, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord, ushort array, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort coord, ushort array, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord, uint array, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint coord, uint array, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_1d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort array, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint array, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort array, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint array, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord, ushort array, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord, uint array, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_1d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_1d_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_1d_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_1d_array_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_texture_1d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_1d_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_texture_1d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_1d_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod)
+  {
+    return __metal_get_width_texture_1d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_texture_1d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_1d_array_t(t);
+  }
+#endif
+
+private:
+  texture_1d_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture1d_array<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct texture2d<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture2d<T, a> &operator,(const thread texture2d<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d<T, a> &operator,(const device texture2d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d<T, a> &operator,(const constant texture2d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d<T, a> &operator,(const thread texture2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d<T, a> &operator,(const device texture2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d<T, a> &operator,(const constant texture2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d<T, a> &operator,(const thread texture2d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d<T, a> &operator,(const device texture2d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d<T, a> &operator,(const constant texture2d<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d() thread : t(__metal_get_null_texture_2d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture2d() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d() constant : t(__metal_get_null_texture_2d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture2d() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d<T, a> &operator=(const thread texture2d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d<T, a> &operator=(const thread texture2d<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d<T, a> &operator=(const device texture2d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d<T, a> &operator=(const device texture2d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d<T, a> &operator=(const constant texture2d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d<T, a> &operator=(const constant texture2d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d<T, a> &operator=(const thread texture2d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d<T, a> &operator=(const thread texture2d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d<T, a> &operator=(const device texture2d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d<T, a> &operator=(const device texture2d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d<T, a> &operator=(const constant texture2d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d<T, a> &operator=(const constant texture2d<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, gradient2d options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_t(t, coord, color, lod, int(a));
+  }
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0), component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_t(t, s.val, coord, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_2d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_2d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_2d_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_2d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_2d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_texture_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_2d_t(t);
+  }
+#endif
+
+private:
+  texture_2d_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture2d<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct texture2d_array<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture2d_array<T, a> &operator,(const thread texture2d_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_array<T, a> &operator,(const device texture2d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_array<T, a> &operator,(const constant texture2d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_array<T, a> &operator,(const thread texture2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_array<T, a> &operator,(const device texture2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_array<T, a> &operator,(const constant texture2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_array<T, a> &operator,(const thread texture2d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_array<T, a> &operator,(const device texture2d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_array<T, a> &operator,(const constant texture2d_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_array() thread : t(__metal_get_null_texture_2d_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture2d_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_array() constant : t(__metal_get_null_texture_2d_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture2d_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_array<T, a> &operator=(const thread texture2d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_array<T, a> &operator=(const thread texture2d_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_array<T, a> &operator=(const device texture2d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_array<T, a> &operator=(const device texture2d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_array<T, a> &operator=(const constant texture2d_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_array<T, a> &operator=(const constant texture2d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_array<T, a> &operator=(const thread texture2d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_array<T, a> &operator=(const thread texture2d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_array<T, a> &operator=(const device texture2d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_array<T, a> &operator=(const device texture2d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_array<T, a> &operator=(const constant texture2d_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_array<T, a> &operator=(const constant texture2d_array<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_array_t(t, coord, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort array, ushort lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint array, uint lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort array, ushort lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint array, uint lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort array, ushort lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint array, uint lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_2d_array_t(t, coord, array, color, lod, int(a));
+  }
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0), component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_2d_array_t(t, s.val, coord, array, true, offset, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_2d_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_2d_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_2d_array_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_texture_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_2d_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_texture_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_2d_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_texture_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_texture_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_2d_array_t(t);
+  }
+#endif
+
+private:
+  texture_2d_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture2d_array<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct texture3d<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture3d<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture3d<T, a> &operator,(const thread texture3d<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture3d<T, a> &operator,(const device texture3d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture3d<T, a> &operator,(const constant texture3d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture3d<T, a> &operator,(const thread texture3d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture3d<T, a> &operator,(const device texture3d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture3d<T, a> &operator,(const constant texture3d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture3d<T, a> &operator,(const thread texture3d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture3d<T, a> &operator,(const device texture3d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture3d<T, a> &operator,(const constant texture3d<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture3d() thread : t(__metal_get_null_texture_3d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture3d() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture3d() constant : t(__metal_get_null_texture_3d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture3d() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture3d<T, a> &operator=(const thread texture3d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture3d<T, a> &operator=(const thread texture3d<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture3d<T, a> &operator=(const device texture3d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture3d<T, a> &operator=(const device texture3d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture3d<T, a> &operator=(const constant texture3d<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture3d<T, a> &operator=(const constant texture3d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture3d<T, a> &operator=(const thread texture3d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture3d<T, a> &operator=(const thread texture3d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture3d<T, a> &operator=(const device texture3d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture3d<T, a> &operator=(const device texture3d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture3d<T, a> &operator=(const constant texture3d<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture3d<T, a> &operator=(const constant texture3d<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradient3d grad_options, min_lod_clamp min_lod_clamp_options, int3 offset = int3(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_3d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort3 coord, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort3 coord, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint3 coord, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint3 coord, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort3 coord, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort3 coord, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint3 coord, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint3 coord, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort3 coord, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort3 coord, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint3 coord, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_3d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint3 coord, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_3d_t(t, coord, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort3 coord, ushort lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint3 coord, uint lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort3 coord, ushort lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint3 coord, uint lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort3 coord, ushort lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint3 coord, uint lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    __metal_write_texture_3d_t(t, coord, color, lod, int(a));
+  }
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_3d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_3d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_3d_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_depth(uint lod = 0) const thread
+  {
+    return __metal_get_depth_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_3d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_depth(uint lod = 0) const device
+  {
+    return __metal_get_depth_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_3d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_depth(uint lod = 0) const constant
+  {
+    return __metal_get_depth_texture_3d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_3d_t(t);
+  }
+#endif
+
+private:
+  texture_3d_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture3d<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct texturecube<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texturecube<T, a> &operator,(const thread texturecube<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube<T, a> &operator,(const device texturecube<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube<T, a> &operator,(const constant texturecube<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube<T, a> &operator,(const thread texturecube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube<T, a> &operator,(const device texturecube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube<T, a> &operator,(const constant texturecube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube<T, a> &operator,(const thread texturecube<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube<T, a> &operator,(const device texturecube<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube<T, a> &operator,(const constant texturecube<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texturecube() thread : t(__metal_get_null_texture_cube_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texturecube() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texturecube() constant : t(__metal_get_null_texture_cube_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texturecube() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube<T, a> &operator=(const thread texturecube<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube<T, a> &operator=(const thread texturecube<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube<T, a> &operator=(const device texturecube<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube<T, a> &operator=(const device texturecube<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube<T, a> &operator=(const constant texturecube<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube<T, a> &operator=(const constant texturecube<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube<T, a> &operator=(const thread texturecube<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube<T, a> &operator=(const thread texturecube<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube<T, a> &operator=(const device texturecube<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube<T, a> &operator=(const device texturecube<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube<T, a> &operator=(const constant texturecube<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube<T, a> &operator=(const constant texturecube<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_CUBE_READ__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_t(t, coord, face, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_CUBE_WRITE__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_t(t, coord, face, color, lod, int(a));
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_t(t, s.val, coord, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_cube_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_cube_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_cube_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_cube_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_cube_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_texture_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_cube_t(t);
+  }
+#endif
+
+private:
+  texture_cube_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texturecube<T, a>);
+#endif
+};
+
+#if defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+template<typename T, access a>
+struct texturecube_array<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texturecube_array<T, a> &operator,(const thread texturecube_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube_array<T, a> &operator,(const device texturecube_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube_array<T, a> &operator,(const constant texturecube_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube_array<T, a> &operator,(const thread texturecube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube_array<T, a> &operator,(const device texturecube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube_array<T, a> &operator,(const constant texturecube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texturecube_array<T, a> &operator,(const thread texturecube_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texturecube_array<T, a> &operator,(const device texturecube_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texturecube_array<T, a> &operator,(const constant texturecube_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texturecube_array() thread : t(__metal_get_null_texture_cube_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texturecube_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texturecube_array() constant : t(__metal_get_null_texture_cube_array_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texturecube_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube_array<T, a> &operator=(const thread texturecube_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube_array<T, a> &operator=(const thread texturecube_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube_array<T, a> &operator=(const device texturecube_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube_array<T, a> &operator=(const device texturecube_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texturecube_array<T, a> &operator=(const constant texturecube_array<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texturecube_array<T, a> &operator=(const constant texturecube_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube_array<T, a> &operator=(const thread texturecube_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube_array<T, a> &operator=(const thread texturecube_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube_array<T, a> &operator=(const device texturecube_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube_array<T, a> &operator=(const device texturecube_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texturecube_array<T, a> &operator=(const constant texturecube_array<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texturecube_array<T, a> &operator=(const constant texturecube_array<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC vec<T, 4> sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<vec<T, 4>> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_sample_texture_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint array, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint array, uint lod = 0) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint array, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint array, uint lod = 0) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint face, uint array, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    return __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint face, uint array, uint lod = 0) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_read(a), _err_read_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_cube_array_t(t, coord, face, array, lod, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort array, ushort lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint array, uint lod = 0) const thread METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort array, ushort lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint array, uint lod = 0) const device METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort2 coord, ushort face, ushort array, ushort lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint2 coord, uint face, uint array, uint lod = 0) const constant METAL_VALID_LOD_ARG(lod)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_write(a), _err_write_access_msg);
+    return __metal_write_texture_cube_array_t(t, coord, face, array, color, lod, int(a));
+  }
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array, component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array, component c = component::x) const thread METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array, component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array, component c = component::x) const device METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array, component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array, component c = component::x) const constant METAL_CONST_ARG(c)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_texture_cube_array_t(t, s.val, coord, array, int(c), int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+#if defined(__HAVE_TEXTURE_READWRITE__)
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_cube_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_cube_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_cube_array_t(t);
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_texture_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_texture_cube_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_texture_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_texture_cube_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_texture_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_texture_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_texture_cube_array_t(t);
+  }
+#endif
+
+private:
+  texture_cube_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texturecube_array<T, a>);
+#endif
+};
+#endif // defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+
+template<typename T, access a>
+struct texture2d_ms<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_ms_access(a), _err_ms_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture2d_ms<T, a> &operator,(const thread texture2d_ms<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms<T, a> &operator,(const device texture2d_ms<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms<T, a> &operator,(const constant texture2d_ms<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms<T, a> &operator,(const thread texture2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms<T, a> &operator,(const device texture2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms<T, a> &operator,(const constant texture2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms<T, a> &operator,(const thread texture2d_ms<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms<T, a> &operator,(const device texture2d_ms<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms<T, a> &operator,(const constant texture2d_ms<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_ms() thread : t(__metal_get_null_texture_2d_ms_t())
+  {
+  }
+#else
+  texture2d_ms() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_ms() constant : t(__metal_get_null_texture_2d_ms_t())
+  {
+  }
+#else
+  texture2d_ms() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms<T, a> &operator=(const thread texture2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms<T, a> &operator=(const thread texture2d_ms<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms<T, a> &operator=(const device texture2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms<T, a> &operator=(const device texture2d_ms<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms<T, a> &operator=(const constant texture2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms<T, a> &operator=(const constant texture2d_ms<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms<T, a> &operator=(const thread texture2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms<T, a> &operator=(const thread texture2d_ms<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms<T, a> &operator=(const device texture2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms<T, a> &operator=(const device texture2d_ms<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms<T, a> &operator=(const constant texture2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms<T, a> &operator=(const constant texture2d_ms<T, a> &) device = delete;
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort sample) const thread
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort sample) const thread
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint sample) const thread
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint sample) const thread
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort sample) const device
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort sample) const device
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint sample) const device
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint sample) const device
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort sample) const constant
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort sample) const constant
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint sample) const constant
+  {
+    return __metal_read_texture_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint sample) const constant
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_t(t, coord, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width() const thread
+  {
+    return __metal_get_width_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const thread
+  {
+    return __metal_get_height_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const thread
+  {
+    return __metal_get_num_samples_texture_2d_ms_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const device
+  {
+    return __metal_get_width_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const device
+  {
+    return __metal_get_height_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const device
+  {
+    return __metal_get_num_samples_texture_2d_ms_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const constant
+  {
+    return __metal_get_width_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const constant
+  {
+    return __metal_get_height_texture_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const constant
+  {
+    return __metal_get_num_samples_texture_2d_ms_t(t);
+  }
+#endif
+
+private:
+  texture_2d_ms_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture2d_ms<T, a>);
+#endif
+};
+
+#if defined(__HAVE_TEXTURE_2D_MS_ARRAY__)
+template<typename T, access a>
+struct texture2d_ms_array<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_ms_access(a), _err_ms_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture2d_ms_array<T, a> &operator,(const thread texture2d_ms_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms_array<T, a> &operator,(const device texture2d_ms_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms_array<T, a> &operator,(const constant texture2d_ms_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms_array<T, a> &operator,(const thread texture2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms_array<T, a> &operator,(const device texture2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms_array<T, a> &operator,(const constant texture2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture2d_ms_array<T, a> &operator,(const thread texture2d_ms_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture2d_ms_array<T, a> &operator,(const device texture2d_ms_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture2d_ms_array<T, a> &operator,(const constant texture2d_ms_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_ms_array() thread : t(__metal_get_null_texture_2d_ms_array_t())
+  {
+  }
+#else
+  texture2d_ms_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture2d_ms_array() constant : t(__metal_get_null_texture_2d_ms_array_t())
+  {
+  }
+#else
+  texture2d_ms_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms_array<T, a> &operator=(const thread texture2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms_array<T, a> &operator=(const thread texture2d_ms_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms_array<T, a> &operator=(const device texture2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms_array<T, a> &operator=(const device texture2d_ms_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture2d_ms_array<T, a> &operator=(const constant texture2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture2d_ms_array<T, a> &operator=(const constant texture2d_ms_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms_array<T, a> &operator=(const thread texture2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms_array<T, a> &operator=(const thread texture2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms_array<T, a> &operator=(const device texture2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms_array<T, a> &operator=(const device texture2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture2d_ms_array<T, a> &operator=(const constant texture2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture2d_ms_array<T, a> &operator=(const constant texture2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort sample) const thread
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort sample) const thread
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint sample) const thread
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint sample) const thread
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort sample) const device
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort sample) const device
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint sample) const device
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint sample) const device
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort2 coord, ushort array, ushort sample) const constant
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(ushort2 coord, ushort array, ushort sample) const constant
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC vec<T, 4> read(uint2 coord, uint array, uint sample) const constant
+  {
+    return __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_read(uint2 coord, uint array, uint sample) const constant
+  {
+    bool nack;
+    vec<T, 4> v = __metal_read_texture_2d_ms_array_t(t, coord, array, sample, int(a), &nack, vec<T, 4>());
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width() const thread
+  {
+    return __metal_get_width_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const thread
+  {
+    return __metal_get_height_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const thread
+  {
+    return __metal_get_num_samples_texture_2d_ms_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const device
+  {
+    return __metal_get_width_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const device
+  {
+    return __metal_get_height_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const device
+  {
+    return __metal_get_num_samples_texture_2d_ms_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const constant
+  {
+    return __metal_get_width_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const constant
+  {
+    return __metal_get_height_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_texture_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const constant
+  {
+    return __metal_get_num_samples_texture_2d_ms_array_t(t);
+  }
+#endif
+
+private:
+  texture_2d_ms_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture2d_ms_array<T, a>);
+#endif
+};
+#endif // defined(__HAVE_TEXTURE_2D_MS_ARRAY__)
+
+#if defined(__HAVE_TEXTURE_BUFFER__)
+template<typename T, access a>
+struct texture_buffer<T, a, typename enable_if<is_color_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_texture_buffer_access(a), _err_texture_buffer_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture_buffer<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread texture_buffer<T, a> &operator,(const thread texture_buffer<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture_buffer<T, a> &operator,(const device texture_buffer<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture_buffer<T, a> &operator,(const constant texture_buffer<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture_buffer<T, a> &operator,(const thread texture_buffer<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture_buffer<T, a> &operator,(const device texture_buffer<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture_buffer<T, a> &operator,(const constant texture_buffer<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread texture_buffer<T, a> &operator,(const thread texture_buffer<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device texture_buffer<T, a> &operator,(const device texture_buffer<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant texture_buffer<T, a> &operator,(const constant texture_buffer<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture_buffer() thread : t(__metal_get_null_texture_buffer_1d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture_buffer() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC texture_buffer() constant : t(__metal_get_null_texture_buffer_1d_t())
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_default_construct(a), _err_default_construct_msg);
+  }
+#else
+  texture_buffer() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture_buffer<T, a> &operator=(const thread texture_buffer<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture_buffer<T, a> &operator=(const thread texture_buffer<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture_buffer<T, a> &operator=(const device texture_buffer<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture_buffer<T, a> &operator=(const device texture_buffer<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread texture_buffer<T, a> &operator=(const constant texture_buffer<T, a> &that) thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  thread texture_buffer<T, a> &operator=(const constant texture_buffer<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture_buffer<T, a> &operator=(const thread texture_buffer<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture_buffer<T, a> &operator=(const thread texture_buffer<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture_buffer<T, a> &operator=(const device texture_buffer<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture_buffer<T, a> &operator=(const device texture_buffer<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device texture_buffer<T, a> &operator=(const constant texture_buffer<T, a> &that) device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_copy_assign(a), _err_copy_assign_msg);
+    t = that.t;
+    return *this;
+  }
+#else
+  device texture_buffer<T, a> &operator=(const constant texture_buffer<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC uint get_width() const thread
+  {
+    return __metal_get_width_texture_buffer_1d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const device
+  {
+    return __metal_get_width_texture_buffer_1d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const constant
+  {
+    return __metal_get_width_texture_buffer_1d_t(t);
+  }
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord) const thread
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord) const thread
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord) const device
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord) const device
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC vec<T, 4> read(ushort coord) const constant
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+  METAL_FUNC vec<T, 4> read(uint coord) const constant
+  {
+    return __metal_read_texture_buffer_1d_t(t, coord, int(a), static_cast<thread bool*>(nullptr), vec<T, 4>());
+  }
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord) const thread
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord) const thread
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord) const device
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord) const device
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC void write(vec<T, 4> color, ushort coord) const constant
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+#endif
+  METAL_FUNC void write(vec<T, 4> color, uint coord) const constant
+  {
+    __metal_write_texture_buffer_1d_t(t, coord, color, int(a));
+  }
+
+  METAL_FUNC void fence() thread
+  {
+    __metal_fence_texture_buffer_1d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() device
+  {
+    __metal_fence_texture_buffer_1d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC void fence() constant
+  {
+    __metal_fence_texture_buffer_1d_t(t);
+  }
+#endif
+
+private:
+  texture_buffer_1d_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(texture_buffer<T, a>);
+#endif
+};
+#endif // defined(__HAVE_TEXTURE_BUFFER__)
+
+template<typename T, access a>
+struct depth2d<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_depth_access(a), _err_depth_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depth2d<T, a> &operator,(const thread depth2d<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d<T, a> &operator,(const device depth2d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d<T, a> &operator,(const constant depth2d<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d<T, a> &operator,(const thread depth2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d<T, a> &operator,(const device depth2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d<T, a> &operator,(const constant depth2d<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d<T, a> &operator,(const thread depth2d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d<T, a> &operator,(const device depth2d<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d<T, a> &operator,(const constant depth2d<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d() thread : t(__metal_get_null_depth_2d_t())
+  {
+  }
+#else
+  depth2d() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d() constant : t(__metal_get_null_depth_2d_t())
+  {
+  }
+#else
+  depth2d() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d<T, a> &operator=(const thread depth2d<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d<T, a> &operator=(const thread depth2d<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d<T, a> &operator=(const device depth2d<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d<T, a> &operator=(const device depth2d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d<T, a> &operator=(const constant depth2d<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d<T, a> &operator=(const constant depth2d<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d<T, a> &operator=(const thread depth2d<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d<T, a> &operator=(const thread depth2d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d<T, a> &operator=(const device depth2d<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d<T, a> &operator=(const device depth2d<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d<T, a> &operator=(const constant depth2d<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d<T, a> &operator=(const constant depth2d<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC T sample(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t(t, s.val, coord, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const thread METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const thread METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const device METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const device METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const constant METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, level options, int2 offset = int2(0)) const constant METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort lod = 0) const thread
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint lod = 0) const thread
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort lod = 0) const device
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint lod = 0) const device
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort lod = 0) const constant
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint lod = 0) const constant
+  {
+    return __metal_read_depth_2d_t(t, coord, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_t(t, coord, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_t(t, s.val, coord, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_t(t, s.val, coord, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_depth_2d_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_depth_2d_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_depth_2d_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_depth_2d_t(t);
+  }
+#endif
+
+private:
+  depth_2d_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depth2d<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct depth2d_array<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_depth_access(a), _err_depth_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depth2d_array<T, a> &operator,(const thread depth2d_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_array<T, a> &operator,(const device depth2d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_array<T, a> &operator,(const constant depth2d_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_array<T, a> &operator,(const thread depth2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_array<T, a> &operator,(const device depth2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_array<T, a> &operator,(const constant depth2d_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_array<T, a> &operator,(const thread depth2d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_array<T, a> &operator,(const device depth2d_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_array<T, a> &operator,(const constant depth2d_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_array() thread : t(__metal_get_null_depth_2d_array_t())
+  {
+  }
+#else
+  depth2d_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_array() constant : t(__metal_get_null_depth_2d_array_t())
+  {
+  }
+#else
+  depth2d_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_array<T, a> &operator=(const thread depth2d_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_array<T, a> &operator=(const thread depth2d_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_array<T, a> &operator=(const device depth2d_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_array<T, a> &operator=(const device depth2d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_array<T, a> &operator=(const constant depth2d_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_array<T, a> &operator=(const constant depth2d_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_array<T, a> &operator=(const thread depth2d_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_array<T, a> &operator=(const thread depth2d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_array<T, a> &operator=(const device depth2d_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_array<T, a> &operator=(const device depth2d_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_array<T, a> &operator=(const constant depth2d_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_array<T, a> &operator=(const constant depth2d_array<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, level options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t(t, s.val, coord, array, true, offset, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, true, offset, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float2 coord, uint array, gradient2d grad_options, min_lod_clamp min_lod_clamp_options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_2d_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, true, offset, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const thread METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const thread METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const device METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const device METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const constant METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, level options, int2 offset = int2(0)) const constant METAL_VALID_LOD_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float2 coord, uint array, float compare_value, min_lod_clamp options, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort lod = 0) const thread
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint lod = 0) const thread
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort lod = 0) const device
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint lod = 0) const device
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort lod = 0) const constant
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint lod = 0) const constant
+  {
+    return __metal_read_depth_2d_array_t(t, coord, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_array_t(t, coord, array, lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float2 coord, uint array, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_2d_array_t(t, s.val, coord, array, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float2 coord, uint array, float compare_value, int2 offset = int2(0)) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_2d_array_t(t, s.val, coord, array, compare_value, true, offset, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_depth_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_depth_2d_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_depth_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_depth_2d_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_depth_2d_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_depth_2d_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_depth_2d_array_t(t);
+  }
+#endif
+
+private:
+  depth_2d_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depth2d_array<T, a>);
+#endif
+};
+
+template<typename T, access a>
+struct depthcube<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_depth_access(a), _err_depth_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depthcube<T, a> &operator,(const thread depthcube<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube<T, a> &operator,(const device depthcube<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube<T, a> &operator,(const constant depthcube<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube<T, a> &operator,(const thread depthcube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube<T, a> &operator,(const device depthcube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube<T, a> &operator,(const constant depthcube<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube<T, a> &operator,(const thread depthcube<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube<T, a> &operator,(const device depthcube<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube<T, a> &operator,(const constant depthcube<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depthcube() thread : t(__metal_get_null_depth_cube_t())
+  {
+  }
+#else
+  depthcube() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depthcube() constant : t(__metal_get_null_depth_cube_t())
+  {
+  }
+#else
+  depthcube() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube<T, a> &operator=(const thread depthcube<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube<T, a> &operator=(const thread depthcube<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube<T, a> &operator=(const device depthcube<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube<T, a> &operator=(const device depthcube<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube<T, a> &operator=(const constant depthcube<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube<T, a> &operator=(const constant depthcube<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube<T, a> &operator=(const thread depthcube<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube<T, a> &operator=(const thread depthcube<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube<T, a> &operator=(const device depthcube<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube<T, a> &operator=(const device depthcube<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube<T, a> &operator=(const constant depthcube<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube<T, a> &operator=(const constant depthcube<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC T sample(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t(t, s.val, coord, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_t_grad(t, s.val, coord, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, level options) const thread METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, level options) const device METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, level options) const constant METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, float compare_value, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_t(t, s.val, coord, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#endif
+
+#if defined(__HAVE_DEPTH_CUBE_READ__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort lod = 0) const thread
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint lod = 0) const thread
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort lod = 0) const device
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint lod = 0) const device
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort lod = 0) const constant
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint lod = 0) const constant
+  {
+    return __metal_read_depth_cube_t(t, coord, face, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_t(t, coord, face, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_t(t, s.val, coord, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_t(t, s.val, coord, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_t(t, s.val, coord, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_t(t, s.val, coord, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_t(t, s.val, coord, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined (__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_t(t, s.val, coord, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_t(t, s.val, coord, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_depth_cube_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_depth_cube_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_depth_cube_t(t, lod);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_depth_cube_t(t);
+  }
+#endif
+
+private:
+  depth_cube_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depthcube<T, a>);
+#endif
+};
+
+#if defined(__HAVE_DEPTH_CUBE_ARRAY__)
+template<typename T, access a>
+struct depthcube_array<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_depth_access(a), _err_depth_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depthcube_array<T, a> &operator,(const thread depthcube_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube_array<T, a> &operator,(const device depthcube_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube_array<T, a> &operator,(const constant depthcube_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube_array<T, a> &operator,(const thread depthcube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube_array<T, a> &operator,(const device depthcube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube_array<T, a> &operator,(const constant depthcube_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depthcube_array<T, a> &operator,(const thread depthcube_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depthcube_array<T, a> &operator,(const device depthcube_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depthcube_array<T, a> &operator,(const constant depthcube_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depthcube_array() thread : t(__metal_get_null_depth_cube_array_t())
+  {
+  }
+#else
+  depthcube_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depthcube_array() constant : t(__metal_get_null_depth_cube_array_t())
+  {
+  }
+#else
+  depthcube_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube_array<T, a> &operator=(const thread depthcube_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube_array<T, a> &operator=(const thread depthcube_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube_array<T, a> &operator=(const device depthcube_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube_array<T, a> &operator=(const device depthcube_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depthcube_array<T, a> &operator=(const constant depthcube_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depthcube_array<T, a> &operator=(const constant depthcube_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube_array<T, a> &operator=(const thread depthcube_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube_array<T, a> &operator=(const thread depthcube_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube_array<T, a> &operator=(const device depthcube_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube_array<T, a> &operator=(const device depthcube_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depthcube_array<T, a> &operator=(const constant depthcube_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depthcube_array<T, a> &operator=(const constant depthcube_array<T, a> &) device = delete;
+#endif
+#endif
+
+  METAL_FUNC T sample(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, level options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, level options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, options.value, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, level options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t(t, s.val, coord, array, false, bias_options.value, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, options.dPdx, options.dPdy, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample(sampler s, float3 coord, uint array, gradientcube grad_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_depth_cube_array_t_grad(t, s.val, coord, array, grad_options.dPdx, grad_options.dPdy, min_lod_clamp_options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const thread METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, bias bias_options, min_lod_clamp min_lod_clamp_options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const thread METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const device METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, bias bias_options, min_lod_clamp min_lod_clamp_options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const device METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const constant METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+  METAL_FUNC T sample_compare(sampler s, float3 coord, uint array, float compare_value, bias bias_options, min_lod_clamp min_lod_clamp_options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    return __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, bias_options.value, min_lod_clamp_options.value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#endif
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, level options) const constant METAL_VALID_LEVEL_ARG(options)
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, true, options.lod, 0.0f, int(a), &nack);
+    return {v, nack};
+  }
+#if defined(__HAVE_MIN_LOD_CLAMP__)
+  METAL_FUNC checked_color<T> check_sample_compare(sampler s, float3 coord, uint array, float compare_value, min_lod_clamp options) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_sample(a), _err_sample_access_msg);
+    bool nack;
+    T v = __metal_sample_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, false, 0.0f, options.value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const thread
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint array, uint lod = 0) const thread
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint array, uint lod = 0) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const device
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint array, uint lod = 0) const device
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint array, uint lod = 0) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const constant
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort face, ushort array, ushort lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint face, uint array, uint lod = 0) const constant
+  {
+    return __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint face, uint array, uint lod = 0) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_cube_array_t(t, coord, face, array, lod, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather(sampler s, float3 coord, uint array) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_depth_cube_array_t(t, s.val, coord, array, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, uint array, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, uint array, float compare_value) const thread
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, uint array, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, uint array, float compare_value) const device
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC vec<T, 4> gather_compare(sampler s, float3 coord, uint array, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    return __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<vec<T, 4>> check_gather_compare(sampler s, float3 coord, uint array, float compare_value) const constant
+  {
+    // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+    // -- see <rdar://problem/31769738>.
+    static_assert(_is_valid_gather(a), _err_gather_access_msg);
+    bool nack;
+    vec<T, 4> v = __metal_gather_compare_depth_cube_array_t(t, s.val, coord, array, compare_value, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width(uint lod = 0) const thread
+  {
+    return __metal_get_width_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const thread
+  {
+    return __metal_get_height_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_depth_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const thread
+  {
+    return __metal_get_num_mip_levels_depth_cube_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const device
+  {
+    return __metal_get_width_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const device
+  {
+    return __metal_get_height_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_depth_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const device
+  {
+    return __metal_get_num_mip_levels_depth_cube_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width(uint lod = 0) const constant
+  {
+    return __metal_get_width_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_height(uint lod = 0) const constant
+  {
+    return __metal_get_height_depth_cube_array_t(t, lod);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_depth_cube_array_t(t);
+  }
+  METAL_FUNC uint get_num_mip_levels() const constant
+  {
+    return __metal_get_num_mip_levels_depth_cube_array_t(t);
+  }
+#endif
+
+private:
+  depth_cube_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depthcube_array<T, a>);
+#endif
+};
+#endif // defined(__HAVE_DEPTH_CUBE_ARRAY__)
+
+template<typename T, access a>
+struct depth2d_ms<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_ms_access(a), _err_ms_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depth2d_ms<T, a> &operator,(const thread depth2d_ms<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms<T, a> &operator,(const device depth2d_ms<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms<T, a> &operator,(const constant depth2d_ms<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms<T, a> &operator,(const thread depth2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms<T, a> &operator,(const device depth2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms<T, a> &operator,(const constant depth2d_ms<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms<T, a> &operator,(const thread depth2d_ms<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms<T, a> &operator,(const device depth2d_ms<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms<T, a> &operator,(const constant depth2d_ms<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_ms() thread : t(__metal_get_null_depth_2d_ms_t())
+  {
+  }
+#else
+  depth2d_ms() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_ms() constant : t(__metal_get_null_depth_2d_ms_t())
+  {
+  }
+#else
+  depth2d_ms() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms<T, a> &operator=(const thread depth2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms<T, a> &operator=(const thread depth2d_ms<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms<T, a> &operator=(const device depth2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms<T, a> &operator=(const device depth2d_ms<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms<T, a> &operator=(const constant depth2d_ms<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms<T, a> &operator=(const constant depth2d_ms<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms<T, a> &operator=(const thread depth2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms<T, a> &operator=(const thread depth2d_ms<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms<T, a> &operator=(const device depth2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms<T, a> &operator=(const device depth2d_ms<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms<T, a> &operator=(const constant depth2d_ms<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms<T, a> &operator=(const constant depth2d_ms<T, a> &) device = delete;
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort sample) const thread
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort sample) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint sample) const thread
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint sample) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort sample) const device
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort sample) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint sample) const device
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint sample) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort sample) const constant
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort sample) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint sample) const constant
+  {
+    return __metal_read_depth_2d_ms_t(t, coord, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint sample) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_t(t, coord, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width() const thread
+  {
+    return __metal_get_width_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const thread
+  {
+    return __metal_get_height_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const thread
+  {
+    return __metal_get_num_samples_depth_2d_ms_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const device
+  {
+    return __metal_get_width_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const device
+  {
+    return __metal_get_height_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const device
+  {
+    return __metal_get_num_samples_depth_2d_ms_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const constant
+  {
+    return __metal_get_width_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_height() const constant
+  {
+    return __metal_get_height_depth_2d_ms_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const constant
+  {
+    return __metal_get_num_samples_depth_2d_ms_t(t);
+  }
+#endif
+
+private:
+  depth_2d_ms_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depth2d_ms<T, a>);
+#endif
+};
+
+#if defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+template<typename T, access a>
+struct depth2d_ms_array<T, a, typename enable_if<is_depth_texture_channel<T>::value>::type>
+{
+  // TODO: Using static assert prevents usage of SFINAE. We need to remove it
+  // -- see <rdar://problem/31769738>.
+  static_assert(_is_valid_ms_access(a), _err_ms_access);
+#if !defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms_array<T, a> &operator&() const thread = delete;
+#endif
+
+  const thread depth2d_ms_array<T, a> &operator,(const thread depth2d_ms_array<T, a> &) const thread = delete;
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms_array<T, a> &operator,(const device depth2d_ms_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms_array<T, a> &operator,(const constant depth2d_ms_array<T, a> &) const thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms_array<T, a> &operator,(const thread depth2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms_array<T, a> &operator,(const device depth2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms_array<T, a> &operator,(const constant depth2d_ms_array<T, a> &) const device = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const thread depth2d_ms_array<T, a> &operator,(const thread depth2d_ms_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const device depth2d_ms_array<T, a> &operator,(const device depth2d_ms_array<T, a> &) const constant = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  const constant depth2d_ms_array<T, a> &operator,(const constant depth2d_ms_array<T, a> &) const constant = delete;
+#endif
+
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_ms_array() thread : t(__metal_get_null_depth_2d_ms_array_t())
+  {
+  }
+#else
+  depth2d_ms_array() thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_DEFAULT_CONSTRUCTABLE_TEXTURE__) && defined(__HAVE_NULL_TEXTURE__)
+  METAL_FUNC depth2d_ms_array() constant : t(__metal_get_null_depth_2d_ms_array_t())
+  {
+  }
+#else
+  depth2d_ms_array() constant = delete;
+#endif
+#endif
+
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms_array<T, a> &operator=(const thread depth2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms_array<T, a> &operator=(const thread depth2d_ms_array<T, a> &) thread = delete;
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms_array<T, a> &operator=(const device depth2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms_array<T, a> &operator=(const device depth2d_ms_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC thread depth2d_ms_array<T, a> &operator=(const constant depth2d_ms_array<T, a> &that) thread
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  thread depth2d_ms_array<T, a> &operator=(const constant depth2d_ms_array<T, a> &) thread = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms_array<T, a> &operator=(const thread depth2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms_array<T, a> &operator=(const thread depth2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms_array<T, a> &operator=(const device depth2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms_array<T, a> &operator=(const device depth2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_COPY_ASSIGNABLE_TEXTURE__)
+  METAL_FUNC device depth2d_ms_array<T, a> &operator=(const constant depth2d_ms_array<T, a> &that) device
+  {
+    t = that.t;
+    return *this;
+  }
+#else
+  device depth2d_ms_array<T, a> &operator=(const constant depth2d_ms_array<T, a> &) device = delete;
+#endif
+#endif
+
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort sample) const thread
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort sample) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint sample) const thread
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint sample) const thread
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort sample) const device
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort sample) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint sample) const device
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint sample) const device
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+#if defined(__HAVE_16B_COORDS__)
+  METAL_FUNC T read(ushort2 coord, ushort array, ushort sample) const constant
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(ushort2 coord, ushort array, ushort sample) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+  METAL_FUNC T read(uint2 coord, uint array, uint sample) const constant
+  {
+    return __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), static_cast<thread bool*>(nullptr));
+  }
+#if defined(__HAVE_SPARSE_TEXTURES__)
+  METAL_FUNC checked_color<T> check_read(uint2 coord, uint array, uint sample) const constant
+  {
+    bool nack;
+    T v = __metal_read_depth_2d_ms_array_t(t, coord, array, sample, int(a), &nack);
+    return {v, nack};
+  }
+#endif
+#endif
+
+  METAL_FUNC uint get_width() const thread
+  {
+    return __metal_get_width_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const thread
+  {
+    return __metal_get_height_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const thread
+  {
+    return __metal_get_array_size_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const thread
+  {
+    return __metal_get_num_samples_depth_2d_ms_array_t(t);
+  }
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const device
+  {
+    return __metal_get_width_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const device
+  {
+    return __metal_get_height_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const device
+  {
+    return __metal_get_array_size_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const device
+  {
+    return __metal_get_num_samples_depth_2d_ms_array_t(t);
+  }
+#endif
+#if defined(__HAVE_INDIRECT_ARGUMENT_BUFFER__)
+  METAL_FUNC uint get_width() const constant
+  {
+    return __metal_get_width_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_height() const constant
+  {
+    return __metal_get_height_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_array_size() const constant
+  {
+    return __metal_get_array_size_depth_2d_ms_array_t(t);
+  }
+  METAL_FUNC uint get_num_samples() const constant
+  {
+    return __metal_get_num_samples_depth_2d_ms_array_t(t);
+  }
+#endif
+
+private:
+  depth_2d_ms_array_t t;
+
+#if defined(__HAVE_NULL_TEXTURE__)
+  friend METAL_FUNC bool metal::is_null_texture<T, a>(depth2d_ms_array<T, a>);
+#endif
+};
+#endif // defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+
+#if defined(__HAVE_NULL_TEXTURE__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture1d<T, a> tex)
+{
+  return __metal_is_null_texture_1d_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture1d_array<T, a> tex)
+{
+  return __metal_is_null_texture_1d_array_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture2d<T, a> tex)
+{
+  return __metal_is_null_texture_2d_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture2d_array<T, a> tex)
+{
+  return __metal_is_null_texture_2d_array_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture3d<T, a> tex)
+{
+  return __metal_is_null_texture_3d_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texturecube<T, a> tex)
+{
+  return __metal_is_null_texture_cube_t(tex.t);
+}
+#if defined(__HAVE_TEXTURE_CUBE_ARRAY__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texturecube_array<T, a> tex)
+{
+  return __metal_is_null_texture_cube_array_t(tex.t);
+}
+#endif
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture2d_ms<T, a> tex)
+{
+  return __metal_is_null_texture_2d_ms_t(tex.t);
+}
+#if defined (__HAVE_TEXTURE_2D_MS_ARRAY__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture2d_ms_array<T, a> tex)
+{
+  return __metal_is_null_texture_2d_ms_array_t(tex.t);
+}
+#endif
+#if defined(__HAVE_TEXTURE_BUFFER__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(texture_buffer<T, a> tex)
+{
+  return __metal_is_null_texture_buffer_1d_t(tex.t);
+}
+#endif // defined(__HAVE_TEXTURE_BUFFER__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depth2d<T, a> tex)
+{
+  return __metal_is_null_depth_2d_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depth2d_array<T, a> tex)
+{
+  return __metal_is_null_depth_2d_array_t(tex.t);
+}
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depthcube<T, a> tex)
+{
+  return __metal_is_null_depth_cube_t(tex.t);
+}
+#if defined(__HAVE_DEPTH_CUBE_ARRAY__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depthcube_array<T, a> tex)
+{
+  return __metal_is_null_depth_cube_array_t(tex.t);
+}
+#endif
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depth2d_ms<T, a> tex)
+{
+  return __metal_is_null_depth_2d_ms_t(tex.t);
+}
+#if defined(__HAVE_DEPTH_2D_MS_ARRAY__)
+template <typename T, access a>
+METAL_FUNC bool is_null_texture(depth2d_ms_array<T, a> tex)
+{
+  return __metal_is_null_depth_2d_ms_array_t(tex.t);
+}
+#endif
+#endif // defined(__HAVE_NULL_TEXTURE__)
+} // namespace metal
+#pragma METAL internals : disable
+
+#endif // __METAL_TEXTURE
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tracing b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tracing
new file mode 100644
index 00000000..244686be
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_tracing
@@ -0,0 +1,435 @@
+//===-- metal_tracing -----------------------------------------------------===//
+// Copyright (c) 2018 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_TRACING
+#define __METAL_TRACING
+
+#if defined(__HAVE_TRACING__)
+
+using namespace metal;
+
+uint32_t kernel_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                  uint3 thread_position_in_grid,
+                                  device void *trace_buffer)
+  __asm("_metal_kernel_thread_tracepoint");
+
+uint32_t vertex_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                  uint vertex_id, uint instance_id,
+                                  device void *trace_buffer)
+  __asm("_metal_vertex_thread_tracepoint");
+
+uint32_t fragment_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                    float4 position, uint sample_id,
+                                    device void *trace_buffer)
+  __asm("_metal_fragment_thread_tracepoint");
+
+uint32_t post_tesselation_vertex_thread_tracepoint(
+    constant uint32_t *module_id, uint32_t id,
+    uint patch_id, uint instance_id,
+    device void *trace_buffer)
+  __asm("_metal_post_tesselation_vertex_thread_tracepoint");
+
+void waypoint_tracepoint(constant uint32_t *module_id, uint32_t id,
+                         uint32_t thread_id, device void *trace_buffer)
+  __asm("_metal_waypoint_tracepoint");
+
+void variable_tracepoint(constant uint32_t *module_id, uint32_t id,
+                         const thread void *address,
+                         uint32_t thread_id, device void *trace_buffer)
+  __asm("_metal_variable_tracepoint.p0i8");
+
+void data_tracepoint(constant uint32_t *module_id, uint32_t id,
+                     const thread void *address, unsigned size,
+                     uint32_t thread_id, device void *trace_buffer)
+  __asm("_metal_data_tracepoint.p0i8");
+
+void data_tracepoint(constant uint32_t *module_id, uint32_t id,
+                     const threadgroup void *address, unsigned size,
+                     uint32_t thread_id, device void *trace_buffer)
+  __asm("_metal_data_tracepoint.p3i8");
+
+#pragma METAL internals : enable
+
+#include <metal_atomic>
+
+namespace {
+struct TraceBuffer {
+  inline uint32_t get_thread_id() device;
+  inline device void *reserve(uint32_t size) device;
+
+private:
+  // Thread-id counter.
+  atomic_uint thread_id;
+
+  // The size of the trace buffer including the header.
+  const uint32_t trace_stream_size;
+
+  // The position of the trace stream.
+  atomic_uint trace_stream_position;
+};
+
+struct KernelTraceBuffer : TraceBuffer {
+  inline bool is_in_region_of_interest(
+      uint3 the_thread_position_in_grid) const device;
+
+private:
+  uint3 thread_position_in_grid[2];
+};
+
+struct VertexTraceBuffer : TraceBuffer {
+  inline bool is_in_region_of_interest(uint the_vertex_id,
+                                       uint the_instance_id) const device;
+
+private:
+  uint instance_id;
+  uint vertex_count;
+  uint vertex_ids[1];
+
+};
+
+struct FragmentTraceBuffer : TraceBuffer {
+  inline bool is_in_region_of_interest(float4 the_position,
+                                       uint the_sample_id) const device;
+
+private:
+  float4 position[2];
+  uint sample_id[2];
+};
+
+struct PostTesselationVertexTraceBuffer : TraceBuffer {
+  inline bool is_in_region_of_interest(uint the_patch_id,
+                                       uint the_instance_id) const device;
+
+private:
+  uint instance_id;
+  uint patch_count;
+  uint patch_ids[1];
+};
+}
+
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+__attribute__((no_tracepoint)) T my_atomic_fetch_add_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_add_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+
+template <typename T, typename U, typename _E = typename enable_if<_disjunction<is_same<T, int>, is_same<T, uint>>::value && is_convertible<T, U>::value>::type>
+__attribute__((no_tracepoint)) T my_atomic_fetch_sub_explicit(volatile device _atomic<T>* object, U operand, memory_order order) METAL_CONST_ARG(order)
+{
+  return __metal_atomic_fetch_sub_explicit(&object->__s, T(operand), int(order), __METAL_MEMORY_SCOPE_DEVICE__);
+}
+
+template <typename T, typename _E = typename enable_if<is_same<make_scalar_t<T>, bool>::value>::type>
+__attribute__((no_tracepoint)) bool my_all(T x)
+{
+  return __metal_all(x);
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+uint32_t TraceBuffer::get_thread_id() device {
+  // TODO: Handle overflow of thread-ids.
+  return my_atomic_fetch_add_explicit(&thread_id, 1, memory_order_relaxed);
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+device void *TraceBuffer::reserve(uint32_t size) device {
+  // NOTE: Ignore the overflow that could theoretically happen here.
+  uint32_t position = my_atomic_fetch_add_explicit(&trace_stream_position, size,
+                                                   memory_order_relaxed);
+  if ((position + size) >= trace_stream_size) {
+    my_atomic_fetch_sub_explicit(&trace_stream_position, size,
+                                 memory_order_relaxed);
+    return nullptr;
+  }
+  return ((device uint8_t *) this) + position;
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+bool KernelTraceBuffer::is_in_region_of_interest(
+    uint3 the_thread_position_in_grid) const device {
+  return (my_all(thread_position_in_grid[0] <= the_thread_position_in_grid) &&
+          my_all(the_thread_position_in_grid <= thread_position_in_grid[1]));
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+bool VertexTraceBuffer::is_in_region_of_interest(
+    uint the_vertex_id, uint the_instance_id) const device {
+  if (instance_id == the_instance_id) {
+    device auto *ids = &vertex_ids[0];
+    for (unsigned i = 0; i != vertex_count; ++i)
+      if (the_vertex_id == ids[i])
+        return true;
+  }
+  return false;
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+bool FragmentTraceBuffer::is_in_region_of_interest(
+    float4 the_position, uint the_sample_id) const device {
+  return (my_all(position[0] <= the_position) &&
+          my_all(the_position <= position[1]) &&
+          (sample_id[0] <= the_sample_id) && (the_sample_id <= sample_id[1]));
+}
+
+METAL_INTERNAL __attribute__((no_tracepoint))
+bool PostTesselationVertexTraceBuffer::is_in_region_of_interest(
+    uint the_patch_id, uint the_instance_id) const device {
+  if (instance_id == the_instance_id) {
+    device auto *ids = &patch_ids[0];
+    for (unsigned i = 0; i != patch_count; ++i)
+      if (the_patch_id == ids[i])
+        return true;
+  }
+  return false;
+}
+
+#pragma METAL internals : disable
+
+#define MEMCPY __builtin_memcpy
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+uint32_t kernel_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                  uint3 thread_position_in_grid,
+                                  device void *trace_buffer) {
+  device auto *tb = (device KernelTraceBuffer *) trace_buffer;
+
+  if (!tb->is_in_region_of_interest(thread_position_in_grid))
+    return 0;
+
+  uint32_t thread_id = tb->get_thread_id();
+  if (thread_id == 0)
+    return 0;
+
+  device uint8_t *stream =
+      (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +
+                                     sizeof (thread_position_in_grid));
+  if (!stream)
+    return 0;
+
+  MEMCPY(stream, &thread_id, sizeof(thread_id));
+  stream += sizeof(thread_id);
+
+  uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);
+  MEMCPY(stream, &real_id, sizeof(real_id));
+  stream += sizeof(real_id);
+
+  MEMCPY(stream, &thread_position_in_grid,
+         sizeof(thread_position_in_grid));
+  stream += sizeof(thread_position_in_grid);
+
+  return thread_id;
+}
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+uint32_t vertex_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                  uint vertex_id, uint instance_id,
+                                  device void *trace_buffer) {
+  device auto *tb = (device VertexTraceBuffer *) trace_buffer;
+
+  if (!tb->is_in_region_of_interest(vertex_id, instance_id))
+    return 0;
+
+  uint32_t thread_id = tb->get_thread_id();
+  if (thread_id == 0)
+    return 0;
+
+  device uint8_t *stream =
+      (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +
+                                     sizeof(vertex_id) + sizeof(instance_id));
+  if (!stream)
+    return 0;
+
+  MEMCPY(stream, &thread_id, sizeof(thread_id));
+  stream += sizeof(thread_id);
+
+  uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);
+  MEMCPY(stream, &real_id, sizeof(real_id));
+  stream += sizeof(real_id);
+
+  MEMCPY(stream, &vertex_id, sizeof(vertex_id));
+  stream += sizeof(vertex_id);
+
+  MEMCPY(stream, &instance_id, sizeof(instance_id));
+  stream += sizeof(instance_id);
+
+  return thread_id;
+}
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+uint32_t fragment_thread_tracepoint(constant uint32_t *module_id, uint32_t id,
+                                    float4 position, uint sample_id,
+                                    device void *trace_buffer) {
+  device auto *tb = (device FragmentTraceBuffer *) trace_buffer;
+
+  if (!tb->is_in_region_of_interest(position, sample_id))
+    return 0;
+
+  uint32_t thread_id = tb->get_thread_id();
+  if (thread_id == 0)
+    return 0;
+
+  device uint8_t *stream =
+      (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +
+                                     sizeof(position) + sizeof(sample_id));
+  if (!stream)
+    return 0;
+
+  MEMCPY(stream, &thread_id, sizeof(thread_id));
+  stream += sizeof(thread_id);
+
+  uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);
+  MEMCPY(stream, &real_id, sizeof(real_id));
+  stream += sizeof(real_id);
+
+  MEMCPY(stream, &position, sizeof(position));
+  stream += sizeof(position);
+
+  MEMCPY(stream, &sample_id, sizeof(sample_id));
+  stream += sizeof(sample_id);
+
+  return thread_id;
+}
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+uint32_t post_tesselation_vertex_thread_tracepoint(
+    constant uint32_t *module_id, uint32_t id,
+    uint patch_id, uint instance_id,
+    device void *trace_buffer) {
+  device auto *tb = (device PostTesselationVertexTraceBuffer *) trace_buffer;
+
+  if (!tb->is_in_region_of_interest(patch_id, instance_id))
+    return 0;
+
+  uint32_t thread_id = tb->get_thread_id();
+  if (thread_id == 0)
+    return 0;
+
+  device uint8_t *stream =
+      (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +
+                                     sizeof(patch_id) + sizeof(instance_id));
+  if (!stream)
+    return 0;
+
+  MEMCPY(stream, &thread_id, sizeof(thread_id));
+  stream += sizeof(thread_id);
+
+  uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);
+  MEMCPY(stream, &real_id, sizeof(real_id));
+  stream += sizeof(real_id);
+
+  MEMCPY(stream, &patch_id, sizeof(patch_id));
+  stream += sizeof(patch_id);
+
+  MEMCPY(stream, &instance_id, sizeof(instance_id));
+  stream += sizeof(instance_id);
+
+  return 0;
+}
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+void waypoint_tracepoint(constant uint32_t *module_id, uint32_t id,
+                         uint32_t thread_id, device void *trace_buffer) {
+  if (thread_id == 0)
+    return;
+
+  device TraceBuffer *tb = (device TraceBuffer *) trace_buffer;
+  device uint8_t *stream =
+      (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id));
+  if (!stream)
+    return;
+
+  MEMCPY(stream, &thread_id, sizeof(thread_id));
+  stream += sizeof(thread_id);
+
+  uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);
+  MEMCPY(stream, &real_id, sizeof(real_id));
+  stream += sizeof(real_id);
+}
+
+#define VARIABLE_TRACEPOINT(AS)                                                           \
+    METAL_INTERNAL __attribute__((no_tracepoint))                                         \
+    static void variable_tracepoint_impl(constant uint32_t *module_id, uint32_t id,       \
+                                         const AS void *address,                          \
+                                         uint32_t thread_id, device void *trace_buffer) { \
+      if (thread_id == 0)                                                                 \
+        return;                                                                           \
+                                                                                          \
+      device TraceBuffer *tb = (device TraceBuffer *) trace_buffer;                       \
+      device uint8_t *stream =                                                            \
+          (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +                 \
+                                         sizeof(address));                                \
+      if (!stream)                                                                        \
+        return;                                                                           \
+                                                                                          \
+      MEMCPY(stream, &thread_id, sizeof(thread_id));                                      \
+      stream += sizeof(thread_id);                                                        \
+                                                                                          \
+      uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);                           \
+      MEMCPY(stream, &real_id, sizeof(real_id));                                          \
+      stream += sizeof(real_id);                                                          \
+                                                                                          \
+      MEMCPY(stream, &address, sizeof(address));                                          \
+      stream += sizeof(address);                                                          \
+    }
+
+VARIABLE_TRACEPOINT(thread)
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+void variable_tracepoint(constant uint32_t *module_id, uint32_t id,
+                         const thread void *address,
+                         uint32_t thread_id, device void *trace_buffer) {
+  variable_tracepoint_impl(module_id, id, address, thread_id, trace_buffer);
+}
+
+#define STATIC_DATA_TRACEPOINT(AS)                                                           \
+    METAL_INTERNAL __attribute__((no_tracepoint))                                            \
+    static void static_data_tracepoint_impl(constant uint32_t *module_id, uint32_t id,       \
+                                            const AS void *address, uint32_t size,           \
+                                            uint32_t thread_id, device void *trace_buffer) { \
+      if (thread_id == 0)                                                                    \
+        return;                                                                              \
+                                                                                             \
+      device TraceBuffer *tb = (device TraceBuffer *) trace_buffer;                          \
+      uint32_t adjusted_size = (size + 3) & ~0x3;                                            \
+      device uint8_t *stream =                                                               \
+          (device uint8_t *) tb->reserve(sizeof(id) + sizeof(thread_id) +                    \
+                                         sizeof(address) + adjusted_size);                   \
+      if (!stream)                                                                           \
+        return;                                                                              \
+                                                                                             \
+      MEMCPY(stream, &thread_id, sizeof(thread_id));                                         \
+      stream += sizeof(thread_id);                                                           \
+                                                                                             \
+      uint32_t real_id = (*module_id << 24) | ((id << 8) >> 8);                              \
+      MEMCPY(stream, &real_id, sizeof(real_id));                                             \
+      stream += sizeof(real_id);                                                             \
+                                                                                             \
+      MEMCPY(stream, &address, sizeof(address));                                             \
+      stream += sizeof(address);                                                             \
+                                                                                             \
+      MEMCPY(stream, address, size);                                                         \
+      stream += size;                                                                        \
+    }
+
+STATIC_DATA_TRACEPOINT(thread)
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+void data_tracepoint(constant uint32_t *module_id, uint32_t id,
+                     const thread void *address, unsigned size,
+                     uint32_t thread_id, device void *trace_buffer) {
+  static_data_tracepoint_impl(module_id, id, address, size, thread_id, trace_buffer);
+}
+
+STATIC_DATA_TRACEPOINT(threadgroup)
+
+METAL_INTERNAL __attribute__((noinline, no_tracepoint, weak))
+void data_tracepoint(constant uint32_t *module_id, uint32_t id,
+                     const threadgroup void *address, unsigned size,
+                     uint32_t thread_id, device void *trace_buffer) {
+  static_data_tracepoint_impl(module_id, id, address, size, thread_id, trace_buffer);
+}
+
+#endif // defined(__HAVE_TRACING__)
+
+#endif // __METAL_TRACING
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_type_traits b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_type_traits
new file mode 100644
index 00000000..c109cdc2
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_type_traits
@@ -0,0 +1,331 @@
+//===-- metal_type_traits -------------------------------------------------===//
+// Copyright (c) 2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_TYPE_TRAITS
+#define __METAL_TYPE_TRAITS
+
+#pragma METAL internals : enable
+namespace metal
+{
+template <bool B, typename T = void>
+struct enable_if
+{
+};
+template <typename T>
+struct enable_if<true, T>
+{
+  typedef T type;
+};
+template <bool B, typename T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+template <bool B, typename T, typename F>
+struct conditional
+{
+  typedef T type;
+};
+template <typename T, typename F>
+struct conditional<false, T, F>
+{
+  typedef F type;
+};
+template <bool B, typename T, typename F>
+using conditional_t = typename conditional<B, T, F>::type;
+
+template <typename T>
+struct remove_volatile
+{
+  typedef T type;
+};
+template <typename T>
+struct remove_volatile<volatile T>
+{
+  typedef T type;
+};
+template <typename T>
+using remove_volatile_t = typename remove_volatile<T>::type;
+
+template <typename T>
+struct remove_const
+{
+  typedef T type;
+};
+template <typename T>
+struct remove_const<const T>
+{
+  typedef T type;
+};
+template <typename T>
+using remove_const_t = typename remove_const<T>::type;
+
+template <typename T>
+struct remove_cv
+{
+  typedef remove_volatile_t<remove_const_t<T>> type;
+};
+
+template <typename T>
+using remove_cv_t = typename remove_cv<T>::type;
+
+template <typename T, T v>
+struct integral_constant
+{
+  typedef T value_type;
+  typedef integral_constant type;
+  static constant constexpr T value = v;
+};
+
+template <bool B>
+using bool_constant = integral_constant<bool, B>;
+using true_type = bool_constant<true>;
+using false_type = bool_constant<false>;
+
+template <typename T>
+struct _is_integral_impl : bool_constant<__is_integral(T)>
+{
+};
+template <typename T, int N>
+struct _is_integral_impl<T __attribute__((ext_vector_type(N)))> : _is_integral_impl<T>
+{
+};
+template <typename T, int N>
+struct _is_integral_impl<T __attribute__((packed_vector_type(N)))> : _is_integral_impl<T>
+{
+};
+
+template <typename T>
+struct is_integral : _is_integral_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_integral_v = is_integral<T>::value;
+#endif
+
+template <typename T>
+struct _is_floating_point_impl : bool_constant<__is_floating_point(T)>
+{
+};
+template <typename T, int N>
+struct _is_floating_point_impl<T __attribute__((ext_vector_type(N)))> : _is_floating_point_impl<T>
+{
+};
+template <typename T, int N>
+struct _is_floating_point_impl<T __attribute__((packed_vector_type(N)))> : _is_floating_point_impl<T>
+{
+};
+
+template <typename T>
+struct is_floating_point : _is_floating_point_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_floating_point_v = is_floating_point<T>::value;
+#endif
+
+template <typename T>
+struct _is_scalar_impl : bool_constant<__is_scalar(T)>
+{
+};
+
+template <typename T>
+struct is_scalar : _is_scalar_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_scalar_v = is_scalar<T>::value;
+#endif
+
+template <typename T>
+struct _is_vector_impl : false_type
+{
+};
+template <typename T, int N>
+struct _is_vector_impl<T __attribute__((ext_vector_type(N)))> : true_type
+{
+};
+template <typename T, int N>
+struct _is_vector_impl<T __attribute__((packed_vector_type(N)))> : true_type
+{
+};
+
+template <typename T>
+struct is_vector : _is_vector_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_vector_v = is_vector<T>::value;
+#endif
+
+template <typename T>
+struct _is_arithmetic_impl : bool_constant<__is_arithmetic(T)>
+{
+};
+template <typename T, int N>
+struct _is_arithmetic_impl<T __attribute__((ext_vector_type(N)))> : _is_arithmetic_impl<T>
+{
+};
+template <typename T, int N>
+struct _is_arithmetic_impl<T __attribute__((packed_vector_type(N)))> : _is_arithmetic_impl<T>
+{
+};
+
+template <typename T>
+struct is_arithmetic : _is_arithmetic_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_arithmetic_v = is_arithmetic<T>::value;
+#endif
+
+template <typename U, typename V>
+struct is_convertible : bool_constant<__is_convertible_to(U, V)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename U, typename V>
+constexpr constant bool is_convertible_v = is_convertible<U, V>::value;
+#endif
+
+template <typename U, typename V>
+struct is_same : bool_constant<__is_same(U, V)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename U, typename V>
+constexpr constant bool is_same_v = is_same<U, V>::value;
+#endif
+
+template <typename T>
+struct is_class : bool_constant<__is_class(T)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_class_v = is_class<T>::value;
+#endif
+
+template <typename T>
+struct is_signed : bool_constant<__is_signed(T)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_signed_v = is_signed<T>::value;
+#endif
+
+template <typename T>
+struct is_unsigned : bool_constant<__is_unsigned(T)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_unsigned_v = is_unsigned<T>::value;
+#endif
+
+template <typename T>
+struct is_enum : bool_constant<__is_enum(T)>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_enum_v = is_enum<T>::value;
+#endif
+
+template <typename T>
+struct _vec_elements_impl : integral_constant<size_t, 0>
+{
+};
+template <typename T, int N>
+struct _vec_elements_impl<T __attribute__((ext_vector_type(N)))> : integral_constant<size_t, N>
+{
+};
+template <typename T, int N>
+struct _vec_elements_impl<T __attribute__((packed_vector_type(N)))> : integral_constant<size_t, N>
+{
+};
+template <typename T>
+struct vec_elements : _vec_elements_impl<remove_cv_t<T>>
+{
+};
+#ifdef __cpp_variables_templates
+template <typename T>
+constexpr constant size_t vec_elements_v = vec_elements<T>::value;
+#endif
+
+template <typename T>
+struct _make_scalar_impl
+{
+  typedef T type;
+};
+template <typename T, int N>
+struct _make_scalar_impl<T __attribute__((ext_vector_type(N)))>
+{
+  typedef T type;
+};
+template <typename T, int N>
+struct _make_scalar_impl<T __attribute__((packed_vector_type(N)))>
+{
+  typedef T type;
+};
+template <typename T>
+struct make_scalar : _make_scalar_impl<remove_cv_t<T>>
+{
+};
+template <typename T>
+using make_scalar_t = typename make_scalar<T>::type;
+
+template <typename T>
+struct underlying_type
+{
+  typedef __underlying_type(T) type;
+};
+template <typename T>
+using underlying_type_t = typename underlying_type<T>::type;
+
+template <typename... T>
+struct _disjunction : false_type
+{
+};
+template <typename T>
+struct _disjunction<T> : T
+{
+};
+template <typename T, typename... U>
+struct _disjunction<T, U...> : conditional_t<bool(T::value), T, _disjunction<U...>>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename... T>
+using disjunction = _disjunction<T...>;
+template <typename... T>
+constexpr constant bool disjunction_v = disjunction<T...>::value;
+#endif
+
+template <typename... T>
+struct _conjunction : true_type
+{
+};
+template <typename T>
+struct _conjunction<T> : T
+{
+};
+template <typename T, typename... U>
+struct _conjunction<T, U...> : conditional_t<bool(T::value), _conjunction<U...>, T>
+{
+};
+#ifdef __cpp_variable_templates
+template <typename... T>
+using conjunction = _conjunction<T...>;
+template <typename... T>
+constexpr constant bool conjunction_v = conjunction<T...>::value;
+#endif
+}
+#pragma METAL internals : disable
+
+#endif // __METAL_TYPE_TRAITS
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types
new file mode 100644
index 00000000..e42d93af
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types
@@ -0,0 +1,286 @@
+//===-- metal_types -------------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_TYPES
+#define __METAL_TYPES
+
+#include <metal_config>
+
+#define METAL_ALIGN(L) __attribute__((aligned(L)))
+#define METAL_ASM
+#define METAL_CONST __attribute__((const))
+#define METAL_DEPRECATED(M) __attribute__((deprecated(M)))
+#define METAL_ENABLE_IF(P, M) __attribute__((enable_if(P, M)))
+#define METAL_FUNC inline __attribute__((__always_inline__))
+#define METAL_INTERNAL
+#define METAL_NON_NULL_RETURN __attribute__((returns_nonnull))
+#define METAL_NORETURN __attribute__((noreturn))
+#define METAL_NOTHROW __attribute__((nothrow))
+#define METAL_PURE __attribute__((pure))
+#define METAL_UNAVAILABLE(M) __attribute__((unavailable(M)))
+#define METAL_IMPLICIT
+#define METAL_EXPLICIT explicit METAL_ENABLE_IF(true, "")
+
+// TODO: This is only used by the builtin library. To be removed -- see
+// <rdar://problem/26107016>.
+#define __INLINE__ __attribute__((__always_inline__))
+
+// Metal 1.1 s2.1: Scalar Data Types.
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef struct __Reserved_Name__Do_not_use_ulong ulong;
+typedef struct __Reserved_Name__Do_not_use_llong llong;
+typedef struct __Reserved_Name__Do_not_use_ullong ullong;
+typedef struct __Reserved_Name__Do_not_use_quad quad;
+typedef struct __Reserved_Name__Do_not_use_complex complex;
+typedef struct __Reserved_Name__Do_not_use_imaginary imaginary;
+
+typedef __INT8_TYPE__ int8_t;
+typedef __UINT8_TYPE__ uint8_t;
+typedef __INT16_TYPE__ int16_t;
+typedef __UINT16_TYPE__ uint16_t;
+typedef __INT32_TYPE__ int32_t;
+typedef __UINT32_TYPE__ uint32_t;
+#if 0
+// TODO: We shall be using the macro defined by the compiler to define
+// int64_t, uint64_t -- see <rdar://problem/29116680>.
+#if 0
+typedef __INT64_TYPE__ int64_t;
+typedef __UINT64_TYPE__ uint64_t;
+#else
+typedef __metal_internal_int64_t int64_t;
+typedef unsigned __metal_internal_int64_t uint64_t;
+#endif
+#else
+typedef struct __Reserved_Name__Do_not_use_packed_int64_t int64_t;
+typedef struct __Reserved_Name__Do_not_use_packed_uint64_t uint64_t;
+#endif
+
+// TODO: We shall be using the macro defined by the compiler to define
+// ptrdiff_t, size_t, intptr_t, uintptr_t -- see <rdar://problem/29116680>.
+#if 0
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __SIZE_TYPE__ size_t;
+typedef __INTPTR_TYPE__ intptr_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
+#else
+typedef __metal_internal_int64_t ptrdiff_t;
+typedef unsigned __metal_internal_int64_t size_t;
+typedef __metal_internal_int64_t intptr_t;
+typedef unsigned __metal_internal_int64_t uintptr_t;
+#endif
+
+namespace metal
+{
+typedef ::uchar uchar;
+typedef ::ushort ushort;
+typedef ::uint uint;
+typedef ::ulong ulong;
+typedef ::llong llong;
+typedef ::ullong ullong;
+typedef ::quad quad;
+typedef ::complex complex;
+typedef ::imaginary imaginary;
+
+typedef ::int8_t int8_t;
+typedef ::uint8_t uint8_t;
+typedef ::int16_t int16_t;
+typedef ::uint16_t uint16_t;
+typedef ::int32_t int32_t;
+typedef ::uint32_t uint32_t;
+typedef ::int64_t int64_t;
+typedef ::uint64_t uint64_t;
+
+typedef ::ptrdiff_t ptrdiff_t;
+typedef ::size_t size_t;
+typedef ::intptr_t intptr_t;
+typedef ::uintptr_t uintptr_t;
+}
+
+#include <metal_extended_vector>
+#include <metal_packed_vector>
+
+#include <metal_type_traits>
+
+#pragma METAL internals : enable
+namespace metal
+{
+// This is intended to be used by the METAL_CONST_ARG macro. Each type that may
+// be interested in being used in constant argument checks must specialize this
+// trait.
+template <typename T, typename = void>
+struct _constarg_traits
+{
+  // Must return true if T is a constant argument, false otherwise. A possible
+  // specialization would be to force a constexpr computation on t, such as
+  // the t == t expression.
+  constexpr static bool check(const thread T &t)
+  {
+    return false;
+  }
+  constexpr static bool check(const threadgroup T &t)
+  {
+    return false;
+  }
+  constexpr static bool check(const constant T &t)
+  {
+    return false;
+  }
+  constexpr static bool check(const device T &t)
+  {
+    return false;
+  }
+};
+#define METAL_CONST_ARG(A) METAL_ENABLE_IF(_constarg_traits<decltype(A)>::check(A), "'" #A "' argument must be known at compile-time")
+
+template <typename T>
+struct _constarg_traits<T, typename enable_if<is_arithmetic<T>::value && !is_vector<T>::value>::type>
+{
+  constexpr static bool check(T a)
+  {
+    return a != 0 || a == 0;
+  }
+};
+template <typename T>
+struct _constarg_traits<T, typename enable_if<is_enum<T>::value>::type>
+{
+  constexpr static bool check(T a)
+  {
+    return _constarg_traits<underlying_type_t<T>>::check(static_cast<underlying_type_t<T>>(a));
+  }
+};
+} // namespace metal
+#pragma METAL internals : disable
+
+#if defined(__HAVE_TESSELLATION__)
+#include <metal_tessellation>
+#endif
+
+#if defined(__HAVE_FUNCTION_CONSTANTS__)
+#define is_function_constant_defined(c) __metal_is_function_constant_defined(c)
+#endif
+
+namespace metal {
+// Metal 2.0 s5.12.1: Memory Order.
+enum memory_order {
+  memory_order_relaxed = __METAL_MEMORY_ORDER_RELAXED__,
+};
+
+} // namespace metal
+
+// TODO: All these constants should be set by the compiler using preprocessor
+// macros/builtins to guarantee interoperability with other languages.
+//
+// FIXME: Determine if these constants should be defined here and we should
+// switch to using an Metal flags instead of CL flags.
+
+#define CHAR_BIT  8                 /* size of char in bits */
+#define SCHAR_MAX 127               /* min value for a signed char */
+#define SCHAR_MIN (-128)            /* max value for a signed char */
+#define UCHAR_MAX 255               /* max value for an unsigned char */
+#define CHAR_MAX  SCHAR_MAX         /* max value for a char */
+#define CHAR_MIN  SCHAR_MIN         /* min value for a char */
+#define USHRT_MAX 65535             /* max value for an unsigned short */
+#define SHRT_MAX  32767             /* max value for a short */
+#define SHRT_MIN  (-32768)          /* min value for a short */
+#define UINT_MAX  0xffffffff        /* max value for an unsigned int */
+#define INT_MAX   2147483647        /* max value for an int */
+#define INT_MIN   (-2147483647 - 1) /* min value for an int */
+
+#define FLT_DIG        6
+#define FLT_MANT_DIG   24
+#define FLT_MAX_10_EXP +38
+#define FLT_MAX_EXP    +128
+#define FLT_MIN_10_EXP -37
+#define FLT_MIN_EXP    -125
+#define FLT_RADIX      2
+#define FLT_MAX        0x1.fffffep127f
+#define FLT_MIN        0x1.0p-126f
+#define FLT_EPSILON    0x1.0p-23f
+
+#define FP_ILOGB0   INT_MIN
+#define FP_ILOGBNAN INT_MIN
+
+#define MAXFLOAT  0x1.fffffep+127f
+#define HUGE_VALF __builtin_huge_valf()
+#define INFINITY  __builtin_inff()
+#define NAN       __builtin_nanf("")
+
+#define M_E_F        2.71828182845904523536028747135266250f   /* e */
+#define M_LOG2E_F    1.44269504088896340735992468100189214f   /* log 2e */
+#define M_LOG10E_F   0.434294481903251827651128918916605082f  /* log 10e */
+#define M_LN2_F      0.693147180559945309417232121458176568f  /* log e2 */
+#define M_LN10_F     2.3025850929940456840179914546843642f    /* log e10 */
+#define M_PI_F       3.14159265358979323846264338327950288f   /* pi */
+#define M_PI_2_F     1.57079632679489661923132169163975144f   /* pi/2 */
+#define M_PI_4_F     0.785398163397448309615660845819875721f  /* pi/4 */
+#define M_1_PI_F     0.318309886183790671537767526745028724f  /* 1/pi */
+#define M_2_PI_F     0.636619772367581343075535053490057448f  /* 2/pi */
+#define M_2_SQRTPI_F 1.12837916709551257389615890312154517f   /* 2/sqrt(pi) */
+#define M_SQRT2_F    1.41421356237309504880168872420969808f   /* sqrt(2) */
+#define M_SQRT1_2_F  0.707106781186547524400844362104849039f  /* 1/sqrt(2) */
+
+#define HALF_DIG        2
+#define HALF_MANT_DIG   11
+#define HALF_MAX_10_EXP +4
+#define HALF_MAX_EXP    +16
+#define HALF_MIN_10_EXP -4
+#define HALF_MIN_EXP    -13
+#define HALF_RADIX      2
+#define HALF_MAX        0x1.ffcp15h
+#define HALF_MIN        0x1.0p-14h
+#define HALF_EPSILON    0x1.0p-10h
+
+#define MAXHALF   0x1.ffcp15h
+#define HUGE_VALH ((half)INFINITY)
+
+#define M_E_H         2.71828182845904523536028747135266250h   /* e */
+#define M_LOG2E_H     1.44269504088896340735992468100189214h   /* log 2e */
+#define M_LOG10E_H    0.434294481903251827651128918916605082h  /* log 10e */
+#define M_LN2_H       0.693147180559945309417232121458176568h  /* log e2 */
+#define M_LN10_H      2.3025850929940456840179914546843642h    /* log e10 */
+#define M_PI_H        3.14159265358979323846264338327950288h   /* pi */
+#define M_PI_2_H      1.57079632679489661923132169163975144h   /* pi/2 */
+#define M_PI_4_H      0.785398163397448309615660845819875721h  /* pi/4 */
+#define M_1_PI_H      0.318309886183790671537767526745028724h  /* 1/pi */
+#define M_2_PI_H      0.636619772367581343075535053490057448h  /* 2/pi */
+#define M_2_SQRTPI_H  1.12837916709551257389615890312154517h   /* 2/sqrt(pi) */
+#define M_SQRT2_H     1.41421356237309504880168872420969808h   /* sqrt(2) */
+#define M_SQRT1_2_H   0.707106781186547524400844362104849039h  /* 1/sqrt(2) */
+
+#if defined(__HAVE_NATIVE_DOUBLE__)
+#define DBL_DIG        15
+#define DBL_MANT_DIG   53
+#define DBL_MAX_10_EXP +308
+#define DBL_MAX_EXP    +1024
+#define DBL_MIN_10_EXP -307
+#define DBL_MIN_EXP    -1021
+#define DBL_RADIX      2
+#define DBL_MAX        0x1.fffffffffffffp1023
+#define DBL_MIN        0x1.0p-1022
+#define DBL_EPSILON    0x1.0p-52
+
+#define HUGE_VAL        __builtin_huge_val()
+
+#define M_E         2.71828182845904523536028747135266250   /* e */
+#define M_LOG2E     1.44269504088896340735992468100189214   /* log 2e */
+#define M_LOG10E    0.434294481903251827651128918916605082  /* log 10e */
+#define M_LN2       0.693147180559945309417232121458176568  /* log e2 */
+#define M_LN10      2.30258509299404568401799145468436421   /* log e10 */
+#define M_PI        3.14159265358979323846264338327950288   /* pi */
+#define M_PI_2      1.57079632679489661923132169163975144   /* pi/2 */
+#define M_PI_4      0.785398163397448309615660845819875721  /* pi/4 */
+#define M_1_PI      0.318309886183790671537767526745028724  /* 1/pi */
+#define M_2_PI      0.636619772367581343075535053490057448  /* 2/pi */
+#define M_2_SQRTPI  1.12837916709551257389615890312154517   /* 2/sqrt(pi) */
+#define M_SQRT2     1.41421356237309504880168872420969808   /* sqrt(2) */
+#define M_SQRT1_2   0.707106781186547524400844362104849039  /* 1/sqrt(2) */
+#endif
+
+// TODO: Temporary workaround, needed till all the clients are moved to
+// explicitly include the simd headers -- see <rdar://problem/35912250>.
+namespace simd = metal;
+
+#endif // __METAL_TYPES
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types.h b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types.h
new file mode 100644
index 00000000..062034dd
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_types.h
@@ -0,0 +1,13 @@
+//===-- metal_types_h -----------------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+// TODO: This file is a temporary workaround. It is going to be removed soon --
+// see <rdar://problem/35032465>.
+
+#ifndef __METAL_TYPES_H
+#define __METAL_TYPES_H
+
+#include <metal_types>
+
+#endif // __METAL_TYPES_H
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_uniform b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_uniform
new file mode 100644
index 00000000..87576f0a
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_uniform
@@ -0,0 +1,1060 @@
+//===-- metal_uniform -----------------------------------------------------===//
+// Copyright (c) 2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_UNIFORM
+#define __METAL_UNIFORM
+
+#ifdef __HAVE_UNIFORM__
+
+#include <metal_type_traits>
+
+#pragma METAL internals : enable
+namespace metal {
+template <typename T, typename = void>
+struct uniform;
+
+template <typename T>
+struct _is_uniform_impl : false_type
+{
+};
+template <typename T>
+struct _is_uniform_impl<uniform<T>> : true_type
+{
+};
+
+template <typename T>
+struct is_uniform : _is_uniform_impl<remove_cv_t<T>>
+{
+};
+template <typename T>
+constexpr constant bool is_uniform_v = is_uniform<T>::value;
+
+template <typename T>
+struct remove_uniform
+{
+  typedef T value_type;
+};
+template <typename T>
+struct remove_uniform<const T>
+{
+  typedef const typename remove_uniform<T>::value_type value_type;
+};
+template <typename T>
+struct remove_uniform<volatile T>
+{
+  typedef volatile typename remove_uniform<T>::value_type value_type;
+};
+template <typename T>
+struct remove_uniform<uniform<T>>
+{
+  typedef T value_type;
+};
+template <typename T>
+using remove_uniform_t = typename remove_uniform<T>::value_type;
+
+template <typename T, typename = void>
+struct _is_arg_uniform : _constarg_traits<T>
+{
+};
+template <typename T>
+struct _is_arg_uniform<uniform<T>>
+{
+  static constexpr bool check(const thread uniform<T> &) { return true; }
+  static constexpr bool check(const device uniform<T> &) { return true; }
+  static constexpr bool check(const constant uniform<T> &) { return true; }
+  static constexpr bool check(const threadgroup uniform<T> &) { return true; }
+};
+
+template <typename U, typename V>
+struct _is_explicit_convertible_impl
+{
+private:
+  template<typename T, typename = decltype(V(T()))>
+  static true_type test(thread void *);
+
+  template<typename T>
+  static false_type test(...);
+
+public:
+  using type = decltype(test<U>(nullptr));
+};
+
+template <typename U, typename V>
+struct _is_explicit_convertible : _is_explicit_convertible_impl<U, V>::type
+{
+};
+template <typename U, typename V>
+constexpr constant bool _is_explicit_convertible_v = _is_explicit_convertible<U, V>::value;
+
+#define METAL_ARG_UNIFORM(x, N)                                                \
+  METAL_ENABLE_IF(_is_arg_uniform<decltype(x)>::check(x), "operand " #N " is not a uniform value")
+
+template <typename T>
+METAL_FUNC constexpr uniform<T> make_uniform(T x)
+{
+  return uniform<T>(x, uniform<T>::_tag_init);
+}
+
+template <typename T>
+struct uniform<T, typename enable_if<is_arithmetic_v<T>>::type>
+{
+  typedef T value_type;
+
+  T __v;
+
+  constexpr uniform() thread = default;
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr uniform(U u) thread METAL_ARG_UNIFORM(u, 1) : __v(u)
+  {
+  }
+
+  constexpr uniform() constant = default;
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr uniform(U u) constant METAL_ARG_UNIFORM(u, 1) : __v(u)
+  {
+  }
+
+  constexpr uniform() threadgroup = default;
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr uniform(U u) threadgroup METAL_ARG_UNIFORM(u, 1) : __v(u)
+  {
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator U() const thread
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator uniform<U>() const thread
+  {
+    return make_uniform<U>(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_EXPLICIT operator U() const thread
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC  METAL_EXPLICIT operator uniform<U>() const thread
+  {
+    return make_uniform<U>(U(__v));
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator U() const device
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator uniform<U>() const device
+  {
+    return make_uniform<U>(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_EXPLICIT operator U() const device
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC  METAL_EXPLICIT operator uniform<U>() const device
+  {
+    return make_uniform<U>(U(__v));
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator U() const constant
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator uniform<U>() const constant
+  {
+    return make_uniform<U>(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_EXPLICIT operator U() const constant
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC  METAL_EXPLICIT operator uniform<U>() const constant
+  {
+    return make_uniform<U>(U(__v));
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator U() const threadgroup
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_IMPLICIT operator uniform<U>() const threadgroup
+  {
+    return make_uniform<U>(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC METAL_EXPLICIT operator U() const threadgroup
+  {
+    __builtin_assume(__metal_is_uniform(__v));
+    return U(__v);
+  }
+
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && !is_convertible_v<T, U> && _is_explicit_convertible_v<T, U>>::type>
+  constexpr METAL_FUNC  METAL_EXPLICIT operator uniform<U>() const threadgroup
+  {
+    return make_uniform<U>(U(__v));
+  }
+
+
+  template <typename U>
+  constexpr typename enable_if<is_convertible_v<T, remove_uniform_t<U>>, thread uniform &>::type operator=(U u) thread METAL_ARG_UNIFORM(u, 1)
+  {
+    __v = remove_uniform_t<U>(u);
+    return *this;
+  }
+
+  template <typename U>
+  constexpr typename enable_if<is_convertible_v<T, remove_uniform_t<U>>, device uniform &>::type operator=(U u) device METAL_ARG_UNIFORM(u, 1)
+  {
+    __v = remove_uniform_t<U>(u);
+    return *this;
+  }
+
+  template <typename U>
+  constexpr typename enable_if<is_convertible_v<T, remove_uniform_t<U>>, threadgroup uniform &>::type operator=(U u) threadgroup METAL_ARG_UNIFORM(u, 1)
+  {
+    __v = remove_uniform_t<U>(u);
+    return *this;
+  }
+
+
+private:
+  enum _tag { _tag_init };
+  template <typename U, typename = typename enable_if<!is_uniform_v<U> && is_convertible_v<T, U>>::type>
+  constexpr uniform(U u, _tag) thread : __v(u)
+  {
+  }
+
+  template <typename U>
+  friend constexpr uniform<U> make_uniform(U);
+};
+
+template <typename U, typename V, template <typename> class P>
+using _binop_uniform_constraints_t = typename enable_if<
+    (is_uniform_v<U> || is_uniform_v<V>) &&
+    P<remove_uniform_t<U>>::value && P<remove_uniform_t<V>>::value &&
+    ((is_vector_v<remove_uniform_t<U>> &&
+      is_vector_v<remove_uniform_t<V>> &&
+      is_convertible_v<remove_uniform_t<U>, remove_uniform_t<V>>) ||
+     !is_vector_v<remove_uniform_t<U>> ||
+     !is_vector_v<remove_uniform_t<V>>)>::type;
+
+template <typename U, typename V, template <typename> class P>
+using _binop_uniform_l_constraints_t = typename enable_if<
+    is_uniform_v<U> &&
+    P<remove_uniform_t<U>>::value && P<V>::value &&
+    ((is_vector_v<remove_uniform_t<U>> && is_vector_v<V> &&
+      is_convertible_v<remove_uniform_t<U>, V>) ||
+     !is_vector_v<remove_uniform_t<U>> || !is_vector_v<V>)>::type;
+
+template <typename U, typename V, template <typename> class P>
+using _binop_uniform_r_constraints_t = typename enable_if<
+    is_uniform_v<V>  &&
+    P<U>::value && P<remove_uniform_t<V>>::value &&
+    ((is_vector_v<U> && is_vector_v<remove_uniform_t<V>> &&
+      is_convertible_v<U, remove_uniform_t<V>>) ||
+     !is_vector_v<V> || !is_vector_v<remove_uniform_t<U>>)>::type;
+
+template <typename U, typename V, template <typename> class P>
+using _op_assign_uniform_constraints_t = typename enable_if<
+    is_uniform_v<U> && is_same_v<U, remove_cv_t<U>> &&
+    P<remove_uniform_t<U>>::value &&
+    P<remove_uniform_t<V>>::value &&
+    ((is_vector_v<remove_uniform_t<U>> &&
+      is_vector_v<remove_uniform_t<V>> &&
+      is_convertible_v<remove_uniform_t<U>, remove_uniform_t<V>>) ||
+     !is_vector_v<remove_uniform_t<U>> ||
+     !is_vector_v<remove_uniform_t<V>>)>::type;
+
+template <typename U, template <typename> class P>
+using _unop_uniform_constraints_t =
+    typename enable_if<is_uniform_v<U> &&
+                       P<remove_uniform_t<U>>::value>::type;
+
+template <typename U>
+using _inc_dec_uniform_constraints_t =
+    typename enable_if<is_uniform_v<U> &&
+                       is_arithmetic_v<remove_uniform_t<U>> &&
+                       !is_same_v<make_scalar_t<remove_uniform_t<U>>, bool>>::type;
+
+template <typename T>
+using _is_convertible_to_bool = is_convertible<T, bool>;
+
+// Binary arithmetic operators.
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() + remove_uniform_t<V>())>
+operator+(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() + remove_uniform_t<V>())>(remove_uniform_t<U>(u) + remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() + V())
+operator+(U u, V v)
+{
+  return remove_uniform_t<U>(u) + V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() + remove_uniform_t<V>())
+operator+(U u, V v)
+{
+  return U(u) + remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() - remove_uniform_t<V>())>
+operator-(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() - remove_uniform_t<V>())>(remove_uniform_t<U>(u) - remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() - V())
+operator-(U u, V v)
+{
+  return remove_uniform_t<U>(u) - V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() - remove_uniform_t<V>())
+operator-(U u, V v)
+{
+  return U(u) - remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() * remove_uniform_t<V>())>
+operator*(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() * remove_uniform_t<V>())>(remove_uniform_t<U>(u) * remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() * V())
+operator*(U u, V v)
+{
+  return remove_uniform_t<U>(u) * V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() * remove_uniform_t<V>())
+operator*(U u, V v)
+{
+  return U(u) * remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() / remove_uniform_t<V>())>
+operator/(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() / remove_uniform_t<V>())>(remove_uniform_t<U>(u) / remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() / V())
+operator/(U u, V v)
+{
+  return remove_uniform_t<U>(u) / V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() / remove_uniform_t<V>())
+operator/(U u, V v)
+{
+  return U(u) / remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() % remove_uniform_t<V>())>
+operator%(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() % remove_uniform_t<V>())>(remove_uniform_t<U>(u) % remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() % V())
+operator%(U u, V v)
+{
+  return remove_uniform_t<U>(u) % V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() % remove_uniform_t<V>())
+operator%(U u, V v)
+{
+  return U(u) % remove_uniform_t<V>(v);
+}
+
+// Unary arithmetic operators.
+template <typename U, typename = _unop_uniform_constraints_t<U, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(+remove_uniform_t<U>())>
+operator+(U u) METAL_ARG_UNIFORM(u, 1)
+{
+  return make_uniform<decltype(+remove_uniform_t<U>())>(+remove_uniform_t<U>(u));
+}
+
+template <typename U, typename = _unop_uniform_constraints_t<U, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(-remove_uniform_t<U>())>
+operator-(U u) METAL_ARG_UNIFORM(u, 1)
+{
+  return make_uniform<decltype(-remove_uniform_t<U>())>(-remove_uniform_t<U>(u));
+}
+
+// Relational operators.
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() == remove_uniform_t<V>())>
+operator==(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() == remove_uniform_t<V>())>(remove_uniform_t<U>(u) == remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() == V())
+operator==(U u, V v)
+{
+  return remove_uniform_t<U>(u) == V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() == remove_uniform_t<V>())
+operator==(U u, V v)
+{
+  return U(u) == remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() != remove_uniform_t<V>())>
+operator!=(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() != remove_uniform_t<V>())>(remove_uniform_t<U>(u) != remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() != V())
+operator!=(U u, V v)
+{
+  return remove_uniform_t<U>(u) != V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() != remove_uniform_t<V>())
+operator!=(U u, V v)
+{
+  return U(u) != remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() < remove_uniform_t<V>())>
+operator<(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() < remove_uniform_t<V>())>(remove_uniform_t<U>(u) < remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() < V())
+operator<(U u, V v)
+{
+  return remove_uniform_t<U>(u) < V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() < remove_uniform_t<V>())
+operator<(U u, V v)
+{
+  return U(u) < remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() > remove_uniform_t<V>())>
+operator>(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() > remove_uniform_t<V>())>(remove_uniform_t<U>(u) > remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() > V())
+operator>(U u, V v)
+{
+  return remove_uniform_t<U>(u) > V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() > remove_uniform_t<V>())
+operator>(U u, V v)
+{
+  return U(u) > remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() <= remove_uniform_t<V>())>
+operator<=(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() <= remove_uniform_t<V>())>(remove_uniform_t<U>(u) <= remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() <= V())
+operator<=(U u, V v)
+{
+  return remove_uniform_t<U>(u) <= V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() <= remove_uniform_t<V>())
+operator<=(U u, V v)
+{
+  return U(u) <= remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() >= remove_uniform_t<V>())>
+operator>=(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() >= remove_uniform_t<V>())>(remove_uniform_t<U>(u) >= remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() >= V())
+operator>=(U u, V v)
+{
+  return remove_uniform_t<U>(u) >= V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC decltype(U() >= remove_uniform_t<V>())
+operator>=(U u, V v)
+{
+  return U(u) >= remove_uniform_t<V>(v);
+}
+
+
+// Shift operators.
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() << remove_uniform_t<V>())>
+operator<<(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() << remove_uniform_t<V>())>(remove_uniform_t<U>(u) << remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() << V())
+operator<<(U u, V v)
+{
+  return remove_uniform_t<U>(u) << V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() << remove_uniform_t<V>())
+operator<<(U u, V v)
+{
+  return U(u) << remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() >> remove_uniform_t<V>())>
+operator>>(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() >> remove_uniform_t<V>())>(remove_uniform_t<U>(u) >> remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() >> V())
+operator>>(U u, V v)
+{
+  return remove_uniform_t<U>(u) >> V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() >> remove_uniform_t<V>())
+operator>>(U u, V v)
+{
+  return U(u) >> remove_uniform_t<V>(v);
+}
+
+
+// Binary logic operators.
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() && remove_uniform_t<V>())>
+operator&&(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() && remove_uniform_t<V>())>(remove_uniform_t<U>(u) && remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() && V())
+operator&&(U u, V v)
+{
+  return remove_uniform_t<U>(u) && V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC decltype(U() && remove_uniform_t<V>())
+operator&&(U u, V v)
+{
+  return U(u) && remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() || remove_uniform_t<V>())>
+operator||(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() || remove_uniform_t<V>())>(remove_uniform_t<U>(u) || remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() || V())
+operator||(U u, V v)
+{
+  return remove_uniform_t<U>(u) || V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, _is_convertible_to_bool>>
+constexpr METAL_FUNC decltype(U() || remove_uniform_t<V>())
+operator||(U u, V v)
+{
+  return U(u) || remove_uniform_t<V>(v);
+}
+
+// Unary logic operators.
+template <typename U, typename = _unop_uniform_constraints_t<U, _is_convertible_to_bool>>
+constexpr METAL_FUNC uniform<decltype(!remove_uniform_t<U>())>
+operator!(U u) METAL_ARG_UNIFORM(u, 1)
+{
+  return make_uniform<decltype(!remove_uniform_t<U>())>(!remove_uniform_t<U>(u));
+}
+
+// Binary bitwise operators.
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() & remove_uniform_t<V>())>
+operator&(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() & remove_uniform_t<V>())>(remove_uniform_t<U>(u) & remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() & V())
+operator&(U u, V v)
+{
+  return remove_uniform_t<U>(u) & V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() & remove_uniform_t<V>())
+operator&(U u, V v)
+{
+  return U(u) & remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() | remove_uniform_t<V>())>
+operator|(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() | remove_uniform_t<V>())>(remove_uniform_t<U>(u) | remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() | V())
+operator|(U u, V v)
+{
+  return remove_uniform_t<U>(u) | V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() | remove_uniform_t<V>())
+operator|(U u, V v)
+{
+  return U(u) | remove_uniform_t<V>(v);
+}
+
+
+template <typename U, typename V, typename = _binop_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC uniform<decltype(remove_uniform_t<U>() ^ remove_uniform_t<V>())>
+operator^(U u, V v) METAL_ARG_UNIFORM(u, 1) METAL_ARG_UNIFORM(v, 2)
+{
+  return make_uniform<decltype(remove_uniform_t<U>() ^ remove_uniform_t<V>())>(remove_uniform_t<U>(u) ^ remove_uniform_t<V>(v));
+}
+
+template <typename U, typename V, typename = _binop_uniform_l_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(remove_uniform_t<U>() ^ V())
+operator^(U u, V v)
+{
+  return remove_uniform_t<U>(u) ^ V(v);
+}
+
+template <typename U, typename V, typename = _binop_uniform_r_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC decltype(U() ^ remove_uniform_t<V>())
+operator^(U u, V v)
+{
+  return U(u) ^ remove_uniform_t<V>(v);
+}
+
+
+// Unary bitwise operators.
+template <typename U, typename = _unop_uniform_constraints_t<U, is_integral>>
+constexpr METAL_FUNC uniform<decltype(~remove_uniform_t<U>())>
+operator~(U u)METAL_ARG_UNIFORM(u, 1)
+{
+  return make_uniform<decltype(~remove_uniform_t<U>())>(~remove_uniform_t<U>(u));
+}
+
+// Increment operators (thread address space).
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC thread U &operator++(thread U &u)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator++(thread U &u, int)
+{
+  U res = u;
+  ++u;
+  return res;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC thread U &operator--(thread U &u)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator--(thread U &u, int)
+{
+  U res = u;
+  --u;
+  return res;
+}
+
+// Compound assignment operators (thread address space).
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC thread U &operator+=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC thread U &operator-=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC thread U &operator*=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) * remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC thread U &operator/=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) / remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator%=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) % remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator<<=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) << remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator>>=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) >> remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator&=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) & remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator|=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) | remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC thread U &operator^=(thread U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) ^ remove_uniform_t<V>(v);
+  return u;
+}
+
+// Increment operators (device address space).
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC device U &operator++(device U &u)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator++(device U &u, int)
+{
+  U res = u;
+  ++u;
+  return res;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC device U &operator--(device U &u)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator--(device U &u, int)
+{
+  U res = u;
+  --u;
+  return res;
+}
+
+// Compound assignment operators (device address space).
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC device U &operator+=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC device U &operator-=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC device U &operator*=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) * remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC device U &operator/=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) / remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator%=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) % remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator<<=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) << remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator>>=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) >> remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator&=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) & remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator|=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) | remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC device U &operator^=(device U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) ^ remove_uniform_t<V>(v);
+  return u;
+}
+
+// Increment operators (threadgroup address space).
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC threadgroup U &operator++(threadgroup U &u)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator++(threadgroup U &u, int)
+{
+  U res = u;
+  ++u;
+  return res;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC threadgroup U &operator--(threadgroup U &u)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<U>(1);
+  return u;
+}
+
+template <typename U, typename = _inc_dec_uniform_constraints_t<U>>
+constexpr METAL_FUNC U operator--(threadgroup U &u, int)
+{
+  U res = u;
+  --u;
+  return res;
+}
+
+// Compound assignment operators (threadgroup address space).
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC threadgroup U &operator+=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) + remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC threadgroup U &operator-=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) - remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC threadgroup U &operator*=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) * remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_arithmetic>>
+constexpr METAL_FUNC threadgroup U &operator/=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) / remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator%=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) % remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator<<=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) << remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator>>=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) >> remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator&=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) & remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator|=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) | remove_uniform_t<V>(v);
+  return u;
+}
+
+template <typename U, typename V, typename = _op_assign_uniform_constraints_t<U, V, is_integral>>
+constexpr METAL_FUNC threadgroup U &operator^=(threadgroup U &u, V v) METAL_ARG_UNIFORM(v, 2)
+{
+  u.__v = remove_uniform_t<U>(u) ^ remove_uniform_t<V>(v);
+  return u;
+}
+
+}
+#pragma METAL internals : disable
+
+#endif
+
+#endif
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_utility b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_utility
new file mode 100644
index 00000000..d9b2d046
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/metal_utility
@@ -0,0 +1,29 @@
+//===-- metal_initializer_list --------------------------------------------===//
+// Copyright (c) 2014-2017 Apple Inc. All rights reserved
+//===----------------------------------------------------------------------===//
+
+#ifndef __METAL_UTILITY
+#define __METAL_UTILITY
+
+namespace metal
+{
+template <typename T, T... I>
+struct _integer_sequence
+{
+  typedef T value_type;
+  static constexpr size_t size()
+  {
+    return sizeof...(I);
+  }
+};
+template <typename T, T N>
+using _make_integer_sequence = __make_integer_seq<_integer_sequence, T, N>;
+#ifdef __cpp_variable_templates
+template <typename T, T... I>
+using integer_sequence = _integer_sequence<T, I...>;
+template <typename T, T N>
+using make_integer_sequence = _make_integer_sequence<T, N>;
+#endif
+} // namespace metal
+
+#endif // __METAL_UTILITY
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/matrix_types.h b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/matrix_types.h
new file mode 100644
index 00000000..a31d6b1c
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/matrix_types.h
@@ -0,0 +1,72 @@
+/*  Copyright (c) 2014 Apple, Inc. All rights reserved.
+ *
+ *  This header defines float matrix types that are also defined on the host.
+ *  Though the implementations are different, the host and device will have the
+ *  same size, alignment, and storage formats. These matrices
+ *  are stored in column-major order, and implemented as arrays of column
+ *  vectors. You should think of matrices as abstract mathematical
+ *  objects that you use to perform arithmetic without worrying about the
+ *  details of the underlying representation.
+ *
+ *  WARNING: vectors of length three are internally represented as length four
+ *  vectors with one element of padding (for alignment purposes).  This means
+ *  that when a floatNx3 or doubleNx3 is viewed as a vector, it appears to
+ *  have 4*N elements instead of the expected 3*N (with one padding element
+ *  at the end of each column). The matrix elements are laid out in the
+ *  elements field as follows:
+ *
+ *      { 0, 1, 2, x, 3, 4, 5, x, ... }
+ *
+ *  (where the scalar indices used above indicate the conceptual column-
+ *  major storage order). If you aren't monkeying around with the internal
+ *  storage details of matrices, you don't need to worry about this at all.
+ *  Consider this yet another good reason to avoid doing so.
+ */
+
+#ifndef __SIMD_MATRIX_TYPES_HEADER__
+#define __SIMD_MATRIX_TYPES_HEADER__
+
+#include <metal_matrix>
+
+using matrix_half2x2 = metal::half2x2;
+using matrix_half3x2 = metal::half3x2;
+using matrix_half4x2 = metal::half4x2;
+
+using matrix_half2x3 = metal::half2x3;
+using matrix_half3x3 = metal::half3x3;
+using matrix_half4x3 = metal::half4x3;
+
+using matrix_half2x4 = metal::half2x4;
+using matrix_half3x4 = metal::half3x4;
+using matrix_half4x4 = metal::half4x4;
+
+using matrix_float2x2 = metal::float2x2;
+using matrix_float3x2 = metal::float3x2;
+using matrix_float4x2 = metal::float4x2;
+
+using matrix_float2x3 = metal::float2x3;
+using matrix_float3x3 = metal::float3x3;
+using matrix_float4x3 = metal::float4x3;
+
+using matrix_float2x4 = metal::float2x4;
+using matrix_float3x4 = metal::float3x4;
+using matrix_float4x4 = metal::float4x4;
+
+#if defined(__HAVE_NATIVE_DOUBLE__)
+using matrix_double2x2 = metal::double2x2;
+using matrix_double3x2 = metal::double3x2;
+using matrix_double4x2 = metal::double4x2;
+
+using matrix_double2x3 = metal::double2x3;
+using matrix_double3x3 = metal::double3x3;
+using matrix_double4x3 = metal::double4x3;
+
+using matrix_double2x4 = metal::double2x4;
+using matrix_double3x4 = metal::double3x4;
+using matrix_double4x4 = metal::double4x4;
+#endif
+
+// We just need to export the metal namespace as simd here.
+namespace simd = metal;
+
+#endif /* __SIMD_MATRIX_TYPES_HEADER__ */
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/packed.h b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/packed.h
new file mode 100644
index 00000000..ee46360c
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/packed.h
@@ -0,0 +1,18 @@
+/*  Copyright (c) 2016-2017 Apple, Inc. All rights reserved.
+ *
+ * This is a version of simd/packed.h suitatable to be used with the Metal
+ * compiler. The main differences are:
+ *
+ *     - Support for 3 elements packed vectors.
+ *     - Depending on the Metal language standard, access to array elements via
+ *       component name -- e.g. .x, .y, ... -- might be enabled.
+ */
+
+#ifndef __SIMD_PACKED_HEADER__
+#define __SIMD_PACKED_HEADER__
+
+// Metal packed vector types are always defined, we just need to export the
+// metal namespace as simd here.
+namespace simd = metal;
+
+#endif /* __SIMD_PACKED_HEADER__ */
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/simd.h b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/simd.h
new file mode 100644
index 00000000..78b496e7
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/simd.h
@@ -0,0 +1,21 @@
+/*  Copyright (c) 2014 Apple, Inc.  All rights reserved.
+ *
+ *  This header provides small vector (SIMD) and matrix types, and basic
+ *  arithmetic and mathematical functions for them.  The vast majority of these
+ *  operations are implemented as header inlines, as they can be performed
+ *  using just a few instructions on most processors.
+ *
+ *  These functions are broken into two groups; vector and matrix.  This header
+ *  includes all of them, but these may also be included separately.  Consult
+ *  these two headers for detailed documentation of what types and operations
+ *  are available.
+ */
+
+#ifndef __SIMD_HEADER__
+#define __SIMD_HEADER__
+
+#include <simd/vector_types.h>
+#include <simd/matrix_types.h>
+#include <simd/packed.h>
+
+#endif /* __SIMD_HEADER__ */
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/vector_types.h b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/vector_types.h
new file mode 100644
index 00000000..d2e93d93
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/lib/clang/802.6/include/metal/simd/vector_types.h
@@ -0,0 +1,15 @@
+/*  Copyright (c) 2014-2017 Apple, Inc. All rights reserved.
+ *
+ * This is a version of simd/vector_types.h suitatable to be used with the Metal
+ * compiler.
+ *
+ */
+
+#ifndef __SIMD_VECTOR_TYPES_HEADER__
+#define __SIMD_VECTOR_TYPES_HEADER__
+
+// Metal vector types are always defined, we just need to export the metal
+// namespace as simd here.
+namespace simd = metal;
+
+#endif /* __SIMD_VECTOR_TYPES_HEADER__ */
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libComposeFilters.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libComposeFilters.dylib
new file mode 100755
index 00000000..5c485796
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libComposeFilters.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompiler.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompiler.dylib
new file mode 100755
index 00000000..1b607ad2
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompiler.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImpl.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImpl.dylib
new file mode 100755
index 00000000..764daa2f
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImpl.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImplLazy.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImplLazy.dylib
new file mode 100755
index 00000000..f8b290ba
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libGPUCompilerImplLazy.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libLLVM.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libLLVM.dylib
new file mode 100755
index 00000000..d3a8f0d7
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libLLVM.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libmetal_timestamp.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libmetal_timestamp.dylib
new file mode 100755
index 00000000..8034d0a1
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/GPUCompiler/3802/Libraries/libmetal_timestamp.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Libraries/libMTLCompilerHelper.dylib b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Libraries/libMTLCompilerHelper.dylib
new file mode 100755
index 00000000..f39c9497
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Libraries/libMTLCompilerHelper.dylib differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/MTLCompiler b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/MTLCompiler
new file mode 100755
index 00000000..62444b35
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/MTLCompiler differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/Info.plist b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/Info.plist
new file mode 100644
index 00000000..15c36d3f
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/Info.plist
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>BuildMachineOSBuild</key>
+	<string>20A241133</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>MTLCompiler</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.apple.MTLCompiler</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>MTLCompiler</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>263.9</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleSupportedPlatforms</key>
+	<array>
+		<string>MacOSX</string>
+	</array>
+	<key>CFBundleVersion</key>
+	<string>263.9</string>
+	<key>DTCompiler</key>
+	<string>com.apple.compilers.llvm.clang.1_0</string>
+	<key>DTPlatformBuild</key>
+	<string>13E6049a</string>
+	<key>DTPlatformName</key>
+	<string>macosx</string>
+	<key>DTPlatformVersion</key>
+	<string>12.7</string>
+	<key>DTSDKBuild</key>
+	<string>21G806</string>
+	<key>DTSDKName</key>
+	<string>macosx12.7.internal</string>
+	<key>DTXcode</key>
+	<string>1330</string>
+	<key>DTXcodeBuild</key>
+	<string>13E6049a</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>12.7</string>
+</dict>
+</plist>
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/libmetal_boundscheck.a b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/libmetal_boundscheck.a
new file mode 100644
index 00000000..e542b4c9
Binary files /dev/null and b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/libmetal_boundscheck.a differ
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/version.plist b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/version.plist
new file mode 100644
index 00000000..24de6e36
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/Resources/version.plist
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>BuildVersion</key>
+	<string>18</string>
+	<key>CFBundleShortVersionString</key>
+	<string>263.9</string>
+	<key>CFBundleVersion</key>
+	<string>263.9</string>
+	<key>ProjectName</key>
+	<string>Metal</string>
+	<key>SourceVersion</key>
+	<string>263009000000000</string>
+</dict>
+</plist>
diff --git a/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/_CodeSignature/CodeResources b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/_CodeSignature/CodeResources
new file mode 100755
index 00000000..5eff7591
--- /dev/null
+++ b/Universal-Binaries/12.7.6-3802/System/Library/PrivateFrameworks/MTLCompiler/3802/_CodeSignature/CodeResources
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>files</key>
+	<dict/>
+	<key>files2</key>
+	<dict/>
+	<key>rules</key>
+	<dict>
+		<key>^.*</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+	<key>rules2</key>
+	<dict>
+		<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>0.0</real>
+		</dict>
+		<key>^.*</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+</dict>
+</plist>
diff --git a/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/Metal b/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/Metal
new file mode 100755
index 00000000..611f201d
Binary files /dev/null and b/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/Metal differ
diff --git a/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/MetalOld.dylib b/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/MetalOld.dylib
new file mode 100755
index 00000000..837fb4e9
Binary files /dev/null and b/Universal-Binaries/13.2.1-24/System/Library/Frameworks/Metal.framework/Versions/A/MetalOld.dylib differ
diff --git a/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage b/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage
new file mode 100755
index 00000000..7aa52ae3
Binary files /dev/null and b/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage differ
diff --git a/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImageOld.dylib b/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImageOld.dylib
new file mode 100755
index 00000000..438c0c1d
Binary files /dev/null and b/Universal-Binaries/14.0 Beta 3-24/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImageOld.dylib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage.metallib
new file mode 100644
index 00000000..62a52bbe
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/CoreImage.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV2.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV2.metallib
new file mode 100644
index 00000000..c5ada795
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV2.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV3.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV3.metallib
new file mode 100644
index 00000000..7c68ff68
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurStitchableV3.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV2.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV2.metallib
new file mode 100644
index 00000000..0451e265
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV2.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV3.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV3.metallib
new file mode 100644
index 00000000..c48baaf7
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/CIPortraitBlurV3.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters.metallib
new file mode 100644
index 00000000..bcd36a43
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters_stitchable.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters_stitchable.metallib
new file mode 100644
index 00000000..a9fc1973
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_filters_stitchable.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib.metallib
new file mode 100644
index 00000000..a6e95052
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_h.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_h.metallib
new file mode 100644
index 00000000..f80a744f
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_h.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable.metallib
new file mode 100644
index 00000000..28e0ff6b
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable_h.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable_h.metallib
new file mode 100644
index 00000000..c8e99086
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/ci_stdlib_stitchable_h.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/default.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/default.metallib
new file mode 100644
index 00000000..f97d5ec3
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources/default.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/MLCompute.framework/Versions/A/Resources/default.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/MLCompute.framework/Versions/A/Resources/default.metallib
new file mode 100644
index 00000000..e41df33f
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/MLCompute.framework/Versions/A/Resources/default.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSCore.framework/Versions/A/Resources/default.metallib b/Universal-Binaries/14.6.1/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSCore.framework/Versions/A/Resources/default.metallib
new file mode 100644
index 00000000..ca0b1ee3
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSCore.framework/Versions/A/Resources/default.metallib differ
diff --git a/Universal-Binaries/14.6.1/System/Library/PrivateFrameworks/CoreUI.framework/Versions/A/Resources/default.metallib b/Universal-Binaries/14.6.1/System/Library/PrivateFrameworks/CoreUI.framework/Versions/A/Resources/default.metallib
new file mode 100644
index 00000000..62639b67
Binary files /dev/null and b/Universal-Binaries/14.6.1/System/Library/PrivateFrameworks/CoreUI.framework/Versions/A/Resources/default.metallib differ