Ejemplo n.º 1
0
        static AddToTree.Tree MulTowDivisionCalculator(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
        {
            if (Dummy == null)
            {
                return(Dummy);
            }
            //int INCREASE = 2147483647;
            UIS.SetProgressValue(UIS.progressBar6, 0);
            if (IS.IsMul(Dummy.SampleAccess))
            {
                if (IS.IsDiv(Dummy.LeftSideAccess.SampleAccess) && IS.IsDiv(Dummy.RightSideAccess.SampleAccess))
                {
                    AddToTree.Tree MUL = new AddToTree.Tree(null, false);
                    MUL = Dummy.CopyNewTree(Dummy.LeftSideAccess.RightSideAccess);
                    Dummy.LeftSideAccess.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess.LeftSideAccess), Dummy.CopyNewTree(Dummy.RightSideAccess.LeftSideAccess));
                    Dummy.LeftSideAccess.SampleAccess = "*";
                    Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess  = Dummy.LeftSideAccess;
                    Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;

                    Dummy.SampleAccess = "/";

                    Dummy.RightSideAccess.SetLefTandRightCommonlySide(MUL, Dummy.CopyNewTree(Dummy.RightSideAccess.RightSideAccess));
                    Dummy.RightSideAccess.SampleAccess = "*";
                    Dummy.RightSideAccess.LeftSideAccess.ThreadAccess  = Dummy.RightSideAccess;
                    Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess;
                }
                UIS.SetProgressValue(UIS.progressBar6, 2147483647);

/*                else
 *                  if (IS.IsDiv(Dummy.LeftSideAccess.SampleAccess))
 *                  {
 *                      AddToTree.Tree MUL = new AddToTree.Tree(null, false);
 *                      MUL = Dummy.CopyNewTree(Dummy.RightSideAccess);
 *                      Dummy.RightSideAccess = Dummy.LeftSideAccess.RightSideAccess;
 *                      Dummy.RightSideAccess.ThreadAccess = Dummy;
 *
 *                      Dummy.SampleAccess = "/";
 *
 *                      Dummy.LeftSideAccess.RightSideAccess = MUL;
 *                      Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;
 *                      Dummy.LeftSideAccess.SampleAccess = "*";
 *
 *
 *                  }
 *                  else
 *                      if (IS.IsDiv(Dummy.RightSideAccess.SampleAccess))
 *                      {
 *                          Dummy.SetLefTandRightCommonlySide(Dummy.RightSideAccess,Dummy.LeftSideAccess);
 *
 *                          AddToTree.Tree MUL = new AddToTree.Tree(null, false);
 *                          MUL = Dummy.CopyNewTree(Dummy.RightSideAccess);
 *                          Dummy.RightSideAccess = Dummy.LeftSideAccess.RightSideAccess;
 *                          Dummy.RightSideAccess.ThreadAccess = Dummy;
 *
 *                          Dummy.SampleAccess = "/";
 *
 *                          Dummy.LeftSideAccess.RightSideAccess = MUL;
 *                          Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;
 *                          Dummy.LeftSideAccess.SampleAccess = "*";
 *
 *
 *                      }
 */
            }
            MulTowDivision.MulTowDivisionCalculator(Dummy.LeftSideAccess, ref UIS);
            MulTowDivision.MulTowDivisionCalculator(Dummy.RightSideAccess, ref UIS);
            return(Dummy);
        }
        static AddToTree.Tree SuitableToSimplifierLocalThatDivIsLocatedAtUp(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool MulTrueDivFalse, ref bool SimplifiedTrueOtherWiseFalse, ref float Num, ref bool RETURNED)
        {
            if (Dummy == null)
            {
                return(Dummy);
            }
            if (RETURNED)
            {
                return(Dummy);
            }
            try
            {
                if (IS.IsMul(Dummy.SampleAccess))
                {
                    //if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified))
                    if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified.RightSideAccess))
                    {
                        if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
                        {
                            Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess);
                            try
                            {
                                if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
                                {
                                    RETURNED = true;
                                    SimplifiedTrueOtherWiseFalse = true;
                                    MulTrueDivFalse = true;
                                    Dummy.SetLefTandRightCommonlySide(null, null);
                                    Dummy.SampleAccess = "1";
                                    Suitable           = true;
                                    return(Dummy);
                                }
                            }
                            catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
                        }

                        /*else
                         * {  //ERRORCORECTION13175402 :Considerable.
                         *  RETURNED = true;
                         *  SimplifiedTrueOtherWiseFalse = true;
                         *  MulTrueDivFalse = true;
                         *  Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
                         *  Dummy.RightSideAccess.SampleAccess = "1";
                         *  Suitable = true;
                         *  Num = 1;
                         *  return Dummy;
                         * }
                         */
                    }
                    else
                    if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified.RightSideAccess))
                    {
                        if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess))
                        {
                            Num = (float)System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess);
                            try
                            {
                                if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "/") && (Dummy.ThreadAccess.SampleAccess == "*"))
                                {
                                    RETURNED = true;
                                    SimplifiedTrueOtherWiseFalse = true;
                                    MulTrueDivFalse = true;
                                    Dummy.SetLefTandRightCommonlySide(null, null);
                                    Dummy.SampleAccess = "1";
                                    Suitable           = true;
                                    return(Dummy);
                                }
                            }
                            catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
                        }

                        /*else
                         * {//ERRORCORECTION13175402 :Considerable.
                         *  SimplifiedTrueOtherWiseFalse = true;
                         *  MulTrueDivFalse = true;
                         *  Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
                         *  Dummy.LeftSideAccess.SampleAccess = "1";
                         *  Suitable = true;
                         *  Num = 1;
                         *  return Dummy;
                         * }*/
                    }
                }
                else
                {
                    RETURNED = true;
                    return(Dummy);
                }
            }
            catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
            LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtUp(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
            LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtUp(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
            return(Dummy);
        }
 static AddToTree.Tree SuitableToSimplifierLocalThatDivIsLocatedAtDown(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool MulTrueDivFalse, ref bool SimplifiedTrueOtherWiseFalse, ref float Num, ref bool RETURNED)
 {
     if (Dummy == null)
     {
         return(Dummy);
     }
     if (RETURNED)
     {
         return(Dummy);
     }
     try
     {
         if (IS.IsMul(Dummy.SampleAccess))
         {
         }
         else
         if (IS.IsDiv(Dummy.SampleAccess))
         {
             if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified.RightSideAccess)) && (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess)))
             {
                 Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess);
                 try
                 {
                     if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "*") && (Dummy.SampleAccess == "/"))
                     {
                         RETURNED = true;
                         SimplifiedTrueOtherWiseFalse = true;
                         MulTrueDivFalse = false;
                         Dummy.SetLefTandRightCommonlySide(null, null);
                         Dummy.SampleAccess = "1";
                     }
                 }
                 catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
                 Suitable = true;
             }
             else
             if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess.LeftSideAccess, ToSimplified.RightSideAccess)) && (IS.IsMul(Dummy.RightSideAccess.SampleAccess) && (Dummy.SampleAccess == "/")))
             {        //ERRORCORECTION9812737 Private state for Page 292.
                 try
                 {
                     if ((ToSimplified.ThreadAccess.SampleAccess == "*"))
                     {
                         RETURNED = true;
                         SimplifiedTrueOtherWiseFalse = true;
                         MulTrueDivFalse = false;
                         Dummy.RightSideAccess.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
                         Dummy.RightSideAccess.LeftSideAccess.SampleAccess = "1";
                         Num = 1;
                     }
                 }
                 catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
             }
             else
             {
                 Suitable = false;
                 return(Dummy);
             }
         }
         else
         {
             RETURNED = true;
             return(Dummy);
         }
     }
     catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
     LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtDown(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
     LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtDown(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
     return(Dummy);
 }
Ejemplo n.º 4
0
        static AddToTree.Tree NumberDivMulFxAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
        {
            if (Dummy == null)
            {
                return(Dummy);
            }
            Dummy.LeftSideAccess  = NumberDivMul.NumberDivMulFxAction(Dummy.LeftSideAccess, ref UIS);
            Dummy.RightSideAccess = NumberDivMul.NumberDivMulFxAction(Dummy.RightSideAccess, ref UIS);
            int INCREASE = 2147483647 / 6;

            try
            {
                UIS.SetProgressValue(UIS.progressBar15, 0);

                if (IS.IsMul(Dummy.SampleAccess))
                {
                    if (IS.IsMul(Dummy.RightSideAccess.SampleAccess))
                    {
                        if (IS.IsNumber(Dummy.RightSideAccess.LeftSideAccess.SampleAccess))
                        {
                            if (Dummy.LeftSideAccess.SampleAccess.ToLower() == "c")
                            {
                                Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy;
                                Dummy.RightSideAccess = Dummy.RightSideAccess.RightSideAccess;
                            }
                        }
                    }
                }
                UIS.SetProgressValue(UIS.progressBar15, INCREASE + UIS.progressBar15.Value);
                if (IS.IsDiv(Dummy.SampleAccess))
                {
                    if (IS.IsMul(Dummy.LeftSideAccess.SampleAccess))
                    {
                        if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess))
                        {
                            if (IS.IsNumber(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess))
                            {
                                //ERRORCORECTION981273 :The Error corrected.refer to page218.
                                float Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess);
                                Num = Num / (float)System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess);
                                Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = Num.ToString();
                                Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
                                Dummy = Dummy.LeftSideAccess;
                            }
                        }
                    }
                }
                UIS.SetProgressValue(UIS.progressBar15, INCREASE + UIS.progressBar15.Value);
                if (IS.IsMul(Dummy.SampleAccess))
                {
                    if (IS.IsMul(Dummy.RightSideAccess.SampleAccess))
                    {
                        if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
                        {
                            if (IS.IsNumber(Dummy.RightSideAccess.LeftSideAccess.SampleAccess))
                            {
                                //ERRORCORECTION981273 :The Error corrected.refer to page218.
                                if (Dummy.LeftSideAccess.SampleAccess.ToLower() != "c")
                                {
                                    if (Dummy.RightSideAccess.SampleAccess.ToLower() != "c")
                                    {
                                        float Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess);
                                        Num = Num * (float)System.Convert.ToDouble(Dummy.RightSideAccess.LeftSideAccess.SampleAccess);
                                        Dummy.LeftSideAccess.SampleAccess = Num.ToString();
                                        Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess.ThreadAccess;
                                        Dummy.RightSideAccess = Dummy.RightSideAccess.RightSideAccess;
                                    }
                                    else
                                    {
                                        Dummy.LeftSideAccess.SampleAccess = "C";
                                    }
                                }
                            }
                        }
                    }
                }
                UIS.SetProgressValue(UIS.progressBar15, INCREASE + UIS.progressBar15.Value);
                if (IS.IsDiv(Dummy.SampleAccess))
                {
                    if (IS.IsMul(Dummy.LeftSideAccess.SampleAccess))
                    {
                        if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess))
                        {
                            if (IS.IsNumber(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess))
                            {
                                //ERRORCORECTION981273 :The Error corrected.refer to page218.
                                float Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess);
                                Num = Num / (float)System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess);
                                Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = Num.ToString();
                                Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                Dummy = Dummy.LeftSideAccess;
                            }
                        }
                    }
                }
                UIS.SetProgressValue(UIS.progressBar15, INCREASE + UIS.progressBar15.Value);
                //ADDCONDITION18979714 :Refer to page 248.
                if (Dummy.SampleAccess == "/")
                {
                    if (Dummy.LeftSideAccess.SampleAccess == "*")
                    {
                        if (Dummy.RightSideAccess.SampleAccess == "*")
                        {
                            if (IS.IsNumber(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess))
                            {
                                if (IS.IsNumber(Dummy.RightSideAccess.LeftSideAccess.SampleAccess))
                                {
                                    if ((Dummy.RightSideAccess.LeftSideAccess.SampleAccess.ToLower() != "c") && ((Dummy.LeftSideAccess.LeftSideAccess.SampleAccess.ToLower() != "c")))
                                    {
                                        float Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess);
                                        Num = Num / (float)System.Convert.ToDouble(Dummy.RightSideAccess.LeftSideAccess.SampleAccess);
                                        Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = Num.ToString();
                                    }
                                    else
                                    {
                                        Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = "C";
                                    }
                                    Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy;
                                    Dummy.RightSideAccess = Dummy.RightSideAccess.RightSideAccess;
                                }
                            }
                        }
                    }
                }
                UIS.SetProgressValue(UIS.progressBar15, INCREASE + UIS.progressBar15.Value);
                if (Dummy.SampleAccess == "*")
                {
                    if (Dummy.LeftSideAccess.SampleAccess == "*")
                    {
                        if (Dummy.RightSideAccess.SampleAccess == "*")
                        {
                            if (IS.IsNumber(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess))
                            {
                                if (IS.IsNumber(Dummy.RightSideAccess.LeftSideAccess.SampleAccess))
                                {
                                    if ((Dummy.RightSideAccess.LeftSideAccess.SampleAccess.ToLower() != "c") && ((Dummy.LeftSideAccess.LeftSideAccess.SampleAccess.ToLower() != "c")))
                                    {
                                        float Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess);
                                        Num = Num * (float)System.Convert.ToDouble(Dummy.RightSideAccess.LeftSideAccess.SampleAccess);
                                        Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = Num.ToString();
                                    }
                                    else
                                    {
                                        Dummy.LeftSideAccess.LeftSideAccess.SampleAccess = "C";
                                    }
                                    Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy;
                                    Dummy.RightSideAccess = Dummy.RightSideAccess.RightSideAccess;
                                }
                            }
                        }
                    }
                }
            }
            catch (NullReferenceException t)
            { ExceptionClass.ExceptionClassMethod(t); }
            UIS.SetProgressValue(UIS.progressBar15, 2147483647);
            return(Dummy);
        }
        static AddToTree.Tree SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool DivTrueMulFalse, ref bool SimplifiedTrueOtherWiseFalse)
        {
            if (Dummy == null)
            {
                return(Dummy);
            }
            try
            {
                if (IS.IsMul(Dummy.SampleAccess))
                {
                    //if (Dummy.FINDTreeWithThreadConsideration(ToSimplified, Dummy.LeftSideAccess) == null)
                    if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified))
                    {
                        try
                        {
                            if ((ToSimplified.ThreadAccess.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
                            {
                                SimplifiedTrueOtherWiseFalse = true;
                                DivTrueMulFalse = true;
                                //LOCATION81726487 :refer to page 265.
                                AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
                                //Dummy = Dummy.ThreadAccess;

                                /*if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess,HOLDER))
                                 * {
                                 *  Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
                                 *  Dummy.RightSideAccess.SampleAccess = "1";
                                 * }
                                 * else
                                 */
                                //if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess,HOLDER))
                                //{
                                Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
                                Dummy.LeftSideAccess.SampleAccess = "1";
                                //}
                            }

                            /*else
                             * if ((ToSimplified.ThreadAccess.SampleAccess == "*") && (Dummy.ThreadAccess.SampleAccess == "/"))
                             * {
                             *    SimplifiedTrueOtherWiseFalse = true;
                             *    DivTrueMulFalse = false;
                             *    //LOCATION81987526487 :refer to page 265.
                             *    AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
                             *    //Dummy = Dummy.ThreadAccess;
                             *    if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
                             *    {
                             *        Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
                             *        Dummy.RightSideAccess.SampleAccess = "1";
                             *    }
                             *    else
                             *        if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
                             *        {
                             *            Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
                             *            Dummy.LeftSideAccess.SampleAccess = null;
                             *        }
                             *
                             *
                             * }*/
                        }
                        catch (NullReferenceException t)
                        { ExceptionClass.ExceptionClassMethod(t); }
                    }
                    else
                    //if (Dummy.FINDTreeWithThreadConsideration(ToSimplified, Dummy.RightSideAccess) == null)
                    if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified))
                    {
                        try
                        {
                            if ((ToSimplified.ThreadAccess.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
                            {
                                SimplifiedTrueOtherWiseFalse = true;
                                DivTrueMulFalse = true;
                                //LOCATION81726487 :refer to page 265.
                                AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
                                Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
                                Dummy.RightSideAccess.SampleAccess = "1";
                                Suitable = true;
                            }
                        }
                        catch (NullReferenceException t)
                        { ExceptionClass.ExceptionClassMethod(t); }
                    }
                    Suitable = true;
                }
                else
                {
                    return(Dummy);
                }
            }
            catch (NullReferenceException t)
            { ExceptionClass.ExceptionClassMethod(t); }
            LocalSearchMulDivisionEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref DivTrueMulFalse, ref SimplifiedTrueOtherWiseFalse);
            LocalSearchMulDivisionEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref DivTrueMulFalse, ref SimplifiedTrueOtherWiseFalse);
            return(Dummy);
        }
