diff --git a/cmake/onnxruntime_providers.cmake b/cmake/onnxruntime_providers.cmake
index 27f03836eb..3e6f62dae7 100644
--- a/cmake/onnxruntime_providers.cmake
+++ b/cmake/onnxruntime_providers.cmake
@@ -242,9 +242,9 @@ endif()
 
 if (MSVC)
    target_compile_options(onnxruntime_providers PRIVATE "/bigobj")
-   if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-      target_compile_options(onnxruntime_providers PRIVATE "/wd4244")
-   endif()
+#   if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+#      target_compile_options(onnxruntime_providers PRIVATE "/wd4244")
+#   endif()
 endif()
 onnxruntime_add_include_to_target(onnxruntime_providers onnxruntime_common onnxruntime_framework onnx onnx_proto ${PROTOBUF_LIB} flatbuffers)
 
diff --git a/onnxruntime/contrib_ops/cpu/activations.h b/onnxruntime/contrib_ops/cpu/activations.h
index 810ea5066a..aed4c22292 100644
--- a/onnxruntime/contrib_ops/cpu/activations.h
+++ b/onnxruntime/contrib_ops/cpu/activations.h
@@ -4,9 +4,11 @@
 #pragma once
 
 #include "core/common/common.h"
+#include "core/common/narrow.h"
 #include "core/framework/op_kernel.h"
 #include "core/util/math_cpuonly.h"
 #include "core/mlas/inc/mlas.h"
+
 #include "core/platform/threadpool.h"
 #include <unsupported/Eigen/SpecialFunctions>
 #include "core/providers/cpu/element_wise_ranged_transform.h"
@@ -120,7 +122,7 @@ class QuickGelu : public OpKernel {
             p_output[i] = p_input[i] * alpha_;
           }
 
-          MlasComputeLogistic(p_output, p_output, count);
+          MlasComputeLogistic(p_output, p_output, onnxruntime::narrow<size_t>(count));
 
           for (int64_t i = 0; i < count; i++) {
             p_output[i] = p_input[i] * p_output[i];
diff --git a/onnxruntime/contrib_ops/cpu/quantization/qlinear_softmax.cc b/onnxruntime/contrib_ops/cpu/quantization/qlinear_softmax.cc
index 176ce21dfd..3f3e7e3b51 100644
--- a/onnxruntime/contrib_ops/cpu/quantization/qlinear_softmax.cc
+++ b/onnxruntime/contrib_ops/cpu/quantization/qlinear_softmax.cc
@@ -93,7 +93,7 @@ QLinearSoftmax::QLinearSoftmax(const OpKernelInfo& info)
     int64_t reduce_size = opset_ < OPSET13 ? input_shape.SizeFromDimension(axis_) : input_shape[axis_];
     // reduce_size could be negative if input-shape has a dynamic axis
     if (reduce_size > 0) {
-      BuildLookupTableIfFixed(info, fixed_lookup_table_, reduce_size, is_signed_);
+      BuildLookupTableIfFixed(info, fixed_lookup_table_, onnxruntime::narrow<size_t>(reduce_size), is_signed_);
     }
   }
 }
@@ -112,7 +112,7 @@ Status QLinearSoftmax::Compute(OpKernelContext* ctx) const {
   auto* Y = ctx->Output(0, X_shape);
 
   concurrency::ThreadPool* thread_pool = ctx->GetOperatorThreadPool();
-  const size_t D = opset_ < OPSET13 ? X_shape.SizeFromDimension(axis) : X_shape[axis];
+  const size_t D = onnxruntime::narrow<size_t>(opset_ < OPSET13 ? X_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis)) : X_shape[onnxruntime::narrow<size_t>(axis)]);
   EXP_OUT_DTYPE tmp_lookup_table[256];
   gsl::span<const EXP_OUT_DTYPE> lookup_table = GetLookupTable(ctx, tmp_lookup_table, D);
 
