using System.Collections.Generic;
using System.Runtime.InteropServices;
using ScreenConnect;

namespace System;

[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct ValueTuple
{
	public static (T1, T2) Create<T1, T2>(T1 item1, T2 item2)
	{
		return (item1, item2);
	}

	public static (T1, T2, T3) Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
	{
		return (item1, item2, item3);
	}

	public static (T1, T2, T3, T4) Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
	{
		return (item1, item2, item3, item4);
	}

	public static (T1, T2, T3, T4, T5) Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
	{
		return (item1, item2, item3, item4, item5);
	}

	public static (T1, T2, T3, T4, T5, T6) Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
	{
		return (item1, item2, item3, item4, item5, item6);
	}

	public static (T1, T2, T3, T4, T5, T6, T7) Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
	{
		return (item1, item2, item3, item4, item5, item6, item7);
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2>(T1 item1, T2 item2) : IEquatable<(T1, T2)>, IComparable, IComparable<(T1, T2)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public static bool operator ==((T1, T2) left, (T1, T2) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2) left, (T1, T2) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2) left, (T1, T2) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2) left, (T1, T2) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2) left, (T1, T2) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2) left, (T1, T2) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1))
		{
			return EqualityComparer<T2>.Default.Equals(Item2, other.Item2);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T2>.Default.Compare(Item2, obj.Item2);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2);
	}

	public override string ToString()
	{
		return $"({Item1}, {Item2})";
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2, T3>(T1 item1, T2 item2, T3 item3) : IEquatable<(T1, T2, T3)>, IComparable, IComparable<(T1, T2, T3)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public T3 Item3 = item3;

	public static bool operator ==((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2, T3) left, (T1, T2, T3) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2, T3) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2))
		{
			return EqualityComparer<T3>.Default.Equals(Item3, other.Item3);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2, T3) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2, T3) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T2>.Default.Compare(Item2, obj.Item2);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T3>.Default.Compare(Item3, obj.Item3);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2, T3) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2).And(Item3);
	}

	public override string ToString()
	{
		return $"({Item1}, {Item2}, {Item3})";
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4) : IEquatable<(T1, T2, T3, T4)>, IComparable, IComparable<(T1, T2, T3, T4)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public T3 Item3 = item3;

	public T4 Item4 = item4;

	public static bool operator ==((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2, T3, T4) left, (T1, T2, T3, T4) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2, T3, T4) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3))
		{
			return EqualityComparer<T4>.Default.Equals(Item4, other.Item4);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2, T3, T4) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2, T3, T4) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T2>.Default.Compare(Item2, obj.Item2);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T3>.Default.Compare(Item3, obj.Item3);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T4>.Default.Compare(Item4, obj.Item4);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2, T3, T4) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2).And(Item3)
			.And(Item4);
	}

	public override string ToString()
	{
		return string.Format("({0}, {1}, {2}, {3})", new object[4] { Item1, Item2, Item3, Item4 });
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) : IEquatable<(T1, T2, T3, T4, T5)>, IComparable, IComparable<(T1, T2, T3, T4, T5)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public T3 Item3 = item3;

	public T4 Item4 = item4;

	public T5 Item5 = item5;

	public static bool operator ==((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2, T3, T4, T5) left, (T1, T2, T3, T4, T5) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2, T3, T4, T5) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4))
		{
			return EqualityComparer<T5>.Default.Equals(Item5, other.Item5);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2, T3, T4, T5) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2, T3, T4, T5) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T2>.Default.Compare(Item2, obj.Item2);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T3>.Default.Compare(Item3, obj.Item3);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T4>.Default.Compare(Item4, obj.Item4);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T5>.Default.Compare(Item5, obj.Item5);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2, T3, T4, T5) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2).And(Item3)
			.And(Item4)
			.And(Item5);
	}

	public override string ToString()
	{
		return string.Format("({0}, {1}, {2}, {3}, {4})", new object[5] { Item1, Item2, Item3, Item4, Item5 });
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) : IEquatable<(T1, T2, T3, T4, T5, T6)>, IComparable, IComparable<(T1, T2, T3, T4, T5, T6)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public T3 Item3 = item3;

	public T4 Item4 = item4;

	public T5 Item5 = item5;

	public T6 Item6 = item6;

	public static bool operator ==((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2, T3, T4, T5, T6) left, (T1, T2, T3, T4, T5, T6) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2, T3, T4, T5, T6) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4) && EqualityComparer<T5>.Default.Equals(Item5, other.Item5))
		{
			return EqualityComparer<T6>.Default.Equals(Item6, other.Item6);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2, T3, T4, T5, T6) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2, T3, T4, T5, T6) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T2>.Default.Compare(Item2, obj.Item2);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T3>.Default.Compare(Item3, obj.Item3);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T4>.Default.Compare(Item4, obj.Item4);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T5>.Default.Compare(Item5, obj.Item5);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T6>.Default.Compare(Item6, obj.Item6);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2, T3, T4, T5, T6) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2).And(Item3)
			.And(Item4)
			.And(Item5)
			.And(Item6);
	}

	public override string ToString()
	{
		return string.Format("({0}, {1}, {2}, {3}, {4}, {5})", new object[6] { Item1, Item2, Item3, Item4, Item5, Item6 });
	}
}
[StructLayout(LayoutKind.Auto)]
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) : IEquatable<(T1, T2, T3, T4, T5, T6, T7)>, IComparable, IComparable<(T1, T2, T3, T4, T5, T6, T7)>
{
	public T1 Item1 = item1;

	public T2 Item2 = item2;

	public T3 Item3 = item3;

	public T4 Item4 = item4;

	public T5 Item5 = item5;

	public T6 Item6 = item6;

	public T7 Item7 = item7;

	public static bool operator ==((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return left.Equals(right);
	}

	public static bool operator !=((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return !left.Equals(right);
	}

	public static bool operator <((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return left.CompareTo(right) < 0;
	}

	public static bool operator >((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return left.CompareTo(right) > 0;
	}

	public static bool operator <=((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return left.CompareTo(right) <= 0;
	}

	public static bool operator >=((T1, T2, T3, T4, T5, T6, T7) left, (T1, T2, T3, T4, T5, T6, T7) right)
	{
		return left.CompareTo(right) >= 0;
	}

	public bool Equals((T1, T2, T3, T4, T5, T6, T7) other)
	{
		if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4) && EqualityComparer<T5>.Default.Equals(Item5, other.Item5) && EqualityComparer<T6>.Default.Equals(Item6, other.Item6))
		{
			return EqualityComparer<T7>.Default.Equals(Item7, other.Item7);
		}
		return false;
	}

	public int CompareTo(object obj)
	{
		if (obj == null)
		{
			return 1;
		}
		if (obj is (T1, T2, T3, T4, T5, T6, T7) obj2)
		{
			return CompareTo(obj2);
		}
		throw new ArgumentException("Not a tuple.", "obj");
	}

	public int CompareTo((T1, T2, T3, T4, T5, T6, T7) obj)
	{
		int num = Comparer<T1>.Default.Compare(Item1, obj.Item1);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T2>.Default.Compare(Item2, obj.Item2);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T3>.Default.Compare(Item3, obj.Item3);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T4>.Default.Compare(Item4, obj.Item4);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T5>.Default.Compare(Item5, obj.Item5);
		if (num != 0)
		{
			return num;
		}
		num = Comparer<T6>.Default.Compare(Item6, obj.Item6);
		if (num != 0)
		{
			return num;
		}
		return Comparer<T7>.Default.Compare(Item7, obj.Item7);
	}

	public override bool Equals(object obj)
	{
		if (obj is (T1, T2, T3, T4, T5, T6, T7) other)
		{
			return Equals(other);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return ScreenConnect.HashCode.Seed.And(Item1).And(Item2).And(Item3)
			.And(Item4)
			.And(Item5)
			.And(Item6)
			.And(Item7);
	}

	public override string ToString()
	{
		return string.Format("({0}, {1}, {2}, {3}, {4}, {5}, {6})", new object[7] { Item1, Item2, Item3, Item4, Item5, Item6, Item7 });
	}
}