Add files using upload-large-folder tool

.gitattributes

@@ -96,3 +96,5 @@ miniCUDA124/bin/npps64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvrtc64_120_0.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvrtc-builtins64_124.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvjpeg64_12.dll filter=lfs diff=lfs merge=lfs -text
+ffmpeg/bin/avfilter-10.dll filter=lfs diff=lfs merge=lfs -text
+ComfyUI-YoloWorld-EfficientSAM/efficient_sam_s_cpu.jit filter=lfs diff=lfs merge=lfs -text

ComfyUI-YoloWorld-EfficientSAM/efficient_sam_s_cpu.jit

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b63ab268e9020b0fb7fc9f46e742644d4c9ea6e5d9caf56045f0afb6475db09
+size 106006979

ffmpeg/bin/avfilter-10.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c31032592fd453217bea06e99449d4febc084e96725f8e0761892c4c421352b
+size 28882432

miniCUDA124/include/thrust/system/tbb/detail/count.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits count
+#include <thrust/system/cpp/detail/count.h>
+

miniCUDA124/include/thrust/system/tbb/detail/equal.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits equal
+#include <thrust/system/cpp/detail/equal.h>
+

miniCUDA124/include/thrust/system/tbb/detail/execution_policy.h

@@ -0,0 +1,90 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+// put the canonical tag in the same ns as the backend's entry points
+namespace tbb
+{
+namespace detail
+{
+
+// this awkward sequence of definitions arise
+// from the desire both for tag to derive
+// from execution_policy and for execution_policy
+// to convert to tag (when execution_policy is not
+// an ancestor of tag)
+
+// forward declaration of tag
+struct tag;
+
+// forward declaration of execution_policy
+template<typename> struct execution_policy;
+
+// specialize execution_policy for tag
+template<>
+  struct execution_policy<tag>
+    : thrust::system::cpp::detail::execution_policy<tag>
+{};
+
+// tag's definition comes before the
+// generic definition of execution_policy
+struct tag : execution_policy<tag> {};
+
+// allow conversion to tag when it is not a successor
+template<typename Derived>
+  struct execution_policy
+    : thrust::system::cpp::detail::execution_policy<Derived>
+{
+  typedef tag tag_type;
+  operator tag() const { return tag(); }
+};
+
+} // end detail
+
+// alias execution_policy and tag here
+using thrust::system::tbb::detail::execution_policy;
+using thrust::system::tbb::detail::tag;
+
+} // end tbb
+} // end system
+
+// alias items at top-level
+namespace tbb
+{
+
+using thrust::system::tbb::execution_policy;
+using thrust::system::tbb::tag;
+
+} // end tbb
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/extrema.h

@@ -0,0 +1,74 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/system/detail/generic/extrema.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  // tbb prefers generic::max_element to cpp::max_element
+  return thrust::system::detail::generic::max_element(exec, first, last, comp);
+} // end max_element()
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  // tbb prefers generic::min_element to cpp::min_element
+  return thrust::system::detail::generic::min_element(exec, first, last, comp);
+} // end min_element()
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(execution_policy<DerivedPolicy> &exec,
+                                                             ForwardIterator first,
+                                                             ForwardIterator last,
+                                                             BinaryPredicate comp)
+{
+  // tbb prefers generic::minmax_element to cpp::minmax_element
+  return thrust::system::detail::generic::minmax_element(exec, first, last, comp);
+} // end minmax_element()
+
+} // end detail
+} // end tbb
+} // end system
+THRUST_NAMESPACE_END
+
+

miniCUDA124/include/thrust/system/tbb/detail/fill.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits fill
+#include <thrust/system/cpp/detail/fill.h>
+

miniCUDA124/include/thrust/system/tbb/detail/find.h

@@ -0,0 +1,53 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/detail/generic/find.h>
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+InputIterator find_if(execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  // tbb prefers generic::find_if to cpp::find_if
+  return thrust::system::detail::generic::find_if(exec, first, last, pred);
+}
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/for_each.h

@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename UnaryFunction>
+  RandomAccessIterator for_each(execution_policy<DerivedPolicy> &exec,
+                                RandomAccessIterator first,
+                                RandomAccessIterator last,
+                                UnaryFunction f);
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename Size,
+         typename UnaryFunction>
+  RandomAccessIterator for_each_n(execution_policy<DerivedPolicy> &exec,
+                                  RandomAccessIterator first,
+                                  Size n,
+                                  UnaryFunction f);
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/for_each.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/for_each.inl

@@ -0,0 +1,110 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/static_assert.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+#include <thrust/system/detail/sequential/execution_policy.h>
+
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace for_each_detail
+{
+
+template<typename RandomAccessIterator,
+         typename Size,
+         typename UnaryFunction>
+  struct body
+{
+  RandomAccessIterator m_first;
+  UnaryFunction m_f;
+
+  body(RandomAccessIterator first, UnaryFunction f)
+    : m_first(first), m_f(f)
+  {}
+
+  void operator()(const ::tbb::blocked_range<Size> &r) const
+  {
+    // we assume that blocked_range specifies a contiguous range of integers
+    thrust::for_each_n(thrust::system::detail::sequential::seq, m_first + r.begin(), r.size(), m_f);
+  } // end operator()()
+}; // end body
+
+
+template<typename Size, typename RandomAccessIterator, typename UnaryFunction>
+  body<RandomAccessIterator,Size,UnaryFunction>
+    make_body(RandomAccessIterator first, UnaryFunction f)
+{
+  return body<RandomAccessIterator,Size,UnaryFunction>(first, f);
+} // end make_body()
+
+
+} // end for_each_detail
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename Size,
+         typename UnaryFunction>
+RandomAccessIterator for_each_n(execution_policy<DerivedPolicy> &,
+                                RandomAccessIterator first,
+                                Size n,
+                                UnaryFunction f)
+{
+  ::tbb::parallel_for(::tbb::blocked_range<Size>(0,n), for_each_detail::make_body<Size>(first,f));
+
+  // return the end of the range
+  return first + n;
+} // end for_each_n
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename UnaryFunction>
+  RandomAccessIterator for_each(execution_policy<DerivedPolicy> &s,
+                                RandomAccessIterator first,
+                                RandomAccessIterator last,
+                                UnaryFunction f)
+{
+  return tbb::detail::for_each_n(s, first, thrust::distance(first,last), f);
+} // end for_each()
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/gather.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits gather
+#include <thrust/system/cpp/detail/gather.h>
+

miniCUDA124/include/thrust/system/tbb/detail/generate.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits generate
+#include <thrust/system/cpp/detail/generate.h>
+

miniCUDA124/include/thrust/system/tbb/detail/get_value.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits get_value
+#include <thrust/system/cpp/detail/get_value.h>
+

miniCUDA124/include/thrust/system/tbb/detail/inner_product.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits inner_product
+#include <thrust/system/cpp/detail/inner_product.h>
+

miniCUDA124/include/thrust/system/tbb/detail/iter_swap.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits iter_swap
+#include <thrust/system/cpp/detail/iter_swap.h>
+

miniCUDA124/include/thrust/system/tbb/detail/logical.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits logical
+#include <thrust/system/cpp/detail/logical.h>
+

miniCUDA124/include/thrust/system/tbb/detail/malloc_and_free.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits malloc and free
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+

miniCUDA124/include/thrust/system/tbb/detail/memory.inl