diff --git a/onnxruntime/contrib_ops/cpu/unique.cc b/onnxruntime/contrib_ops/cpu/unique.cc
index b0d8040f40..9077365c98 100644
--- a/onnxruntime/contrib_ops/cpu/unique.cc
+++ b/onnxruntime/contrib_ops/cpu/unique.cc
@@ -47,7 +47,7 @@ Status Unique<float>::Compute(OpKernelContext* ctx) const {
   // used originally for float uniqueness, is this correct?
   using IndexingMap = InlinedHashMap<float, ElementData>;
   IndexingMap mapped_indices;
-  mapped_indices.reserve(num_elements);
+  mapped_indices.reserve(onnxruntime::narrow<size_t>(num_elements));
 
   // processing
   for (int64_t i = 0; i < num_elements; ++i) {
diff --git a/onnxruntime/core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.cc b/onnxruntime/core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.cc
index 21daeea902..6a531488e8 100644
--- a/onnxruntime/core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.cc
+++ b/onnxruntime/core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.cc
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 #include "einsum_typed_compute_processor.h"
-
+#include "core/common/narrow.h"
 #include "core/common/span_utils.h"
 
 namespace onnxruntime {
@@ -199,7 +199,10 @@ std::unique_ptr<Tensor> EinsumTypedComputeProcessor<T>::PairwiseOperandProcess(c
   left_permutation.reserve(lro.size() + lo.size() + reduce_dims.size() + ro.size());
   left_permutation.insert(left_permutation.end(), lro.begin(), lro.end());
   left_permutation.insert(left_permutation.end(), lo.begin(), lo.end());
-  left_permutation.insert(left_permutation.end(), reduce_dims.begin(), reduce_dims.end());
+//  left_permutation.insert(left_permutation.end(), reduce_dims.begin(), reduce_dims.end());
+  for(auto & a : reduce_dims){
+    left_permutation.push_back(onnxruntime::narrow<size_t>(a));
+  }
   left_permutation.insert(left_permutation.end(), ro.begin(), ro.end());
   if (EinsumOp::IsTransposeRequired(current_left ? current_left->Shape().NumDimensions() : left_dims.size(),
                                     left_permutation)) {
@@ -224,7 +227,10 @@ std::unique_ptr<Tensor> EinsumTypedComputeProcessor<T>::PairwiseOperandProcess(c
   InlinedVector<size_t> right_permutation;
   right_permutation.reserve(lro.size() + lo.size() + reduce_dims.size() + ro.size());
   right_permutation.insert(right_permutation.end(), lro.begin(), lro.end());
-  right_permutation.insert(right_permutation.end(), reduce_dims.begin(), reduce_dims.end());
+//  right_permutation.insert(right_permutation.end(), reduce_dims.begin(), reduce_dims.end());
+  for(auto & a : reduce_dims){
+    right_permutation.push_back(onnxruntime::narrow<size_t>(a));
+  }
   right_permutation.insert(right_permutation.end(), ro.begin(), ro.end());
   right_permutation.insert(right_permutation.end(), lo.begin(), lo.end());
   if (EinsumOp::IsTransposeRequired(current_right ? current_right->Shape().GetDims().size() : right_dims.size(),
diff --git a/onnxruntime/core/providers/cpu/reduction/reduction_ops.cc b/onnxruntime/core/providers/cpu/reduction/reduction_ops.cc
index f1a7ebb437..5ec47ab76a 100644
--- a/onnxruntime/core/providers/cpu/reduction/reduction_ops.cc
+++ b/onnxruntime/core/providers/cpu/reduction/reduction_ops.cc
@@ -626,7 +626,7 @@ FastReduceKind OptimizeShapeForFastReduce(gsl::span<const int64_t> input_shape,
       if (reduce[onnxruntime::narrow<size_t>(i)]) {
         fast_axes.push_back(onnxruntime::narrow<int64_t>(fast_shape.size()));
       }
-      fast_shape.push_back(input_shape[i]);
+      fast_shape.push_back(input_shape[onnxruntime::narrow<size_t>(i)]);
     }
   }
   if (fast_shape.size() == 1) {
diff --git a/onnxruntime/core/providers/cpu/signal/dft.cc b/onnxruntime/core/providers/cpu/signal/dft.cc
index 0f8d1a8cb4..b938f115a1 100644
--- a/onnxruntime/core/providers/cpu/signal/dft.cc
+++ b/onnxruntime/core/providers/cpu/signal/dft.cc
@@ -251,7 +251,7 @@ static Status discrete_fourier_transform(OpKernelContext* ctx, const Tensor* X,
       if (r == static_cast<size_t>(axis)) {
         continue;
       }
-      cumulative_packed_stride /= X_shape[onnxruntime::narrow<size_t>(r)];
+      cumulative_packed_stride /= onnxruntime::narrow<size_t>(X_shape[r]);
       auto index = temp / cumulative_packed_stride;
       temp -= (index * cumulative_packed_stride);
       X_offset += index * SafeInt<size_t>(X_shape.SizeFromDimension(r + 1)) / complex_input_factor;
@@ -265,7 +265,7 @@ static Status discrete_fourier_transform(OpKernelContext* ctx, const Tensor* X,
       if (r == static_cast<size_t>(axis)) {
         continue;
       }
-      cumulative_packed_stride /= X_shape[onnxruntime::narrow<size_t>(r)];
+      cumulative_packed_stride /= onnxruntime::narrow<size_t>(X_shape[r]);
       auto index = temp / cumulative_packed_stride;
       temp -= (index * cumulative_packed_stride);
       Y_offset += index * SafeInt<size_t>(Y_shape.SizeFromDimension(r + 1)) / 2;
diff --git a/onnxruntime/core/providers/cpu/tensor/gather_nd.cc b/onnxruntime/core/providers/cpu/tensor/gather_nd.cc
index 19790ec525..ad3faa70ed 100644
--- a/onnxruntime/core/providers/cpu/tensor/gather_nd.cc
+++ b/onnxruntime/core/providers/cpu/tensor/gather_nd.cc
@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-
+#include <core/common/safeint.h>
 #include "gather_nd.h"
 #include "core/platform/threadpool.h"
 
@@ -64,13 +64,13 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
 
   const auto num_slice_dims = indices_shape[indices_shape.NumDimensions() - 1];
   const auto num_slices = indices_shape.SizeToDimension(indices_shape.NumDimensions() - 1);
-  const auto slice_size = input_shape.SizeFromDimension(batch_dims_ + num_slice_dims);
-  const auto num_batches = input_shape.SizeToDimension(batch_dims_);
-  const auto input_batch_stride = input_shape.SizeFromDimension(batch_dims_);
+  const auto slice_size = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_) + num_slice_dims);
+  const auto num_batches = input_shape.SizeToDimension(SafeInt<size_t>(batch_dims_));
+  const auto input_batch_stride = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_));
   const auto num_slices_per_batch = num_slices / num_batches;
-  std::vector<int64_t> sizes_from_slice_dims(num_slice_dims);
+  std::vector<int64_t> sizes_from_slice_dims(onnxruntime::narrow<size_t>(num_slice_dims));
   for (int64_t i = 0; i < num_slice_dims; ++i) {
-    sizes_from_slice_dims[i] = input_shape.SizeFromDimension(batch_dims_ + i + 1);
+    sizes_from_slice_dims[onnxruntime::narrow<size_t>(i)] = input_shape.SizeFromDimension(SafeInt<size_t>(batch_dims_) + i + 1);
   }
 
   int64_t err_index = 0;
@@ -78,18 +78,18 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
   p.element_count_per_slice = slice_size;
   p.bytes_per_slice = p.element_bytes * p.element_count_per_slice;
   const auto* indices_data = indices_tensor->Data<Tind>();
-  p.slice_offsets.assign(num_slices, 0LL);
+  p.slice_offsets.assign(onnxruntime::narrow<size_t>(num_slices), 0LL);
 
   // Compute the element_offset
   auto lambda = [&](int64_t slice_idx) {
-    const size_t batch_idx = slice_idx / num_slices_per_batch;
-    const size_t input_base_offset = batch_idx * input_batch_stride;
+    const size_t batch_idx = onnxruntime::narrow<size_t>(slice_idx / num_slices_per_batch);
+    const size_t input_base_offset = batch_idx * SafeInt<size_t>(input_batch_stride);
 
     const auto* const slice_indices = indices_data + slice_idx * num_slice_dims;
     size_t relative_slice_offset = 0;
     for (int64_t dim_idx = 0; dim_idx < num_slice_dims; ++dim_idx) {
       int64_t index = static_cast<int64_t>(slice_indices[dim_idx]);
-      const auto upper_limit = input_shape[batch_dims_ + dim_idx];
+      const auto upper_limit = input_shape[SafeInt<size_t>(batch_dims_) + dim_idx];
       const auto lower_limit = -upper_limit;
       if (index < lower_limit || index >= upper_limit) {
         err_index = index;
@@ -97,14 +97,14 @@ Status GatherNDBase::PrepareForCompute(const TensorShape& input_shape, const Ten
       }
       if (index < 0) index += upper_limit;
 
-      relative_slice_offset += index * sizes_from_slice_dims[dim_idx];
+      relative_slice_offset += SafeInt<size_t>(index) * sizes_from_slice_dims[onnxruntime::narrow<size_t>(dim_idx)];
     }
 
-    p.slice_offsets[slice_idx] = static_cast<uint64_t>(input_base_offset) + relative_slice_offset;
+    p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] = static_cast<uint64_t>(input_base_offset) + relative_slice_offset;
   };
 
   concurrency::ThreadPool::TryParallelFor(
-      tp, num_slices, static_cast<double>(num_slice_dims),
+      tp, onnxruntime::narrow<size_t>(num_slices), static_cast<double>(num_slice_dims),
       [&lambda](ptrdiff_t first, ptrdiff_t last) {
         for (int slice_idx = static_cast<int>(first), end = static_cast<int>(last); slice_idx < end; ++slice_idx) {
           lambda(slice_idx);
@@ -143,7 +143,7 @@ Status GatherND::Compute(OpKernelContext* context) const {
   }
 
   std::vector<int64_t> shape(indices_shape.GetDims().begin(), indices_shape.GetDims().end() - 1);
-  shape.insert(shape.end(), input_shape.GetDims().begin() + last_indices_dimension,
+  shape.insert(shape.end(), input_shape.GetDims().begin() + onnxruntime::narrow<std::ptrdiff_t>(last_indices_dimension),
                input_shape.GetDims().end());
 
   auto* output_tensor = context->Output(0, TensorShape(std::move(shape)));
@@ -178,8 +178,8 @@ Status GatherND::Compute(OpKernelContext* context) const {
 
 Status GatherND::GatherNumber(const Prepare& p, concurrency::ThreadPool* tp) const {
   auto lambda = [&](int64_t slice_idx) {
-    memcpy(p.output_base + slice_idx * p.bytes_per_slice, p.input_base + p.slice_offsets[slice_idx] * p.element_bytes,
-           p.bytes_per_slice);
+    memcpy(p.output_base + slice_idx * p.bytes_per_slice, p.input_base + p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] * p.element_bytes,
+           onnxruntime::narrow<size_t>(p.bytes_per_slice));
   };
   concurrency::ThreadPool::TryParallelFor(
       tp, p.slice_offsets.size(), static_cast<double>(p.bytes_per_slice),
@@ -195,7 +195,7 @@ Status GatherND::GatherString(const Prepare& p, concurrency::ThreadPool* tp) con
   auto lambda = [&](int64_t slice_idx) {
     const int64_t slice_base_offset = slice_idx * p.element_count_per_slice;
     for (int64_t j = 0; j < static_cast<int64_t>(p.element_count_per_slice); ++j) {
-      p.output_str_base[slice_base_offset + j] = p.input_str_base[p.slice_offsets[slice_idx] + j];
+      p.output_str_base[slice_base_offset + j] = p.input_str_base[p.slice_offsets[onnxruntime::narrow<size_t>(slice_idx)] + j];
     }
   };
   concurrency::ThreadPool::TryParallelFor(
diff --git a/onnxruntime/core/providers/cpu/tensor/grid_sample.cc b/onnxruntime/core/providers/cpu/tensor/grid_sample.cc
index 8e23bf14d8..bd8033b40f 100644
--- a/onnxruntime/core/providers/cpu/tensor/grid_sample.cc
+++ b/onnxruntime/core/providers/cpu/tensor/grid_sample.cc
@@ -172,7 +172,7 @@ Status GridSample<T>::Compute(OpKernelContext* context) const {
   for (int64_t n = 0; n < N; n++) {
     const T* grid_data = grid->Data<T>() + n * (H_out * W_out) * 2;
     concurrency::ThreadPool::TrySimpleParallelFor(
-        tp, C,
+        tp, onnxruntime::narrow<std::ptrdiff_t>(C),
         [&](std::ptrdiff_t c) {
           const T* X_data = input->Data<T>() + (n * C + c) * (H_in * W_in);
           T* Y_data = Y.MutableData<T>() + (n * C + c) * (H_out * W_out);
diff --git a/onnxruntime/core/providers/cpu/tensor/identity_op.h b/onnxruntime/core/providers/cpu/tensor/identity_op.h
index 59eb98d9f8..6fa6c26b1e 100644
--- a/onnxruntime/core/providers/cpu/tensor/identity_op.h
+++ b/onnxruntime/core/providers/cpu/tensor/identity_op.h
@@ -8,6 +8,7 @@
 #pragma warning(disable : 4996)
 #endif
 #include "core/common/common.h"
+#include "core/common/narrow.h"
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -54,7 +55,7 @@ class IdentityOp final : public OpKernel {
       //If source and target pointers are not equal, we need to copy the data.
       if (target != source) {
         if (!X->IsDataTypeString()) {
-          memcpy(target, source, shape.Size() * X_type->Size());
+          memcpy(target, source, SafeInt<size_t>(shape.Size()) * X_type->Size());
         } else {
           // handle std::string
           const auto* src = X->Data<std::string>();
diff --git a/onnxruntime/core/providers/cpu/tensor/isinf.cc b/onnxruntime/core/providers/cpu/tensor/isinf.cc
index 25dfe19cc9..bc99caa803 100644
--- a/onnxruntime/core/providers/cpu/tensor/isinf.cc
+++ b/onnxruntime/core/providers/cpu/tensor/isinf.cc
@@ -74,7 +74,7 @@ struct ComputeDispatchTarget {
           });
     } else {
       // all false
-      memset(output_data, false, total_items);
+      memset(output_data, false, onnxruntime::narrow<size_t>(total_items));
     }
   }
 };
diff --git a/onnxruntime/core/providers/cpu/tensor/isnan.cc b/onnxruntime/core/providers/cpu/tensor/isnan.cc
index a22d619709..bcc75185ee 100644
--- a/onnxruntime/core/providers/cpu/tensor/isnan.cc
+++ b/onnxruntime/core/providers/cpu/tensor/isnan.cc
@@ -62,7 +62,7 @@ Status IsNaN<MLFloat16>::Compute(OpKernelContext* context) const {
   auto& Y = *context->Output(0, dims);
 
   EigenMap<bool>(Y) =
-      ConstEigenVectorMap<Eigen::half>(static_cast<const Eigen::half*>(static_cast<const void*>(X_data)), shape_size)
+      ConstEigenVectorMap<Eigen::half>(static_cast<const Eigen::half*>(static_cast<const void*>(X_data)), onnxruntime::narrow<size_t>(shape_size))
           .array()
           .isNaN();
 
diff --git a/onnxruntime/core/providers/cpu/tensor/mean_variance_normalization.h b/onnxruntime/core/providers/cpu/tensor/mean_variance_normalization.h
index a84941e3e3..2f2692e7ed 100644
--- a/onnxruntime/core/providers/cpu/tensor/mean_variance_normalization.h
+++ b/onnxruntime/core/providers/cpu/tensor/mean_variance_normalization.h
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 #pragma once
-
+#include <core/common/safeint.h>
 #include "core/common/common.h"
 #include "core/framework/op_kernel.h"
 #include "core/util/math_cpuonly.h"
@@ -45,18 +45,18 @@ class MeanVarianceNormalization_0 : public OpKernel {
     mean.setZero();
     var.setZero();
 
-    ConstEigenArrayMap<T> X_arr(Xdata, sample_size, N * C);
+    ConstEigenArrayMap<T> X_arr(Xdata, onnxruntime::narrow<std::ptrdiff_t>(sample_size), SafeInt<ptrdiff_t>(N) * C);
     for (int nc = 0; nc < N * C; ++nc) {
       mean(nc % C) += X_arr.col(nc).sum();
     }
     mean /= gsl::narrow_cast<T>(N * sample_size);
     for (int64_t nc = 0; nc < N * C; ++nc) {
-      var(nc % C) += (X_arr.col(nc) - mean(nc % C)).matrix().squaredNorm();
+      var(onnxruntime::narrow<std::ptrdiff_t>(nc % C)) += (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C))).matrix().squaredNorm();
     }
     var /= gsl::narrow_cast<T>(N * sample_size);
 
     Eigen::Array<T, Eigen::Dynamic, 1> inv_std;
-    EigenArrayMap<T> Y_arr(Ydata, sample_size, N * C);
+    EigenArrayMap<T> Y_arr(Ydata, onnxruntime::narrow<std::ptrdiff_t>(sample_size), SafeInt<ptrdiff_t>(N) * C);
 
     if (across_channels_) {
       // m_c = sum(m_i) / n
@@ -79,13 +79,13 @@ class MeanVarianceNormalization_0 : public OpKernel {
         // inv_std = 1
         for (int64_t nc = 0; nc < N * C; ++nc) {
           // y = (x - mean)
-          Y_arr.col(nc) = (X_arr.col(nc) - mean(nc % C));
+          Y_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) = (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C)));
         }
       } else {
         inv_std = var.sqrt().inverse();
         for (int64_t nc = 0; nc < N * C; ++nc) {
           // y = (x - mean) * (inv_std)
-          Y_arr.col(nc) = (X_arr.col(nc) - mean(nc % C)) * inv_std(nc % C);
+          Y_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) = (X_arr.col(onnxruntime::narrow<std::ptrdiff_t>(nc)) - mean(onnxruntime::narrow<std::ptrdiff_t>(nc % C))) * inv_std(onnxruntime::narrow<std::ptrdiff_t>(nc % C));
         }
       }
     }
diff --git a/onnxruntime/core/providers/cpu/tensor/nonzero_op.cc b/onnxruntime/core/providers/cpu/tensor/nonzero_op.cc
index 9fc0aeb2b9..59978bb40c 100644
--- a/onnxruntime/core/providers/cpu/tensor/nonzero_op.cc
+++ b/onnxruntime/core/providers/cpu/tensor/nonzero_op.cc
@@ -5,7 +5,7 @@
 
 #include <cassert>
 #include <vector>
-
+#include <core/common/safeint.h>
 #include "core/util/math_cpuonly.h"
 
 namespace onnxruntime {
@@ -59,10 +59,10 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
   const auto& X_shape = X->Shape();
   assert(X_shape.Size() >= 0);
 
-  const Eigen::Index coordinate_size = X_shape.IsScalar() ? 1 : X_shape.NumDimensions();
+  const Eigen::Index coordinate_size = X_shape.IsScalar() ? 1 : onnxruntime::narrow<Eigen::Index>(X_shape.NumDimensions());
   std::vector<int64_t> non_zero_indices_buffer{};
   // reserve enough space for indices for every element of X
-  non_zero_indices_buffer.reserve(X_shape.Size() * coordinate_size);
+  non_zero_indices_buffer.reserve(SafeInt<size_t>(X_shape.Size()) * coordinate_size);
 
   const T* data = X->Data<T>();
 
@@ -87,7 +87,7 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
       }
     };
 
-    for (size_t i = 0, end = X_shape.Size(); i < end; ++i) {
+    for (size_t i = 0, end = onnxruntime::narrow<size_t>(X_shape.Size()); i < end; ++i) {
       const T& value = *data++;
       if (value != T{}) {
         non_zero_indices_buffer.insert(non_zero_indices_buffer.end(),
@@ -98,7 +98,7 @@ Status NonZero<T>::Compute(OpKernelContext* context) const {
     }
   }
 
-  const Eigen::Index num_non_zero_values = non_zero_indices_buffer.size() / coordinate_size;
+  const Eigen::Index num_non_zero_values = onnxruntime::narrow<Eigen::Index>(non_zero_indices_buffer.size()) / coordinate_size;
 
   // transpose result for output
   ConstEigenMatrixMapRowMajor<int64_t> non_zero_indices_matrix{
diff --git a/onnxruntime/core/providers/cpu/tensor/onehot.cc b/onnxruntime/core/providers/cpu/tensor/onehot.cc
index 48de8629f6..91d6ada1fb 100644
--- a/onnxruntime/core/providers/cpu/tensor/onehot.cc
+++ b/onnxruntime/core/providers/cpu/tensor/onehot.cc
@@ -102,7 +102,7 @@ Status PrepareOutputShape(const Tensor* indices, const int64_t depth_val, const
 
   prefix_dim_size = 1;
   for (int64_t i = 0; i < true_axis; ++i) {
-    prefix_dim_size *= indices_dims[i];
+    prefix_dim_size *= indices_dims[onnxruntime::narrow<size_t>(i)];
   }
   suffix_dim_size = indices_shape.Size() / prefix_dim_size;
 
@@ -180,7 +180,7 @@ Status OneHotOp<in_type, out_type, depth_type>::Compute(OpKernelContext* p_op_ke
   const auto* indices_data = indices->Data<in_type>();
   const auto indices_size = indices->Shape().Size();
   std::vector<in_type> adjusted_indices;
-  adjusted_indices.reserve(indices_size);
+  adjusted_indices.reserve(onnxruntime::narrow<size_t>(indices_size));
   for (int64_t i = 0; i < indices_size; ++i) {
     if (indices_data[i] < 0)
       adjusted_indices.push_back(indices_data[i] + static_cast<in_type>(depth_val));
diff --git a/onnxruntime/core/providers/cpu/tensor/pad.cc b/onnxruntime/core/providers/cpu/tensor/pad.cc
index dc7fb8946c..f14ed4c2f3 100644
--- a/onnxruntime/core/providers/cpu/tensor/pad.cc
+++ b/onnxruntime/core/providers/cpu/tensor/pad.cc
@@ -283,9 +283,9 @@ static Status PadImpl(OpKernelContext* ctx,
   // Reshape padding
   size_t new_dims_count = reshaped_input_dims.size();
   size_t inner_axis = new_dims_count - 1;
-  size_t inner_no_pad_size = output_dims[inner_axis] > 0
+  size_t inner_no_pad_size = onnxruntime::narrow<size_t>(output_dims[inner_axis] > 0
                                  ? reshaped_input_dims[inner_axis] / output_dims[inner_axis]
-                                 : 0;
+                                 : 0);
   PadsVector reshaped_pad(2 * new_dims_count), reshaped_slice(2 * new_dims_count);
   ReshapePads(pads, data_rank, new_dims_count, inner_no_pad_size, reshaped_pad);
   ReshapePads(slices, data_rank, new_dims_count, inner_no_pad_size, reshaped_slice);
@@ -327,7 +327,7 @@ static Status PadImpl(OpKernelContext* ctx,
 
   // Initial skip, sum up the begin padding on each axis
   for (size_t i = 0; i < new_dims_count; i++)
-    alignSkip += reshaped_pad[i] * output_pitches[i];
+    alignSkip += SafeInt<size_t>(reshaped_pad[i] )* output_pitches[i];
 
   ExtentAxisCounters input_counters(input_extents);
 
@@ -344,21 +344,21 @@ static Status PadImpl(OpKernelContext* ctx,
 
           int64_t prePad = reshaped_pad[inner_axis];
           int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
-          PadAxisConstant(axisStart - prePad, value, prePad);
-          PadAxisConstant(output, value, postPad);
+          PadAxisConstant(axisStart - prePad, value, onnxruntime::narrow<size_t>(prePad));
+          PadAxisConstant(output, value, onnxruntime::narrow<size_t>(postPad));
           output += postPad;
-          alignSkip = prePad;
+          alignSkip = onnxruntime::narrow<size_t>(prePad);
         }
         // Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
         while (input_counters.Increment()) {
-          ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
+          ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
           T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
           int64_t prePad = reshaped_pad[input_counters.Axis()];
           int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
-          PadAxisConstant(axisStart - prePad * inner_pitch, value, prePad * inner_pitch);
-          PadAxisConstant(output, value, postPad * inner_pitch);
+          PadAxisConstant(axisStart - prePad * inner_pitch, value, SafeInt<std::ptrdiff_t>(prePad) * inner_pitch);
+          PadAxisConstant(output, value, SafeInt<ptrdiff_t>(postPad) * inner_pitch);
           output += inner_pitch * postPad;
-          alignSkip += inner_pitch * prePad;
+          alignSkip += inner_pitch * SafeInt<size_t>(prePad);
         }
       }
       break;
@@ -376,27 +376,27 @@ static Status PadImpl(OpKernelContext* ctx,
           int64_t prePad = reshaped_pad[inner_axis];
           int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
           if (inner_no_pad_size == 1) {
-            PadAxisConstant(axisStart - prePad, *axisStart, prePad);
-            PadAxisConstant(output, *(output - 1), postPad);
+            PadAxisConstant(axisStart - prePad, *axisStart, onnxruntime::narrow<size_t>(prePad));
+            PadAxisConstant(output, *(output - 1), onnxruntime::narrow<size_t>(postPad));
           } else {
             // When inner_most axis(es) do not need pad, above PadAxisConstant() do not fit for Edge mode.
             // Also general loop below after handling first pad axis with non-pad axis works fine.
-            PadAxis(axisStart - prePad, axisStart, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, pads[inner_axis]);
-            PadAxis(output, output - inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, pads[inner_axis + data_rank]);
+            PadAxis(axisStart - prePad, axisStart, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis]));
+            PadAxis(output, output - inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis + data_rank]));
           }
           output += postPad;
-          alignSkip = prePad;
+          alignSkip = onnxruntime::narrow<size_t>(prePad);
         }
         // Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
         while (input_counters.Increment()) {
-          ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
+          ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
           T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
           int64_t prePad = reshaped_pad[input_counters.Axis()];
           int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
-          PadAxis(axisStart - prePad * inner_pitch, axisStart, 1, -inner_pitch, inner_pitch, prePad);
-          PadAxis(output, output - inner_pitch, 1, -inner_pitch, inner_pitch, postPad);
+          PadAxis(axisStart - prePad * inner_pitch, axisStart, 1, -inner_pitch, inner_pitch, onnxruntime::narrow<size_t>(prePad));
+          PadAxis(output, output - inner_pitch, 1, -inner_pitch, inner_pitch, onnxruntime::narrow<size_t>(postPad));
           output += inner_pitch * postPad;
-          alignSkip += inner_pitch * prePad;
+          alignSkip += inner_pitch * SafeInt<size_t>(prePad);
         }
       }
       break;
@@ -414,27 +414,27 @@ static Status PadImpl(OpKernelContext* ctx,
           int64_t prePad = reshaped_pad[inner_axis];
           int64_t postPad = reshaped_pad[inner_axis + new_dims_count];
           if (inner_no_pad_size == 1) {
-            PadInnermostAxis(axisStart - prePad, axisStart + prePad, -1 /* inputDelta */, prePad);
-            PadInnermostAxis(output, output - 2, -1 /* inputDelta */, postPad);
+            PadInnermostAxis(axisStart - prePad, axisStart + prePad, -1 /* inputDelta */, onnxruntime::narrow<size_t>(prePad));
+            PadInnermostAxis(output, output - 2, -1 /* inputDelta */, onnxruntime::narrow<size_t>(postPad));
           } else {
             // When inner_most axis(es) do not need pad, Above PadInnermostAxis() do not fit for Reflect mode.
-            PadAxis(axisStart - prePad, axisStart + prePad, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, pads[inner_axis]);
-            PadAxis(output, output - 2 * inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, pads[inner_axis + data_rank]);
+            PadAxis(axisStart - prePad, axisStart + prePad, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis]));
+            PadAxis(output, output - 2 * inner_no_pad_size, 1, -ptrdiff_t(inner_no_pad_size * 2), inner_no_pad_size, onnxruntime::narrow<size_t>(pads[inner_axis + data_rank]));
           }
           output += postPad;
-          alignSkip = prePad;
+          alignSkip = onnxruntime::narrow<size_t>(prePad);
         }
         // Calculate the size of the next block of padding (skipping over the innermost axis since that's already done)
         while (input_counters.Increment()) {
-          ptrdiff_t inner_pitch = output_pitches[input_counters.Axis()];
+          ptrdiff_t inner_pitch = onnxruntime::narrow<std::ptrdiff_t>(output_pitches[input_counters.Axis()]);
           T* axisStart = output - inner_pitch * input_extents[input_counters.Axis()];
           int64_t prePad = reshaped_pad[input_counters.Axis()];
           int64_t postPad = reshaped_pad[input_counters.Axis() + new_dims_count];
           PadAxis(axisStart - prePad * inner_pitch, axisStart + prePad * inner_pitch, 1, -inner_pitch * 2,
-                  inner_pitch, prePad);
-          PadAxis(output, output - 2 * inner_pitch, 1, -inner_pitch * 2, inner_pitch, postPad);
+                  inner_pitch, onnxruntime::narrow<size_t>(prePad));
+          PadAxis(output, output - 2 * inner_pitch, 1, -inner_pitch * 2, inner_pitch, onnxruntime::narrow<size_t>(postPad));
           output += inner_pitch * postPad;
-          alignSkip += inner_pitch * prePad;
+          alignSkip += inner_pitch * SafeInt<size_t>(prePad);
         }
       }
       break;
diff --git a/onnxruntime/core/providers/cpu/tensor/reverse_sequence.cc b/onnxruntime/core/providers/cpu/tensor/reverse_sequence.cc
index fa0bd02ee5..d31b61e1ad 100644
--- a/onnxruntime/core/providers/cpu/tensor/reverse_sequence.cc
+++ b/onnxruntime/core/providers/cpu/tensor/reverse_sequence.cc
@@ -146,9 +146,9 @@ static Status ReverseSequenceImpl(const Tensor& X,
     }
 
     for (int64_t j = 0; j < seq_len; j++) {
-      gsl::span<const T> src = inputs.subspan(input_offset(max_seq_len, batch_size, input_size, i, j), input_size);
+      gsl::span<const T> src = inputs.subspan(onnxruntime::narrow<size_t>(input_offset(max_seq_len, batch_size, input_size, i, j)), onnxruntime::narrow<size_t>(input_size));
       gsl::span<T> dest = inputs_reverse.subspan(
-          reversed_output_offset(max_seq_len, batch_size, input_size, i, j, seq_len), input_size);
+          onnxruntime::narrow<size_t>(reversed_output_offset(max_seq_len, batch_size, input_size, i, j, seq_len)), onnxruntime::narrow<size_t>(input_size));
 
       // Use gsl::copy instead of std::copy() to allow compiler to optimize the code
       gsl::copy(src, dest);
@@ -156,8 +156,8 @@ static Status ReverseSequenceImpl(const Tensor& X,
 
     for (int64_t j = seq_len; j < max_seq_len; j++) {
       const auto offset = input_offset(max_seq_len, batch_size, input_size, i, j);
-      gsl::span<const T> src = inputs.subspan(offset, input_size);
-      gsl::span<T> dest = inputs_reverse.subspan(offset, input_size);
+      gsl::span<const T> src = inputs.subspan(onnxruntime::narrow<size_t>(offset), onnxruntime::narrow<size_t>(input_size));
+      gsl::span<T> dest = inputs_reverse.subspan(onnxruntime::narrow<size_t>(offset), onnxruntime::narrow<size_t>(input_size));
 
       // Use gsl::copy instead of std::copy() to allow compiler to optimize the code
       gsl::copy(src, dest);
diff --git a/onnxruntime/core/providers/cpu/tensor/scatter_nd.cc b/onnxruntime/core/providers/cpu/tensor/scatter_nd.cc
index 2b08ef4fe0..d7ede706bd 100644
--- a/onnxruntime/core/providers/cpu/tensor/scatter_nd.cc
+++ b/onnxruntime/core/providers/cpu/tensor/scatter_nd.cc
@@ -83,7 +83,7 @@ Status ScatterND::ValidateShapes(
 
     // Part 2: The shape of the update tensor after indices rank - 1 (inclusive)
     // should match the shape of the input tensor after `last_indice_dimension`
-    if (input_shape.Slice(last_indice_dimension) != update_shape.Slice(indice_rank - 1)) {
+    if (input_shape.Slice(onnxruntime::narrow<size_t>(last_indice_dimension)) != update_shape.Slice(indice_rank - 1)) {
       return true;
     }
 
@@ -144,17 +144,17 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
     }
   }
 
-  std::vector<int64_t> element_counts(last_indice_dimension, 0LL);  // Number of elements for each input dimension
+  std::vector<int64_t> element_counts(onnxruntime::narrow<size_t>(last_indice_dimension), 0LL);  // Number of elements for each input dimension
 
   TensorPitches input_strides(input_shape);
   for (int64_t i = 0; i < last_indice_dimension; ++i) {
-    element_counts[i] = input_strides[i];
+    element_counts[onnxruntime::narrow<size_t>(i)] = input_strides[onnxruntime::narrow<size_t>(i)];
   }
 
-  p.element_to_copy = input_shape.SizeFromDimension(last_indice_dimension);
+  p.element_to_copy = input_shape.SizeFromDimension(onnxruntime::narrow<size_t>(last_indice_dimension));
   const int64_t* indice_offset = indice_tensor->Data<int64_t>();
   auto offset_count = indice_shape.Size() / last_indice_dimension;  // Times to copy
-  p.element_offsets.assign(offset_count, 0LL);
+  p.element_offsets.assign(onnxruntime::narrow<size_t>(offset_count), 0LL);
 
   p.input_base = update_tensor->Data<TData>();
   p.output_base = output_tensor->MutableData<TData>();
@@ -164,18 +164,18 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
       auto indice = *(indice_offset + i * last_indice_dimension + j);
 
       if (indice >= 0) {
-        if (indice >= input_shape[j]) {
+        if (indice >= input_shape[onnxruntime::narrow<size_t>(j)]) {
           return ORT_MAKE_STATUS(ONNXRUNTIME, INVALID_ARGUMENT, "invalid indice found, indice = ", indice);
         }
       } else {
-        if (indice < -input_shape[j]) {
+        if (indice < -input_shape[onnxruntime::narrow<size_t>(j)]) {
           return ORT_MAKE_STATUS(ONNXRUNTIME, INVALID_ARGUMENT, "invalid indice found, indice = ", indice);
         } else {
-          indice += input_shape[j];
+          indice += input_shape[onnxruntime::narrow<size_t>(j)];
         }
       }
 
-      p.element_offsets[i] += indice * element_counts[j];
+      p.element_offsets[onnxruntime::narrow<size_t>(i)] += indice * element_counts[onnxruntime::narrow<size_t>(j)];
     }
   }
   return Status::OK();
@@ -184,7 +184,7 @@ Status PrepareForCompute(OpKernelContext* context, Prepare<TData>& p) {
 template <class T>
 struct Func_Copy_ND {
   void operator()(T* a, const T* b, uint64_t element_to_copy) const {
-    memcpy(a, b, element_to_copy * sizeof(T));
+    memcpy(a, b, SafeInt<size_t>(element_to_copy) * sizeof(T));
   }
 };
 
@@ -274,14 +274,14 @@ struct ScatterNDDispatchTarget {
         case ScatterND::Reduction::Add: {
           auto func = Func_Add_ND<TData>();
           func(
-              prepare.output_base + prepare.element_offsets[i],
+              prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
               prepare.input_base + i * prepare.element_to_copy,
               prepare.element_to_copy);
         } break;
         case ScatterND::Reduction::Mul: {
           auto func = Func_Mul_ND<TData>();
           func(
-              prepare.output_base + prepare.element_offsets[i],
+              prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
               prepare.input_base + i * prepare.element_to_copy,
               prepare.element_to_copy);
         } break;
@@ -289,7 +289,7 @@ struct ScatterNDDispatchTarget {
         case ScatterND::Reduction::None: {
           auto func = Func_Copy_ND<TData>();
           func(
-              prepare.output_base + prepare.element_offsets[i],
+              prepare.output_base + prepare.element_offsets[onnxruntime::narrow<size_t>(i)],
               prepare.input_base + i * prepare.element_to_copy,
               prepare.element_to_copy);
         } break;
diff --git a/onnxruntime/core/providers/cpu/tensor/shape_op.h b/onnxruntime/core/providers/cpu/tensor/shape_op.h
index 877a83df55..bc9068bf43 100644
--- a/onnxruntime/core/providers/cpu/tensor/shape_op.h
+++ b/onnxruntime/core/providers/cpu/tensor/shape_op.h
@@ -5,6 +5,7 @@
 
 #ifndef SHARED_PROVIDER
 #include "core/common/common.h"
+#include "core/common/narrow.h"
 #include "core/framework/op_kernel.h"
 #endif
 
@@ -54,7 +55,7 @@ class Shape final : public OpKernel {
       Tensor* output = context->Output(0, {slice_length < 0 ? 0 : slice_length});
 
       if (slice_length > 0) {
-        input_shape.CopyDims(output->MutableData<int64_t>(), true_start, slice_length);
+        input_shape.CopyDims(output->MutableData<int64_t>(), onnxruntime::narrow<size_t>(true_start), onnxruntime::narrow<size_t>(slice_length));
       }
     }
 
diff --git a/onnxruntime/core/providers/cpu/tensor/slice_helper.h b/onnxruntime/core/providers/cpu/tensor/slice_helper.h
index 0f54e12795..e0513af753 100644
--- a/onnxruntime/core/providers/cpu/tensor/slice_helper.h
+++ b/onnxruntime/core/providers/cpu/tensor/slice_helper.h
@@ -6,6 +6,7 @@
 #pragma once
 #include "core/providers/cpu/tensor/slice_compute_metadata.h"
 #include "core/common/inlined_containers.h"
+#include "core/common/narrow.h"
 #include "core/framework/ort_stl_allocator.h"
 
 namespace onnxruntime {
@@ -45,26 +46,26 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
     if (!p.second)
       return Status(common::ONNXRUNTIME, common::INVALID_ARGUMENT, "'axes' has duplicates");
 
-    const auto dim_value = compute_metadata.input_dimensions_[axis];
+    const auto dim_value = compute_metadata.input_dimensions_[onnxruntime::narrow<size_t>(axis)];
 
     // process start
     auto start = raw_starts[axis_index];
     if (start < 0)
       start += dim_value;
-    compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value);
+    compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value);
 
     // process end
     auto end = raw_ends[axis_index];
     if (end < 0)
       end += dim_value;
-    compute_metadata.ends_[axis] = std::clamp(end, int64_t{0}, dim_value);
+    compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = std::clamp(end, int64_t{0}, dim_value);
 
     // find output dim value for this axis
-    const auto temp = compute_metadata.ends_[axis] - compute_metadata.starts_[axis];
+    const auto temp = compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] - compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)];
     if (temp < 0)
-      compute_metadata.output_dims_[axis] = 0;
+      compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
     else
-      compute_metadata.output_dims_[axis] = temp;
+      compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = temp;
   }
 
   return Status::OK();
@@ -103,7 +104,7 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
     auto p = unique_axes.insert(axis);
     if (!p.second)
       return Status(common::ONNXRUNTIME, common::INVALID_ARGUMENT, "'axes' has duplicates");
-    const auto dim_value = compute_metadata.input_dimensions_[axis];
+    const auto dim_value = compute_metadata.input_dimensions_[onnxruntime::narrow<size_t>(axis)];
 
     // process step
     auto step = axis_index < raw_steps.size() ? raw_steps[axis_index] : 1;
@@ -112,10 +113,10 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
 
     if (dim_value == 0) {
       // shape with empty dim. only output_dims_ matters but set everything for completeness
-      compute_metadata.steps_[axis] = step;
-      compute_metadata.starts_[axis] = 0;
-      compute_metadata.ends_[axis] = 0;
-      compute_metadata.output_dims_[axis] = 0;
+      compute_metadata.steps_[onnxruntime::narrow<size_t>(axis)] = step;
+      compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = 0;
+      compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = 0;
+      compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
       continue;
     }
 
@@ -123,16 +124,16 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
     // as long as the clamped value is >= the size of the dimension a single step will push us past the end
     step = std::clamp(step, -dim_value, dim_value);
 
-    compute_metadata.steps_[axis] = step;
+    compute_metadata.steps_[onnxruntime::narrow<size_t>(axis)] = step;
 
     // process start
     auto start = raw_starts[axis_index];
     if (start < 0)
       start += dim_value;
     if (step < 0)
-      compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value - 1);
+      compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value - 1);
     else
-      compute_metadata.starts_[axis] = std::clamp(start, int64_t{0}, dim_value);
+      compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)] = std::clamp(start, int64_t{0}, dim_value);
 
     // process end
     auto end = raw_ends[axis_index];
@@ -151,14 +152,14 @@ inline Status PrepareForComputeHelper(const gsl::span<const int64_t>& raw_starts
         end = std::clamp(end, int64_t{0}, dim_value);
     }
 
-    compute_metadata.ends_[axis] = end;
+    compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] = end;
 
     // find output dim value for this axis
-    const auto temp = static_cast<int64_t>(ceil(1.0 * (compute_metadata.ends_[axis] - compute_metadata.starts_[axis]) / step));
+    const auto temp = static_cast<int64_t>(ceil(1.0 * (compute_metadata.ends_[onnxruntime::narrow<size_t>(axis)] - compute_metadata.starts_[onnxruntime::narrow<size_t>(axis)]) / step));
     if (temp < 0)
-      compute_metadata.output_dims_[axis] = 0;
+      compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = 0;
     else
-      compute_metadata.output_dims_[axis] = temp;
+      compute_metadata.output_dims_[onnxruntime::narrow<size_t>(axis)] = temp;
   }
 
   return Status::OK();
diff --git a/onnxruntime/core/providers/cpu/tensor/space_depth_ops.cc b/onnxruntime/core/providers/cpu/tensor/space_depth_ops.cc
index f63c91b374..dfe4602625 100644
--- a/onnxruntime/core/providers/cpu/tensor/space_depth_ops.cc
+++ b/onnxruntime/core/providers/cpu/tensor/space_depth_ops.cc
@@ -107,13 +107,31 @@ Status SpaceToDepth::Compute(OpKernelContext* context) const {
   std::array<Eigen::DenseIndex, IntermediateTensorRank> permutation{{0, 3, 5, 1, 2, 4}};
 
   if (input.IsDataType<float>()) {
-    SpaceDepthOpCpuImpl<float>(input, output, permutation, batch,
-                               input_depth, input_height / blocksize_, blocksize_, input_width / blocksize_, blocksize_,
-                               blocksize_, blocksize_, input_depth, input_height / blocksize_, input_width / blocksize_);
+    SpaceDepthOpCpuImpl<float>(input, output, permutation,
+                              onnxruntime::narrow<ptrdiff_t>(batch),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_depth),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
+                              onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_),
+                              onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                              onnxruntime::narrow<ptrdiff_t>(blocksize_),
+                              onnxruntime::narrow<ptrdiff_t>(blocksize_),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_depth),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
+                              onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_));
   } else if (input.IsDataType<double>()) {
-    SpaceDepthOpCpuImpl<double>(input, output, permutation, batch,
-                                input_depth, input_height / blocksize_, blocksize_, input_width / blocksize_, blocksize_,
-                                blocksize_, blocksize_, input_depth, input_height / blocksize_, input_width / blocksize_);
+    SpaceDepthOpCpuImpl<double>(input, output, permutation,
+                                onnxruntime::narrow<ptrdiff_t>(batch),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_depth),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_depth),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_height / blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_width / blocksize_));
   } else {
     // user will not see this as the kernel doesn't claim support for types other than float and double
     return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "Unsupported input type in SpaceToDepth op: ", input.DataType());
