diff --git a/orttraining/orttraining/training_ops/cuda/tensor/concat.cc b/orttraining/orttraining/training_ops/cuda/tensor/concat.cc
index c753489ba0..b1b8a95ae3 100644
--- a/orttraining/orttraining/training_ops/cuda/tensor/concat.cc
+++ b/orttraining/orttraining/training_ops/cuda/tensor/concat.cc
@@ -3,8 +3,10 @@
 
 #include "orttraining/training_ops/cuda/tensor/concat.h"
 #include "core/providers/cuda/tensor/concat_impl.h"
+
 namespace onnxruntime {
 namespace cuda {
+
 ONNX_OPERATOR_KERNEL_EX(ConcatTraining,
                         kMSDomain,
                         1,
@@ -28,8 +30,9 @@ Status ConcatTraining::ComputeInternal(OpKernelContext* ctx) const {
   ORT_RETURN_IF_ERROR(PrepareForCompute(ctx, input_tensors, p));
 
   // Return at this point if output tensor is going to be empty
-  if (p.output_num_elements == 0)
+  if (p.output_num_elements == 0) {
     return Status::OK();
+  }
 
   std::vector<int64_t> concat_sizes(input_count);
 
@@ -58,28 +61,27 @@ Status ConcatTraining::ComputeInternal(OpKernelContext* ctx) const {
       // pass by value to avoid host-to-device copy on same stream
       TArray<const void*, 32> input_table(input_count);
       for (int i = 0; i < input_count; ++i) {
-	input_table[i] = input_ptr_cpuspan[i];
+        input_table[i] = input_ptr_cpuspan[i];
       }
       ORT_RETURN_IF_ERROR(ConcatSameConcatDimImpl(Stream(),
-                                 element_bytes,
-                                 block_size_including_axis_dim,
-                                 block_size_inside_axis_dim,
-                                 concat_sizes[0],
-                                 p.output_tensor->MutableDataRaw(),
-                                 input_table,
-                                 p.output_num_elements));
- 
+                                                  element_bytes,
+                                                  block_size_including_axis_dim,
+                                                  block_size_inside_axis_dim,
+                                                  concat_sizes[0],
+                                                  p.output_tensor->MutableDataRaw(),
+                                                  input_table,
+                                                  p.output_num_elements));
     } else {
       // too many inputs, so copy sizes to device memory
       ORT_RETURN_IF_ERROR(input_ptr.CopyToGpu());
       ORT_RETURN_IF_ERROR(ConcatSameConcatDimImpl(Stream(),
-                                 element_bytes,
-                                 block_size_including_axis_dim,
-                                 block_size_inside_axis_dim,
-                                 concat_sizes[0],
-                                 p.output_tensor->MutableDataRaw(),
-                                 input_ptr.GpuPtr(),
-                                 p.output_num_elements));
+                                                  element_bytes,
+                                                  block_size_including_axis_dim,
+                                                  block_size_inside_axis_dim,
+                                                  concat_sizes[0],
+                                                  p.output_tensor->MutableDataRaw(),
+                                                  input_ptr.GpuPtr(),
+                                                  p.output_num_elements));
     }
   } else {
     // input sizes vary, copy input sizes and range metadata to device
@@ -93,15 +95,15 @@ Status ConcatTraining::ComputeInternal(OpKernelContext* ctx) const {
     ORT_RETURN_IF_ERROR(concat_sizes_range_gpu.CopyToGpu());
 
     ORT_RETURN_IF_ERROR(ConcatImpl(Stream(),
-                                  element_bytes,
-                                  block_size_including_axis_dim,
-                                  block_size_inside_axis_dim,
-                                  concat_sizes_gpu.GpuPtr(),
-                                  concat_sizes_range_gpu.GpuPtr(),
-                                  axis_dimension_input_output_mapping_gpu.GpuPtr(),
-                                  p.output_tensor->MutableDataRaw(),
-                                  input_ptr.GpuPtr(),
-                                  p.output_num_elements));
+                                   element_bytes,
+                                   block_size_including_axis_dim,
+                                   block_size_inside_axis_dim,
+                                   concat_sizes_gpu.GpuPtr(),
+                                   concat_sizes_range_gpu.GpuPtr(),
+                                   axis_dimension_input_output_mapping_gpu.GpuPtr(),
+                                   p.output_tensor->MutableDataRaw(),
+                                   input_ptr.GpuPtr(),
+                                   p.output_num_elements));
   }
 
   // Create optional output tensor for 'per_input_length'
@@ -112,5 +114,6 @@ Status ConcatTraining::ComputeInternal(OpKernelContext* ctx) const {
 
   return Status::OK();
 }
+
 }  // namespace cuda
 }  // namespace onnxruntime