@@ -0,0 +1,95 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/system/tbb/memory.h>
+#include <thrust/system/cpp/memory.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+
+
+namespace detail
+{
+
+// XXX circular #inclusion problems cause the compiler to believe that cpp::malloc
+//     is not defined
+//     WAR the problem by using adl to call cpp::malloc, which requires it to depend
+//     on a template parameter
+template<typename Tag>
+  pointer<void> malloc_workaround(Tag t, std::size_t n)
+{
+  return pointer<void>(malloc(t, n));
+} // end malloc_workaround()
+
+// XXX circular #inclusion problems cause the compiler to believe that cpp::free
+//     is not defined
+//     WAR the problem by using adl to call cpp::free, which requires it to depend
+//     on a template parameter
+template<typename Tag>
+  void free_workaround(Tag t, pointer<void> ptr)
+{
+  free(t, ptr.get());
+} // end free_workaround()
+
+} // end detail
+
+inline pointer<void> malloc(std::size_t n)
+{
+  // XXX this is how we'd like to implement this function,
+  //     if not for circular #inclusion problems:
+  //
+  // return pointer<void>(thrust::system::cpp::malloc(n))
+  //
+  return detail::malloc_workaround(cpp::tag(), n);
+} // end malloc()
+
+template<typename T>
+pointer<T> malloc(std::size_t n)
+{
+  pointer<void> raw_ptr = thrust::system::tbb::malloc(sizeof(T) * n);
+  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
+} // end malloc()
+
+inline void free(pointer<void> ptr)
+{
+  // XXX this is how we'd like to implement this function,
+  //     if not for circular #inclusion problems:
+  //
+  // thrust::system::cpp::free(ptr)
+  //
+  detail::free_workaround(cpp::tag(), ptr);
+} // end free()
+
+} // end tbb
+} // end system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/merge.h

@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template<typename ExecutionPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+OutputIterator merge(execution_policy<ExecutionPolicy> &exec,
+                     InputIterator1 first1,
+                     InputIterator1 last1,
+                     InputIterator2 first2,
+                     InputIterator2 last2,
+                     OutputIterator result,
+                     StrictWeakOrdering comp);
+
+template <typename ExecutionPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename StrictWeakOrdering>
+thrust::pair<OutputIterator1,OutputIterator2>
+  merge_by_key(execution_policy<ExecutionPolicy> &exec,
+               InputIterator1 keys_first1,
+               InputIterator1 keys_last1,
+               InputIterator2 keys_first2,
+               InputIterator2 keys_last2,
+               InputIterator3 values_first3,
+               InputIterator4 values_first4,
+               OutputIterator1 keys_result,
+               OutputIterator2 values_result,
+               StrictWeakOrdering comp);
+
+} // end detail
+} // end tbb
+} // end system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/merge.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/merge.inl

@@ -0,0 +1,297 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/merge.h>
+#include <thrust/binary_search.h>
+#include <thrust/detail/seq.h>
+#include <tbb/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace merge_detail
+{
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+struct range
+{
+  InputIterator1 first1, last1;
+  InputIterator2 first2, last2;
+  OutputIterator result;
+  StrictWeakOrdering comp;
+  size_t grain_size;
+
+  range(InputIterator1 first1, InputIterator1 last1,
+        InputIterator2 first2, InputIterator2 last2,
+        OutputIterator result,
+        StrictWeakOrdering comp,
+        size_t grain_size = 1024)
+    : first1(first1), last1(last1),
+      first2(first2), last2(last2),
+      result(result), comp(comp), grain_size(grain_size)
+  {}
+
+  range(range& r, ::tbb::split)
+    : first1(r.first1), last1(r.last1),
+      first2(r.first2), last2(r.last2),
+      result(r.result), comp(r.comp), grain_size(r.grain_size)
+  {
+    // we can assume n1 and n2 are not both 0
+    size_t n1 = thrust::distance(first1, last1);
+    size_t n2 = thrust::distance(first2, last2);
+
+    InputIterator1 mid1 = first1;
+    InputIterator2 mid2 = first2;
+
+    if (n1 > n2)
+    {
+      mid1 += n1 / 2;
+      mid2 = thrust::lower_bound(thrust::seq, first2, last2, raw_reference_cast(*mid1), comp);
+    }
+    else
+    {
+      mid2 += n2 / 2;
+      mid1 = thrust::upper_bound(thrust::seq, first1, last1, raw_reference_cast(*mid2), comp);
+    }
+
+    // set first range to [first1, mid1), [first2, mid2), result
+    r.last1 = mid1;
+    r.last2 = mid2;
+
+    // set second range to [mid1, last1), [mid2, last2), result + (mid1 - first1) + (mid2 - first2)
+    first1 = mid1;
+    first2 = mid2;
+    result += thrust::distance(r.first1, mid1) + thrust::distance(r.first2, mid2);
+  }
+
+  bool empty(void) const
+  {
+    return (first1 == last1) && (first2 == last2);
+  }
+
+  bool is_divisible(void) const
+  {
+    return static_cast<size_t>(thrust::distance(first1, last1) + thrust::distance(first2, last2)) > grain_size;
+  }
+};
+
+struct body
+{
+  template <typename Range>
+  void operator()(Range& r) const
+  {
+    thrust::merge(thrust::seq,
+                  r.first1, r.last1,
+                  r.first2, r.last2,
+                  r.result,
+                  r.comp);
+  }
+};
+
+} // end namespace merge_detail
+
+namespace merge_by_key_detail
+{
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+struct range
+{
+  InputIterator1 keys_first1, keys_last1;
+  InputIterator2 keys_first2, keys_last2;
+  InputIterator3 values_first1;
+  InputIterator4 values_first2;
+  OutputIterator1 keys_result;
+  OutputIterator2 values_result;
+  StrictWeakOrdering comp;
+  size_t grain_size;
+
+  range(InputIterator1 keys_first1, InputIterator1 keys_last1,
+        InputIterator2 keys_first2, InputIterator2 keys_last2,
+        InputIterator3 values_first1,
+        InputIterator4 values_first2,
+        OutputIterator1 keys_result,
+        OutputIterator2 values_result,
+        StrictWeakOrdering comp,
+        size_t grain_size = 1024)
+    : keys_first1(keys_first1), keys_last1(keys_last1),
+      keys_first2(keys_first2), keys_last2(keys_last2),
+      values_first1(values_first1),
+      values_first2(values_first2),
+      keys_result(keys_result), values_result(values_result),
+      comp(comp), grain_size(grain_size)
+  {}
+
+  range(range& r, ::tbb::split)
+    : keys_first1(r.keys_first1), keys_last1(r.keys_last1),
+      keys_first2(r.keys_first2), keys_last2(r.keys_last2),
+      values_first1(r.values_first1),
+      values_first2(r.values_first2),
+      keys_result(r.keys_result), values_result(r.values_result),
+      comp(r.comp), grain_size(r.grain_size)
+  {
+    // we can assume n1 and n2 are not both 0
+    size_t n1 = thrust::distance(keys_first1, keys_last1);
+    size_t n2 = thrust::distance(keys_first2, keys_last2);
+
+    InputIterator1 mid1 = keys_first1;
+    InputIterator2 mid2 = keys_first2;
+
+    if (n1 > n2)
+    {
+      mid1 += n1 / 2;
+      mid2 = thrust::lower_bound(thrust::seq, keys_first2, keys_last2, raw_reference_cast(*mid1), comp);
+    }
+    else
+    {
+      mid2 += n2 / 2;
+      mid1 = thrust::upper_bound(thrust::seq, keys_first1, keys_last1, raw_reference_cast(*mid2), comp);
+    }
+
+    // set first range to [keys_first1, mid1), [keys_first2, mid2), keys_result, values_result
+    r.keys_last1 = mid1;
+    r.keys_last2 = mid2;
+
+    // set second range to [mid1, keys_last1), [mid2, keys_last2), keys_result + (mid1 - keys_first1) + (mid2 - keys_first2), values_result + (mid1 - keys_first1) + (mid2 - keys_first2)
+    keys_first1 = mid1;
+    keys_first2 = mid2;
+    values_first1 += thrust::distance(r.keys_first1, mid1);
+    values_first2 += thrust::distance(r.keys_first2, mid2);
+    keys_result += thrust::distance(r.keys_first1, mid1) + thrust::distance(r.keys_first2, mid2);
+    values_result += thrust::distance(r.keys_first1, mid1) + thrust::distance(r.keys_first2, mid2);
+  }
+
+  bool empty(void) const
+  {
+    return (keys_first1 == keys_last1) && (keys_first2 == keys_last2);
+  }
+
+  bool is_divisible(void) const
+  {
+    return static_cast<size_t>(thrust::distance(keys_first1, keys_last1) + thrust::distance(keys_first2, keys_last2)) > grain_size;
+  }
+};
+
+struct body
+{
+  template <typename Range>
+  void operator()(Range& r) const
+  {
+    thrust::merge_by_key(thrust::seq,
+                         r.keys_first1, r.keys_last1,
+                         r.keys_first2, r.keys_last2,
+                         r.values_first1,
+                         r.values_first2,
+                         r.keys_result,
+                         r.values_result,
+                         r.comp);
+  }
+};
+
+} // end namespace merge_by_key_detail
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+OutputIterator merge(execution_policy<DerivedPolicy> &,
+                     InputIterator1 first1,
+                     InputIterator1 last1,
+                     InputIterator2 first2,
+                     InputIterator2 last2,
+                     OutputIterator result,
+                     StrictWeakOrdering comp)
+{
+  typedef typename merge_detail::range<InputIterator1,InputIterator2,OutputIterator,StrictWeakOrdering> Range;
+  typedef          merge_detail::body                                                                   Body;
+  Range range(first1, last1, first2, last2, result, comp);
+  Body  body;
+
+  ::tbb::parallel_for(range, body);
+
+  thrust::advance(result, thrust::distance(first1, last1) + thrust::distance(first2, last2));
+
+  return result;
+} // end merge()
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename StrictWeakOrdering>
+thrust::pair<OutputIterator1,OutputIterator2>
+  merge_by_key(execution_policy<DerivedPolicy> &,
+               InputIterator1 keys_first1,
+               InputIterator1 keys_last1,
+               InputIterator2 keys_first2,
+               InputIterator2 keys_last2,
+               InputIterator3 values_first3,
+               InputIterator4 values_first4,
+               OutputIterator1 keys_result,
+               OutputIterator2 values_result,
+               StrictWeakOrdering comp)
+{
+  typedef typename merge_by_key_detail::range<InputIterator1,InputIterator2,InputIterator3,InputIterator4,OutputIterator1,OutputIterator2,StrictWeakOrdering> Range;
+  typedef          merge_by_key_detail::body                                                                                                                  Body;
+
+  Range range(keys_first1, keys_last1, keys_first2, keys_last2, values_first3, values_first4, keys_result, values_result, comp);
+  Body  body;
+
+  ::tbb::parallel_for(range, body);
+
+  thrust::advance(keys_result,   thrust::distance(keys_first1, keys_last1) + thrust::distance(keys_first2, keys_last2));
+  thrust::advance(values_result, thrust::distance(keys_first1, keys_last1) + thrust::distance(keys_first2, keys_last2));
+
+  return thrust::make_pair(keys_result,values_result);
+}
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/mismatch.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits mismatch
+#include <thrust/system/cpp/detail/mismatch.h>
+