@@ -153,13 +171,31 @@ Status DepthToSpace::Compute(OpKernelContext* context) const {
                              : std::array<Eigen::DenseIndex, IntermediateTensorRank>{{0, 1, 4, 2, 5, 3}};
 
   if (input.IsDataType<float>()) {
-    SpaceDepthOpCpuImpl<float>(input, output, permutation, batch,
-                               dim1, blocksize_, dim3, input_height, input_width,
-                               input_depth / blocksize_ / blocksize_, input_height, blocksize_, input_width, blocksize_);
+    SpaceDepthOpCpuImpl<float>(input, output, permutation,
+                               onnxruntime::narrow<std::ptrdiff_t>(batch),
+                               onnxruntime::narrow<std::ptrdiff_t>(dim1),
+                               onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                               onnxruntime::narrow<std::ptrdiff_t>(dim3),
+                               onnxruntime::narrow<std::ptrdiff_t>(input_height),
+                               onnxruntime::narrow<std::ptrdiff_t>(input_width),
+                               onnxruntime::narrow<std::ptrdiff_t>(input_depth / blocksize_ / blocksize_),
+                               onnxruntime::narrow<std::ptrdiff_t>(input_height),
+                               onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                               onnxruntime::narrow<std::ptrdiff_t>(input_width),
+                               onnxruntime::narrow<std::ptrdiff_t>(blocksize_));
   } else if (input.IsDataType<double>()) {
-    SpaceDepthOpCpuImpl<double>(input, output, permutation, batch,
-                                dim1, blocksize_, dim3, input_height, input_width,
-                                input_depth / blocksize_ / blocksize_, input_height, blocksize_, input_width, blocksize_);
+    SpaceDepthOpCpuImpl<double>(input, output, permutation,
+                                onnxruntime::narrow<std::ptrdiff_t>(batch),
+                                onnxruntime::narrow<std::ptrdiff_t>(dim1),
+                                onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(dim3),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_height),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_width),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_depth / blocksize_ / blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_height),
+                                onnxruntime::narrow<std::ptrdiff_t>(blocksize_),
+                                onnxruntime::narrow<std::ptrdiff_t>(input_width),
+                                onnxruntime::narrow<std::ptrdiff_t>(blocksize_));
   } else {
     // user will not see this as the kernel doesn't claim support for types other than float and double
     return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "Unsupported input type in DepthToSpace op: ", input.DataType());
