Оптимизация кода с массивом

for (int pye=0; pye<(1103-104+1); pye++)
                {
                   for (int pxe=0; pxe<(1103-104+1); pxe++)
                  {
                    int ert = 0;
                    double summa_FragmentMassiv1 = 0;
                    double summa_FragmentMassiv2 = 0;
                    for (int o=pye; o<(pye+104);o++)
                         {
                            int egb = 0;
             for (int l=pxe; l<(pxe+104);l++)
                {
            summa_FragmentMassiv1+=Massiv1[o,l]*VesPF[ert,egb];
                                  summa_FragmentMassiv2+=Massiv2[o,l]*VesPF[ert,egb];                       
                   egb++;
                }
            ert++;
                   }
                     MassivRandn1[pye,pxe]=summa_FragmentMassiv1;
                     MassivRandn2[pye,pxe]=summa_FragmentMassiv2;
                   
                  }                
                }

private static void Main(string[] args)
        {
            Stopwatch sw= new Stopwatch();
            sw.Start();
            for (long pye = 0; pye < 10000000000; pye++)
            {
                int d = 2344*42342;
                int c = 244 * 42342;
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
            Console.ReadLine();
        }

for (long pye = 0; pye < 500; pye++)
   {
       for (long j = 0; j < 10000000; j++)
       {
           int a = 400*753;
       }
    }

Parallel.For(0, 500, x =>
    {
        for (long j = 0; j < 10000000; j++)
        {
            int a = 400 * 753;
        }
    });

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace _1036069
{
    public class DataElement
    {
        public DataElement(int x, int y, int width, int height)
        {
            X1 = x;
            X2 = x + width;
            Y1 = y;
            Y2 = y + height;
            Width = width;
            Height = height;
        }
 
        public int X1 { get; set; }
        public int X2 { get; set; }
        public int Y1 { get; set; }
        public int Y2 { get; set; }
        public int Width { get; set; }
        public int Height { get; set; }
        public double Result { get; set; }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            int dataWidth = 1003, dataHeight = 1017, filterWidth = 4, filterHeight = 9;
            double[,] data = new double[dataWidth, dataHeight];
            double[,] filter = new double[filterWidth, filterHeight];
            double[,] result = new double[dataWidth, dataHeight];
            Random random = new Random();
            for (var x = 0; x < dataWidth; x++)
                for (var y = 0; y < dataHeight; y++)
                    data[x, y] = Math.Round(random.NextDouble()*10,3);
            for (var x = 0; x < filterWidth; x++)
                for (var y = 0; y < filterHeight; y++)
                    filter[x, y] = Math.Round(random.NextDouble() * 10, 3);
            var dataWidthLimit = dataWidth - filterWidth;
            var dataHeightLimit = dataHeight - filterHeight;
            var dataElements = new List<DataElement>();
            for (var x = 0; x < dataWidthLimit; x++)
                for (var y = 0; y < dataHeightLimit; y++)
                    dataElements.Add(new DataElement(x, y, filterWidth, filterHeight));
            long start = DateTime.Now.Ticks;
            dataElements.AsParallel().ForAll(element =>
                {
                    for (var x=0; x<element.Width;x++)
                        for (var y = 0; y < element.Height; y++)
                            element.Result = element.Result + data[element.X1 + x, element.Y1 + y] / filter[x, y];
                    result[element.X1, element.Y2] = element.Result;
                    Console.WriteLine("{0}, {1}; Result: {2}", element.X1, element.Y1, element.Result);
                });
            long end = DateTime.Now.Ticks;
            Console.WriteLine("Время обработки: {0} сек", new TimeSpan(end - start));
            Console.ReadLine();
        }
    }
}

  static Tuple<int, int, int>[] ArrayIndex(int lengthChild, int lengthInit, out int cres)
        {
            Tuple<int, int, int>[] result = new Tuple<int, int, int>[cres = (int)Math.Pow(lengthInit - lengthChild + 1, 2)];
            for (int i = 0, index = 0, count = 0; i < result.Length; i++,
                new Action(() =>
                {
                    if (index + 1 + lengthChild <= lengthInit) index++;
                    else
                    {
                        index = 0;
                        count++;
                    }
                })()
                )
            {
                result[i] = new Tuple<int, int, int>(count, index, i);
            }
            return result;
        }
 
        static void Main(string[] args)
        {
            //init
            int[,] init = new int[1000, 1000];
            int lengthRectangle = 10;
            Parallel.For(0, 1000, _ =>
            {
                Parallel.For(0, 1000, __ =>
                {
                    init[_, __] = _+__;
                });
            });
 
            //calculation
            Console.WriteLine("start");
            var t = System.Diagnostics.Stopwatch.StartNew();
            int countRectangles;
            var initArray = ArrayIndex(lengthRectangle, init.GetLength(0), out countRectangles);
            long[] sum = new long[countRectangles];
 
            Parallel.ForEach(initArray, index =>
            {
                long sumIn = 0;
                for (int i = index.Item1; i < index.Item1 + lengthRectangle; i++)
                    for (int j = index.Item2; j < index.Item2 + lengthRectangle; j++) sumIn += init[i, j];
                sum[index.Item3] = sumIn;
            }
            );
            t.Stop();
 
            //output
               Console.WriteLine(t.ElapsedMilliseconds+"mc "+initArray.Length+" rectangles");