miniCUDA124/include/thrust/system/tbb/detail/par.h

@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/allocator_aware_execution_policy.h>
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+
+struct par_t : thrust::system::tbb::detail::execution_policy<par_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    thrust::system::tbb::detail::execution_policy>
+{
+  __host__ __device__
+  constexpr par_t() : thrust::system::tbb::detail::execution_policy<par_t>() {}
+};
+
+
+} // end detail
+
+
+static const detail::par_t par;
+
+
+} // end tbb
+} // end system
+
+
+// alias par here
+namespace tbb
+{
+
+
+using thrust::system::tbb::par;
+
+
+} // end tbb
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/partition.h

@@ -0,0 +1,94 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred);
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred);
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/partition.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/partition.inl

@@ -0,0 +1,109 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/partition.h>
+#include <thrust/system/detail/generic/partition.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred)
+{
+  // tbb prefers generic::stable_partition to cpp::stable_partition
+  return thrust::system::detail::generic::stable_partition(exec, first, last, pred);
+} // end stable_partition()
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred)
+{
+  // tbb prefers generic::stable_partition to cpp::stable_partition
+  return thrust::system::detail::generic::stable_partition(exec, first, last, stencil, pred);
+} // end stable_partition()
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  // tbb prefers generic::stable_partition_copy to cpp::stable_partition_copy
+  return thrust::system::detail::generic::stable_partition_copy(exec, first, last, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  // tbb prefers generic::stable_partition_copy to cpp::stable_partition_copy
+  return thrust::system::detail::generic::stable_partition_copy(exec, first, last, stencil, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/per_device_resource.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system has no special per device resource functions
+

miniCUDA124/include/thrust/system/tbb/detail/reduce.h

@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file reduce.h
+ *  \brief TBB implementation of reduce.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputType,
+         typename BinaryFunction>
+  OutputType reduce(execution_policy<DerivedPolicy> &exec,
+                    InputIterator begin,
+                    InputIterator end,
+                    OutputType init,
+                    BinaryFunction binary_op);
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/reduce.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/reduce.inl

@@ -0,0 +1,138 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/function.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+#include <thrust/reduce.h>
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_reduce.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace reduce_detail
+{
+
+template<typename RandomAccessIterator,
+         typename OutputType,
+         typename BinaryFunction>
+struct body
+{
+  RandomAccessIterator first;
+  OutputType sum;
+  bool first_call;  // TBB can invoke operator() multiple times on the same body
+  thrust::detail::wrapped_function<BinaryFunction,OutputType> binary_op;
+
+  // note: we only initalize sum with init to avoid calling OutputType's default constructor
+  body(RandomAccessIterator first, OutputType init, BinaryFunction binary_op)
+    : first(first), sum(init), first_call(true), binary_op(binary_op)
+  {}
+
+  // note: we only initalize sum with b.sum to avoid calling OutputType's default constructor
+  body(body& b, ::tbb::split)
+    : first(b.first), sum(b.sum), first_call(true), binary_op(b.binary_op)
+  {}
+
+  template <typename Size>
+  void operator()(const ::tbb::blocked_range<Size> &r)
+  {
+    // we assume that blocked_range specifies a contiguous range of integers
+
+    if (r.empty()) return; // nothing to do
+
+    RandomAccessIterator iter = first + r.begin();
+
+    OutputType temp = thrust::raw_reference_cast(*iter);
+
+    ++iter;
+
+    for (Size i = r.begin() + 1; i != r.end(); ++i, ++iter)
+      temp = binary_op(temp, *iter);
+
+
+    if (first_call)
+    {
+      // first time body has been invoked
+      first_call = false;
+      sum = temp;
+    }
+    else
+    {
+      // body has been previously invoked, accumulate temp into sum
+      sum = binary_op(sum, temp);
+    }
+  } // end operator()()
+
+  void join(body& b)
+  {
+    sum = binary_op(sum, b.sum);
+  }
+}; // end body
+
+} // end reduce_detail
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputType,
+         typename BinaryFunction>
+  OutputType reduce(execution_policy<DerivedPolicy> &,
+                    InputIterator begin,
+                    InputIterator end,
+                    OutputType init,
+                    BinaryFunction binary_op)
+{
+  typedef typename thrust::iterator_difference<InputIterator>::type Size;
+
+  Size n = thrust::distance(begin, end);
+
+  if (n == 0)
+  {
+    return init;
+  }
+  else
+  {
+    typedef typename reduce_detail::body<InputIterator,OutputType,BinaryFunction> Body;
+    Body reduce_body(begin, init, binary_op);
+    ::tbb::parallel_reduce(::tbb::blocked_range<Size>(0,n), reduce_body);
+    return binary_op(init, reduce_body.sum);
+  }
+}
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/reduce_by_key.h

@@ -0,0 +1,64 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    reduce_by_key(execution_policy<DerivedPolicy> &exec,
+                  InputIterator1 keys_first,
+                  InputIterator1 keys_last,
+                  InputIterator2 values_first,
+                  OutputIterator1 keys_output,
+                  OutputIterator2 values_output,
+                  BinaryPredicate binary_pred,
+                  BinaryFunction binary_op);
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/reduce_by_key.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/reduce_by_key.inl

@@ -0,0 +1,349 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/reduce_by_key.h>
+#include <thrust/iterator/reverse_iterator.h>
+#include <thrust/detail/seq.h>
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/system/tbb/detail/reduce_intervals.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/range/tail_flags.h>
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
+
+#include <cassert>
+#include <thread>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace reduce_by_key_detail
+{
+
+
+template<typename L, typename R>
+  inline L divide_ri(const L x, const R y)
+{
+  return (x + (y - 1)) / y;
+}
+
+
+template<typename InputIterator, typename BinaryFunction, typename OutputIterator = void>
+  struct partial_sum_type
+    : thrust::detail::eval_if<
+        thrust::detail::has_result_type<BinaryFunction>::value,
+        thrust::detail::result_type<BinaryFunction>,
+        thrust::detail::eval_if<
+          thrust::detail::is_output_iterator<OutputIterator>::value,
+          thrust::iterator_value<InputIterator>,
+          thrust::iterator_value<OutputIterator>
+        >
+      >
+{};
+
+
+template<typename InputIterator, typename BinaryFunction>
+  struct partial_sum_type<InputIterator,BinaryFunction,void>
+    : thrust::detail::eval_if<
+        thrust::detail::has_result_type<BinaryFunction>::value,
+        thrust::detail::result_type<BinaryFunction>,
+        thrust::iterator_value<InputIterator>
+      >
+{};
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+  thrust::pair<
+    InputIterator1,
+    thrust::pair<
+      typename thrust::iterator_value<InputIterator1>::type,
+      typename partial_sum_type<InputIterator2,BinaryFunction>::type
+    >
+  >
+    reduce_last_segment_backward(InputIterator1 keys_first,
+                                 InputIterator1 keys_last,
+                                 InputIterator2 values_first,
+                                 BinaryPredicate binary_pred,
+                                 BinaryFunction binary_op)
+{
+  typename thrust::iterator_difference<InputIterator1>::type n = keys_last - keys_first;
+
+  // reverse the ranges and consume from the end
+  thrust::reverse_iterator<InputIterator1> keys_first_r(keys_last);
+  thrust::reverse_iterator<InputIterator1> keys_last_r(keys_first);
+  thrust::reverse_iterator<InputIterator2> values_first_r(values_first + n);
+
+  typename thrust::iterator_value<InputIterator1>::type result_key = *keys_first_r;
+  typename partial_sum_type<InputIterator2,BinaryFunction>::type result_value = *values_first_r;
+
+  // consume the entirety of the first key's sequence
+  for(++keys_first_r, ++values_first_r;
+      (keys_first_r != keys_last_r) && binary_pred(*keys_first_r, result_key);
+      ++keys_first_r, ++values_first_r)
+  {
+    result_value = binary_op(result_value, *values_first_r);
+  }
+
+  return thrust::make_pair(keys_first_r.base(), thrust::make_pair(result_key, result_value));
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+  thrust::tuple<
+    OutputIterator1,
+    OutputIterator2,
+    typename thrust::iterator_value<InputIterator1>::type,
+    typename partial_sum_type<InputIterator2,BinaryFunction>::type
+  >
+    reduce_by_key_with_carry(InputIterator1 keys_first,
+                             InputIterator1 keys_last,
+                             InputIterator2 values_first,
+                             OutputIterator1 keys_output,
+                             OutputIterator2 values_output,
+                             BinaryPredicate binary_pred,
+                             BinaryFunction binary_op)
+{
+  // first, consume the last sequence to produce the carry
+  // XXX is there an elegant way to pose this such that we don't need to default construct carry?
+  thrust::pair<
+    typename thrust::iterator_value<InputIterator1>::type,
+    typename partial_sum_type<InputIterator2,BinaryFunction>::type
+  > carry;
+
+  thrust::tie(keys_last, carry) = reduce_last_segment_backward(keys_first, keys_last, values_first, binary_pred, binary_op);
+
+  // finish with sequential reduce_by_key
+  thrust::tie(keys_output, values_output) =
+    thrust::reduce_by_key(thrust::seq, keys_first, keys_last, values_first, keys_output, values_output, binary_pred, binary_op);
+
+  return thrust::make_tuple(keys_output, values_output, carry.first, carry.second);
+}
+
+
+template<typename Iterator>
+  bool interval_has_carry(size_t interval_idx, size_t interval_size, size_t num_intervals, Iterator tail_flags)
+{
+  // to discover whether the interval has a carry, look at the tail_flag corresponding to its last element
+  // the final interval never has a carry by definition
+  return (interval_idx + 1 < num_intervals) ? !tail_flags[(interval_idx + 1) * interval_size - 1] : false;
+}
+
+
+template<typename Iterator1, typename Iterator2, typename Iterator3, typename Iterator4, typename Iterator5, typename Iterator6, typename BinaryPredicate, typename BinaryFunction>
+  struct serial_reduce_by_key_body
+{
+  typedef typename thrust::iterator_difference<Iterator1>::type size_type;
+
+  Iterator1 keys_first;
+  Iterator2 values_first;
+  Iterator3 result_offset;
+  Iterator4 keys_result;
+  Iterator5 values_result;
+  Iterator6 carry_result;
+
+  size_type n;
+  size_type interval_size;
+  size_type num_intervals;
+
+  BinaryPredicate binary_pred;
+  BinaryFunction binary_op;
+
+  serial_reduce_by_key_body(Iterator1 keys_first, Iterator2 values_first, Iterator3 result_offset, Iterator4 keys_result, Iterator5 values_result, Iterator6 carry_result, size_type n, size_type interval_size, size_type num_intervals, BinaryPredicate binary_pred, BinaryFunction binary_op)
+    : keys_first(keys_first), values_first(values_first),
+      result_offset(result_offset),
+      keys_result(keys_result),
+      values_result(values_result),
+      carry_result(carry_result),
+      n(n),
+      interval_size(interval_size),
+      num_intervals(num_intervals),
+      binary_pred(binary_pred),
+      binary_op(binary_op)
+  {}
+
+  void operator()(const ::tbb::blocked_range<size_type> &r) const
+  {
+    assert(r.size() == 1);
+
+    const size_type interval_idx = r.begin();
+
+    const size_type offset_to_first = interval_size * interval_idx;
+    const size_type offset_to_last = (thrust::min)(n, offset_to_first + interval_size);
+
+    Iterator1 my_keys_first     = keys_first    + offset_to_first;
+    Iterator1 my_keys_last      = keys_first    + offset_to_last;
+    Iterator2 my_values_first   = values_first  + offset_to_first;
+    Iterator3 my_result_offset  = result_offset + interval_idx;
+    Iterator4 my_keys_result    = keys_result   + *my_result_offset;
+    Iterator5 my_values_result  = values_result + *my_result_offset;
+    Iterator6 my_carry_result   = carry_result  + interval_idx;
+
+    // consume the rest of the interval with reduce_by_key
+    typedef typename thrust::iterator_value<Iterator1>::type key_type;
+    typedef typename partial_sum_type<Iterator2,BinaryFunction>::type value_type;
+
+    // XXX is there a way to pose this so that we don't require default construction of carry?
+    thrust::pair<key_type, value_type> carry;
+
+    thrust::tie(my_keys_result, my_values_result, carry.first, carry.second) =
+      reduce_by_key_with_carry(my_keys_first,
+                               my_keys_last,
+                               my_values_first,
+                               my_keys_result,
+                               my_values_result,
+                               binary_pred,
+                               binary_op);
+
+    // store to carry only when we actually have a carry
+    // store to my_keys_result & my_values_result otherwise
+
+    // create tail_flags so we can check for a carry
+    thrust::detail::tail_flags<Iterator1,BinaryPredicate> flags = thrust::detail::make_tail_flags(keys_first, keys_first + n, binary_pred);
+
+    if(interval_has_carry(interval_idx, interval_size, num_intervals, flags.begin()))
+    {
+      // we can ignore the carry's key
+      // XXX because the carry result is uninitialized, we should copy construct
+      *my_carry_result = carry.second;
+    }
+    else
+    {
+      *my_keys_result = carry.first;
+      *my_values_result = carry.second;
+    }
+  }
+};
+
+
+template<typename Iterator1, typename Iterator2, typename Iterator3, typename Iterator4, typename Iterator5, typename Iterator6, typename BinaryPredicate, typename BinaryFunction>
+  serial_reduce_by_key_body<Iterator1,Iterator2,Iterator3,Iterator4,Iterator5,Iterator6,BinaryPredicate,BinaryFunction>
+    make_serial_reduce_by_key_body(Iterator1 keys_first, Iterator2 values_first, Iterator3 result_offset, Iterator4 keys_result, Iterator5 values_result, Iterator6 carry_result, typename thrust::iterator_difference<Iterator1>::type n, size_t interval_size, size_t num_intervals, BinaryPredicate binary_pred, BinaryFunction binary_op)
+{
+  return serial_reduce_by_key_body<Iterator1,Iterator2,Iterator3,Iterator4,Iterator5,Iterator6,BinaryPredicate,BinaryFunction>(keys_first, values_first, result_offset, keys_result, values_result, carry_result, n, interval_size, num_intervals, binary_pred, binary_op);
+}
+
+
+} // end reduce_by_key_detail
+
+
+template<typename DerivedPolicy, typename Iterator1, typename Iterator2, typename Iterator3, typename Iterator4, typename BinaryPredicate, typename BinaryFunction>
+  thrust::pair<Iterator3,Iterator4>
+    reduce_by_key(thrust::tbb::execution_policy<DerivedPolicy> &exec,
+                  Iterator1 keys_first, Iterator1 keys_last,
+                  Iterator2 values_first,
+                  Iterator3 keys_result,
+                  Iterator4 values_result,
+                  BinaryPredicate binary_pred,
+                  BinaryFunction binary_op)
+{
+
+  typedef typename thrust::iterator_difference<Iterator1>::type difference_type;
+  difference_type n = keys_last - keys_first;
+  if(n == 0) return thrust::make_pair(keys_result, values_result);
+
+  // XXX this value is a tuning opportunity
+  const difference_type parallelism_threshold = 10000;
+
+  if(n < parallelism_threshold)
+  {
+    // don't bother parallelizing for small n
+    return thrust::reduce_by_key(thrust::seq, keys_first, keys_last, values_first, keys_result, values_result, binary_pred, binary_op);
+  }
+
+  // count the number of processors
+  const unsigned int p = thrust::max<unsigned int>(1u, std::thread::hardware_concurrency());
+
+  // generate O(P) intervals of sequential work
+  // XXX oversubscribing is a tuning opportunity
+  const unsigned int subscription_rate = 1;
+  difference_type interval_size = thrust::min<difference_type>(parallelism_threshold, thrust::max<difference_type>(n, n / (subscription_rate * p)));
+  difference_type num_intervals = reduce_by_key_detail::divide_ri(n, interval_size);
+
+  // decompose the input into intervals of size N / num_intervals
+  // add one extra element to this vector to store the size of the entire result
+  thrust::detail::temporary_array<difference_type, DerivedPolicy> interval_output_offsets(0, exec, num_intervals + 1);
+
+  // first count the number of tail flags in each interval
+  thrust::detail::tail_flags<Iterator1,BinaryPredicate> tail_flags = thrust::detail::make_tail_flags(keys_first, keys_last, binary_pred);
+  thrust::system::tbb::detail::reduce_intervals(exec, tail_flags.begin(), tail_flags.end(), interval_size, interval_output_offsets.begin() + 1, thrust::plus<size_t>());
+  interval_output_offsets[0] = 0;
+
+  // scan the counts to get each body's output offset
+  thrust::inclusive_scan(thrust::seq,
+                         interval_output_offsets.begin() + 1, interval_output_offsets.end(),
+                         interval_output_offsets.begin() + 1);
+
+  // do a reduce_by_key serially in each thread
+  // the final interval never has a carry by definition, so don't reserve space for it
+  typedef typename reduce_by_key_detail::partial_sum_type<Iterator2,BinaryFunction>::type carry_type;
+  thrust::detail::temporary_array<carry_type, DerivedPolicy> carries(0, exec, num_intervals - 1);
+
+  // force grainsize == 1 with simple_partioner()
+  ::tbb::parallel_for(::tbb::blocked_range<difference_type>(0, num_intervals, 1),
+    reduce_by_key_detail::make_serial_reduce_by_key_body(keys_first, values_first, interval_output_offsets.begin(), keys_result, values_result, carries.begin(), n, interval_size, num_intervals, binary_pred, binary_op),
+    ::tbb::simple_partitioner());
+
+  difference_type size_of_result = interval_output_offsets[num_intervals];
+
+  // sequentially accumulate the carries
+  // note that the last interval does not have a carry
+  // XXX find a way to express this loop via a sequential algorithm, perhaps reduce_by_key
+  for(typename thrust::detail::temporary_array<carry_type,DerivedPolicy>::size_type i = 0; i < carries.size(); ++i)
+  {
+    // if our interval has a carry, then we need to sum the carry to the next interval's output offset
+    // if it does not have a carry, then we need to ignore carry_value[i]
+    if(reduce_by_key_detail::interval_has_carry(i, interval_size, num_intervals, tail_flags.begin()))
+    {
+      difference_type output_idx = interval_output_offsets[i+1];
+
+      values_result[output_idx] = binary_op(values_result[output_idx], carries[i]);
+    }
+  }
+
+  return thrust::make_pair(keys_result + size_of_result, values_result + size_of_result);
+}
+
+
+} // end detail
+} // end tbb
+} // end system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/reduce_intervals.h