diff --git a/onnxruntime/core/providers/cpu/tensor/split.cc b/onnxruntime/core/providers/cpu/tensor/split.cc
index d058deb9d3..ca662c1999 100644
--- a/onnxruntime/core/providers/cpu/tensor/split.cc
+++ b/onnxruntime/core/providers/cpu/tensor/split.cc
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+#include <core/common/safeint.h>
 #include "core/providers/cpu/tensor/split.h"
 
 #include "core/common/gsl.h"
@@ -57,13 +58,13 @@ Status SplitBase::PrepareForCompute(const TensorShape& input_shape, int num_outp
   auto input_dims = input_shape.GetDims();
   const auto num_dimensions = gsl::narrow_cast<int64_t>(input_shape.NumDimensions());
   axis = HandleNegativeAxis(axis_, num_dimensions);  // handle negative and enforce axis is valid
-  const int64_t split_dim_size = input_dims[axis];
+  const int64_t split_dim_size = input_dims[onnxruntime::narrow<size_t>(axis)];
 
-  before_dims = narrow<int>(input_shape.SizeToDimension(axis));
-  after_dims_including_split_axis = narrow<int>(input_shape.SizeFromDimension(axis));
+  before_dims = narrow<int>(input_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis)));
+  after_dims_including_split_axis = narrow<int>(input_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis)));
   after_dims_excluding_split = (axis + 1 == num_dimensions)
                                    ? 1  // we multiply by this value so must be 1 not 0
