public static Int128 Int128Mul(long lhs, long rhs)
{
bool flag = lhs < 0L != rhs < 0L;
if (lhs < 0L)
{
lhs = -lhs;
}
if (rhs < 0L)
{
rhs = -rhs;
}
ulong num = (ulong)lhs >> 32;
ulong num2 = (ulong)(lhs & (long)((ulong)-1));
ulong num3 = (ulong)rhs >> 32;
ulong num4 = (ulong)(rhs & (long)((ulong)-1));
ulong num5 = num * num3;
ulong num6 = num2 * num4;
ulong num7 = num * num4 + num2 * num3;
long num8 = (long)(num5 + (num7 >> 32));
ulong num9 = (num7 << 32) + num6;
if (num9 < num6)
{
num8 += 1L;
}
Int128 @int = new Int128(num8, num9);
return((!flag) ? @int : (-@int));
}
public static Int128 Int128Mul(long lhs, long rhs)
{
bool flag = (lhs < 0L) != (rhs < 0L);
if (lhs < 0L)
{
lhs = -lhs;
}
if (rhs < 0L)
{
rhs = -rhs;
}
ulong num = (ulong)(lhs >> 0x20);
ulong num2 = ((ulong)lhs) & 0xffffffffL;
ulong num3 = (ulong)(rhs >> 0x20);
ulong num4 = ((ulong)rhs) & 0xffffffffL;
ulong num5 = num * num3;
ulong num6 = num2 * num4;
ulong num7 = (num * num4) + (num2 * num3);
long num9 = (long)(num5 + (num7 >> 0x20));
ulong num8 = (num7 << 0x20) + num6;
if (num8 < num6)
{
num9 += 1L;
}
Int128 num10 = new Int128(num9, num8);
return(!flag ? num10 : -num10);
}
internal bool PointInPolygon(IntPoint pt, OutPt pp, bool UseFullRange)
{
OutPt next = pp;
bool flag = false;
if (UseFullRange)
{
do
{
if ((next.Pt.Y > pt.Y) != (next.Prev.Pt.Y > pt.Y))
{
Int128 introduced2 = Int128.Int128Mul(next.Prev.Pt.X - next.Pt.X, pt.Y - next.Pt.Y);
if (new Int128(pt.X - next.Pt.X) < (introduced2 / new Int128(next.Prev.Pt.Y - next.Pt.Y)))
{
flag = !flag;
}
}
next = next.Next;
}while (next != pp);
return(flag);
}
do
{
if (((next.Pt.Y > pt.Y) != (next.Prev.Pt.Y > pt.Y)) && ((pt.X - next.Pt.X) < (((next.Prev.Pt.X - next.Pt.X) * (pt.Y - next.Pt.Y)) / (next.Prev.Pt.Y - next.Pt.Y))))
{
flag = !flag;
}
next = next.Next;
}while (next != pp);
return(flag);
}
protected static bool SlopesEqual(IntPoint pt1, IntPoint pt2, IntPoint pt3, bool UseFullRange)
{
if (UseFullRange)
{
return(Int128.Int128Mul(pt1.Y - pt2.Y, pt2.X - pt3.X) == Int128.Int128Mul(pt1.X - pt2.X, pt2.Y - pt3.Y));
}
return((((pt1.Y - pt2.Y) * (pt2.X - pt3.X)) - ((pt1.X - pt2.X) * (pt2.Y - pt3.Y))) == 0L);
}
internal static bool SlopesEqual(TEdge e1, TEdge e2, bool UseFullRange)
{
if (UseFullRange)
{
return(Int128.Int128Mul(e1.Delta.Y, e2.Delta.X) == Int128.Int128Mul(e1.Delta.X, e2.Delta.Y));
}
return(e1.Delta.Y * e2.Delta.X == e1.Delta.X * e2.Delta.Y);
}
internal static bool SlopesEqual(TEdge e1, TEdge e2, bool UseFullRange)
{
if (UseFullRange)
{
Int128 introduced0 = Int128.Int128Mul(e1.Delta.Y, e2.Delta.X);
return(introduced0 == Int128.Int128Mul(e1.Delta.X, e2.Delta.Y));
}
return((e1.Delta.Y * e2.Delta.X) == (e1.Delta.X * e2.Delta.Y));
}
public override bool Equals(object obj)
{
if (obj == null || !(obj is Int128))
{
return(false);
}
Int128 @int = (Int128)obj;
return(@int.hi == this.hi && @int.lo == this.lo);
}
public override bool Equals(object obj)
{
if ((obj == null) || !(obj is Int128))
{
return(false);
}
Int128 num = (Int128)obj;
return((num.hi == this.hi) && (num.lo == this.lo));
}
public Int128(Int128 val)
{
this.hi = val.hi;
this.lo = val.lo;
}
public static Int128 operator /(Int128 lhs, Int128 rhs)
{
if (rhs.lo == 0uL && rhs.hi == 0L)
{
throw new ClipperException("Int128: divide by zero");
}
bool flag = rhs.hi < 0L != lhs.hi < 0L;
if (lhs.hi < 0L)
{
lhs = -lhs;
}
if (rhs.hi < 0L)
{
rhs = -rhs;
}
if (rhs < lhs)
{
Int128 @int = new Int128(0L);
Int128 int2 = new Int128(1L);
while (rhs.hi >= 0L && !(rhs > lhs))
{
rhs.hi <<= 1;
if (rhs.lo < 0uL)
{
rhs.hi += 1L;
}
rhs.lo <<= 1;
int2.hi <<= 1;
if (int2.lo < 0uL)
{
int2.hi += 1L;
}
int2.lo <<= 1;
}
rhs.lo >>= 1;
if ((rhs.hi & 1L) == 1L)
{
rhs.lo |= 9223372036854775808uL;
}
rhs.hi = (long)((ulong)rhs.hi >> 1);
int2.lo >>= 1;
if ((int2.hi & 1L) == 1L)
{
int2.lo |= 9223372036854775808uL;
}
int2.hi >>= 1;
while (int2.hi != 0L || int2.lo != 0uL)
{
if (!(lhs < rhs))
{
lhs -= rhs;
@int.hi |= int2.hi;
@int.lo |= int2.lo;
}
rhs.lo >>= 1;
if ((rhs.hi & 1L) == 1L)
{
rhs.lo |= 9223372036854775808uL;
}
rhs.hi >>= 1;
int2.lo >>= 1;
if ((int2.hi & 1L) == 1L)
{
int2.lo |= 9223372036854775808uL;
}
int2.hi >>= 1;
}
return((!flag) ? @int : (-@int));
}
if (rhs == lhs)
{
return(new Int128(1L));
}
return(new Int128(0L));
}
internal bool PointOnLineSegment(IntPoint pt, IntPoint linePt1, IntPoint linePt2, bool UseFullRange)
{
if (UseFullRange)
{
return((((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) || ((pt.X == linePt2.X) && (pt.Y == linePt2.Y))) || ((((pt.X > linePt1.X) == (pt.X < linePt2.X)) && ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y))) && (Int128.Int128Mul(pt.X - linePt1.X, linePt2.Y - linePt1.Y) == Int128.Int128Mul(linePt2.X - linePt1.X, pt.Y - linePt1.Y))));
}
return((((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) || ((pt.X == linePt2.X) && (pt.Y == linePt2.Y))) || ((((pt.X > linePt1.X) == (pt.X < linePt2.X)) && ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y))) && (((pt.X - linePt1.X) * (linePt2.Y - linePt1.Y)) == ((linePt2.X - linePt1.X) * (pt.Y - linePt1.Y)))));
}
public static Int128 operator /(Int128 lhs, Int128 rhs)
{
if ((rhs.lo == 0L) && (rhs.hi == 0L))
{
throw new ClipperException("Int128: divide by zero");
}
bool flag = (rhs.hi < 0L) != (lhs.hi < 0L);
if (lhs.hi < 0L)
{
lhs = -lhs;
}
if (rhs.hi < 0L)
{
rhs = -rhs;
}
if (rhs < lhs)
{
Int128 num = new Int128(0L);
Int128 num2 = new Int128(1L);
while ((rhs.hi >= 0L) && (rhs <= lhs))
{
rhs.hi = rhs.hi << 1;
if (rhs.lo < 0L)
{
rhs.hi += 1L;
}
rhs.lo = rhs.lo << 1;
num2.hi = num2.hi << 1;
if (num2.lo < 0L)
{
num2.hi += 1L;
}
num2.lo = num2.lo << 1;
}
rhs.lo = rhs.lo >> 1;
if ((rhs.hi & 1L) == 1L)
{
rhs.lo |= 9223372036854775808L;
}
rhs.hi = rhs.hi >> 1;
num2.lo = num2.lo >> 1;
if ((num2.hi & 1L) == 1L)
{
num2.lo |= 9223372036854775808L;
}
num2.hi = num2.hi >> 1;
while ((num2.hi != 0L) || (num2.lo != 0L))
{
if (lhs >= rhs)
{
lhs -= rhs;
num.hi |= num2.hi;
num.lo |= num2.lo;
}
rhs.lo = rhs.lo >> 1;
if ((rhs.hi & 1L) == 1L)
{
rhs.lo |= 9223372036854775808L;
}
rhs.hi = rhs.hi >> 1;
num2.lo = num2.lo >> 1;
if ((num2.hi & 1L) == 1L)
{
num2.lo |= 9223372036854775808L;
}
num2.hi = num2.hi >> 1;
}
return(!flag ? num : -num);
}
if (rhs == lhs)
{
return(new Int128(1L));
}
return(new Int128(0L));
}
internal bool PointInPolygon(IntPoint pt, OutPt pp, bool UseFullRange)
{
OutPt outPt = pp;
bool flag = false;
if (UseFullRange)
{
do
{
if (outPt.Pt.Y > pt.Y != outPt.Prev.Pt.Y > pt.Y && new Int128(pt.X - outPt.Pt.X) < Int128.Int128Mul(outPt.Prev.Pt.X - outPt.Pt.X, pt.Y - outPt.Pt.Y) / new Int128(outPt.Prev.Pt.Y - outPt.Pt.Y))
{
flag = !flag;
}
outPt = outPt.Next;
}while (outPt != pp);
}
else
{
do
{
if (outPt.Pt.Y > pt.Y != outPt.Prev.Pt.Y > pt.Y && pt.X - outPt.Pt.X < (outPt.Prev.Pt.X - outPt.Pt.X) * (pt.Y - outPt.Pt.Y) / (outPt.Prev.Pt.Y - outPt.Pt.Y))
{
flag = !flag;
}
outPt = outPt.Next;
}while (outPt != pp);
}
return(flag);
}
public static Int128 operator /(Int128 lhs, Int128 rhs)
{
if (rhs.lo == 0 && rhs.hi == 0)
throw new ClipperException("Int128: divide by zero");
bool negate = (rhs.hi < 0) != (lhs.hi < 0);
if (lhs.hi < 0) lhs = -lhs;
if (rhs.hi < 0) rhs = -rhs;
if (rhs < lhs)
{
Int128 result = new Int128(0);
Int128 cntr = new Int128(1);
while (rhs.hi >= 0 && !(rhs > lhs))
{
rhs.hi <<= 1;
if ((Int64)rhs.lo < 0) rhs.hi++;
rhs.lo <<= 1;
cntr.hi <<= 1;
if ((Int64)cntr.lo < 0) cntr.hi++;
cntr.lo <<= 1;
}
rhs.lo >>= 1;
if ((rhs.hi & 1) == 1)
rhs.lo |= 0x8000000000000000;
rhs.hi = (Int64)((UInt64)rhs.hi >> 1);
cntr.lo >>= 1;
if ((cntr.hi & 1) == 1)
cntr.lo |= 0x8000000000000000;
cntr.hi >>= 1;
while (cntr.hi != 0 || cntr.lo != 0)
{
if (!(lhs < rhs))
{
lhs -= rhs;
result.hi |= cntr.hi;
result.lo |= cntr.lo;
}
rhs.lo >>= 1;
if ((rhs.hi & 1) == 1)
rhs.lo |= 0x8000000000000000;
rhs.hi >>= 1;
cntr.lo >>= 1;
if ((cntr.hi & 1) == 1)
cntr.lo |= 0x8000000000000000;
cntr.hi >>= 1;
}
return negate ? -result : result;
}
else if (rhs == lhs)
return new Int128(1);
else
return new Int128(0);
}
//nb: Constructing two new Int128 objects every time we want to multiply longs
//is slow. So, although calling the Int128Mul method doesn't look as clean, the
//code runs significantly faster than if we'd used the * operator.
public static Int128 Int128Mul(Int64 lhs, Int64 rhs)
{
bool negate = (lhs < 0) != (rhs < 0);
if (lhs < 0) lhs = -lhs;
if (rhs < 0) rhs = -rhs;
UInt64 int1Hi = (UInt64)lhs >> 32;
UInt64 int1Lo = (UInt64)lhs & 0xFFFFFFFF;
UInt64 int2Hi = (UInt64)rhs >> 32;
UInt64 int2Lo = (UInt64)rhs & 0xFFFFFFFF;
//nb: see comments in clipper.pas
UInt64 a = int1Hi * int2Hi;
UInt64 b = int1Lo * int2Lo;
UInt64 c = int1Hi * int2Lo + int1Lo * int2Hi;
UInt64 lo;
Int64 hi;
hi = (Int64)(a + (c >> 32));
unchecked { lo = (c << 32) + b; }
if (lo < b) hi++;
Int128 result = new Int128(hi, lo);
return negate ? -result : result;
}
public Int128(Int128 val)
{
hi = val.hi;
lo = val.lo;
}