@@ -0,0 +1,132 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/detail/seq.h>
+
+#include <tbb/parallel_for.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/system/cpp/memory.h>
+#include <thrust/reduce.h>
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace reduce_intervals_detail
+{
+
+
+template<typename L, typename R>
+  inline L divide_ri(const L x, const R y)
+{
+  return (x + (y - 1)) / y;
+}
+
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Size, typename BinaryFunction>
+  struct body
+{
+  RandomAccessIterator1 first;
+  RandomAccessIterator2 result;
+  Size n, interval_size;
+  BinaryFunction binary_op;
+
+  body(RandomAccessIterator1 first, RandomAccessIterator2 result, Size n, Size interval_size, BinaryFunction binary_op)
+    : first(first), result(result), n(n), interval_size(interval_size), binary_op(binary_op)
+  {}
+
+  void operator()(const ::tbb::blocked_range<Size> &r) const
+  {
+    assert(r.size() == 1);
+
+    Size interval_idx = r.begin();
+
+    Size offset_to_first = interval_size * interval_idx;
+    Size offset_to_last = (thrust::min)(n, offset_to_first + interval_size);
+
+    RandomAccessIterator1 my_first = first + offset_to_first;
+    RandomAccessIterator1 my_last  = first + offset_to_last;
+
+    // carefully pass the init value for the interval with raw_reference_cast
+    typedef typename BinaryFunction::result_type sum_type;
+    result[interval_idx] =
+      thrust::reduce(thrust::seq, my_first + 1, my_last, sum_type(thrust::raw_reference_cast(*my_first)), binary_op);
+  }
+};
+
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Size, typename BinaryFunction>
+  body<RandomAccessIterator1,RandomAccessIterator2,Size,BinaryFunction>
+    make_body(RandomAccessIterator1 first, RandomAccessIterator2 result, Size n, Size interval_size, BinaryFunction binary_op)
+{
+  return body<RandomAccessIterator1,RandomAccessIterator2,Size,BinaryFunction>(first, result, n, interval_size, binary_op);
+}
+
+
+} // end reduce_intervals_detail
+
+
+template<typename DerivedPolicy, typename RandomAccessIterator1, typename Size, typename RandomAccessIterator2, typename BinaryFunction>
+  void reduce_intervals(thrust::tbb::execution_policy<DerivedPolicy> &,
+                        RandomAccessIterator1 first,
+                        RandomAccessIterator1 last,
+                        Size interval_size,
+                        RandomAccessIterator2 result,
+                        BinaryFunction binary_op)
+{
+  typename thrust::iterator_difference<RandomAccessIterator1>::type n = last - first;
+
+  Size num_intervals = reduce_intervals_detail::divide_ri(n, interval_size);
+
+  ::tbb::parallel_for(::tbb::blocked_range<Size>(0, num_intervals, 1), reduce_intervals_detail::make_body(first, result, Size(n), interval_size, binary_op), ::tbb::simple_partitioner());
+}
+
+
+template<typename DerivedPolicy, typename RandomAccessIterator1, typename Size, typename RandomAccessIterator2>
+  void reduce_intervals(thrust::tbb::execution_policy<DerivedPolicy> &exec,
+                        RandomAccessIterator1 first,
+                        RandomAccessIterator1 last,
+                        Size interval_size,
+                        RandomAccessIterator2 result)
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator1>::type value_type;
+
+  return thrust::system::tbb::detail::reduce_intervals(exec, first, last, interval_size, result, thrust::plus<value_type>());
+}
+
+
+} // end detail
+} // end tbb
+} // end system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/remove.h

