@@ -0,0 +105,4 @@
+#if BLI_HAVE_SSE2
+    for (; int_i + 1 < ints_to_check; int_i += 2) {
+      /* Loads the next 128 bit. */
+      const __m128i group = _mm_loadu_si128(reinterpret_cast<const __m128i *>(start + int_i));

@@ -0,0 +22,4 @@
+ * \note This data structure has a pre-defined capacity and can not automatically grow once that
+ * capacity is reached. Use #IndexRangesBuilderBuffer to control the capacity.
+ */
+template<typename T> class IndexRangesBuilder : NonCopyable, NonMovable {

@@ -0,0 +34,4 @@
+  /* Iterate over chunks of booleans. */
+  for (; bool_i + 16 < bools.size(); bool_i += 16) {
+    /* Load 16 bools at once. */
+    const __m128i group = _mm_loadu_si128(reinterpret_cast<const __m128i *>(bools_ + bool_i));

@@ -452,0 +491,4 @@
+                              IndexRangesBuilder<int16_t> &builder)> batch_predicate,
+    Vector<IndexMaskSegment, 16> &r_segments)
+{
+  IndexRangesBuilderBuffer<int16_t, max_segment_size> builder_buffer;

@@ -452,0 +503,4 @@
+   * masks with fewer segments can be build more efficiently, but when iterating over a mask it may
+   * be benefitial to have more ranges if that means that there are more ranges which can be
+   * processed more efficiently. This could be exposed to the caller in the future. */
+  const int64_t threshold = 64;

@@ -124,1 +124,4 @@
 }
+MINLINE int count_bits_uint64(const uint64_t a)
+{
+  return count_bits_i((uint32_t)a) + count_bits_i((uint32_t)(a >> 32));

@@ -171,3 +171,1 @@
-inline void mix_into_first_expr(ExprFn &&expr,
-                                const FirstBitSpanT &first_arg,
-                                const BitSpanT &...args)
+inline void mix_into_first_expr(ExprFn &&expr, FirstBitSpanT &&first_arg, const BitSpanT &...args)

@@ -0,0 +53,4 @@
+    }
+    const int64_t bit_i_to_output_offset = start - start_bit;
+
+    /* Iterate over ranges of 1s. For example, the the bits are 0b000111110001111000, the loop

@@ -0,0 +55,4 @@
+
+    /* Iterate over ranges of 1s. For example, the the bits are 0b000111110001111000, the loop
+     * below requires two iterations. The worst case for this is when the there are very many small
+     * ranges of 1s (e.g. 0b10101010101). So far it seemed like the overhead of detecting such

@@ -0,0 +111,4 @@
+
+template<typename T, int64_t MaxRangesNum>
+struct IndexRangesBuilderBuffer
+    : public std::array<T,

@@ -0,0 +17,4 @@
+
+#ifndef NDEBUG
+  /* Assert that all bits are zero. This is often already the case and simplifies the code below.
+   * So it's good if the caller is responsible for zeroing the bits. */

@@ -452,0 +459,4 @@
+      memory,
+      [&](const IndexMaskSegment universe_segment, IndexRangesBuilder<int16_t> &builder) {
+        const int64_t segment_start = universe_segment[0];
+        if (unique_sorted_indices::non_empty_is_range(universe_segment.base_span())) {

@@ -452,0 +507,4 @@
+  int64_t next_range_to_process = 0;
+  int64_t skipped_indices_num = 0;
+
+  auto consolidate_skipped_ranges = [&](int64_t end_range_i) {

@@ -476,2 +592,2 @@
-  return IndexMask::from_predicate(
-      universe, GrainSize(1024), memory, [bools](const int64_t index) { return !bools[index]; });
+  BitVector bits(bools);
+  bits::invert(bits);