public static MyBigNumber Sum2MyBigNumbers(MyBigNumber myNmbr1, MyBigNumber myNmbr2)
        {
            int         smallerByAbs = MyBigNumber.SmallerByAbsIsFirstOrSecond(myNmbr1, myNmbr2);
            MyBigNumber bgrByAbs, smlrByAbs;
            int         signOfBigger = 0;

            if (smallerByAbs == 1)
            {
                smlrByAbs    = myNmbr1;
                bgrByAbs     = myNmbr2;
                signOfBigger = myNmbr2.SignNmbr;
            }
            else
            {
                smlrByAbs    = myNmbr2;
                bgrByAbs     = myNmbr1;
                signOfBigger = myNmbr1.SignNmbr;
            }
            string biggerAbsNmbrs  = bgrByAbs.PartDigits;
            string smallerAbsNmbrs = smlrByAbs.PartDigits;
            int    biggerAbsFlPos  = bgrByAbs.FloatPointPosition;
            int    smallerAbsFlPos = smlrByAbs.FloatPointPosition;
            int    biggerFlPPos    = 0;

            if (biggerAbsFlPos > smallerAbsFlPos)
            {
                biggerFlPPos    = biggerAbsFlPos;
                smallerAbsNmbrs = MyBigNumber.AddNmbrZero(smallerAbsNmbrs, -1 * (biggerAbsFlPos - smallerAbsFlPos));
            }
            else
            {
                biggerFlPPos   = smallerAbsFlPos;
                biggerAbsNmbrs = MyBigNumber.AddNmbrZero(biggerAbsNmbrs, -1 * (smallerAbsFlPos - biggerAbsFlPos));
            }
            if (smallerAbsNmbrs.Length < biggerAbsNmbrs.Length)
            {
                smallerAbsNmbrs = MyBigNumber.AddNmbrZero(smallerAbsNmbrs, biggerAbsNmbrs.Length - smallerAbsNmbrs.Length);
            }
            string newStrPartDigits;

            if ((myNmbr1.SignNmbr * myNmbr2.SignNmbr) >= 0)
            {
                newStrPartDigits = MyBigNumber.AddTwoLines(biggerAbsNmbrs, smallerAbsNmbrs);
            }
            else
            {
                newStrPartDigits = MyBigNumber.BiggerMinusSmaller(biggerAbsNmbrs, smallerAbsNmbrs);
            }
            var myNmbr3 = new MyBigNumber()
            {
                PartDigits = newStrPartDigits, SignNmbr = signOfBigger, FloatPointPosition = biggerFlPPos
            };
            string newStringVal = myNmbr3.Value();

            return(MyBigNumber.CreateMyBigNumber(newStringVal));
        }
        public static int SmallerByAbsIsFirstOrSecond(MyBigNumber myNmbr1, MyBigNumber myNmbr2)
        {
            int         floatPstn1 = myNmbr1.FloatPointPosition;
            int         floatPstn2 = myNmbr2.FloatPointPosition;
            MyBigNumber longFloatPart, shortFloatPart;
            int         longFloatLngth  = 0;
            int         shortFloatLngth = 0;

            if (floatPstn2 > floatPstn1)
            {
                longFloatLngth  = floatPstn2;
                shortFloatLngth = floatPstn1;
                longFloatPart   = myNmbr2;
                shortFloatPart  = myNmbr1;
            }
            else
            {
                longFloatLngth  = floatPstn1;
                shortFloatLngth = floatPstn2;
                longFloatPart   = myNmbr1;
                shortFloatPart  = myNmbr2;
            }
            string longFltStr  = longFloatPart.PartDigits;
            string shortFltStr = MyBigNumber.AddNmbrZero(shortFloatPart.PartDigits, -1 * (longFloatLngth - shortFloatLngth));
            var    lsToEqual   = new List <string>(2);

            lsToEqual.Add(longFltStr);
            lsToEqual.Add(shortFltStr);
            MyBigNumber.IndentLengthWithZeroes(lsToEqual);
            bool smallerLong = MyBigNumber.FirstLineSmallerThanSecond(lsToEqual[0], lsToEqual[1]);
            int  resCmpr     = 0;

            if (smallerLong)
            {
                if (floatPstn2 > floatPstn1)
                {
                    resCmpr = 2;
                }
                else
                {
                    resCmpr = 1;
                }
            }
            else
            {
                if (floatPstn2 > floatPstn1)
                {
                    resCmpr = 1;
                }
                else
                {
                    resCmpr = 2;
                }
            }
            return(resCmpr);
        }
        static void Main(string[] args)
        {
            string strFirstNmbr = Console.ReadLine();
            string strScndNmbr  = Console.ReadLine();
            var    myBigN1      = MyBigNumber.CreateMyBigNumber(strFirstNmbr);
            var    myBigN2      = MyBigNumber.CreateMyBigNumber(strScndNmbr);
            var    mySum        = MyBigNumber.Sum2MyBigNumbers(myBigN1, myBigN2);

            Console.WriteLine(mySum.Value());
        }
        public static MyBigNumber CreateMyBigNumber(string nmbrString)
        {
            string[] strArr   = nmbrString.Split(new char[] { '.', ',', '-', '+' }, StringSplitOptions.RemoveEmptyEntries).ToArray();
            int      signNmbr = 1;

            for (int i = 0; i < nmbrString.Length; i++)
            {
                if (nmbrString[i].Equals('-'))
                {
                    signNmbr *= -1;
                }
                else if (!(nmbrString[i].Equals('+')))
                {
                    break;
                }
            }
            string tmpStrVal = strArr[0].TrimStart('0');

            if (tmpStrVal.Equals(""))
            {
                strArr[0] = "0";
            }
            else
            {
                strArr[0] = tmpStrVal;
            }
            int floatPointPosition = 0;

            if (strArr.Length > 1)
            {
                tmpStrVal = strArr[1].TrimEnd('0');
                if (!tmpStrVal.Equals(""))
                {
                    floatPointPosition = tmpStrVal.Length;
                    strArr[0]         += tmpStrVal;
                }
            }

            if (strArr[0].Equals("0"))
            {
                signNmbr = 1;
            }
            MyBigNumber nmbr = new MyBigNumber()
            {
                PartDigits = strArr[0], FloatPointPosition = floatPointPosition, SignNmbr = signNmbr
            };

            return(nmbr);
        }
        public static MyBigNumber MultiplyBy(MyBigNumber myBigNumber, MyBigNumber myBigMultiplier)
        {
            string tmpNmbrString   = myBigNumber.PartDigits;
            string tmpMltplrString = myBigMultiplier.PartDigits;
            var    lstMtpldLines   = new List <string>(tmpMltplrString.Length);

            for (int i = tmpMltplrString.Length - 1; i >= 0; i--)
            {
                string line = MyBigNumber.MultiplyLineByChar(tmpNmbrString, tmpMltplrString[i]);
                line = MyBigNumber.AddNmbrZero(line, (-1 * (tmpMltplrString.Length - 1 - i)));
                lstMtpldLines.Add(line);
            }
            MyBigNumber.IndentLengthWithZeroes(lstMtpldLines);
            string lineSum = lstMtpldLines[0];

            for (int i = 1; i < lstMtpldLines.Count; i++)
            {
                string tmpLine  = lstMtpldLines[i];
                var    lsAppend = new List <string>(2);
                lsAppend.Add(lineSum);
                lsAppend.Add(tmpLine);
                MyBigNumber.IndentLengthWithZeroes(lsAppend);
                lineSum = MyBigNumber.AddTwoLines(lsAppend[0], lsAppend[1]);
            }
            int pstnFloatPoint = myBigNumber.FloatPointPosition + myBigMultiplier.FloatPointPosition;
            int nmbrLeadZeroes = pstnFloatPoint - lineSum.Length + 1;

            if (nmbrLeadZeroes > 0)
            {
                lineSum = MyBigNumber.AddNmbrZero(lineSum, nmbrLeadZeroes);
            }
            int newSign     = myBigMultiplier.SignNmbr * myBigNumber.SignNmbr;
            var newMyNumber = new MyBigNumber()
            {
                PartDigits = lineSum, FloatPointPosition = pstnFloatPoint, SignNmbr = newSign
            };
            string resultValue = newMyNumber.Value();
            var    resMyNumber = MyBigNumber.CreateMyBigNumber(resultValue);

            return(resMyNumber);
        }
        public static void IndentLengthWithZeroes(List <string> inLsLines)
        {
            int maxLength = 0;

            for (int i = 0; i < inLsLines.Count; i++)
            {
                if (maxLength < inLsLines[i].Length)
                {
                    maxLength = inLsLines[i].Length;
                }
            }
            for (int i = 0; i < inLsLines.Count; i++)
            {
                string elm     = inLsLines[i];
                int    nmbZero = maxLength - elm.Length;
                if (nmbZero > 0)
                {
                    string newElm = MyBigNumber.AddNmbrZero(elm, nmbZero);
                    inLsLines[i] = newElm;
                }
            }
        }