@@ -0,0 +1,88 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/omp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator remove_if(execution_policy<ExecutionPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator remove_if(execution_policy<ExecutionPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(execution_policy<ExecutionPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(execution_policy<ExecutionPolicy> &exec,
+                                InputIterator1 first,
+                                InputIterator1 last,
+                                InputIterator2 stencil,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/remove.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/remove.inl

@@ -0,0 +1,101 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/remove.h>
+#include <thrust/system/detail/generic/remove.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator remove_if(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred)
+{
+  // tbb prefers generic::remove_if to cpp::remove_if
+  return thrust::system::detail::generic::remove_if(exec, first, last, pred);
+}
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator remove_if(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred)
+{
+  // tbb prefers generic::remove_if to cpp::remove_if
+  return thrust::system::detail::generic::remove_if(exec, first, last, stencil, pred);
+}
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(execution_policy<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred)
+{
+  // tbb prefers generic::remove_copy_if to cpp::remove_copy_if
+  return thrust::system::detail::generic::remove_copy_if(exec, first, last, result, pred);
+}
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(execution_policy<DerivedPolicy> &exec,
+                                InputIterator1 first,
+                                InputIterator1 last,
+                                InputIterator2 stencil,
+                                OutputIterator result,
+                                Predicate pred)
+{
+  // tbb prefers generic::remove_copy_if to cpp::remove_copy_if
+  return thrust::system::detail::generic::remove_copy_if(exec, first, last, stencil, result, pred);
+}
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/replace.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits this algorithm
+#include <thrust/system/cpp/detail/scatter.h>
+

miniCUDA124/include/thrust/system/tbb/detail/reverse.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits reverse
+#include <thrust/system/cpp/detail/reverse.h>
+

miniCUDA124/include/thrust/system/tbb/detail/scan.h

@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file scan.h
+ *  \brief TBB implementations of scan functions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction>
+  OutputIterator inclusive_scan(tag,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                BinaryFunction binary_op);
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename BinaryFunction>
+  OutputIterator exclusive_scan(tag,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init,
+                                BinaryFunction binary_op);
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/scan.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/scan.inl

@@ -0,0 +1,266 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/scan.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/function.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/function_traits.h>
+#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_scan.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace scan_detail
+{
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction,
+         typename ValueType>
+struct inclusive_body
+{
+  InputIterator input;
+  OutputIterator output;
+  thrust::detail::wrapped_function<BinaryFunction,ValueType> binary_op;
+  ValueType sum;
+  bool first_call;
+
+  inclusive_body(InputIterator input, OutputIterator output, BinaryFunction binary_op, ValueType dummy)
+    : input(input), output(output), binary_op(binary_op), sum(dummy), first_call(true)
+  {}
+
+  inclusive_body(inclusive_body& b, ::tbb::split)
+    : input(b.input), output(b.output), binary_op(b.binary_op), sum(b.sum), first_call(true)
+  {}
+
+  template<typename Size>
+  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::pre_scan_tag)
+  {
+    InputIterator iter = input + r.begin();
+
+    ValueType temp = *iter;
+
+    ++iter;
+
+    for (Size i = r.begin() + 1; i != r.end(); ++i, ++iter)
+      temp = binary_op(temp, *iter);
+
+    if (first_call)
+      sum = temp;
+    else
+      sum = binary_op(sum, temp);
+
+    first_call = false;
+  }
+
+  template<typename Size>
+  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::final_scan_tag)
+  {
+    InputIterator  iter1 = input  + r.begin();
+    OutputIterator iter2 = output + r.begin();
+
+    if (first_call)
+    {
+      *iter2 = sum = *iter1;
+      ++iter1;
+      ++iter2;
+      for (Size i = r.begin() + 1; i != r.end(); ++i, ++iter1, ++iter2)
+        *iter2 = sum = binary_op(sum, *iter1);
+    }
+    else
+    {
+      for (Size i = r.begin(); i != r.end(); ++i, ++iter1, ++iter2)
+        *iter2 = sum = binary_op(sum, *iter1);
+    }
+
+    first_call = false;
+  }
+
+  void reverse_join(inclusive_body& b)
+  {
+    // Only accumulate this functor's partial sum if this functor has been
+    // called at least once -- otherwise we'll over-count the initial value.
+    if (!first_call)
+    {
+      sum = binary_op(b.sum, sum);
+    }
+  }
+
+  void assign(inclusive_body& b)
+  {
+    sum = b.sum;
+  }
+};
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction,
+         typename ValueType>
+struct exclusive_body
+{
+  InputIterator input;
+  OutputIterator output;
+  thrust::detail::wrapped_function<BinaryFunction,ValueType> binary_op;
+  ValueType sum;
+  bool first_call;
+
+  exclusive_body(InputIterator input, OutputIterator output, BinaryFunction binary_op, ValueType init)
+    : input(input), output(output), binary_op(binary_op), sum(init), first_call(true)
+  {}
+
+  exclusive_body(exclusive_body& b, ::tbb::split)
+    : input(b.input), output(b.output), binary_op(b.binary_op), sum(b.sum), first_call(true)
+  {}
+
+  template<typename Size>
+  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::pre_scan_tag)
+  {
+    InputIterator iter = input + r.begin();
+
+    ValueType temp = *iter;
+
+    ++iter;
+
+    for (Size i = r.begin() + 1; i != r.end(); ++i, ++iter)
+      temp = binary_op(temp, *iter);
+
+    if (first_call && r.begin() > 0)
+      sum = temp;
+    else
+      sum = binary_op(sum, temp);
+
+    first_call = false;
+  }
+
+  template<typename Size>
+  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::final_scan_tag)
+  {
+    InputIterator  iter1 = input  + r.begin();
+    OutputIterator iter2 = output + r.begin();
+
+    for (Size i = r.begin(); i != r.end(); ++i, ++iter1, ++iter2)
+    {
+      ValueType temp = binary_op(sum, *iter1);
+      *iter2 = sum;
+      sum = temp;
+    }
+
+    first_call = false;
+  }
+
+  void reverse_join(exclusive_body& b)
+  {
+    // Only accumulate this functor's partial sum if this functor has been
+    // called at least once -- otherwise we'll over-count the initial value.
+    if (!first_call)
+    {
+      sum = binary_op(b.sum, sum);
+    }
+  }
+
+  void assign(exclusive_body& b)
+  {
+    sum = b.sum;
+  }
+};
+
+} // end scan_detail
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction>
+  OutputIterator inclusive_scan(tag,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                BinaryFunction binary_op)
+{
+  using namespace thrust::detail;
+
+  // Use the input iterator's value type per https://wg21.link/P0571
+  using ValueType = typename thrust::iterator_value<InputIterator>::type;
+
+  using Size = typename thrust::iterator_difference<InputIterator>::type;
+  Size n = thrust::distance(first, last);
+
+  if (n != 0)
+  {
+    typedef typename scan_detail::inclusive_body<InputIterator,OutputIterator,BinaryFunction,ValueType> Body;
+    Body scan_body(first, result, binary_op, *first);
+    ::tbb::parallel_scan(::tbb::blocked_range<Size>(0,n), scan_body);
+  }
+
+  thrust::advance(result, n);
+
+  return result;
+}
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename InitialValueType,
+         typename BinaryFunction>
+  OutputIterator exclusive_scan(tag,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                InitialValueType init,
+                                BinaryFunction binary_op)
+{
+  using namespace thrust::detail;
+
+  // Use the initial value type per https://wg21.link/P0571
+  using ValueType = InitialValueType;
+
+  using Size = typename thrust::iterator_difference<InputIterator>::type;
+  Size n = thrust::distance(first, last);
+
+  if (n != 0)
+  {
+    typedef typename scan_detail::exclusive_body<InputIterator,OutputIterator,BinaryFunction,ValueType> Body;
+    Body scan_body(first, result, binary_op, init);
+    ::tbb::parallel_scan(::tbb::blocked_range<Size>(0,n), scan_body);
+  }
+
+  thrust::advance(result, n);
+
+  return result;
+}
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/tbb/detail/scan_by_key.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits scan_by_key
+#include <thrust/system/cpp/detail/scan_by_key.h>
+

