C#

long l1 = 500;
long l2 = long.MaxValue;
long l3 = 568678;

Console.WriteLine("Value1\tValue2");
Console.WriteLine("--------------");
Console.WriteLine("{0}\t{1}", l1, l3);
Console.WriteLine("{0}\t{1}", l2, l3);

Value1  Value2
--------------
500     568678
9223372036854775807     568678

long l1 = 500;
long l2 = long.MaxValue;
long l3 = 568678;
Console.WriteLine("Value1\t\t\tValue2");
            Console.WriteLine("------------------------------");
Console.WriteLine("{0}\t\t\t{1}", l1, l3);
Console.WriteLine("{0}\t{1}", l2, l3);

Value1                  Value2
------------------------------
500                     568678
9223372036854775807     568678

public partial class Equipment : UserControl
{
    public Equipment(){InitializeComponent();}
    string path = Application.StartupPath;
    PictureBox pictureBox3429= new PictureBox();

    public void Equipment_Load(object sender, EventArgs e)
    {
        panel1.BackgroundImage = Image.FromFile(path + "\\unit.jpg");
        try
        {
            //second variant, same problem:
            //pictureBox3429.Load(path + "\\mechhero.com\\unit.jpg");
            //panel1.BackgroundImage = pictureBox3429.Image;
        }
        catch (Exception) { throw; }
    }
}

class VectorSafeConcurency
    {
        int[] V;
        const int sizeV = 100000;
        //Stack<int> numbers = new Stack<int>();

        void push2(Stack<int> s, int a, int b)
        {
            s.Push(b);
            s.Push(a);
        }

        public VectorSafeConcurency()
        {
            V= new int[sizeV];

            int value= sizeV;

            for (int i = 0; i < sizeV; ++i)
                V[i] = value--;
        }

        void exchange(ref int x, ref int y)
        {
            int temp= x; 
            x= y;
            y= temp;
        }

        int partition(int[] A, int l, int r)
        {
            int i = l - 1;
            int j = r;
            int v= A[r];

            for(;;)
            {
                while(A[++i] <v);
                while (v < A[--j]) if (j == l) break;
                if (i >= j) break;
                exchange(ref A[i], ref A[j]);
            }
            exchange(ref A[i], ref A[r]);
            return i;
        }

        struct ThData
        {
            public int[] A;
            public int l;
            public int r;

            public ThData(int []a, int i, int j)
            {
                A = a; l = i; r = j;
            }
        }


        void thWorkerParititoner(object data)
        {
            int[] A = ((ThData)data).A;
            int l = ((ThData)data).l;
            int r = ((ThData)data).r;

            quicksort(A, l, r);
        }


        void StartQuicksort(int[] A, int l, int r)
        {
            if (r <= l) return;
            int i = partition(A, l, r);

            Thread t1 = new Thread(thWorkerParititoner);
            t1.Start(new ThData (A, l, i-1));

            Thread t2 = new Thread(thWorkerParititoner);
            t2.Start(new ThData(A, i+1, r));
            //start th 1
            //start th2
        }

        void quicksort(int[] A, int l, int r)
        {
            Stack<int> Indexes = new Stack<int>();
            push2(Indexes, l, r);

            while (Indexes.Count > 0)
            {
                l = Indexes.Pop(); r = Indexes.Pop();

                if (r <= l) continue;
                int i = partition(V, l, r);

                push2(Indexes, l, i - 1);
                push2(Indexes, i + 1, r);
            }
        }

        public void StartSort()
        {
            quicksort(V, 0, V.Length - 1);

            int d = 1;
        }
    }