diff --git a/source/blender/blenkernel/intern/mesh_calc_edges.cc b/source/blender/blenkernel/intern/mesh_calc_edges.cc
index cda13f07c8a..7a6f52cb38b 100644
--- a/source/blender/blenkernel/intern/mesh_calc_edges.cc
+++ b/source/blender/blenkernel/intern/mesh_calc_edges.cc
@@ -209,6 +209,25 @@ static IndexMask mask_first_distinct_edges(const Span<int2> edges,
       });
 }
 
+static void map_edge_to_span_index(const Span<int2> edges,
+                                   const Span<EdgeMap> edge_maps,
+                                   const uint32_t parallel_mask,
+                                   const OffsetIndices<int> edge_offsets,
+                                   MutableSpan<int> indices)
+{
+  threading::parallel_for_each(edge_maps.index_range(), [&](const int map_i) {
+    int edge_map_iter = 0;
+    for (const int edge_i : edges.index_range()) {
+      const int edge_map = calc_edges::edge_to_hash_map_i(edges[edge_i], parallel_mask);
+      if (map_i != edge_map) {
+        continue;
+      }
+      indices[edge_offsets[edge_map][edge_map_iter]] = edge_i;
+      edge_map_iter++;
+    }
+  });
+}
+
 }  // namespace calc_edges
 
 void mesh_calc_edges(Mesh &mesh,
@@ -268,6 +287,8 @@ void mesh_calc_edges(Mesh &mesh,
   corner_edges.fill(-1);
 #endif
 
+  const int result_edges_num = edge_offsets.total_size();
+
   const OffsetIndices<int> faces = mesh.faces();
   const Span<int2> original_edges = mesh.edges();
   const Span<int> corner_verts = mesh.corner_verts();
@@ -276,13 +297,20 @@ void mesh_calc_edges(Mesh &mesh,
      * that case. TODO: make this optional. */
     calc_edges::update_edge_indices_in_face_loops(
         faces, corner_verts, edge_maps, parallel_mask, edge_offsets, corner_edges);
+
+    Array<int> edge_map_to_result_index(result_edges_num);
+#ifndef NDEBUG
+    edge_map_to_result_index.as_mutable_span().fill(-1);
+#endif
+    calc_edges::map_edge_to_span_index(
+        original_edges, edge_maps, parallel_mask, edge_offsets, edge_map_to_result_index);
+    array_utils::gather(edge_map_to_result_index.as_span(), corner_edges.as_span(), corner_edges);
+
     BLI_assert(!corner_edges.contains(-1));
     BLI_assert(BKE_mesh_is_valid(&mesh));
     return;
   }
 
-  const int result_edges_num = edge_offsets.total_size();
-
   IndexMaskMemory memory;
   IndexRange back_range_of_new_edges;
   IndexMask src_to_dst_mask;
@@ -321,18 +349,11 @@ void mesh_calc_edges(Mesh &mesh,
     if (original_edges_are_distinct) {
       /* TODO: Do we can group edges by .low vertex? Or by hash, but with Span<int> of edges by
        * group?... */
-      threading::parallel_for_each(edge_maps.index_range(), [&](const int map_i) {
-        int edge_map_iter = 0;
-        for (const int edge_i : IndexRange(mesh.edges_num)) {
-          const int edge_map = calc_edges::edge_to_hash_map_i(original_edges[edge_i],
-                                                              parallel_mask);
-          if (map_i != edge_map) {
-            continue;
-          }
-          edge_map_to_result_index[edge_offsets[edge_map][edge_map_iter]] = edge_i;
-          edge_map_iter++;
-        }
-      });
+      calc_edges::map_edge_to_span_index(original_edges.take_front(mesh.edges_num),
+                                         edge_maps,
+                                         parallel_mask,
+                                         edge_offsets,
+                                         edge_map_to_result_index);
     }
     else {
       src_to_dst_mask.foreach_index(