-                                   : narrow<int>(input_shape.SizeFromDimension(axis + 1));
+                                   : narrow<int>(input_shape.SizeFromDimension(SafeInt<size_t>(axis) + 1));
 
   if (split_sizes.empty()) {
     // equal split based on number of outputs
@@ -166,7 +167,7 @@ Status Split::ComputeImpl(OpKernelContext& context, const Tensor& input) const {
   for (int i = 0; i < num_outputs; ++i) {
     // update size of dimension for axis we're splitting on
     auto split_size = narrow<int>(split_sizes[i]);
-    output_dimensions[axis] = split_size;
+    output_dimensions[onnxruntime::narrow<size_t>(axis)] = split_size;
 
     Tensor* output = context.Output(i, TensorShape{output_dimensions});
     T* output_data = output->MutableData<T>();
diff --git a/onnxruntime/core/providers/cpu/tensor/transpose.cc b/onnxruntime/core/providers/cpu/tensor/transpose.cc
index a252186bd7..52f69e114c 100644
--- a/onnxruntime/core/providers/cpu/tensor/transpose.cc
+++ b/onnxruntime/core/providers/cpu/tensor/transpose.cc
@@ -147,7 +147,7 @@ static void DoTransposeImpl(int64_t num_axes, gsl::span<const int64_t> target_di
                             const uint8_t* source, uint8_t* target, size_t element_size) {
   size_t blocksize = num_elts_in_block * element_size;
   MultiIndex mindex;
-  IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, element_size);
+  IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, element_size);
 
   const uint8_t* local_source = source;
   for (size_t i = 0; i < num_blocks; ++i) {
@@ -163,7 +163,7 @@ static void DoTransposeImpl(int64_t num_axes, gsl::span<const int64_t> target_di
                             const std::string* source, std::string* target) {
   ORT_ENFORCE(num_axes > 0, "Transpose not implemented for empty tensors.");
   MultiIndex mindex;
-  IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, 1);
+  IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, 1);
 
   const std::string* local_source = source;
   for (size_t i = 0; i < num_blocks; ++i) {
@@ -187,7 +187,7 @@ static bool TypedDoTransposeEltWise(int64_t num_axes, gsl::span<const int64_t> t
 
   if (enabled) {
     MultiIndex mindex;
-    IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, sizeof(T));
+    IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, sizeof(T));
 
     const uint8_t* local_source = source;
     uint8_t* target_end = target + sizeof(T) * num_blocks;
@@ -235,7 +235,7 @@ static void DoTransposeEltWise(int64_t num_axes, gsl::span<const int64_t> target
                                const gsl::span<const size_t>& stride, const std::string* source, std::string* target) {
   ORT_ENFORCE(num_axes > 0, "Transpose not implemented for empty tensors.");
   MultiIndex mindex;
-  IncrementIndexAndComputeOffsetSetup(mindex, num_axes, target_dims, stride, 1);
+  IncrementIndexAndComputeOffsetSetup(mindex, onnxruntime::narrow<size_t>(num_axes), target_dims, stride, 1);
 
   // index used to iterate over target iteration-space
   const std::string* local_source = source;
@@ -261,7 +261,7 @@ static Status DoUntypedTranspose(const gsl::span<const size_t>& permutations, co
   for (size_t i = 0; i < rank; i++) {
     size_t inpdim = permutations[i];
     if (inpdim + 1 < rank)
-      stride[i] = input_shape.SizeFromDimension(inpdim + 1);
+      stride[i] = onnxruntime::narrow<size_t>(input_shape.SizeFromDimension(inpdim + 1));
     else
       stride[i] = 1;
   }
@@ -273,13 +273,13 @@ static Status DoUntypedTranspose(const gsl::span<const size_t>& permutations, co
   size_t prefix_blocksize = 1;     // product of dimensions in the prefix
   bool is_suffix = true;
 
-  for (int64_t i = rank - 1; i >= 0; --i) {
-    int64_t input_axis = permutations[i];
+  for (int64_t i = SafeInt<int64_t>(rank) - 1; i >= 0; --i) {
+    int64_t input_axis = onnxruntime::narrow<int64_t>(permutations[onnxruntime::narrow<size_t>(i)]);
     if (is_suffix && (input_axis == i)) {
-      suffix_blocksize *= static_cast<size_t>(input_dims[input_axis]);
+      suffix_blocksize *= static_cast<size_t>(input_dims[onnxruntime::narrow<size_t>(input_axis)]);
     } else {
       is_suffix = false;
-      prefix_blocksize *= static_cast<size_t>(input_dims[input_axis]);
+      prefix_blocksize *= static_cast<size_t>(input_dims[onnxruntime::narrow<size_t>(input_axis)]);
       ++num_axes_in_prefix;
     }
   }
diff --git a/onnxruntime/core/providers/cpu/tensor/trilu.cc b/onnxruntime/core/providers/cpu/tensor/trilu.cc
index f11237f9d9..91e429ef60 100644
--- a/onnxruntime/core/providers/cpu/tensor/trilu.cc
+++ b/onnxruntime/core/providers/cpu/tensor/trilu.cc
@@ -7,6 +7,7 @@
 #include "Eigen/src/Core/Map.h"
 #include "trilu.h"
 #include <functional>
+#include <core/common/safeint.h>
 
 using namespace onnxruntime::common;
 
@@ -39,12 +40,12 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
   int64_t X_num_dims = static_cast<int64_t>(X_shape.NumDimensions());
 
   const auto* X_data = reinterpret_cast<const T*>(X->DataRaw());
-  int64_t matrix_h = static_cast<int64_t>(X_shape[X_num_dims - 2]);
-  int64_t matrix_w = static_cast<int64_t>(X_shape[X_num_dims - 1]);
+  int64_t matrix_h = static_cast<int64_t>(X_shape[SafeInt<size_t>(X_num_dims) - 2]);
+  int64_t matrix_w = static_cast<int64_t>(X_shape[SafeInt<size_t>(X_num_dims) - 1]);
 
   int64_t batch_size = 1;
   for (int64_t i = 0; i < X_num_dims - 2; ++i) {
-    batch_size *= X_shape[i];
+    batch_size *= X_shape[onnxruntime::narrow<size_t>(i)];
   }
 
   int64_t num_matrix_elems = matrix_h * matrix_w;
@@ -53,8 +54,8 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
     auto X_batch_data = X_data + (b * num_matrix_elems);
     auto Y_batch_data = Y_data + (b * num_matrix_elems);
 
-    auto input_mat = ConstEigenMatrixMapRowMajor<T>(X_batch_data, matrix_h, matrix_w);
-    auto output_mat = EigenMatrixMapRowMajor<T>(Y_batch_data, matrix_h, matrix_w);
+    auto input_mat = ConstEigenMatrixMapRowMajor<T>(X_batch_data, onnxruntime::narrow<std::ptrdiff_t>(matrix_h), onnxruntime::narrow<std::ptrdiff_t>(matrix_w));
+    auto output_mat = EigenMatrixMapRowMajor<T>(Y_batch_data, onnxruntime::narrow<std::ptrdiff_t>(matrix_h), onnxruntime::narrow<std::ptrdiff_t>(matrix_w));
 
     if (X_batch_data != Y_batch_data) {
       output_mat = input_mat;
@@ -64,14 +65,14 @@ static Status TriluImpl(const Tensor* X, Tensor* Y, int64_t k_val, bool up) {
       int64_t start_i = k_val > 0 ? 0 : 1 - k_val;
       for (int64_t i = start_i; i < matrix_h; i++) {
         for (int64_t j = 0; j < i + k_val && j < matrix_w; j++) {
-          output_mat(i, j) = 0;
+          output_mat(onnxruntime::narrow<std::ptrdiff_t>(i), onnxruntime::narrow<std::ptrdiff_t>(j)) = 0;
         }
       }
     } else {
       int64_t end_i = std::min(matrix_h, matrix_w - k_val);
       for (int64_t i = 0; i < end_i; i++) {
         for (int64_t j = std::max(static_cast<int64_t>(0), i + k_val + 1); j < matrix_w; j++) {
-          output_mat(i, j) = 0;
+          output_mat(onnxruntime::narrow<std::ptrdiff_t>(i), onnxruntime::narrow<std::ptrdiff_t>(j)) = 0;
         }
       }
     }
diff --git a/onnxruntime/core/providers/cpu/tensor/unique.cc b/onnxruntime/core/providers/cpu/tensor/unique.cc
index 8ace7c7281..f42375ae86 100644
--- a/onnxruntime/core/providers/cpu/tensor/unique.cc
+++ b/onnxruntime/core/providers/cpu/tensor/unique.cc
@@ -2,8 +2,8 @@
 // Licensed under the MIT License.
 
 #include "core/providers/cpu/tensor/unique.h"
-
 #include <map>
+#include <core/common/safeint.h>
 #include "core/common/gsl.h"
 #include "core/framework/op_kernel_type_control_utils.h"
 #include "core/providers/common.h"
@@ -116,10 +116,10 @@ class Subtensor {
   Subtensor(const gsl::span<const T>& data, const TensorShape& subtensor_shape,
             int64_t axis, int64_t n_axis, int64_t idx) {
     // rows and columns for the slice along axis, flattened to 2D by merging the dimensions before and after the axis
-    int64_t columns = subtensor_shape.SizeFromDimension(axis);
-    int64_t rows = subtensor_shape.SizeToDimension(axis);
-    items_.reserve(rows * columns);
-    size_t cur_data = idx * columns;  // offset into data for first row of slice
+    int64_t columns = subtensor_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis));
+    int64_t rows = subtensor_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis));
+    items_.reserve(SafeInt<size_t>(rows) * columns);
+    size_t cur_data = SafeInt<size_t>(idx) * columns;  // offset into data for first row of slice
 
     for (int r = 0; r < rows; ++r) {
       for (int c = 0; c < columns; ++c) {
@@ -127,7 +127,7 @@ class Subtensor {
         items_.push_back(data[cur_data + c]);
       }
 
-      cur_data += columns * n_axis;
+      cur_data += SafeInt<size_t>(columns) * n_axis;
     }
   }
 
@@ -169,14 +169,14 @@ static void CreateFlattenedOutput(OpKernelContext& context,
     auto unsorted_idx = offsets_iter->second;
     auto output_idx = sorted ? i : unsorted_idx;
 
-    Y_data[output_idx] = offsets_iter->first;
+    Y_data[onnxruntime::narrow<size_t>(output_idx)] = offsets_iter->first;
 
     if (indices_out) {
-      indices_data[output_idx] = indices[unsorted_idx].front();
+      indices_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].front();
     }
 
     if (counts) {
-      counts_data[output_idx] = indices[unsorted_idx].size();
+      counts_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].size();
     }
   }
 
@@ -184,14 +184,14 @@ static void CreateFlattenedOutput(OpKernelContext& context,
     if (sorted) {
       // need to convert unsorted entries in the inverse index to their sorted values
       std::vector<int64_t> unsorted_to_sorted;
-      unsorted_to_sorted.resize(num_unique);
+      unsorted_to_sorted.resize(onnxruntime::narrow<size_t>(num_unique));
       int64_t sorted_idx = 0;
       for (const auto& offset : offsets) {
-        unsorted_to_sorted[offset.second] = sorted_idx++;
+        unsorted_to_sorted[onnxruntime::narrow<size_t>(offset.second)] = sorted_idx++;
       }
 
       for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
-        inverse_indices_data[i] = unsorted_to_sorted[inverse_index[i]];
+        inverse_indices_data[onnxruntime::narrow<size_t>(i)] = unsorted_to_sorted[onnxruntime::narrow<size_t>(inverse_index[i])];
       }
     } else {
       for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
@@ -212,8 +212,8 @@ static void CreateOutput(OpKernelContext& context,
   int64_t num_unique = static_cast<int64_t>(indices.size());
 
   // rows and columns for the slice along axis, flattened to 2D by merging the dimensions before and after the axis
-  int64_t num_cols = subtensor_shape.SizeFromDimension(axis);
-  int64_t num_rows = subtensor_shape.SizeToDimension(axis);
+  int64_t num_cols = subtensor_shape.SizeFromDimension(onnxruntime::narrow<size_t>(axis));
+  int64_t num_rows = subtensor_shape.SizeToDimension(onnxruntime::narrow<size_t>(axis));
 
   auto subtensor_dims = subtensor_shape.GetDims();
   std::vector<int64_t> Y_dims;
@@ -222,7 +222,7 @@ static void CreateOutput(OpKernelContext& context,
     if (i == axis)
       Y_dims.push_back(num_unique);
     else
-      Y_dims.push_back(subtensor_dims[i]);
+      Y_dims.push_back(subtensor_dims[onnxruntime::narrow<size_t>(i)]);
   }
 
   Tensor& Y = *context.Output(0, TensorShape(std::move(Y_dims)));
@@ -255,23 +255,23 @@ static void CreateOutput(OpKernelContext& context,
     for (int64_t row = 0; row < num_rows; ++row) {
       // copy num_cols items from entries to output
       if (std::is_same<T, std::string>::value) {
-        std::copy(item, item + num_cols, &Y_data[out_offset]);
+        std::copy(item, item + onnxruntime::narrow<size_t>(num_cols), &Y_data[onnxruntime::narrow<size_t>(out_offset)]);
       } else {
-        std::copy_n(item, num_cols, &Y_data[out_offset]);
+        std::copy_n(item, onnxruntime::narrow<size_t>(num_cols), &Y_data[onnxruntime::narrow<size_t>(out_offset)]);
       }
 
-      item += num_cols;
+      item += onnxruntime::narrow<size_t>(num_cols);
       out_offset += num_unique * num_cols;
     }
 
     assert(item == items.cend());
 
     if (indices_out) {
-      indices_data[output_idx] = indices[unsorted_idx].front();
+      indices_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].front();
     }
 
     if (counts) {
-      counts_data[output_idx] = indices[unsorted_idx].size();
+      counts_data[onnxruntime::narrow<size_t>(output_idx)] = indices[onnxruntime::narrow<size_t>(unsorted_idx)].size();
     }
   }
 
@@ -279,14 +279,14 @@ static void CreateOutput(OpKernelContext& context,
     if (sorted) {
       // need to convert unsorted entries in the inverse index to their sorted values
       std::vector<int64_t> unsorted_to_sorted;
-      unsorted_to_sorted.resize(num_unique);
+      unsorted_to_sorted.resize(onnxruntime::narrow<size_t>(num_unique));
       int64_t sorted_idx = 0;
       for (const auto& offset : offsets) {
-        unsorted_to_sorted[offset.second] = sorted_idx++;
+        unsorted_to_sorted[onnxruntime::narrow<size_t>(offset.second)] = sorted_idx++;
       }
 
       for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
-        inverse_indices_data[i] = unsorted_to_sorted[inverse_index[i]];
+        inverse_indices_data[i] = unsorted_to_sorted[onnxruntime::narrow<size_t>(inverse_index[i])];
       }
     } else {
       for (size_t i = 0, end = inverse_index.size(); i < end; ++i) {
@@ -316,16 +316,16 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
     int64_t num_unique = 0;
 
     for (int64_t i = 0, end = input.Shape().Size(); i < end; ++i) {
-      auto entry = offsets.find(data[i]);
+      auto entry = offsets.find(data[onnxruntime::narrow<size_t>(i)]);
       if (entry == offsets.end()) {
-        offsets[data[i]] = num_unique;
+        offsets[data[onnxruntime::narrow<size_t>(i)]] = num_unique;
         inverse_index.push_back({num_unique});
         indices.push_back({i});
         ++num_unique;
       } else {
-        size_t indices_idx = entry->second;
+        size_t indices_idx = onnxruntime::narrow<size_t>(entry->second);
         indices[indices_idx].push_back(i);
-        inverse_index.push_back(indices_idx);
+        inverse_index.push_back(onnxruntime::narrow<int64_t>(indices_idx));
       }
     }
 
@@ -336,9 +336,9 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
     const int64_t axis = HandleNegativeAxis(axis_, input_dims);
 
     std::vector<int64_t> subtensor_dims;
-    subtensor_dims.reserve(input_dims);
+    subtensor_dims.reserve(onnxruntime::narrow<size_t>(input_dims));
     for (int64_t i = 0; i < input_dims; ++i) {
-      subtensor_dims.push_back(i == axis ? 1 : input_shape[i]);
+      subtensor_dims.push_back(i == axis ? 1 : input_shape[onnxruntime::narrow<size_t>(i)]);
     }
 
     TensorShape subtensor_shape(std::move(subtensor_dims));
@@ -351,7 +351,7 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
     inverse_index.reserve(data.size());
 
     int64_t num_unique = 0;
-    int64_t n_axis = input_shape[axis];
+    int64_t n_axis = input_shape[onnxruntime::narrow<size_t>(axis)];
 
     for (int64_t i = 0; i < n_axis; ++i) {
       Subtensor<T> s(data, subtensor_shape, axis, n_axis, i);
@@ -363,9 +363,9 @@ Status Unique::ComputeImpl(OpKernelContext& context) const {
         indices.push_back({i});
         ++num_unique;
       } else {
-        size_t indices_idx = entry->second;
+        size_t indices_idx = onnxruntime::narrow<size_t>(entry->second);
         indices[indices_idx].push_back(i);
-        inverse_index.push_back(indices_idx);
+        inverse_index.push_back(onnxruntime::narrow<int64_t>(indices_idx));
       }
     }
 
diff --git a/onnxruntime/core/providers/cpu/tensor/unsqueeze.cc b/onnxruntime/core/providers/cpu/tensor/unsqueeze.cc
index de4125763a..9a21f4bd10 100644
--- a/onnxruntime/core/providers/cpu/tensor/unsqueeze.cc
+++ b/onnxruntime/core/providers/cpu/tensor/unsqueeze.cc
@@ -62,12 +62,12 @@ Status UnsqueezeBase::PrepareCompute(OpKernelContext* ctx, Prepare& p) const {
   // Set all axes indices to 1 in output_dims and check for duplicates
   for (int64_t axis : axes) {
     // Valid axis range is [0, output_rank - 1]
-    axis = HandleNegativeAxis(axis, output_dims.size());
+    axis = HandleNegativeAxis(axis, onnxruntime::narrow<int64_t>(output_dims.size()));
     if (axis < 0 || axis >= static_cast<int64_t>(output_dims.size()))
       return Status(ONNXRUNTIME, INVALID_ARGUMENT, "'axes' has an out of range axis");
-    if (output_dims[axis] != 0)
+    if (output_dims[onnxruntime::narrow<size_t>(axis)] != 0)
       return Status(ONNXRUNTIME, INVALID_ARGUMENT, "'axes' has a duplicate axis");
-    output_dims[axis] = 1;
+    output_dims[onnxruntime::narrow<size_t>(axis)] = 1;
   }
 
   // Now fill in the zero entries with the existing shape
diff --git a/onnxruntime/core/providers/cpu/tensor/upsample.cc b/onnxruntime/core/providers/cpu/tensor/upsample.cc
index 1d4cf65c60..f72e24b0db 100644
--- a/onnxruntime/core/providers/cpu/tensor/upsample.cc
+++ b/onnxruntime/core/providers/cpu/tensor/upsample.cc
@@ -66,7 +66,7 @@ static std::vector<int64_t> UpsampleNearestSetupRank1InputMapping(
     bool extrapolation_enabled,
     const GetOriginalCoordinateFunc& get_original_coordinate,
     const GetNearestPixelFunc& get_nearest_pixel) {
-  std::vector<int64_t> input_mapping(length_resized);
+  std::vector<int64_t> input_mapping(onnxruntime::narrow<size_t>(length_resized));
 
   for (int64_t output_dim0_idx = 0; output_dim0_idx < length_resized; ++output_dim0_idx) {
     float original_0_idx = get_original_coordinate(static_cast<float>(output_dim0_idx),
@@ -234,7 +234,7 @@ static Status UpsampleNearestImpl(const T* input,
     return Status::OK();
   }
 
-  std::vector<int64_t> output_dim_counter(n_dim);
+  std::vector<int64_t> output_dim_counter(onnxruntime::narrow<size_t>(n_dim));
   for (int64_t dim_idx = 0; dim_idx < n_dim; dim_idx++) {
     input_idx += input_mappings[narrow<size_t>(dim_idx)][0 /* output_dim_counter[narrow<size_t>(dim_idx)] */];
   }
diff --git a/onnxruntime/core/providers/cpu/tensor/upsamplebase.h b/onnxruntime/core/providers/cpu/tensor/upsamplebase.h
index 93223b686b..e13bff6fac 100644
--- a/onnxruntime/core/providers/cpu/tensor/upsamplebase.h
+++ b/onnxruntime/core/providers/cpu/tensor/upsamplebase.h
@@ -5,6 +5,8 @@
 
 #include <string>
 #include <vector>
+#include <core/common/safeint.h>
+#include <core/common/narrow.h>
 #ifndef SHARED_PROVIDER
 #include "core/framework/op_kernel.h"
 #endif
@@ -318,17 +320,17 @@ class UpsampleBase {
     int64_t scales_size = scale->Shape().Size();
     ORT_ENFORCE(scales_size > 0, "scales size should be greater than 0.");
     if (scales.empty()) {
-      scales.resize(scales_size);
+      scales.resize(onnxruntime::narrow<size_t>(scales_size));
     }
-    memcpy(scales.data(), scale_data, scales_size * sizeof(float));
+    memcpy(scales.data(), scale_data, SafeInt<size_t>(scales_size) * sizeof(float));
     ScalesValidation(scales, mode_);
   }
 
   void ParseRoiData(const Tensor* roi, std::vector<float>& roi_array) const {
     int64_t roi_size = roi->Shape().Size();
     if (roi_size > 0) {
-      roi_array.resize(roi_size);
-      memcpy(roi_array.data(), roi->Data<float>(), roi_size * sizeof(float));
+      roi_array.resize(onnxruntime::narrow<size_t>(roi_size));
+      memcpy(roi_array.data(), roi->Data<float>(), SafeInt<size_t>(roi_size) * sizeof(float));
     }
   }
 
diff --git a/onnxruntime/core/util/qmath.h b/onnxruntime/core/util/qmath.h
index 34c68ea4ff..9d14b5dcc0 100644
--- a/onnxruntime/core/util/qmath.h
+++ b/onnxruntime/core/util/qmath.h
@@ -5,7 +5,7 @@
 
 #include "core/mlas/inc/mlas.h"
 #include "core/platform/threadpool.h"
-
+#include "core/common/narrow.h"
 #include <cmath>
 
 namespace onnxruntime {
@@ -51,12 +51,12 @@ void GetQuantizationParameter(const float* data, int64_t num_of_elements, float&
   std::ptrdiff_t block_size;
   std::ptrdiff_t num_blocks;
   if (concurrency::ThreadPool::ShouldParallelize(thread_pool) && num_of_elements > granularity) {
-    block_size = (num_of_elements + MAX_DEGREE_OF_PAR_FOR_MINMAX - 1) / MAX_DEGREE_OF_PAR_FOR_MINMAX;
+    block_size = onnxruntime::narrow<std::ptrdiff_t>((num_of_elements + MAX_DEGREE_OF_PAR_FOR_MINMAX - 1) / MAX_DEGREE_OF_PAR_FOR_MINMAX);
     block_size = (block_size + granularity - 1) / granularity * granularity;
-    num_blocks = (num_of_elements + block_size - 1) / block_size;
+    num_blocks = onnxruntime::narrow<std::ptrdiff_t>((num_of_elements + block_size - 1) / block_size);
   } else {
     num_blocks = 1;
-    block_size = num_of_elements;
+    block_size = onnxruntime::narrow<std::ptrdiff_t>(num_of_elements);
   }
 
   for (int i = 0; i < num_blocks; i++) {