Ejemplo n.º 6
0
        static AddToTree.Tree RepeatedlyDeletedAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
        {
            if (Dummy == null)
            {
                return(Dummy);
            }
            DeletingMultaplification.RepeatedlyDeletedAction(Dummy.LeftSideAccess, ref UIS);
            DeletingMultaplification.RepeatedlyDeletedAction(Dummy.RightSideAccess, ref UIS);
            AddToTree.Tree Current    = Dummy;
            AddToTree.Tree CurrentTow = Dummy.LeftSideAccess;
            //int INCREASE = 2147483647 / 9;

            try
            {
                UIS.SetProgressValue(UIS.progressBar14, 0);
                if (CurrentTow != null)
                {
                    if (Dummy != null)
                    {
                        while ((IS.IsMul(Dummy.SampleAccess)))
                        {
                            if (!DELETED.FINDTreeWithThreadConsideration(Dummy))
                            {
                                if (!EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow, Dummy))
                                {
                                    if (CurrentTow != null)
                                    {
                                        while ((IS.IsMul(CurrentTow.SampleAccess)) && (CurrentTow != null))
                                        {
                                            if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
                                            {
                                                if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                                {
                                                    ///bool LeftTrueRightFalse = false;
                                                    ///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
                                                    ///LeftTrueRightFalse = true;
                                                    ///else
                                                    //if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
                                                    //  LeftTrueRightFalse = false;
                                                    AddToTree.Tree HOLDE           = Dummy;
                                                    AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                                    Dummy.SetLefTandRightCommonlySide(CurrentTow.RightSideAccess, Dummy.RightSideAccess);
                                                    Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                    while (Dummy.ThreadAccess != null)
                                                    {
                                                        Dummy = Dummy.ThreadAccess;
                                                    }
                                                    Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
                                                    Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, DummyCurrentTow);
                                                    Dummy.RightSideAccess.ThreadAccess = Dummy;
                                                    while (Dummy.ThreadAccess != null)
                                                    {
                                                        Dummy = Dummy.ThreadAccess;
                                                    }
                                                    Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
                                                    DELETED.ADDToTree(Dummy);
                                                }
                                            }



                                            if (IS.ISindependenceVaribale(Dummy.LeftSideAccess.SampleAccess))
                                            {
                                                if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                                {
                                                    if ((IS.IsPower(CurrentTow.RightSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
                                                    {
                                                        if ((IS.ISindependenceVaribale(CurrentTow.RightSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
                                                        {
                                                            AddToTree.Tree HOLDE           = Dummy;
                                                            AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                                            Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
                                                            Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                            while (Dummy.ThreadAccess != null)
                                                            {
                                                                Dummy = Dummy.ThreadAccess;
                                                            }
                                                            Dummy = CurrentTow;
                                                            Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
                                                            Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                            while (Dummy.ThreadAccess != null)
                                                            {
                                                                Dummy = Dummy.ThreadAccess;
                                                            }
                                                            while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
                                                            {
                                                                Dummy = Dummy.LeftSideAccess;
                                                            }
                                                            DELETED.ADDToTree(Dummy);
                                                        }
                                                    }
                                                }
                                            }

                                            if (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess))
                                            {
                                                if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                                {
                                                    if ((IS.IsPower(Dummy.LeftSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
                                                    {
                                                        if ((IS.ISindependenceVaribale(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
                                                        {
                                                            AddToTree.Tree HOLDE           = Dummy;
                                                            AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                                            Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
                                                            Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                            while (Dummy.ThreadAccess != null)
                                                            {
                                                                Dummy = Dummy.ThreadAccess;
                                                            }
                                                            Dummy = CurrentTow;
                                                            Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
                                                            Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                            while (Dummy.ThreadAccess != null)
                                                            {
                                                                Dummy = Dummy.ThreadAccess;
                                                            }
                                                            while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
                                                            {
                                                                Dummy = Dummy.LeftSideAccess;
                                                            }
                                                            DELETED.ADDToTree(Dummy);
                                                        }
                                                    }
                                                }
                                            }


                                            CurrentTow = CurrentTow.LeftSideAccess;
                                        }
                                    }
                                }
                            }
                            if (Dummy.LeftSideAccess == null)
                            {
                                break;
                            }
                            Dummy      = Dummy.LeftSideAccess;
                            CurrentTow = Dummy.LeftSideAccess;
                        }
                    }
                }
                //Dummy= Dummy;
                while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current)) && (Dummy.ThreadAccess != null))
                {
                    Dummy = Dummy.ThreadAccess;
                }
                CurrentTow = Dummy.RightSideAccess;

                UIS.SetProgressValue(UIS.progressBar14, 2147483647 / 2);

                if (CurrentTow != null)
                {
                    while (IS.IsMul(Dummy.SampleAccess))
                    {
                        if (CurrentTow != null)
                        {
                            while (IS.IsMul(CurrentTow.SampleAccess) && (CurrentTow != null))
                            {
                                if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
                                {
                                    if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                    {
                                        ///bool LeftTrueRightFalse = false;
                                        ///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
                                        ///LeftTrueRightFalse = true;
                                        ///else
                                        //if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
                                        //  LeftTrueRightFalse = false;
                                        AddToTree.Tree HOLDE           = Dummy;
                                        AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                        Dummy.SetLefTandRightCommonlySide(CurrentTow.RightSideAccess, Dummy.RightSideAccess);
                                        Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                        while (Dummy.ThreadAccess != null)
                                        {
                                            Dummy = Dummy.ThreadAccess;
                                        }
                                        Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
                                        Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, DummyCurrentTow);
                                        Dummy.RightSideAccess.ThreadAccess = Dummy;
                                        while (Dummy.ThreadAccess != null)
                                        {
                                            Dummy = Dummy.ThreadAccess;
                                        }
                                        Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
                                        DELETED.ADDToTree(Dummy);
                                    }
                                }


                                if (IS.ISindependenceVaribale(Dummy.LeftSideAccess.SampleAccess))
                                {
                                    if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                    {
                                        if ((IS.IsPower(CurrentTow.RightSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
                                        {
                                            if ((IS.ISindependenceVaribale(CurrentTow.RightSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
                                            {
                                                ///bool LeftTrueRightFalse = false;
                                                ///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
                                                ///LeftTrueRightFalse = true;
                                                ///else
                                                //if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
                                                //  LeftTrueRightFalse = false;
                                                AddToTree.Tree HOLDE           = Dummy;
                                                AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                                Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
                                                Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                while (Dummy.ThreadAccess != null)
                                                {
                                                    Dummy = Dummy.ThreadAccess;
                                                }
                                                //Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
                                                Dummy = CurrentTow;
                                                Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
                                                Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                while (Dummy.ThreadAccess != null)
                                                {
                                                    Dummy = Dummy.ThreadAccess;
                                                }
                                                //Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
                                                while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
                                                {
                                                    Dummy = Dummy.RightSideAccess;
                                                }
                                                DELETED.ADDToTree(Dummy);
                                            }
                                        }
                                    }
                                }


                                if (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess))
                                {
                                    if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
                                    {
                                        if ((IS.IsPower(Dummy.LeftSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
                                        {
                                            if ((IS.ISindependenceVaribale(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
                                            {
                                                AddToTree.Tree HOLDE           = Dummy;
                                                AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
                                                Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
                                                Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                while (Dummy.ThreadAccess != null)
                                                {
                                                    Dummy = Dummy.ThreadAccess;
                                                }
                                                Dummy = CurrentTow;
                                                Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
                                                Dummy.LeftSideAccess.ThreadAccess = Dummy;
                                                while (Dummy.ThreadAccess != null)
                                                {
                                                    Dummy = Dummy.ThreadAccess;
                                                }
                                                while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
                                                {
                                                    Dummy = Dummy.LeftSideAccess;
                                                }
                                                DELETED.ADDToTree(Dummy);
                                            }
                                        }
                                    }
                                }


                                CurrentTow = CurrentTow.RightSideAccess;
                            }
                        }
                        if (Dummy.RightSideAccess == null)
                        {
                            break;
                        }
                        Dummy      = Dummy.RightSideAccess;
                        CurrentTow = Dummy.RightSideAccess;
                    }
                }
                while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current)) && (Dummy.ThreadAccess != null))
                {
                    Dummy = Dummy.ThreadAccess;
                }
            }
            catch (NullReferenceException t)
            {
                ExceptionClass.ExceptionClassMethod(t);
            }
            UIS.SetProgressValue(UIS.progressBar14, 2147483647);
            return(Dummy);
        }