using System;
using System.Text.RegularExpressions;
[System.Serializable]
public class Int :IComparable
{
public string Body = "0";
public static readonly Int Zero = new Int("0");
public int Length
{
get
{
if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
return this.Body.Length - 1;
return this.Body.Length;
}
}
public int this[int index]
{
get
{
if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
return (int)this.Body[index + 1] - 48;
return (int)this.Body[index] - 48;
}
}
public bool IsPositive
{
get
{
return (int)this.Body[0] != 45 || !(new Int(this.Body.Substring(1)) != (Int)0L);
}
}
public Int()
{
}
public Int(string numStr)
{
if (string.IsNullOrEmpty(numStr))
this.Body = "0";
else
this.Body = this.Trim(numStr);
}
public static implicit operator string(Int source)
{
return source.Body;
}
public static implicit operator Int(long real)
{
return new Int(real.ToString());
}
public static implicit operator Int(string real)
{
return new Int(real);
}
public static bool operator >(Int left, Int right)
{
if (left.IsPositive && !right.IsPositive && left.Absolute().Body != "0" && right.Absolute().Body != "0")
return true;
if (left.IsPositive && right.IsPositive)
{
if (left.Length > right.Length)
return true;
if (left.Length != right.Length)
return false;
for (int index = 0; index < left.Length; ++index)
{
if (left[index] > right[index])
return true;
if (left[index] < right[index])
return false;
}
}
else if (!left.IsPositive && !right.IsPositive)
{
if (left.Length < right.Length)
return true;
if (left.Length != right.Length)
return false;
for (int index = 0; index < left.Length; ++index)
{
if (left[index] < right[index])
return true;
if (left[index] > right[index])
return false;
}
}
else if (left.IsPositive && !right.IsPositive && (left.Absolute().Body == "0" && right.Absolute().Body != "0" || left.Absolute().Body != "0" && right.Absolute().Body == "0"))
return true;
return false;
}
public static bool operator <(Int left, Int right)
{
return right > left;
}
public static bool operator >=(Int left, Int right)
{
return left > right || left == right;
}
public static bool operator <=(Int left, Int right)
{
return left < right || left == right;
}
public static bool operator ==(Int left, Int right)
{
return !(left > right) && !(left < right);
}
public static bool operator !=(Int left, Int right)
{
return left > right || left < right;
}
public static bool operator >(Int left, object right)
{
return left > new Int(right.ToString());
}
public static bool operator >(object left, Int right)
{
return new Int(left.ToString()) > right;
}
public static bool operator <(Int left, object right)
{
return left < new Int(right.ToString());
}
public static bool operator <(object left, Int right)
{
return new Int(left.ToString()) < right;
}
public static bool operator >=(Int left, object right)
{
return left >= new Int(right.ToString());
}
public static bool operator >=(object left, Int right)
{
return new Int(left.ToString()) >= right;
}
public static bool operator <=(Int left, object right)
{
return left <= new Int(right.ToString());
}
public static bool operator <=(object left, Int right)
{
return new Int(left.ToString()) <= right;
}
public static bool operator ==(Int left, object right)
{
return left == new Int(right.ToString());
}
public static bool operator ==(object left, Int right)
{
return new Int(left.ToString()) == right;
}
public static bool operator !=(Int left, object right)
{
return left != new Int(right.ToString());
}
public static bool operator !=(object left, Int right)
{
return new Int(left.ToString()) != right;
}
public static string operator +(string left, Int right) {
return string.Format("{0}{1}",left,right.Body);
}
public static string operator + (Int right ,string left )
{
return string.Format("{0}{1}", right.Body,left);
}
public static Int operator +(Int left, Int right)
{
Int Int1 = new Int();
if (left.IsPositive && right.IsPositive)
{
int length = right.Length;
if (left.Length > right.Length)
length = left.Length;
int num1 = 0;
for (int index = 0; index < length; ++index)
{
int num2 = index >= left.Length || index >= right.Length ? (index < left.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] + num1) : right[right.Length - 1 - index] + num1) : left[left.Length - 1 - index] + right[right.Length - 1 - index] + num1;
num1 = num2 / 10;
int num3;
if (index == 0)
{
Int Int2 = Int1;
num3 = num2 % 10;
string str = num3.ToString();
Int2.Body = str;
}
else
{
Int Int2 = Int1;
string str1 = Int1.Body;
int startIndex = 0;
num3 = num2 % 10;
string str2 = num3.ToString();
string str3 = str1.Insert(startIndex, str2);
Int2.Body = str3;
}
}
Int1.Body = Int1.Body.Insert(0, num1.ToString());
}
else if (left.IsPositive && !right.IsPositive)
Int1 = left - new Int((string)right.Absolute());
else if (!left.IsPositive && right.IsPositive)
Int1 = right - new Int((string)left.Absolute());
else if (!left.IsPositive && !right.IsPositive)
Int1 = left - new Int((string)right.Absolute());
Int1.Trim();
return Int1;
}
public static Int operator -(Int left, Int right)
{
Int Int = new Int();
if (left == right)
return new Int("0");
if (left > Int.Zero && right == Int.Zero)
return left;
if (left == Int.Zero && right < Int.Zero)
return new Int((string)right.Absolute());
if (left == Int.Zero && right > Int.Zero)
return new Int(right.Body.Insert(0, "-"));
if (left > Int.Zero && right > Int.Zero)
{
if (left > right)
{
int num1 = 0;
for (int index = 0; index < left.Length; ++index)
{
int num2 = index >= left.Length || index >= right.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] - num1) : left[left.Length - 1 - index] - right[right.Length - 1 - index] - num1;
num1 = num2 / 10;
if (num2 < 0)
{
num1 = 1;
num2 = 10 + num2;
}
Int.Body = index != 0 ? Int.Body.Insert(0, num2.ToString()) : num2.ToString();
}
}
else if (left < right)
{
Int = right - left;
Int.Body = Int.Body.Insert(0, "-");
}
}
else if (left < Int.Zero && right < Int.Zero)
Int = new Int((string)right.Absolute()) - new Int((string)left.Absolute());
else if (left > Int.Zero && right < Int.Zero)
Int = left + new Int((string)right.Absolute());
else if (left < Int.Zero && right > Int.Zero)
{
Int = new Int((string)left.Absolute()) + right;
Int.Body = Int.Body.Insert(0, "-");
}
Int.Trim();
return Int;
}
public static Int operator *(Int left, Int right)
{
Int Int = new Int();
if (left == Int.Zero || right == Int.Zero)
return Int.Zero;
if (left.IsPositive && right.IsPositive)
{
for (int index1 = right.Length - 1; index1 >= 0; --index1)
{
int num1 = 0;
string numStr = "";
for (int index2 = left.Length - 1; index2 >= 0; --index2)
{
int num2 = right.Absolute()[index1] * left.Absolute()[index2] + num1;
numStr = numStr.Insert(0, (num2 % 10).ToString());
num1 = num2 / 10;
}
if ((uint)num1 > 0U)
numStr = numStr.Insert(0, num1.ToString());
for (int index2 = 0; index2 < right.Length - 1 - index1; ++index2)
numStr += "0";
Int += new Int(numStr);
}
}
else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
{
Int = new Int((string)left.Absolute()) * new Int((string)right.Absolute());
Int.Body = Int.Body.Insert(0, "-");
}
else if (!left.IsPositive && !right.IsPositive)
Int = new Int((string)left.Absolute()) * new Int((string)right.Absolute());
Int.Trim();
return Int;
}
public static Int operator /(Int left, Int right)
{
Int Int1 = new Int();
if (right == Int.Zero)
throw new Exception("除零错误！");
if (left == Int.Zero)
return Int.Zero;
if (right == new Int("1"))
return left;
if (left.IsPositive && right.IsPositive)
{
if (left < right)
{
Int1 = Int.Zero;
}
else
{
string numStr = "";
Int Int2 = new Int(left.Body.Substring(0, right.Length - 1));
for (int index = right.Length - 1; index < left.Length; ++index)
{
Int2 = Int2 * new Int("10") + new Int(left[index].ToString());
Int2.Trim();
int num = 0;
for (num = 0; num < 10; ++num)
{
Int Int3 = right * new Int(num.ToString());
if (Int3 > Int2)
{
numStr += (num - 1);
Int2 -= right * new Int((num - 1).ToString());
break;
}
if (Int3 == Int2)
{
numStr += num;
Int2 = Int.Zero;
break;
}
}
if (num == 10)
{
numStr += (num - 1);
Int2 -= right * new Int((num - 1).ToString());
}
}
Int1 = new Int(numStr);
}
}
else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
{
Int1 = new Int((string)left.Absolute()) / new Int((string)right.Absolute());
Int1.Body = Int1.Body.Insert(0, "-");
}
else if (!left.IsPositive && !right.IsPositive)
Int1 = new Int((string)left.Absolute()) / new Int((string)right.Absolute());
Int1.Trim();
return Int1;
}
public static Int operator %(Int left, Int right)
{
Int Int1 = new Int();
Int Int2 = left - left / right * right;
Int2.Trim();
return Int2;
}
public static Int operator +(Int left, object right)
{
return left.Body + new Int(right.ToString());
}
public static Int operator +(object left, Int right)
{
return new Int(left.ToString()) + right.Body;
}
public static Int operator -(Int left, object right)
{
return left - new Int(right.ToString());
}
public static Int operator -(object left, Int right)
{
return new Int(left.ToString()) - right;
}
public static Int operator *(Int left, object right)
{
return left * new Int(right.ToString());
}
public static Int operator *(object left, Int right)
{
return new Int(left.ToString()) * right;
}
public static Int operator /(Int left, object right)
{
return left / new Int(right.ToString());
}
public static Int operator /(object left, Int right)
{
return new Int(left.ToString()) / right;
}
public static Int operator %(Int left, object right)
{
return left % new Int(right.ToString());
}
public static Int operator %(object left, Int right)
{
return new Int(left.ToString()) % right;
}
public Int Absolute()
{
if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
return new Int(this.Body.Substring(1));
return this;
}
public void Trim()
{
this.Body = this.Trim(this.Body);
}
public string Trim(string numStr)
{
string str1 = numStr.Trim();
if ((int)str1[0] == 43)
str1 = str1.Substring(1);
string str2 = str1;
if ((int)str1[0] == 45)
str2 = str1.Substring(1);
int index = 0;
while (index < str2.Length && (int)str2[index] == 48)
++index;
if (index == str2.Length)
return "0";
bool flag = true;
if ((int)str1[0] == 45)
flag = false;
int startIndex = 0;
while (startIndex < str2.Length && (int)str2[startIndex] == 48)
++startIndex;
string str3 = str2.Substring(startIndex);
if (!flag)
str3 = str3.Insert(0, "-");
return str3;
}
public override string ToString()
{
return this.Body;
}
public int CompareTo(object obj)
{
return this == (Int)obj ? 0 : this - (Int)obj > 0 ? 1 : -1;
}
public Float ToFloat()
{
return new Float(this.Body);
}
public override bool Equals(object obj)
{
return base.Equals(obj);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
[System.Serializable]
public class Float : Int
{
public static int DividResaultPrecision = 50;
private long DotIndex = 0;
private string BodyNoDotNoSignal = "0";
public string IntPart
{
get
{
if (this.DotIndex <= 0L)
return "0";
return this.BodyNoDotNoSignal.Substring(0, (int)this.DotIndex);
}
}
public string FloatPart
{
get
{
if (this.DotIndex == (long)this.BodyNoDotNoSignal.Length)
return "0";
if (this.DotIndex == 0L)
return this.BodyNoDotNoSignal;
if (this.DotIndex >= 0L)
return this.BodyNoDotNoSignal.Substring((int)this.DotIndex);
string str = this.BodyNoDotNoSignal;
for (int index = 0; (long)index < -this.DotIndex; ++index)
str = str.Insert(0, "0");
return str;
}
}
public int IntPartLength
{
get
{
return this.IntPart.Length;
}
}
public int FloatPartLength
{
get
{
if (this.FloatPart.Length == 1 && (int)this.FloatPart[0] == 48)
return 0;
return this.FloatPart.Length;
}
}
public Float()
{
this.DotIndex = 1L;
this.Body = "0";
this.BodyNoDotNoSignal = "0";
}
public Float(string body)
{
if (string.IsNullOrEmpty(body))
this.Body = "0";
else
this.Body = this.Trim(body);
Match match = Regex.Match(this.Body, "[1-9]");
int num = this.Body.IndexOf('.');
this.DotIndex = num < 0 ? (long)(this.Body.Length - match.Index) : (num <= match.Index ? (long)(num - match.Index + 1) : (long)(num - match.Index));
this.BodyNoDotNoSignal = this.Body.Substring(match.Index);
int startIndex = this.BodyNoDotNoSignal.IndexOf('.');
if (startIndex >= 0)
this.BodyNoDotNoSignal = this.BodyNoDotNoSignal.Remove(startIndex, 1);
this.BodyNoDotNoSignal = base.Trim(this.BodyNoDotNoSignal);
}
public static implicit operator string(Float source)
{
return source.Body;
}
public static implicit operator Float(long real)
{
return new Float(real.ToString());
}
public static implicit operator Float(string real)
{
return new Float(real);
}
public static implicit operator Float(float real)
{
return new Float(real.ToString());
}
public static bool operator >(Float left, Float right)
{
if (left.IsPositive && right.IsPositive)
{
if (new Int(left.IntPart) > new Int(right.IntPart))
return true;
int length1 = left.FloatPart.Length;
int length2 = right.FloatPart.Length;
string floatPart1 = left.FloatPart;
string floatPart2 = right.FloatPart;
if (length1 > length2)
{
for (int index = length2; index < length1; ++index)
floatPart2 += "0";
}
else if (length1 < length2)
{
for (int index = length1; index < length2; ++index)
floatPart1 += "0";
}
return new Int(floatPart1) > new Int(floatPart2);
}
return left.IsPositive && !right.IsPositive || (left.IsPositive || !right.IsPositive) && (!left.IsPositive && !right.IsPositive && new Float((string)right.Absolute()) > new Float((string)left.Absolute()));
}
public static bool operator <(Float left, Float right)
{
return right > left;
}
public static bool operator ==(Float left, Float right)
{
return !(left > right) && !(left < right);
}
public static bool operator !=(Float left, Float right)
{
return left > right || left < right;
}
public static bool operator >=(Float left, Float right)
{
return left < right || left == right;
}
public static bool operator <=(Float left, Float right)
{
return left > right || left == right;
}
public static bool operator >(Float left, object right)
{
return left > new Float(right.ToString());
}
public static bool operator >(object left, Float right)
{
return new Float(left.ToString()) > right;
}
public static bool operator <(Float left, object right)
{
return left < new Float(right.ToString());
}
public static bool operator <(object left, Float right)
{
return new Float(left.ToString()) < right;
}
public static bool operator ==(Float left, object right)
{
return left == new Float(right.ToString());
}
public static bool operator ==(object left, Float right)
{
return new Float(left.ToString()) == right;
}
public static bool operator !=(Float left, object right)
{
return left != new Float(right.ToString());
}
public static bool operator !=(object left, Float right)
{
return new Float(left.ToString()) != right;
}
public static bool operator >=(Float left, object right)
{
return left >= new Float(right.ToString());
}
public static bool operator >=(object left, Float right)
{
return new Float(left.ToString()) >= right;
}
public static bool operator <=(Float left, object right)
{
return left <= new Float(right.ToString());
}
public static bool operator <=(object left, Float right)
{
return new Float(left.ToString()) <= right;
}
public static Float operator +(Float left, Float right)
{
if (left == (Float)0L)
return right;
if (right == (Float)0L)
return left;
string numStr1 = left.Body;
int startIndex1 = numStr1.IndexOf('.');
if (startIndex1 >= 0)
numStr1 = numStr1.Remove(startIndex1, 1);
string numStr2 = right.Body;
int startIndex2 = numStr2.IndexOf('.');
if (startIndex2 >= 0)
numStr2 = numStr2.Remove(startIndex2, 1);
int length1 = left.FloatPart.Length;
if (right.FloatPart.Length > length1)
{
length1 = right.FloatPart.Length;
if (left.FloatPart == "0")
{
for (int length2 = left.FloatPart.Length; length2 <= length1; ++length2)
numStr1 += "0";
}
else
{
for (int length2 = left.FloatPart.Length; length2 < length1; ++length2)
numStr1 += "0";
}
}
else if (right.FloatPart == "0")
{
for (int length2 = right.FloatPart.Length; length2 <= length1; ++length2)
numStr2 += "0";
}
else
{
for (int length2 = right.FloatPart.Length; length2 < length1; ++length2)
numStr2 += "0";
}
Int Int = new Int(numStr1) + new Int(numStr2);
if (Int.Length == length1)
return (Float)Int.Body.Insert(Int.Body.Length - length1, "0.");
if (Int.Length >= length1)
return (Float)Int.Body.Insert(Int.Body.Length - length1, ".");
string str = (string)Int.Absolute();
for (int length2 = str.Length; length2 < length1; ++length2)
str = "0" + str;
if (Int.IsPositive)
return (Float)str.Insert(0, "0.");
return (Float)str.Insert(0, "-0.");
}
public static Float operator -(Float left, Float right)
{
if (right == (Float)0L)
return left;
if (right.IsPositive)
return left + (Float)right.Absolute().Body.Insert(0, "-");
return left + right.Absolute();
}
public static Float operator *(Float left, Float right)
{
string numStr1 = left.Body;
int startIndex1 = numStr1.IndexOf('.');
if (startIndex1 >= 0)
numStr1 = numStr1.Remove(startIndex1, 1);
string numStr2 = right.Body;
int startIndex2 = numStr2.IndexOf('.');
if (startIndex2 >= 0)
numStr2 = numStr2.Remove(startIndex2, 1);
int floatPartLength1 = left.FloatPartLength;
if (right.FloatPartLength > floatPartLength1)
{
floatPartLength1 = right.FloatPartLength;
for (int floatPartLength2 = left.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
numStr1 += "0";
}
else if (right.FloatPartLength < floatPartLength1)
{
for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
numStr2 += "0";
}
Int Int = new Int(numStr1) * new Int(numStr2);
int num = floatPartLength1 + floatPartLength1;
if (Int.Length == num)
return (Float)Int.Body.Insert(Int.Body.Length - num, "0.");
if (Int.Length >= num)
return (Float)Int.Body.Insert(Int.Body.Length - num, ".");
string str = (string)Int.Absolute();
for (int length = str.Length; length < num; ++length)
str = "0" + str;
if (Int.IsPositive)
return (Float)str.Insert(0, "0.");
return (Float)str.Insert(0, "-0.");
}
public static Float operator /(Float left, Float right)
{
string numStr1 = left.Body;
int startIndex1 = numStr1.IndexOf('.');
if (startIndex1 >= 0)
numStr1 = numStr1.Remove(startIndex1, 1);
string numStr2 = right.Body;
int startIndex2 = numStr2.IndexOf('.');
if (startIndex2 >= 0)
numStr2 = numStr2.Remove(startIndex2, 1);
int floatPartLength1 = left.FloatPartLength;
if (right.FloatPartLength > floatPartLength1)
{
int floatPartLength2 = right.FloatPartLength;
for (int floatPartLength3 = left.FloatPartLength; floatPartLength3 < floatPartLength2; ++floatPartLength3)
numStr1 += "0";
}
else if (right.FloatPartLength < floatPartLength1)
{
for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
numStr2 += "0";
}
for (int index = 0; index < Float.DividResaultPrecision; ++index)
numStr1 += "0";
Int Int = new Int(numStr1) / new Int(numStr2);
int num = Float.DividResaultPrecision;
if (Int.Length == num)
return (Float)Int.Body.Insert(Int.Body.Length - num, "0.");
if (Int.Length >= num)
return (Float)Int.Body.Insert(Int.Body.Length - num, ".");
string str = (string)Int.Absolute();
for (int length = str.Length; length < num; ++length)
str = "0" + str;
if (Int.IsPositive)
return (Float)str.Insert(0, "0.");
return (Float)str.Insert(0, "-0.");
}
public static Float operator +(Float left, object right)
{
return left + new Float(right.ToString());
}
public static Float operator +(object left, Float right)
{
return new Float(left.ToString()) + right;
}
public static Float operator -(Float left, object right)
{
return left - new Float(right.ToString());
}
public static Float operator -(object left, Float right)
{
return new Float(left.ToString()) - right;
}
public static Float operator *(Float left, object right)
{
return left * new Float(right.ToString());
}
public static Float operator *(object left, Float right)
{
return new Float(left.ToString()) * right;
}
public static Float operator /(Float left, object right)
{
return left / new Float(right.ToString());
}
public static Float operator /(object left, Float right)
{
return new Float(left.ToString()) / right;
}
public Float Absolute()
{
if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
return new Float(this.Body.Substring(1));
return this;
}
public new string Trim(string numStr)
{
string str1 = numStr.Trim();
if ((int)str1[0] == 43)
str1 = str1.Substring(1);
int num = str1.IndexOf('.');
if (num >= 0)
{
for (int length = str1.Length - 1; length >= num; --length)
{
if ((int)str1[length] != 48)
{
str1 = (int)str1[length] != 46 ? str1.Substring(0, length + 1) : str1.Substring(0, length);
break;
}
}
}
bool flag = false;
string str2 = str1;
string str3 = "";
char ch;
for (int index = 0; index < str2.Length; ++index)
{
if (flag)
{
string str4 = str3;
ch = str2[index];
string str5 = ch.ToString();
str3 = str4 + str5;
}
else if ((int)str2[index] == 45)
{
string str4 = str3;
ch = str2[index];
string str5 = ch.ToString();
str3 = str4 + str5;
}
else if ((int)str2[index] == 48)
{
if (index + 1 < str2.Length && (int)str2[index + 1] == 46 || index + 1 >= str2.Length)
{
string str4 = str3;
ch = str2[index];
string str5 = ch.ToString();
str3 = str4 + str5;
flag = true;
}
}
else
{
string str4 = str3;
ch = str2[index];
string str5 = ch.ToString();
str3 = str4 + str5;
flag = true;
}
}
if (str3.Length == 2 && (int)str3[0] == 45 && (int)str3[1] == 48)
str3 = "0";
return str3;
}
public override string ToString()
{
return this.Body;
}
public Int ToInt()
{
string numStr = this.IntPart;
if (!this.IsPositive)
numStr = numStr.Insert(0, "-");
return new Int(numStr);
}
public override bool Equals(object obj)
{
return base.Equals(obj);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
