Refactor: Update integer type usage

This updates the usage of integer types in code I wrote according to our new style guides.

Major changes:
* Use signed instead of unsigned integers in many places.
* C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`).
* Hash values for C++ containers are 64 bit wide now (instead of 32 bit).

I do hope that I broke no builds, but it is quite likely that some compiler reports
slightly different errors. Please let me know when there are any errors. If the fix
is small, feel free to commit it yourself.
I compiled successfully on linux with gcc and on windows.

16 files changed, 266 insertions, 260 deletions

diff --git a/source/blender/functions/FN_array_spans.hh b/source/blender/functions/FN_array_spans.hh
index 3f71b36c49c..c362fef3630 100644
--- a/source/blender/functions/FN_array_spans.hh
+++ b/source/blender/functions/FN_array_spans.hh
@@ -39,17 +39,17 @@ enum class VArraySpanCategory {
 
 template<typename T> class VArraySpanBase {
  protected:
-  uint virtual_size_;
+  int64_t virtual_size_;
   VArraySpanCategory category_;
 
   union {
     struct {
       const T *start;
-      uint size;
+      int64_t size;
     } single_array;
     struct {
       const T *const *starts;
-      const uint *sizes;
+      const int64_t *sizes;
     } starts_and_sizes;
   } data_;
 
@@ -71,7 +71,7 @@ template<typename T> class VArraySpanBase {
     return this->virtual_size_ == 0;
   }
 
-  uint size() const
+  int64_t size() const
   {
     return this->virtual_size_;
   }
@@ -99,15 +99,16 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> {
     this->data_.starts_and_sizes.sizes = nullptr;
   }
 
-  VArraySpan(Span<T> span, uint virtual_size)
+  VArraySpan(Span<T> span, int64_t virtual_size)
   {
+    BLI_assert(virtual_size >= 0);
     this->virtual_size_ = virtual_size;
     this->category_ = VArraySpanCategory::SingleArray;
     this->data_.single_array.start = span.data();
     this->data_.single_array.size = span.size();
   }
 
-  VArraySpan(Span<const T *> starts, Span<uint> sizes)
+  VArraySpan(Span<const T *> starts, Span<int64_t> sizes)
   {
     BLI_assert(starts.size() == sizes.size());
     this->virtual_size_ = starts.size();
@@ -116,8 +117,9 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> {
     this->data_.starts_and_sizes.sizes = sizes.begin();
   }
 
-  VSpan<T> operator[](uint index) const
+  VSpan<T> operator[](int64_t index) const
   {
+    BLI_assert(index >= 0);
     BLI_assert(index < this->virtual_size_);
     switch (this->category_) {
       case VArraySpanCategory::SingleArray:
@@ -151,7 +153,7 @@ class GVArraySpan : public VArraySpanBase<void> {
     this->data_.starts_and_sizes.sizes = nullptr;
   }
 
-  GVArraySpan(GSpan array, uint virtual_size)
+  GVArraySpan(GSpan array, int64_t virtual_size)
   {
     this->type_ = &array.type();
     this->virtual_size_ = virtual_size;
@@ -160,7 +162,7 @@ class GVArraySpan : public VArraySpanBase<void> {
     this->data_.single_array.size = array.size();
   }
 
-  GVArraySpan(const CPPType &type, Span<const void *> starts, Span<uint> sizes)
+  GVArraySpan(const CPPType &type, Span<const void *> starts, Span<int64_t> sizes)
   {
     BLI_assert(starts.size() == sizes.size());
     this->type_ = &type;
@@ -187,7 +189,7 @@ class GVArraySpan : public VArraySpanBase<void> {
     return VArraySpan<T>(*this);
   }
 
-  GVSpan operator[](uint index) const
+  GVSpan operator[](int64_t index) const
   {
     BLI_assert(index < virtual_size_);
     switch (category_) {
diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh
index cf5ef2af8a6..2af35317827 100644
--- a/source/blender/functions/FN_attributes_ref.hh
+++ b/source/blender/functions/FN_attributes_ref.hh
@@ -65,7 +65,7 @@ class AttributesInfoBuilder : NonCopyable, NonMovable {
 class AttributesInfo : NonCopyable, NonMovable {
  private:
   LinearAllocator<> allocator_;
-  Map<StringRefNull, uint> index_by_name_;
+  Map<StringRefNull, int> index_by_name_;
   Vector<StringRefNull> name_by_index_;
   Vector<const CPPType *> type_by_index_;
   Vector<void *> defaults_;
@@ -75,7 +75,7 @@ class AttributesInfo : NonCopyable, NonMovable {
   AttributesInfo(const AttributesInfoBuilder &builder);
   ~AttributesInfo();
 
-  uint size() const
+  int size() const
   {
     return name_by_index_.size();
   }
@@ -85,17 +85,17 @@ class AttributesInfo : NonCopyable, NonMovable {
     return name_by_index_.index_range();
   }
 
-  StringRefNull name_of(uint index) const
+  StringRefNull name_of(int index) const
   {
     return name_by_index_[index];
   }
 
-  uint index_of(StringRef name) const
+  int index_of(StringRef name) const
   {
     return index_by_name_.lookup_as(name);
   }
 
-  const void *default_of(uint index) const
+  const void *default_of(int index) const
   {
     return defaults_[index];
   }
@@ -105,7 +105,7 @@ class AttributesInfo : NonCopyable, NonMovable {
     return this->default_of(this->index_of(name));
   }
 
-  template<typename T> const T &default_of(uint index) const
+  template<typename T> const T &default_of(int index) const
   {
     BLI_assert(type_by_index_[index]->is<T>());
     return *(T *)defaults_[index];
@@ -116,7 +116,7 @@ class AttributesInfo : NonCopyable, NonMovable {
     return this->default_of<T>(this->index_of(name));
   }
 
-  const CPPType &type_of(uint index) const
+  const CPPType &type_of(int index) const
   {
     return *type_by_index_[index];
   }
@@ -133,7 +133,7 @@ class AttributesInfo : NonCopyable, NonMovable {
 
   int try_index_of(StringRef name) const
   {
-    return (int)index_by_name_.lookup_default_as(name, -1);
+    return index_by_name_.lookup_default_as(name, -1);
   }
 
   int try_index_of(StringRef name, const CPPType &type) const
@@ -142,7 +142,7 @@ class AttributesInfo : NonCopyable, NonMovable {
     if (index == -1) {
       return -1;
     }
-    else if (this->type_of((uint)index) == type) {
+    else if (this->type_of(index) == type) {
       return index;
     }
     else {
@@ -164,7 +164,7 @@ class MutableAttributesRef {
   friend class AttributesRef;
 
  public:
-  MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, uint size)
+  MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, int64_t size)
       : MutableAttributesRef(info, buffers, IndexRange(size))
   {
   }
@@ -174,7 +174,7 @@ class MutableAttributesRef {
   {
   }
 
-  uint size() const
+  int64_t size() const
   {
     return range_.size();
   }
@@ -184,7 +184,7 @@ class MutableAttributesRef {
     return *info_;
   }
 
-  GMutableSpan get(uint index) const
+  GMutableSpan get(int index) const
   {
     const CPPType &type = info_->type_of(index);
     void *ptr = POINTER_OFFSET(buffers_[index], type.size() * range_.start());
@@ -196,7 +196,7 @@ class MutableAttributesRef {
     return this->get(info_->index_of(name));
   }
 
-  template<typename T> MutableSpan<T> get(uint index) const
+  template<typename T> MutableSpan<T> get(int index) const
   {
     BLI_assert(info_->type_of(index).is<T>());
     return MutableSpan<T>((T *)buffers_[index] + range_.start(), range_.size());
@@ -214,7 +214,7 @@ class MutableAttributesRef {
       return {};
     }
     else {
-      return this->get((uint)index);
+      return this->get(index);
     }
   }
 
@@ -224,8 +224,8 @@ class MutableAttributesRef {
     if (index == -1) {
       return {};
     }
-    else if (info_->type_of((uint)index).is<T>()) {
-      return this->get<T>((uint)index);
+    else if (info_->type_of(index).is<T>()) {
+      return this->get<T>(index);
     }
     else {
       return {};
@@ -237,7 +237,7 @@ class MutableAttributesRef {
     return this->slice(range.start(), range.size());
   }
 
-  MutableAttributesRef slice(uint start, uint size) const
+  MutableAttributesRef slice(int64_t start, int64_t size) const
   {
     return MutableAttributesRef(*info_, buffers_, range_.slice(start, size));
   }
@@ -250,7 +250,7 @@ class AttributesRef {
   IndexRange range_;
 
  public:
-  AttributesRef(const AttributesInfo &info, Span<const void *> buffers, uint size)
+  AttributesRef(const AttributesInfo &info, Span<const void *> buffers, int64_t size)
       : AttributesRef(info, buffers, IndexRange(size))
   {
   }
@@ -265,7 +265,7 @@ class AttributesRef {
   {
   }
 
-  uint size() const
+  int64_t size() const
   {
     return range_.size();
   }
@@ -275,7 +275,7 @@ class AttributesRef {
     return *info_;
   }
 
-  GSpan get(uint index) const
+  GSpan get(int index) const
   {
     const CPPType &type = info_->type_of(index);
     const void *ptr = POINTER_OFFSET(buffers_[index], type.size() * range_.start());
@@ -287,7 +287,7 @@ class AttributesRef {
     return this->get(info_->index_of(name));
   }
 
-  template<typename T> Span<T> get(uint index) const
+  template<typename T> Span<T> get(int index) const
   {
     BLI_assert(info_->type_of(index).is<T>());
     return Span<T>((T *)buffers_[index] + range_.start(), range_.size());
@@ -300,12 +300,12 @@ class AttributesRef {
 
   std::optional<GSpan> try_get(StringRef name, const CPPType &type) const
   {
-    int index = info_->try_index_of(name, type);
+    int64_t index = info_->try_index_of(name, type);
     if (index == -1) {
       return {};
     }
     else {
-      return this->get((uint)index);
+      return this->get(index);
     }
   }
 
@@ -315,8 +315,8 @@ class AttributesRef {
     if (index == -1) {
       return {};
     }
-    else if (info_->type_of((uint)index).is<T>()) {
-      return this->get<T>((uint)index);
+    else if (info_->type_of(index).is<T>()) {
+      return this->get<T>(index);
     }
     else {
       return {};
@@ -328,7 +328,7 @@ class AttributesRef {
     return this->slice(range.start(), range.size());
   }
 
-  AttributesRef slice(uint start, uint size) const
+  AttributesRef slice(int64_t start, int64_t size) const
   {
     return AttributesRef(*info_, buffers_, range_.slice(start, size));
   }
diff --git a/source/blender/functions/FN_cpp_type.hh b/source/blender/functions/FN_cpp_type.hh
index ce02bfd05be..594890e353a 100644
--- a/source/blender/functions/FN_cpp_type.hh
+++ b/source/blender/functions/FN_cpp_type.hh
@@ -38,7 +38,7 @@
  * methods come in three variants. Using the construct-default methods as example:
  *  - construct_default(void *ptr):
  *      Constructs a single instance of that type at the given pointer.
- *  - construct_default_n(void *ptr, uint n):
+ *  - construct_default_n(void *ptr, int64_t n):
  *      Constructs n instances of that type in an array that starts at the given pointer.
  *  - construct_default_indices(void *ptr, IndexMask mask):
  *      Constructs multiple instances of that type in an array that starts at the given pointer.
@@ -77,42 +77,42 @@ namespace blender::fn {
 class CPPType : NonCopyable, NonMovable {
  public:
   using ConstructDefaultF = void (*)(void *ptr);
-  using ConstructDefaultNF = void (*)(void *ptr, uint n);
+  using ConstructDefaultNF = void (*)(void *ptr, int64_t n);
   using ConstructDefaultIndicesF = void (*)(void *ptr, IndexMask mask);
 
   using DestructF = void (*)(void *ptr);
-  using DestructNF = void (*)(void *ptr, uint n);
+  using DestructNF = void (*)(void *ptr, int64_t n);
   using DestructIndicesF = void (*)(void *ptr, IndexMask mask);
 
   using CopyToInitializedF = void (*)(const void *src, void *dst);
-  using CopyToInitializedNF = void (*)(const void *src, void *dst, uint n);
+  using CopyToInitializedNF = void (*)(const void *src, void *dst, int64_t n);
   using CopyToInitializedIndicesF = void (*)(const void *src, void *dst, IndexMask mask);
 
   using CopyToUninitializedF = void (*)(const void *src, void *dst);
-  using CopyToUninitializedNF = void (*)(const void *src, void *dst, uint n);
+  using CopyToUninitializedNF = void (*)(const void *src, void *dst, int64_t n);
   using CopyToUninitializedIndicesF = void (*)(const void *src, void *dst, IndexMask mask);
 
   using RelocateToInitializedF = void (*)(void *src, void *dst);
-  using RelocateToInitializedNF = void (*)(void *src, void *dst, uint n);
+  using RelocateToInitializedNF = void (*)(void *src, void *dst, int64_t n);
   using RelocateToInitializedIndicesF = void (*)(void *src, void *dst, IndexMask mask);
 
   using RelocateToUninitializedF = void (*)(void *src, void *dst);
-  using RelocateToUninitializedNF = void (*)(void *src, void *dst, uint n);
+  using RelocateToUninitializedNF = void (*)(void *src, void *dst, int64_t n);
   using RelocateToUninitializedIndicesF = void (*)(void *src, void *dst, IndexMask mask);
 
-  using FillInitializedF = void (*)(const void *value, void *dst, uint n);
+  using FillInitializedF = void (*)(const void *value, void *dst, int64_t n);
   using FillInitializedIndicesF = void (*)(const void *value, void *dst, IndexMask mask);
 
-  using FillUninitializedF = void (*)(const void *value, void *dst, uint n);
+  using FillUninitializedF = void (*)(const void *value, void *dst, int64_t n);
   using FillUninitializedIndicesF = void (*)(const void *value, void *dst, IndexMask mask);
 
   using DebugPrintF = void (*)(const void *value, std::stringstream &ss);
   using IsEqualF = bool (*)(const void *a, const void *b);
-  using HashF = uint32_t (*)(const void *value);
+  using HashF = uint64_t (*)(const void *value);
 
  private:
-  uint size_;
-  uint alignment_;
+  int64_t size_;
+  int64_t alignment_;
   uintptr_t alignment_mask_;
   bool is_trivially_destructible_;
 
@@ -155,8 +155,8 @@ class CPPType : NonCopyable, NonMovable {
 
  public:
   CPPType(std::string name,
-          uint size,
-          uint alignment,
+          int64_t size,
+          int64_t alignment,
           bool is_trivially_destructible,
           ConstructDefaultF construct_default,
           ConstructDefaultNF construct_default_n,
@@ -250,7 +250,7 @@ class CPPType : NonCopyable, NonMovable {
    * C++ equivalent:
    *   sizeof(T);
    */
-  uint size() const
+  int64_t size() const
   {
     return size_;
   }
@@ -261,7 +261,7 @@ class CPPType : NonCopyable, NonMovable {
    * C++ equivalent:
    *   alignof(T);
    */
-  uint alignment() const
+  int64_t alignment() const
   {
     return alignment_;
   }
@@ -306,7 +306,7 @@ class CPPType : NonCopyable, NonMovable {
     construct_default_(ptr);
   }
 
-  void construct_default_n(void *ptr, uint n) const
+  void construct_default_n(void *ptr, int64_t n) const
   {
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(ptr));
 
@@ -335,7 +335,7 @@ class CPPType : NonCopyable, NonMovable {
     destruct_(ptr);
   }
 
-  void destruct_n(void *ptr, uint n) const
+  void destruct_n(void *ptr, int64_t n) const
   {
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(ptr));
 
@@ -369,7 +369,7 @@ class CPPType : NonCopyable, NonMovable {
     copy_to_initialized_(src, dst);
   }
 
-  void copy_to_initialized_n(const void *src, void *dst, uint n) const
+  void copy_to_initialized_n(const void *src, void *dst, int64_t n) const
   {
     BLI_assert(src != dst);
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(src));
@@ -404,7 +404,7 @@ class CPPType : NonCopyable, NonMovable {
     copy_to_uninitialized_(src, dst);
   }
 
-  void copy_to_uninitialized_n(const void *src, void *dst, uint n) const
+  void copy_to_uninitialized_n(const void *src, void *dst, int64_t n) const
   {
     BLI_assert(src != dst);
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(src));
@@ -439,7 +439,7 @@ class CPPType : NonCopyable, NonMovable {
     relocate_to_initialized_(src, dst);
   }
 
-  void relocate_to_initialized_n(void *src, void *dst, uint n) const
+  void relocate_to_initialized_n(void *src, void *dst, int64_t n) const
   {
     BLI_assert(src != dst);
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(src));
@@ -474,7 +474,7 @@ class CPPType : NonCopyable, NonMovable {
     relocate_to_uninitialized_(src, dst);
   }
 
-  void relocate_to_uninitialized_n(void *src, void *dst, uint n) const
+  void relocate_to_uninitialized_n(void *src, void *dst, int64_t n) const
   {
     BLI_assert(src != dst);
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(src));
@@ -497,7 +497,7 @@ class CPPType : NonCopyable, NonMovable {
    *
    * Other instances of the same type should live in the array before this method is called.
    */
-  void fill_initialized(const void *value, void *dst, uint n) const
+  void fill_initialized(const void *value, void *dst, int64_t n) const
   {
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(value));
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(dst));
@@ -518,7 +518,7 @@ class CPPType : NonCopyable, NonMovable {
    *
    * The array should be uninitialized before this method is called.
    */
-  void fill_uninitialized(const void *value, void *dst, uint n) const
+  void fill_uninitialized(const void *value, void *dst, int64_t n) const
   {
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(value));
     BLI_assert(n == 0 || this->pointer_can_point_to_instance(dst));
@@ -547,7 +547,7 @@ class CPPType : NonCopyable, NonMovable {
     return is_equal_(a, b);
   }
 
-  uint32_t hash(const void *value) const
+  uint64_t hash(const void *value) const
   {
     BLI_assert(this->pointer_can_point_to_instance(value));
     return hash_(value);
@@ -562,7 +562,7 @@ class CPPType : NonCopyable, NonMovable {
     return default_value_;
   }
 
-  uint32_t hash() const
+  uint64_t hash() const
   {
     return DefaultHash<const CPPType *>{}(this);
   }
@@ -583,39 +583,39 @@ template<typename T> void construct_default_cb(void *ptr)
 {
   new (ptr) T;
 }
-template<typename T> void construct_default_n_cb(void *ptr, uint n)
+template<typename T> void construct_default_n_cb(void *ptr, int64_t n)
 {
   blender::default_construct_n((T *)ptr, n);
 }
 template<typename T> void construct_default_indices_cb(void *ptr, IndexMask mask)
 {
-  mask.foreach_index([&](uint i) { new ((T *)ptr + i) T; });
+  mask.foreach_index([&](int64_t i) { new ((T *)ptr + i) T; });
 }
 
 template<typename T> void destruct_cb(void *ptr)
 {
   ((T *)ptr)->~T();
 }
-template<typename T> void destruct_n_cb(void *ptr, uint n)
+template<typename T> void destruct_n_cb(void *ptr, int64_t n)
 {
   blender::destruct_n((T *)ptr, n);
 }
 template<typename T> void destruct_indices_cb(void *ptr, IndexMask mask)
 {
   T *ptr_ = (T *)ptr;
-  mask.foreach_index([&](uint i) { ptr_[i].~T(); });
+  mask.foreach_index([&](int64_t i) { ptr_[i].~T(); });
 }
 
 template<typename T> void copy_to_initialized_cb(const void *src, void *dst)
 {
   *(T *)dst = *(T *)src;
 }
-template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, uint n)
+template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, int64_t n)
 {
   const T *src_ = (const T *)src;
   T *dst_ = (T *)dst;
 
-  for (uint i = 0; i < n; i++) {
+  for (int64_t i = 0; i < n; i++) {
     dst_[i] = src_[i];
   }
 }
@@ -625,14 +625,14 @@ void copy_to_initialized_indices_cb(const void *src, void *dst, IndexMask mask)
   const T *src_ = (const T *)src;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) { dst_[i] = src_[i]; });
+  mask.foreach_index([&](int64_t i) { dst_[i] = src_[i]; });
 }
 
 template<typename T> void copy_to_uninitialized_cb(const void *src, void *dst)
 {
   blender::uninitialized_copy_n((T *)src, 1, (T *)dst);
 }
-template<typename T> void copy_to_uninitialized_n_cb(const void *src, void *dst, uint n)
+template<typename T> void copy_to_uninitialized_n_cb(const void *src, void *dst, int64_t n)
 {
   blender::uninitialized_copy_n((T *)src, n, (T *)dst);
 }
@@ -642,7 +642,7 @@ void copy_to_uninitialized_indices_cb(const void *src, void *dst, IndexMask mask
   const T *src_ = (const T *)src;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) { new (dst_ + i) T(src_[i]); });
+  mask.foreach_index([&](int64_t i) { new (dst_ + i) T(src_[i]); });
 }
 
 template<typename T> void relocate_to_initialized_cb(void *src, void *dst)
@@ -653,7 +653,7 @@ template<typename T> void relocate_to_initialized_cb(void *src, void *dst)
   *dst_ = std::move(*src_);
   src_->~T();
 }
-template<typename T> void relocate_to_initialized_n_cb(void *src, void *dst, uint n)
+template<typename T> void relocate_to_initialized_n_cb(void *src, void *dst, int64_t n)
 {
   blender::initialized_relocate_n((T *)src, n, (T *)dst);
 }
@@ -662,7 +662,7 @@ template<typename T> void relocate_to_initialized_indices_cb(void *src, void *ds
   T *src_ = (T *)src;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) {
+  mask.foreach_index([&](int64_t i) {
     dst_[i] = std::move(src_[i]);
     src_[i].~T();
   });
@@ -676,7 +676,7 @@ template<typename T> void relocate_to_uninitialized_cb(void *src, void *dst)
   new (dst_) T(std::move(*src_));
   src_->~T();
 }
-template<typename T> void relocate_to_uninitialized_n_cb(void *src, void *dst, uint n)
+template<typename T> void relocate_to_uninitialized_n_cb(void *src, void *dst, int64_t n)
 {
   blender::uninitialized_relocate_n((T *)src, n, (T *)dst);
 }
@@ -686,18 +686,18 @@ void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask)
   T *src_ = (T *)src;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) {
+  mask.foreach_index([&](int64_t i) {
     new (dst_ + i) T(std::move(src_[i]));
     src_[i].~T();
   });
 }
 
-template<typename T> void fill_initialized_cb(const void *value, void *dst, uint n)
+template<typename T> void fill_initialized_cb(const void *value, void *dst, int64_t n)
 {
   const T &value_ = *(const T *)value;
   T *dst_ = (T *)dst;
 
-  for (uint i = 0; i < n; i++) {
+  for (int64_t i = 0; i < n; i++) {
     dst_[i] = value_;
   }
 }
@@ -706,15 +706,15 @@ template<typename T> void fill_initialized_indices_cb(const void *value, void *d
   const T &value_ = *(const T *)value;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) { dst_[i] = value_; });
+  mask.foreach_index([&](int64_t i) { dst_[i] = value_; });
 }
 
-template<typename T> void fill_uninitialized_cb(const void *value, void *dst, uint n)
+template<typename T> void fill_uninitialized_cb(const void *value, void *dst, int64_t n)
 {
   const T &value_ = *(const T *)value;
   T *dst_ = (T *)dst;
 
-  for (uint i = 0; i < n; i++) {
+  for (int64_t i = 0; i < n; i++) {
     new (dst_ + i) T(value_);
   }
 }
@@ -724,7 +724,7 @@ void fill_uninitialized_indices_cb(const void *value, void *dst, IndexMask mask)
   const T &value_ = *(const T *)value;
   T *dst_ = (T *)dst;
 
-  mask.foreach_index([&](uint i) { new (dst_ + i) T(value_); });
+  mask.foreach_index([&](int64_t i) { new (dst_ + i) T(value_); });
 }
 
 template<typename T> void debug_print_cb(const void *value, std::stringstream &ss)
@@ -740,7 +740,7 @@ template<typename T> bool is_equal_cb(const void *a, const void *b)
   return a_ == b_;
 }
 
-template<typename T> uint32_t hash_cb(const void *value)
+template<typename T> uint64_t hash_cb(const void *value)
 {
   const T &value_ = *(const T *)value;
   return DefaultHash<T>{}(value_);
diff --git a/source/blender/functions/FN_generic_vector_array.hh b/source/blender/functions/FN_generic_vector_array.hh
index 2672484c184..ee67db000e5 100644
--- a/source/blender/functions/FN_generic_vector_array.hh
+++ b/source/blender/functions/FN_generic_vector_array.hh
@@ -42,10 +42,10 @@ template<typename T> class GVectorArrayRef;
 class GVectorArray : NonCopyable, NonMovable {
  private:
   const CPPType &type_;
-  uint element_size_;
+  int64_t element_size_;
   Array<void *, 1> starts_;
-  Array<uint, 1> lengths_;
-  Array<uint, 1> capacities_;
+  Array<int64_t, 1> lengths_;
+  Array<int64_t, 1> capacities_;
   LinearAllocator<> allocator_;
 
   template<typename T> friend class GVectorArrayRef;
@@ -53,16 +53,16 @@ class GVectorArray : NonCopyable, NonMovable {
  public:
   GVectorArray() = delete;
 
-  GVectorArray(const CPPType &type, uint array_size)
+  GVectorArray(const CPPType &type, int64_t array_size)
       : type_(type),
         element_size_(type.size()),
         starts_(array_size),
         lengths_(array_size),
         capacities_(array_size)
   {
-    starts_.fill(nullptr);
-    lengths_.fill(0);
-    capacities_.fill(0);
+    starts_.as_mutable_span().fill(nullptr);
+    lengths_.as_mutable_span().fill(0);
+    capacities_.as_mutable_span().fill(0);
   }
 
   ~GVectorArray()
@@ -71,7 +71,7 @@ class GVectorArray : NonCopyable, NonMovable {
       return;
     }
 
-    for (uint i : starts_.index_range()) {
+    for (int64_t i : starts_.index_range()) {
       type_.destruct_n(starts_[i], lengths_[i]);
     }
   }
@@ -86,7 +86,7 @@ class GVectorArray : NonCopyable, NonMovable {
     return starts_.size() == 0;
   }
 
-  uint size() const
+  int64_t size() const
   {
     return starts_.size();
   }
@@ -101,14 +101,14 @@ class GVectorArray : NonCopyable, NonMovable {
     return starts_;
   }
 
-  Span<uint> lengths() const
+  Span<int64_t> lengths() const
   {
     return lengths_;
   }
 
-  void append(uint index, const void *src)
+  void append(int64_t index, const void *src)
   {
-    uint old_length = lengths_[index];
+    int64_t old_length = lengths_[index];
     if (old_length == capacities_[index]) {
       this->grow_at_least_one(index);
     }
@@ -118,10 +118,10 @@ class GVectorArray : NonCopyable, NonMovable {
     lengths_[index]++;
   }
 
-  void extend(uint index, GVSpan span)
+  void extend(int64_t index, GVSpan span)
   {
     BLI_assert(type_ == span.type());
-    for (uint i = 0; i < span.size(); i++) {
+    for (int64_t i = 0; i < span.size(); i++) {
       this->append(index, span[i]);
     }
   }
@@ -130,12 +130,12 @@ class GVectorArray : NonCopyable, NonMovable {
   {
     BLI_assert(type_ == array_span.type());
     BLI_assert(mask.min_array_size() <= array_span.size());
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       this->extend(i, array_span[i]);
     }
   }
 
-  GMutableSpan operator[](uint index)
+  GMutableSpan operator[](int64_t index)
   {
     BLI_assert(index < starts_.size());
     return GMutableSpan(type_, starts_[index], lengths_[index]);
@@ -146,10 +146,10 @@ class GVectorArray : NonCopyable, NonMovable {
   }
 
  private:
-  void grow_at_least_one(uint index)
+  void grow_at_least_one(int64_t index)
   {
     BLI_assert(lengths_[index] == capacities_[index]);
-    uint new_capacity = lengths_[index] * 2 + 1;
+    int64_t new_capacity = lengths_[index] * 2 + 1;
 
     void *new_buffer = allocator_.allocate(element_size_ * new_capacity, type_.alignment());
     type_.relocate_to_uninitialized_n(starts_[index], new_buffer, lengths_[index]);
@@ -169,28 +169,28 @@ template<typename T> class GVectorArrayRef {
     BLI_assert(vector_array.type_.is<T>());
   }
 
-  void append(uint index, const T &value)
+  void append(int64_t index, const T &value)
   {
     vector_array_->append(index, &value);
   }
 
-  void extend(uint index, Span<T> values)
+  void extend(int64_t index, Span<T> values)
   {
     vector_array_->extend(index, values);
   }
 
-  void extend(uint index, VSpan<T> values)
+  void extend(int64_t index, VSpan<T> values)
   {
     vector_array_->extend(index, GVSpan(values));
   }
 
-  MutableSpan<T> operator[](uint index)
+  MutableSpan<T> operator[](int64_t index)
   {
     BLI_assert(index < vector_array_->starts_.size());
     return MutableSpan<T>((T *)vector_array_->starts_[index], vector_array_->lengths_[index]);
   }
 
-  uint size() const
+  int64_t size() const
   {
     return vector_array_->size();
   }
diff --git a/source/blender/functions/FN_multi_function.hh b/source/blender/functions/FN_multi_function.hh
index 35f144368ac..77ab2749377 100644
--- a/source/blender/functions/FN_multi_function.hh
+++ b/source/blender/functions/FN_multi_function.hh
@@ -63,7 +63,7 @@ class MultiFunction {
 
   virtual void call(IndexMask mask, MFParams params, MFContext context) const = 0;
 
-  virtual uint32_t hash() const
+  virtual uint64_t hash() const
   {
     return DefaultHash<const MultiFunction *>{}(this);
   }
@@ -73,7 +73,7 @@ class MultiFunction {
     return false;
   }
 
-  uint param_amount() const
+  int param_amount() const
   {
     return signature_.param_types.size();
   }
@@ -83,12 +83,12 @@ class MultiFunction {
     return signature_.param_types.index_range();
   }
 
-  MFParamType param_type(uint param_index) const
+  MFParamType param_type(int param_index) const
   {
     return signature_.param_types[param_index];
   }
 
-  StringRefNull param_name(uint param_index) const
+  StringRefNull param_name(int param_index) const
   {
     return signature_.param_names[param_index];
   }
@@ -111,7 +111,7 @@ class MultiFunction {
   }
 };
 
-inline MFParamsBuilder::MFParamsBuilder(const class MultiFunction &fn, uint min_array_size)
+inline MFParamsBuilder::MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size)
     : MFParamsBuilder(fn.signature(), min_array_size)
 {
 }
diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh
index c2c95f7c355..95e216558e7 100644
--- a/source/blender/functions/FN_multi_function_builder.hh
+++ b/source/blender/functions/FN_multi_function_builder.hh
@@ -59,7 +59,7 @@ template<typename In1, typename Out1> class CustomMF_SI_SO : public MultiFunctio
   template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
   {
     return [=](IndexMask mask, VSpan<In1> in1, MutableSpan<Out1> out1) {
-      mask.foreach_index([&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); });
+      mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); });
     };
   }
 
@@ -101,7 +101,7 @@ class CustomMF_SI_SI_SO : public MultiFunction {
   template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
   {
     return [=](IndexMask mask, VSpan<In1> in1, VSpan<In2> in2, MutableSpan<Out1> out1) {
-      mask.foreach_index([&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); });
+      mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); });
     };
   }
 
@@ -152,7 +152,7 @@ class CustomMF_SI_SI_SI_SO : public MultiFunction {
                VSpan<In3> in3,
                MutableSpan<Out1> out1) {
       mask.foreach_index(
-          [&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); });
+          [&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); });
     };
   }
 
@@ -191,7 +191,7 @@ template<typename Mut1> class CustomMF_SM : public MultiFunction {
   template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
   {
     return [=](IndexMask mask, MutableSpan<Mut1> mut1) {
-      mask.foreach_index([&](uint i) { element_fn(mut1[i]); });
+      mask.foreach_index([&](int i) { element_fn(mut1[i]); });
     };
   }
 
@@ -220,7 +220,7 @@ template<typename From, typename To> class CustomMF_Convert : public MultiFuncti
     VSpan<From> inputs = params.readonly_single_input<From>(0);
     MutableSpan<To> outputs = params.uninitialized_single_output<To>(1);
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       new ((void *)&outputs[i]) To(inputs[i]);
     }
   }
@@ -240,7 +240,7 @@ class CustomMF_GenericConstant : public MultiFunction {
  public:
   CustomMF_GenericConstant(const CPPType &type, const void *value);
   void call(IndexMask mask, MFParams params, MFContext context) const override;
-  uint32_t hash() const override;
+  uint64_t hash() const override;
   bool equals(const MultiFunction &other) const override;
 };
 
@@ -276,10 +276,10 @@ template<typename T> class CustomMF_Constant : public MultiFunction {
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
     MutableSpan<T> output = params.uninitialized_single_output<T>(0);
-    mask.foreach_index([&](uint i) { new (&output[i]) T(value_); });
+    mask.foreach_index([&](int i) { new (&output[i]) T(value_); });
   }
 
-  uint32_t hash() const override
+  uint64_t hash() const override
   {
     return DefaultHash<T>{}(value_);
   }
@@ -304,7 +304,7 @@ template<typename T> class CustomMF_Constant : public MultiFunction {
 
 class CustomMF_DefaultOutput : public MultiFunction {
  private:
-  uint output_amount_;
+  int output_amount_;
 
  public:
   CustomMF_DefaultOutput(StringRef name,
diff --git a/source/blender/functions/FN_multi_function_data_type.hh b/source/blender/functions/FN_multi_function_data_type.hh
index 57aea046006..23a1c0e5680 100644
--- a/source/blender/functions/FN_multi_function_data_type.hh
+++ b/source/blender/functions/FN_multi_function_data_type.hh
@@ -109,9 +109,9 @@ class MFDataType {
     return "";
   }
 
-  uint hash() const
+  uint64_t hash() const
   {
-    return DefaultHash<CPPType>{}(*type_) + (uint32_t)category_;
+    return DefaultHash<CPPType>{}(*type_) + (uint64_t)category_;
   }
 };
 
diff --git a/source/blender/functions/FN_multi_function_network.hh b/source/blender/functions/FN_multi_function_network.hh
index 91eb5bb65dc..f6d6c7417e7 100644
--- a/source/blender/functions/FN_multi_function_network.hh
+++ b/source/blender/functions/FN_multi_function_network.hh
@@ -62,14 +62,14 @@ class MFNode : NonCopyable, NonMovable {
   Span<MFInputSocket *> inputs_;
   Span<MFOutputSocket *> outputs_;
   bool is_dummy_;
-  uint id_;
+  int id_;
 
   friend MFNetwork;
 
  public:
   StringRefNull name() const;
 
-  uint id() const;
+  int id() const;
 
   MFNetwork &network();
   const MFNetwork &network() const;
@@ -83,11 +83,11 @@ class MFNode : NonCopyable, NonMovable {
   MFFunctionNode &as_function();
   const MFFunctionNode &as_function() const;
 
-  MFInputSocket &input(uint index);
-  const MFInputSocket &input(uint index) const;
+  MFInputSocket &input(int index);
+  const MFInputSocket &input(int index) const;
 
-  MFOutputSocket &output(uint index);
-  const MFOutputSocket &output(uint index) const;
+  MFOutputSocket &output(int index);
+  const MFOutputSocket &output(int index) const;
 
   Span<MFInputSocket *> inputs();
   Span<const MFInputSocket *> inputs() const;
@@ -104,8 +104,8 @@ class MFNode : NonCopyable, NonMovable {
 class MFFunctionNode : public MFNode {
  private:
   const MultiFunction *function_;
-  Span<uint> input_param_indices_;
-  Span<uint> output_param_indices_;
+  Span<int> input_param_indices_;
+  Span<int> output_param_indices_;
 
   friend MFNetwork;
 
@@ -114,8 +114,8 @@ class MFFunctionNode : public MFNode {
 
   const MultiFunction &function() const;
 
-  const MFInputSocket &input_for_param(uint param_index) const;
-  const MFOutputSocket &output_for_param(uint param_index) const;
+  const MFInputSocket &input_for_param(int param_index) const;
+  const MFOutputSocket &output_for_param(int param_index) const;
 };
 
 class MFDummyNode : public MFNode {
@@ -137,9 +137,9 @@ class MFSocket : NonCopyable, NonMovable {
  protected:
   MFNode *node_;
   bool is_output_;
-  uint index_;
+  int index_;
   MFDataType data_type_;
-  uint id_;
+  int id_;
   StringRefNull name_;
 
   friend MFNetwork;
@@ -147,8 +147,8 @@ class MFSocket : NonCopyable, NonMovable {
  public:
   StringRefNull name() const;
 
-  uint id() const;
-  uint index() const;
+  int id() const;
+  int index() const;
 
   const MFDataType &data_type() const;
 
@@ -217,17 +217,17 @@ class MFNetwork : NonCopyable, NonMovable {
   void remove(MFNode &node);
   void remove(Span<MFNode *> nodes);
 
-  uint socket_id_amount() const;
-  uint node_id_amount() const;
+  int socket_id_amount() const;
+  int node_id_amount() const;
 
   Span<MFDummyNode *> dummy_nodes();
   Span<MFFunctionNode *> function_nodes();
 
-  MFNode *node_or_null_by_id(uint id);
-  const MFNode *node_or_null_by_id(uint id) const;
+  MFNode *node_or_null_by_id(int id);
+  const MFNode *node_or_null_by_id(int id) const;
 
-  MFSocket *socket_or_null_by_id(uint id);
-  const MFSocket *socket_or_null_by_id(uint id) const;
+  MFSocket *socket_or_null_by_id(int id);
+  const MFSocket *socket_or_null_by_id(int id) const;
 
   void find_dependencies(Span<const MFInputSocket *> sockets,
                          VectorSet<const MFOutputSocket *> &r_dummy_sockets,
@@ -252,7 +252,7 @@ inline StringRefNull MFNode::name() const
   }
 }
 
-inline uint MFNode::id() const
+inline int MFNode::id() const
 {
   return id_;
 }
@@ -301,22 +301,22 @@ inline const MFFunctionNode &MFNode::as_function() const
   return *(const MFFunctionNode *)this;
 }
 
-inline MFInputSocket &MFNode::input(uint index)
+inline MFInputSocket &MFNode::input(int index)
 {
   return *inputs_[index];
 }
 
-inline const MFInputSocket &MFNode::input(uint index) const
+inline const MFInputSocket &MFNode::input(int index) const
 {
   return *inputs_[index];
 }
 
-inline MFOutputSocket &MFNode::output(uint index)
+inline MFOutputSocket &MFNode::output(int index)
 {
   return *outputs_[index];
 }
 
-inline const MFOutputSocket &MFNode::output(uint index) const
+inline const MFOutputSocket &MFNode::output(int index) const
 {
   return *outputs_[index];
 }
@@ -365,12 +365,12 @@ inline const MultiFunction &MFFunctionNode::function() const
   return *function_;
 }
 
-inline const MFInputSocket &MFFunctionNode::input_for_param(uint param_index) const
+inline const MFInputSocket &MFFunctionNode::input_for_param(int param_index) const
 {
   return this->input(input_param_indices_.first_index(param_index));
 }
 
-inline const MFOutputSocket &MFFunctionNode::output_for_param(uint param_index) const
+inline const MFOutputSocket &MFFunctionNode::output_for_param(int param_index) const
 {
   return this->output(output_param_indices_.first_index(param_index));
 }
@@ -403,12 +403,12 @@ inline StringRefNull MFSocket::name() const
   return name_;
 }
 
-inline uint MFSocket::id() const
+inline int MFSocket::id() const
 {
   return id_;
 }
 
-inline uint MFSocket::index() const
+inline int MFSocket::index() const
 {
   return index_;
 }
@@ -504,32 +504,32 @@ inline Span<MFFunctionNode *> MFNetwork::function_nodes()
   return function_nodes_;
 }
 
-inline MFNode *MFNetwork::node_or_null_by_id(uint id)
+inline MFNode *MFNetwork::node_or_null_by_id(int id)
 {
   return node_or_null_by_id_[id];
 }
 
-inline const MFNode *MFNetwork::node_or_null_by_id(uint id) const
+inline const MFNode *MFNetwork::node_or_null_by_id(int id) const
 {
   return node_or_null_by_id_[id];
 }
 
-inline MFSocket *MFNetwork::socket_or_null_by_id(uint id)
+inline MFSocket *MFNetwork::socket_or_null_by_id(int id)
 {
   return socket_or_null_by_id_[id];
 }
 
-inline const MFSocket *MFNetwork::socket_or_null_by_id(uint id) const
+inline const MFSocket *MFNetwork::socket_or_null_by_id(int id) const
 {
   return socket_or_null_by_id_[id];
 }
 
-inline uint MFNetwork::socket_id_amount() const
+inline int MFNetwork::socket_id_amount() const
 {
   return socket_or_null_by_id_.size();
 }
 
-inline uint MFNetwork::node_id_amount() const
+inline int MFNetwork::node_id_amount() const
 {
   return node_or_null_by_id_.size();
 }
diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh
index e6683693a0a..9cce8bb7401 100644
--- a/source/blender/functions/FN_multi_function_params.hh
+++ b/source/blender/functions/FN_multi_function_params.hh
@@ -34,7 +34,7 @@ namespace blender::fn {
 class MFParamsBuilder {
  private:
   const MFSignature *signature_;
-  uint min_array_size_;
+  int64_t min_array_size_;
   Vector<GVSpan> virtual_spans_;
   Vector<GMutableSpan> mutable_spans_;
   Vector<GVArraySpan> virtual_array_spans_;
@@ -43,12 +43,12 @@ class MFParamsBuilder {
   friend class MFParams;
 
  public:
-  MFParamsBuilder(const MFSignature &signature, uint min_array_size)
+  MFParamsBuilder(const MFSignature &signature, int64_t min_array_size)
       : signature_(&signature), min_array_size_(min_array_size)
   {
   }
 
-  MFParamsBuilder(const class MultiFunction &fn, uint min_array_size);
+  MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size);
 
   template<typename T> void add_readonly_single_input(const T *value)
   {
@@ -96,21 +96,21 @@ class MFParamsBuilder {
     vector_arrays_.append(&vector_array);
   }
 
-  GMutableSpan computed_array(uint param_index)
+  GMutableSpan computed_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
                     MFParamType::SingleOutput,
                     MFParamType::SingleMutable));
-    uint data_index = signature_->data_index(param_index);
+    int data_index = signature_->data_index(param_index);
     return mutable_spans_[data_index];
   }
 
-  GVectorArray &computed_vector_array(uint param_index)
+  GVectorArray &computed_vector_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
                     MFParamType::VectorOutput,
                     MFParamType::VectorMutable));
-    uint data_index = signature_->data_index(param_index);
+    int data_index = signature_->data_index(param_index);
     return *vector_arrays_[data_index];
   }
 
@@ -119,13 +119,13 @@ class MFParamsBuilder {
   {
     UNUSED_VARS_NDEBUG(param_type);
 #ifdef DEBUG
-    uint param_index = this->current_param_index();
+    int param_index = this->current_param_index();
     MFParamType expected_type = signature_->param_types[param_index];
     BLI_assert(expected_type == param_type);
 #endif
   }
 
-  uint current_param_index() const
+  int current_param_index() const
   {
     return virtual_spans_.size() + mutable_spans_.size() + virtual_array_spans_.size() +
            vector_arrays_.size();
@@ -141,75 +141,75 @@ class MFParams {
   {
   }
 
-  template<typename T> VSpan<T> readonly_single_input(uint param_index, StringRef name = "")
+  template<typename T> VSpan<T> readonly_single_input(int param_index, StringRef name = "")
   {
     return this->readonly_single_input(param_index, name).typed<T>();
   }
-  GVSpan readonly_single_input(uint param_index, StringRef name = "")
+  GVSpan readonly_single_input(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleInput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->virtual_spans_[data_index];
   }
 
   template<typename T>
-  MutableSpan<T> uninitialized_single_output(uint param_index, StringRef name = "")
+  MutableSpan<T> uninitialized_single_output(int param_index, StringRef name = "")
   {
     return this->uninitialized_single_output(param_index, name).typed<T>();
   }
-  GMutableSpan uninitialized_single_output(uint param_index, StringRef name = "")
+  GMutableSpan uninitialized_single_output(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleOutput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
 
-  template<typename T> VArraySpan<T> readonly_vector_input(uint param_index, StringRef name = "")
+  template<typename T> VArraySpan<T> readonly_vector_input(int param_index, StringRef name = "")
   {
     return this->readonly_vector_input(param_index, name).typed<T>();
   }
-  GVArraySpan readonly_vector_input(uint param_index, StringRef name = "")
+  GVArraySpan readonly_vector_input(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorInput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->virtual_array_spans_[data_index];
   }
 
-  template<typename T> GVectorArrayRef<T> vector_output(uint param_index, StringRef name = "")
+  template<typename T> GVectorArrayRef<T> vector_output(int param_index, StringRef name = "")
   {
     return this->vector_output(param_index, name).typed<T>();
   }
-  GVectorArray &vector_output(uint param_index, StringRef name = "")
+  GVectorArray &vector_output(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorOutput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
 
-  template<typename T> MutableSpan<T> single_mutable(uint param_index, StringRef name = "")
+  template<typename T> MutableSpan<T> single_mutable(int param_index, StringRef name = "")
   {
     return this->single_mutable(param_index, name).typed<T>();
   }
-  GMutableSpan single_mutable(uint param_index, StringRef name = "")
+  GMutableSpan single_mutable(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleMutable);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
 
-  template<typename T> GVectorArrayRef<T> vector_mutable(uint param_index, StringRef name = "")
+  template<typename T> GVectorArrayRef<T> vector_mutable(int param_index, StringRef name = "")
   {
     return this->vector_mutable(param_index, name).typed<T>();
   }
-  GVectorArray &vector_mutable(uint param_index, StringRef name = "")
+  GVectorArray &vector_mutable(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorMutable);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
 
  private:
-  void assert_correct_param(uint param_index, StringRef name, MFParamType param_type)
+  void assert_correct_param(int param_index, StringRef name, MFParamType param_type)
   {
     UNUSED_VARS_NDEBUG(param_index, name, param_type);
 #ifdef DEBUG
@@ -220,7 +220,7 @@ class MFParams {
 #endif
   }
 
-  void assert_correct_param(uint param_index, StringRef name, MFParamType::Category category)
+  void assert_correct_param(int param_index, StringRef name, MFParamType::Category category)
   {
     UNUSED_VARS_NDEBUG(param_index, name, category);
 #ifdef DEBUG
diff --git a/source/blender/functions/FN_multi_function_signature.hh b/source/blender/functions/FN_multi_function_signature.hh
index e2cf783753e..4ccceb39503 100644
--- a/source/blender/functions/FN_multi_function_signature.hh
+++ b/source/blender/functions/FN_multi_function_signature.hh
@@ -35,9 +35,9 @@ struct MFSignature {
   /* Use RawAllocator so that a MultiFunction can have static storage duration. */
   Vector<std::string, 4, RawAllocator> param_names;
   Vector<MFParamType, 4, RawAllocator> param_types;
-  Vector<uint, 4, RawAllocator> param_data_indices;
+  Vector<int, 4, RawAllocator> param_data_indices;
 
-  uint data_index(uint param_index) const
+  int data_index(int param_index) const
   {
     return param_data_indices[param_index];
   }
@@ -46,10 +46,10 @@ struct MFSignature {
 class MFSignatureBuilder {
  private:
   MFSignature &data_;
-  uint span_count_ = 0;
-  uint virtual_span_count_ = 0;
-  uint virtual_array_span_count_ = 0;
-  uint vector_array_count_ = 0;
+  int span_count_ = 0;
+  int virtual_span_count_ = 0;
+  int virtual_array_span_count_ = 0;
+  int vector_array_count_ = 0;
 
  public:
   MFSignatureBuilder(MFSignature &data) : data_(data)
diff --git a/source/blender/functions/FN_spans.hh b/source/blender/functions/FN_spans.hh
index c8c98d66628..d8b381199cc 100644
--- a/source/blender/functions/FN_spans.hh
+++ b/source/blender/functions/FN_spans.hh
@@ -52,12 +52,13 @@ class GSpan {
  private:
   const CPPType *type_;
   const void *buffer_;
-  uint size_;
+  int64_t size_;
 
  public:
-  GSpan(const CPPType &type, const void *buffer, uint size)
+  GSpan(const CPPType &type, const void *buffer, int64_t size)
       : type_(&type), buffer_(buffer), size_(size)
   {
+    BLI_assert(size >= 0);
     BLI_assert(buffer != nullptr || size == 0);
     BLI_assert(type.pointer_has_valid_alignment(buffer));
   }
@@ -81,7 +82,7 @@ class GSpan {
     return size_ == 0;
   }
 
-  uint size() const
+  int64_t size() const
   {
     return size_;
   }
@@ -91,7 +92,7 @@ class GSpan {
     return buffer_;
   }
 
-  const void *operator[](uint index) const
+  const void *operator[](int64_t index) const
   {
     BLI_assert(index < size_);
     return POINTER_OFFSET(buffer_, type_->size() * index);
@@ -112,12 +113,13 @@ class GMutableSpan {
  private:
   const CPPType *type_;
   void *buffer_;
-  uint size_;
+  int64_t size_;
 
  public:
-  GMutableSpan(const CPPType &type, void *buffer, uint size)
+  GMutableSpan(const CPPType &type, void *buffer, int64_t size)
       : type_(&type), buffer_(buffer), size_(size)
   {
+    BLI_assert(size >= 0);
     BLI_assert(buffer != nullptr || size == 0);
     BLI_assert(type.pointer_has_valid_alignment(buffer));
   }
@@ -147,7 +149,7 @@ class GMutableSpan {
     return size_ == 0;
   }
 
-  uint size() const
+  int64_t size() const
   {
     return size_;
   }
@@ -157,7 +159,7 @@ class GMutableSpan {
     return buffer_;
   }
 
-  void *operator[](uint index)
+  void *operator[](int64_t index)
   {
     BLI_assert(index < size_);
     return POINTER_OFFSET(buffer_, type_->size() * index);
@@ -178,7 +180,7 @@ enum class VSpanCategory {
 
 template<typename T> struct VSpanBase {
  protected:
-  uint virtual_size_;
+  int64_t virtual_size_;
   VSpanCategory category_;
   union {
     struct {
@@ -212,7 +214,7 @@ template<typename T> struct VSpanBase {
     return this->virtual_size_ == 0;
   }
 
-  uint size() const
+  int64_t size() const
   {
     return this->virtual_size_;
   }
@@ -259,7 +261,7 @@ template<typename T> class VSpan : public VSpanBase<T> {
     this->data_.full_pointer_array.data = values.begin();
   }
 
-  static VSpan FromSingle(const T *value, uint virtual_size)
+  static VSpan FromSingle(const T *value, int64_t virtual_size)
   {
     VSpan ref;
     ref.virtual_size_ = virtual_size;
@@ -268,8 +270,9 @@ template<typename T> class VSpan : public VSpanBase<T> {
     return ref;
   }
 
-  const T &operator[](uint index) const
+  const T &operator[](int64_t index) const
   {
+    BLI_assert(index >= 0);
     BLI_assert(index < this->virtual_size_);
     switch (this->category_) {
       case VSpanCategory::Single:
@@ -329,7 +332,7 @@ class GVSpan : public VSpanBase<void> {
   {
   }
 
-  static GVSpan FromSingle(const CPPType &type, const void *value, uint virtual_size)
+  static GVSpan FromSingle(const CPPType &type, const void *value, int64_t virtual_size)
   {
     GVSpan ref;
     ref.type_ = &type;
@@ -341,7 +344,7 @@ class GVSpan : public VSpanBase<void> {
 
   static GVSpan FromSingleWithMaxSize(const CPPType &type, const void *value)
   {
-    return GVSpan::FromSingle(type, value, UINT32_MAX);
+    return GVSpan::FromSingle(type, value, INT64_MAX);
   }
 
   static GVSpan FromDefault(const CPPType &type)
@@ -349,7 +352,7 @@ class GVSpan : public VSpanBase<void> {
     return GVSpan::FromSingleWithMaxSize(type, type.default_value());
   }
 
-  static GVSpan FromFullPointerArray(const CPPType &type, const void *const *values, uint size)
+  static GVSpan FromFullPointerArray(const CPPType &type, const void *const *values, int64_t size)
   {
     GVSpan ref;
     ref.type_ = &type;
@@ -364,8 +367,9 @@ class GVSpan : public VSpanBase<void> {
     return *this->type_;
   }
 
-  const void *operator[](uint index) const
+  const void *operator[](int64_t index) const
   {
+    BLI_assert(index >= 0);
     BLI_assert(index < this->virtual_size_);
     switch (this->category_) {
       case VSpanCategory::Single:
@@ -400,8 +404,8 @@ class GVSpan : public VSpanBase<void> {
   {
     BLI_assert(this->size() >= mask.min_array_size());
 
-    uint element_size = type_->size();
-    for (uint i : mask) {
+    int64_t element_size = type_->size();
+    for (int64_t i : mask) {
       type_->copy_to_uninitialized((*this)[i], POINTER_OFFSET(dst, element_size * i));
     }
   }
diff --git a/source/blender/functions/intern/attributes_ref.cc b/source/blender/functions/intern/attributes_ref.cc
index f61a9165c47..7bfcc69671a 100644
--- a/source/blender/functions/intern/attributes_ref.cc
+++ b/source/blender/functions/intern/attributes_ref.cc
@@ -20,7 +20,7 @@ namespace blender::fn {
 
 AttributesInfoBuilder::~AttributesInfoBuilder()
 {
-  for (uint i : defaults_.index_range()) {
+  for (int i : defaults_.index_range()) {
     types_[i]->destruct(defaults_[i]);
   }
 }
@@ -45,7 +45,7 @@ void AttributesInfoBuilder::add(StringRef name, const CPPType &type, const void
 
 AttributesInfo::AttributesInfo(const AttributesInfoBuilder &builder)
 {
-  for (uint i : builder.types_.index_range()) {
+  for (int i : builder.types_.index_range()) {
     StringRefNull name = allocator_.copy_string(builder.names_[i]);
     const CPPType &type = *builder.types_[i];
     const void *default_value = builder.defaults_[i];
@@ -62,7 +62,7 @@ AttributesInfo::AttributesInfo(const AttributesInfoBuilder &builder)
 
 AttributesInfo::~AttributesInfo()
 {
-  for (uint i : defaults_.index_range()) {
+  for (int i : defaults_.index_range()) {
     type_by_index_[i]->destruct(defaults_[i]);
   }
 }
diff --git a/source/blender/functions/intern/multi_function_builder.cc b/source/blender/functions/intern/multi_function_builder.cc
index 7797c19d563..06084247e66 100644
--- a/source/blender/functions/intern/multi_function_builder.cc
+++ b/source/blender/functions/intern/multi_function_builder.cc
@@ -37,7 +37,7 @@ void CustomMF_GenericConstant::call(IndexMask mask,
   type_.fill_uninitialized_indices(value_, output.buffer(), mask);
 }
 
-uint CustomMF_GenericConstant::hash() const
+uint64_t CustomMF_GenericConstant::hash() const
 {
   return type_.hash(value_);
 }
@@ -58,8 +58,8 @@ static std::string gspan_to_string(GSpan array)
 {
   std::stringstream ss;
   ss << "[";
-  uint max_amount = 5;
-  for (uint i : IndexRange(std::min(max_amount, array.size()))) {
+  const int64_t max_amount = 5;
+  for (int64_t i : IndexRange(std::min(max_amount, array.size()))) {
     array.type().debug_print(array[i], ss);
     ss << ", ";
   }
@@ -82,7 +82,7 @@ void CustomMF_GenericConstantArray::call(IndexMask mask,
                                          MFContext UNUSED(context)) const
 {
   GVectorArray &vectors = params.vector_output(0);
-  for (uint i : mask) {
+  for (int64_t i : mask) {
     vectors.extend(i, array_);
   }
 }
@@ -102,7 +102,7 @@ CustomMF_DefaultOutput::CustomMF_DefaultOutput(StringRef name,
 }
 void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const
 {
-  for (uint param_index : this->param_indices()) {
+  for (int param_index : this->param_indices()) {
     MFParamType param_type = this->param_type(param_index);
     if (!param_type.is_output()) {
       continue;
diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc
index 1d3d3a8b5f2..cd3c38dd09f 100644
--- a/source/blender/functions/intern/multi_function_network.cc
+++ b/source/blender/functions/intern/multi_function_network.cc
@@ -50,9 +50,9 @@ void MFNode::destruct_sockets()
  */
 MFFunctionNode &MFNetwork::add_function(const MultiFunction &function)
 {
-  Vector<uint, 16> input_param_indices, output_param_indices;
+  Vector<int, 16> input_param_indices, output_param_indices;
 
-  for (uint param_index : function.param_indices()) {
+  for (int param_index : function.param_indices()) {
     switch (function.param_type(param_index).interface_type()) {
       case MFParamType::Input: {
         input_param_indices.append(param_index);
@@ -77,16 +77,16 @@ MFFunctionNode &MFNetwork::add_function(const MultiFunction &function)
   node.is_dummy_ = false;
   node.id_ = node_or_null_by_id_.append_and_get_index(&node);
   node.function_ = &function;
-  node.input_param_indices_ = allocator_.construct_array_copy<uint>(input_param_indices);
-  node.output_param_indices_ = allocator_.construct_array_copy<uint>(output_param_indices);
+  node.input_param_indices_ = allocator_.construct_array_copy<int>(input_param_indices);
+  node.output_param_indices_ = allocator_.construct_array_copy<int>(output_param_indices);
 
   node.inputs_ = allocator_.construct_elements_and_pointer_array<MFInputSocket>(
       input_param_indices.size());
   node.outputs_ = allocator_.construct_elements_and_pointer_array<MFOutputSocket>(
       output_param_indices.size());
 
-  for (uint i : input_param_indices.index_range()) {
-    uint param_index = input_param_indices[i];
+  for (int i : input_param_indices.index_range()) {
+    int param_index = input_param_indices[i];
     MFParamType param = function.param_type(param_index);
     BLI_assert(param.is_input_or_mutable());
 
@@ -100,8 +100,8 @@ MFFunctionNode &MFNetwork::add_function(const MultiFunction &function)
     socket.id_ = socket_or_null_by_id_.append_and_get_index(&socket);
   }
 
-  for (uint i : output_param_indices.index_range()) {
-    uint param_index = output_param_indices[i];
+  for (int i : output_param_indices.index_range()) {
+    int param_index = output_param_indices[i];
     MFParamType param = function.param_type(param_index);
     BLI_assert(param.is_output_or_mutable());
 
@@ -145,7 +145,7 @@ MFDummyNode &MFNetwork::add_dummy(StringRef name,
   node.input_names_ = allocator_.allocate_array<StringRefNull>(input_types.size());
   node.output_names_ = allocator_.allocate_array<StringRefNull>(output_types.size());
 
-  for (uint i : input_types.index_range()) {
+  for (int i : input_types.index_range()) {
     MFInputSocket &socket = *node.inputs_[i];
     socket.data_type_ = input_types[i];
     socket.node_ = &node;
@@ -156,7 +156,7 @@ MFDummyNode &MFNetwork::add_dummy(StringRef name,
     node.input_names_[i] = socket.name_;
   }
 
-  for (uint i : output_types.index_range()) {
+  for (int i : output_types.index_range()) {
     MFOutputSocket &socket = *node.outputs_[i];
     socket.data_type_ = output_types[i];
     socket.node_ = &node;
diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc
index b59cbc6a1a2..a7e1a2f42af 100644
--- a/source/blender/functions/intern/multi_function_network_evaluation.cc
+++ b/source/blender/functions/intern/multi_function_network_evaluation.cc
@@ -55,10 +55,10 @@ class MFNetworkEvaluationStorage {
   LinearAllocator<> allocator_;
   IndexMask mask_;
   Array<Value *> value_per_output_id_;
-  uint min_array_size_;
+  int64_t min_array_size_;
 
  public:
-  MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount);
+  MFNetworkEvaluationStorage(IndexMask mask, int socket_id_amount);
   ~MFNetworkEvaluationStorage();
 
   /* Add the values that have been provided by the caller of the multi-function network. */
@@ -155,8 +155,8 @@ void MFNetworkEvaluator::call(IndexMask mask, MFParams params, MFContext context
 BLI_NOINLINE void MFNetworkEvaluator::copy_inputs_to_storage(MFParams params,
                                                              Storage &storage) const
 {
-  for (uint input_index : inputs_.index_range()) {
-    uint param_index = input_index + 0;
+  for (int input_index : inputs_.index_range()) {
+    int param_index = input_index + 0;
     const MFOutputSocket &socket = *inputs_[input_index];
     switch (socket.data_type().category()) {
       case MFDataType::Single: {
@@ -178,8 +178,8 @@ BLI_NOINLINE void MFNetworkEvaluator::copy_outputs_to_storage(
     Storage &storage,
     Vector<const MFInputSocket *> &outputs_to_initialize_in_the_end) const
 {
-  for (uint output_index : outputs_.index_range()) {
-    uint param_index = output_index + inputs_.size();
+  for (int output_index : outputs_.index_range()) {
+    int param_index = output_index + inputs_.size();
     const MFInputSocket &socket = *outputs_[output_index];
     const MFOutputSocket &origin = *socket.origin();
 
@@ -263,7 +263,7 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
      * function only on a single element. This can avoid many duplicate computations. */
     MFParamsBuilder params{function, 1};
 
-    for (uint param_index : function.param_indices()) {
+    for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
@@ -312,7 +312,7 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
   else {
     MFParamsBuilder params{function, storage.mask().min_array_size()};
 
-    for (uint param_index : function.param_indices()) {
+    for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
@@ -384,7 +384,7 @@ BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs(
     MFParams params, Storage &storage, Span<const MFInputSocket *> remaining_outputs) const
 {
   for (const MFInputSocket *socket : remaining_outputs) {
-    uint param_index = inputs_.size() + outputs_.first_index_of(socket);
+    int param_index = inputs_.size() + outputs_.first_index_of(socket);
 
     switch (socket->data_type().category()) {
       case MFDataType::Single: {
@@ -506,7 +506,7 @@ struct OwnVectorValue : public Value {
 /** \name Storage methods
  * \{ */
 
-MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount)
+MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, int socket_id_amount)
     : mask_(mask),
       value_per_output_id_(socket_id_amount, nullptr),
       min_array_size_(mask.min_array_size())
diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc
index 849b24a318f..e76b2f51a15 100644
--- a/source/blender/functions/intern/multi_function_network_optimization.cc
+++ b/source/blender/functions/intern/multi_function_network_optimization.cc
@@ -107,7 +107,7 @@ static Vector<MFNode *> find_nodes_based_on_mask(MFNetwork &network,
                                                  bool mask_value)
 {
   Vector<MFNode *> nodes;
-  for (uint id : id_mask.index_range()) {
+  for (int id : id_mask.index_range()) {
     if (id_mask[id] == mask_value) {
       MFNode *node = network.node_or_null_by_id(id);
       if (node != nullptr) {
@@ -212,7 +212,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn,
                                                 MFParamsBuilder &params,
                                                 ResourceCollector &resources)
 {
-  for (uint param_index : network_fn.param_indices()) {
+  for (int param_index : network_fn.param_indices()) {
     MFParamType param_type = network_fn.param_type(param_index);
     MFDataType data_type = param_type.data_type();
 
@@ -244,7 +244,7 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction &
 {
   Array<MFOutputSocket *> folded_sockets{network_fn.param_indices().size(), nullptr};
 
-  for (uint param_index : network_fn.param_indices()) {
+  for (int param_index : network_fn.param_indices()) {
     MFParamType param_type = network_fn.param_type(param_index);
     MFDataType data_type = param_type.data_type();
 
@@ -302,7 +302,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources)
   Array<MFOutputSocket *> folded_sockets = compute_constant_sockets_and_add_folded_nodes(
       network, inputs_to_fold, resources);
 
-  for (uint i : inputs_to_fold.index_range()) {
+  for (int i : inputs_to_fold.index_range()) {
     MFOutputSocket &original_socket = *inputs_to_fold[i]->origin();
     network.relink(original_socket, *folded_sockets[i]);
   }
@@ -317,12 +317,12 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources)
  *
  * \{ */
 
-static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t> node_hashes)
+static uint64_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint64_t> node_hashes)
 {
-  uint32_t combined_inputs_hash = 394659347u;
+  uint64_t combined_inputs_hash = 394659347u;
   for (MFInputSocket *input_socket : node.inputs()) {
     MFOutputSocket *origin_socket = input_socket->origin();
-    uint32_t input_hash;
+    uint64_t input_hash;
     if (origin_socket == nullptr) {
       input_hash = BLI_rng_get_uint(rng);
     }
@@ -333,8 +333,8 @@ static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t>
     combined_inputs_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, input_hash);
   }
 
-  uint32_t function_hash = node.function().hash();
-  uint32_t node_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, function_hash);
+  uint64_t function_hash = node.function().hash();
+  uint64_t node_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, function_hash);
   return node_hash;
 }
 
@@ -342,15 +342,15 @@ static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t>
  * Produces a hash for every node. Two nodes with the same hash should have a high probability of
  * outputting the same values.
  */
-static Array<uint32_t> compute_node_hashes(MFNetwork &network)
+static Array<uint64_t> compute_node_hashes(MFNetwork &network)
 {
   RNG *rng = BLI_rng_new(0);
-  Array<uint32_t> node_hashes(network.node_id_amount());
+  Array<uint64_t> node_hashes(network.node_id_amount());
   Array<bool> node_is_hashed(network.node_id_amount(), false);
 
   /* No dummy nodes are not assumed to output the same values. */
   for (MFDummyNode *node : network.dummy_nodes()) {
-    uint32_t node_hash = BLI_rng_get_uint(rng);
+    uint64_t node_hash = BLI_rng_get_uint(rng);
     node_hashes[node->id()] = node_hash;
     node_is_hashed[node->id()] = true;
   }
@@ -381,7 +381,7 @@ static Array<uint32_t> compute_node_hashes(MFNetwork &network)
       continue;
     }
 
-    uint32_t node_hash = compute_node_hash(node, rng, node_hashes);
+    uint64_t node_hash = compute_node_hash(node, rng, node_hashes);
     node_hashes[node.id()] = node_hash;
     node_is_hashed[node.id()] = true;
     nodes_to_check.pop();
@@ -391,14 +391,14 @@ static Array<uint32_t> compute_node_hashes(MFNetwork &network)
   return node_hashes;
 }
 
-static Map<uint32_t, Vector<MFNode *, 1>> group_nodes_by_hash(MFNetwork &network,
-                                                              Span<uint32_t> node_hashes)
+static Map<uint64_t, Vector<MFNode *, 1>> group_nodes_by_hash(MFNetwork &network,
+                                                              Span<uint64_t> node_hashes)
 {
-  Map<uint32_t, Vector<MFNode *, 1>> nodes_by_hash;
-  for (uint id : IndexRange(network.node_id_amount())) {
+  Map<uint64_t, Vector<MFNode *, 1>> nodes_by_hash;
+  for (int id : IndexRange(network.node_id_amount())) {
     MFNode *node = network.node_or_null_by_id(id);
     if (node != nullptr) {
-      uint32_t node_hash = node_hashes[id];
+      uint64_t node_hash = node_hashes[id];
       nodes_by_hash.lookup_or_add_default(node_hash).append(node);
     }
   }
@@ -428,7 +428,7 @@ static bool nodes_output_same_values(DisjointSet &cache, const MFNode &a, const
   if (!functions_are_equal(a.as_function().function(), b.as_function().function())) {
     return false;
   }
-  for (uint i : a.inputs().index_range()) {
+  for (int i : a.inputs().index_range()) {
     const MFOutputSocket *origin_a = a.input(i).origin();
     const MFOutputSocket *origin_b = b.input(i).origin();
     if (origin_a == nullptr || origin_b == nullptr) {
@@ -444,7 +444,7 @@ static bool nodes_output_same_values(DisjointSet &cache, const MFNode &a, const
 }
 
 static void relink_duplicate_nodes(MFNetwork &network,
-                                   Map<uint32_t, Vector<MFNode *, 1>> &nodes_by_hash)
+                                   Map<uint64_t, Vector<MFNode *, 1>> &nodes_by_hash)
 {
   DisjointSet same_node_cache{network.node_id_amount()};
 
@@ -462,7 +462,7 @@ static void relink_duplicate_nodes(MFNetwork &network,
         /* This is true with fairly high probability, but hash collisions can happen. So we have to
          * check if the node actually output the same values. */
         if (nodes_output_same_values(same_node_cache, deduplicated_node, *node)) {
-          for (uint i : deduplicated_node.outputs().index_range()) {
+          for (int i : deduplicated_node.outputs().index_range()) {
             network.relink(node->output(i), deduplicated_node.output(i));
           }
         }
@@ -481,8 +481,8 @@ static void relink_duplicate_nodes(MFNetwork &network,
  */
 void common_subnetwork_elimination(MFNetwork &network)
 {
-  Array<uint32_t> node_hashes = compute_node_hashes(network);
-  Map<uint32_t, Vector<MFNode *, 1>> nodes_by_hash = group_nodes_by_hash(network, node_hashes);
+  Array<uint64_t> node_hashes = compute_node_hashes(network);
+  Map<uint64_t, Vector<MFNode *, 1>> nodes_by_hash = group_nodes_by_hash(network, node_hashes);
   relink_duplicate_nodes(network, nodes_by_hash);
 }