miniCUDA124/include/thrust/system/tbb/detail/scatter.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits this algorithm
+#include <thrust/system/cpp/detail/scatter.h>
+

miniCUDA124/include/thrust/system/tbb/detail/sequence.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits sequence
+#include <thrust/system/cpp/detail/sequence.h>
+

miniCUDA124/include/thrust/system/tbb/detail/set_operations.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits set_operations
+#include <thrust/system/cpp/detail/set_operations.h>
+

miniCUDA124/include/thrust/system/tbb/detail/sort.h

@@ -0,0 +1,62 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/tbb/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+  void stable_sort(execution_policy<DerivedPolicy> &exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp);
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void stable_sort_by_key(execution_policy<DerivedPolicy> &exec,
+                          RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first,
+                          StrictWeakOrdering comp);
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/tbb/detail/sort.inl>
+

miniCUDA124/include/thrust/system/tbb/detail/sort.inl

@@ -0,0 +1,274 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/copy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+#include <thrust/merge.h>
+#include <thrust/sort.h>
+#include <thrust/detail/seq.h>
+#include <tbb/parallel_invoke.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace tbb
+{
+namespace detail
+{
+namespace sort_detail
+{
+
+
+// TODO tune this based on data type and comp
+const static int threshold = 128 * 1024;
+
+
+template<typename DerivedPolicy, typename Iterator1, typename Iterator2, typename StrictWeakOrdering>
+void merge_sort(execution_policy<DerivedPolicy> &exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, StrictWeakOrdering comp, bool inplace);
+
+
+template<typename DerivedPolicy, typename Iterator1, typename Iterator2, typename StrictWeakOrdering>
+struct merge_sort_closure
+{
+  execution_policy<DerivedPolicy> &exec;
+  Iterator1 first1, last1;
+  Iterator2 first2;
+  StrictWeakOrdering comp;
+  bool inplace;
+
+  merge_sort_closure(execution_policy<DerivedPolicy> &exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, StrictWeakOrdering comp, bool inplace)
+    : exec(exec), first1(first1), last1(last1), first2(first2), comp(comp), inplace(inplace)
+  {}
+
+  void operator()(void) const
+  {
+    merge_sort(exec, first1, last1, first2, comp, inplace);
+  }
+};
+
+
+template<typename DerivedPolicy, typename Iterator1, typename Iterator2, typename StrictWeakOrdering>
+void merge_sort(execution_policy<DerivedPolicy> &exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, StrictWeakOrdering comp, bool inplace)
+{
+  typedef typename thrust::iterator_difference<Iterator1>::type difference_type;
+
+  difference_type n = thrust::distance(first1, last1);
+
+  if (n < threshold)
+  {
+    thrust::stable_sort(thrust::seq, first1, last1, comp);
+
+    if(!inplace)
+    {
+      thrust::copy(thrust::seq, first1, last1, first2);
+    }
+
+    return;
+  }
+
+  Iterator1 mid1  = first1 + (n / 2);
+  Iterator2 mid2  = first2 + (n / 2);
+  Iterator2 last2 = first2 + n;
+
+  typedef merge_sort_closure<DerivedPolicy,Iterator1,Iterator2,StrictWeakOrdering> Closure;
+
+  Closure left (exec, first1, mid1,  first2, comp, !inplace);
+  Closure right(exec, mid1,   last1, mid2,   comp, !inplace);
+
+  ::tbb::parallel_invoke(left, right);
+
+  if(inplace) thrust::merge(exec, first2, mid2, mid2, last2, first1, comp);
+  else	      thrust::merge(exec, first1, mid1, mid1, last1, first2, comp);
+}
+
+
+} // end namespace sort_detail
+
+
+namespace sort_by_key_detail
+{
+
+
+// TODO tune this based on data type and comp
+const static int threshold = 128 * 1024;
+
+
+template<typename DerivedPolicy,
+         typename Iterator1,
+         typename Iterator2,
+         typename Iterator3,
+         typename Iterator4,
+         typename StrictWeakOrdering>
+void merge_sort_by_key(execution_policy<DerivedPolicy> &exec,
+                       Iterator1 first1,
+                       Iterator1 last1,
+                       Iterator2 first2,
+                       Iterator3 first3,
+                       Iterator4 first4,
+                       StrictWeakOrdering comp,
+                       bool inplace);
+
+
+template<typename DerivedPolicy,
+         typename Iterator1,
+         typename Iterator2,
+         typename Iterator3,
+         typename Iterator4,
+         typename StrictWeakOrdering>
+struct merge_sort_by_key_closure
+{
+  execution_policy<DerivedPolicy> &exec;
+  Iterator1 first1, last1;
+  Iterator2 first2;
+  Iterator3 first3;
+  Iterator4 first4;
+  StrictWeakOrdering comp;
+  bool inplace;
+
+  merge_sort_by_key_closure(execution_policy<DerivedPolicy> &exec,
+                            Iterator1 first1,
+                            Iterator1 last1,
+                            Iterator2 first2,
+                            Iterator3 first3,
+                            Iterator4 first4,
+                            StrictWeakOrdering comp,
+                            bool inplace)
+    : exec(exec), first1(first1), last1(last1), first2(first2), first3(first3), first4(first4), comp(comp), inplace(inplace)
+  {}
+
+  void operator()(void) const
+  {
+    merge_sort_by_key(exec, first1, last1, first2, first3, first4, comp, inplace);
+  }
+};
+
+
+template<typename DerivedPolicy,
+         typename Iterator1,
+         typename Iterator2,
+         typename Iterator3,
+         typename Iterator4,
+         typename StrictWeakOrdering>
+void merge_sort_by_key(execution_policy<DerivedPolicy> &exec,
+                       Iterator1 first1,
+                       Iterator1 last1,
+                       Iterator2 first2,
+                       Iterator3 first3,
+                       Iterator4 first4,
+                       StrictWeakOrdering comp,
+                       bool inplace)
+{
+  typedef typename thrust::iterator_difference<Iterator1>::type difference_type;
+
+  difference_type n = thrust::distance(first1, last1);
+
+  Iterator1 mid1  = first1 + (n / 2);
+  Iterator2 mid2  = first2 + (n / 2);
+  Iterator3 mid3  = first3 + (n / 2);
+  Iterator4 mid4  = first4 + (n / 2);
+  Iterator2 last2 = first2 + n;
+  Iterator3 last3 = first3 + n;
+
+  if (n < threshold)
+  {
+    thrust::stable_sort_by_key(thrust::seq, first1, last1, first2, comp);
+
+    if(!inplace)
+    {
+      thrust::copy(thrust::seq, first1, last1, first3);
+      thrust::copy(thrust::seq, first2, last2, first4);
+    }
+
+    return;
+  }
+
+  typedef merge_sort_by_key_closure<DerivedPolicy,Iterator1,Iterator2,Iterator3,Iterator4,StrictWeakOrdering> Closure;
+
+  Closure left (exec, first1, mid1,  first2, first3, first4, comp, !inplace);
+  Closure right(exec, mid1,   last1, mid2,   mid3,   mid4,   comp, !inplace);
+
+  ::tbb::parallel_invoke(left, right);
+
+  if(inplace)
+  {
+    thrust::merge_by_key(exec, first3, mid3, mid3, last3, first4, mid4, first1, first2, comp);
+  }
+  else
+  {
+    thrust::merge_by_key(exec, first1, mid1, mid1, last1, first2, mid2, first3, first4, comp);
+  }
+}
+
+
+} // end namespace sort_detail
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+void stable_sort(execution_policy<DerivedPolicy> &exec,
+                 RandomAccessIterator first,
+                 RandomAccessIterator last,
+                 StrictWeakOrdering comp)
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator>::type key_type;
+
+  thrust::detail::temporary_array<key_type, DerivedPolicy> temp(exec, first, last);
+
+  sort_detail::merge_sort(exec, first, last, temp.begin(), comp, true);
+}
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void stable_sort_by_key(execution_policy<DerivedPolicy> &exec,
+                          RandomAccessIterator1 first1,
+                          RandomAccessIterator1 last1,
+                          RandomAccessIterator2 first2,
+                          StrictWeakOrdering comp)
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator1>::type key_type;
+  typedef typename thrust::iterator_value<RandomAccessIterator2>::type val_type;
+
+  RandomAccessIterator2 last2 = first2 + thrust::distance(first1, last1);
+
+  thrust::detail::temporary_array<key_type, DerivedPolicy> temp1(exec, first1, last1);
+  thrust::detail::temporary_array<val_type, DerivedPolicy> temp2(exec, first2, last2);
+
+  sort_by_key_detail::merge_sort_by_key(exec, first1, last1, first2, temp1.begin(), temp2.begin(), comp, true);
+}
+
+
+} // end namespace detail
+} // end namespace tbb
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/tbb/detail/swap_ranges.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// tbb inherits swap_ranges
+#include <thrust/system/cpp/detail/swap_ranges.h>
+

miniCUDA124/include/thrust/system/tbb/detail/tabulate.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits tabulate
+#include <thrust/system/cpp/detail/tabulate.h>
+

miniCUDA124/include/thrust/system/tbb/detail/temporary_buffer.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system has no special temporary buffer functions
+

miniCUDA124/include/thrust/system/tbb/detail/transform.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// omp inherits transform
+#include <thrust/system/cpp/detail/transform.h>
+

miniCUDA124/include/thrust/system/tbb/detail/transform_reduce.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits transform_reduce
+#include <thrust/system/cpp/detail/transform_reduce.h>
+

miniCUDA124/include/thrust/system/tbb/detail/transform_scan.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits transform_scan
+#include <thrust/system/cpp/detail/transform_scan.h>
+

miniCUDA124/include/thrust/system/tbb/detail/uninitialized_copy.h

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system inherits uninitialized_copy
+#include <thrust/system/cpp/detail/uninitialized_copy.h>
+