int.GetHashCode()

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountHolderCode != null)
                    hashCode = hashCode * 59 + this.AccountHolderCode.GetHashCode();
                if (this.AccountHolderDetails != null)
                    hashCode = hashCode * 59 + this.AccountHolderDetails.GetHashCode();
                if (this.Description != null)
                    hashCode = hashCode * 59 + this.Description.GetHashCode();
                if (this.LegalEnreplacedy != null)
                    hashCode = hashCode * 59 + this.LegalEnreplacedy.GetHashCode();
                if (this.PrimaryCurrency != null)
                    hashCode = hashCode * 59 + this.PrimaryCurrency.GetHashCode();
                if (this.ProcessingTier != null)
                    hashCode = hashCode * 59 + this.ProcessingTier.GetHashCode();
                return hashCode;
            }
        }

public int GetHashCode(EqualityComparerSample obj)
        {
            return obj.IntProperty.GetHashCode() ^ obj.StringProperty.GetHashCode();
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AcceptHeader != null)
                    hashCode = hashCode * 59 + this.AcceptHeader.GetHashCode();
                if (this.ColorDepth != null)
                    hashCode = hashCode * 59 + this.ColorDepth.GetHashCode();
                if (this.JavaEnabled != null)
                    hashCode = hashCode * 59 + this.JavaEnabled.GetHashCode();
                if (this.JavaScriptEnabled != null)
                    hashCode = hashCode * 59 + this.JavaScriptEnabled.GetHashCode();
                if (this.Language != null)
                    hashCode = hashCode * 59 + this.Language.GetHashCode();
                if (this.ScreenHeight != null)
                    hashCode = hashCode * 59 + this.ScreenHeight.GetHashCode();
                if (this.ScreenWidth != null)
                    hashCode = hashCode * 59 + this.ScreenWidth.GetHashCode();
                if (this.TimeZoneOffset != null)
                    hashCode = hashCode * 59 + this.TimeZoneOffset.GetHashCode();
                if (this.UserAgent != null)
                    hashCode = hashCode * 59 + this.UserAgent.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.DisableReason != null)
                    hashCode = hashCode * 59 + this.DisableReason.GetHashCode();
                if (this.Disabled != null)
                    hashCode = hashCode * 59 + this.Disabled.GetHashCode();
                if (this.ProcessedFrom != null)
                    hashCode = hashCode * 59 + this.ProcessedFrom.GetHashCode();
                if (this.ProcessedTo != null)
                    hashCode = hashCode * 59 + this.ProcessedTo.GetHashCode();
                if (this.TierNumber != null)
                    hashCode = hashCode * 59 + this.TierNumber.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountScore != null)
                    hashCode = hashCode * 59 + this.AccountScore.GetHashCode();
                if (this.CheckId != null)
                    hashCode = hashCode * 59 + this.CheckId.GetHashCode();
                if (this.Name != null)
                    hashCode = hashCode * 59 + this.Name.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
		{
			unchecked
			{
				return (Mantissa.GetHashCode() * 397) ^ Exponent.GetHashCode();
			}
		}

public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;
                // Suitable nullity checks etc, of course :)
                if (this.Value != null)
                    hash = hash * 59 + this.Value.GetHashCode();
                return hash;
            }
        }

public override int GetHashCode()
        {
            int hash = 0;

            if (Sphere != null)
                hash = (hash * 397) ^ Sphere.GetHashCode();

            hash = (hash * 397) ^ SplittingPlane.get_hash_code();
            hash = (hash * 397) ^ Type.GetHashCode();

            if (Typename != null)
                hash = (hash * 397) ^ Typename.GetHashCode();

            hash = (hash * 397) ^ NumPolys.GetHashCode();

            for (var i = 0; i < NumPolys; i++)
            {
                hash = (hash * 397) ^ PolyIDs[i].GetHashCode();
                hash = (hash * 397) ^ Polygons[i].GetHashCode();
            }
            if (PosNode != null)
                hash = (hash * 397) ^ PosNode.GetHashCode();

            if (NegNode != null)
                hash = (hash * 397) ^ NegNode.GetHashCode();

            return hash;
        }

internal override int GetDeepHashCode()
        {
            int valueHashCode = (_value != null) ? _value.GetHashCode() : 0;

            // GetHashCode on an enum boxes so cast to int
            return ((int)_valueType).GetHashCode() ^ valueHashCode;
        }

public override int GetHashCode()
        {
            var hash = base.GetHashCode();

            hash = (hash * 397) ^ NumPortals.GetHashCode();

            for (var i = 0; i < NumPortals; i++)
                hash = (hash * 397) ^ Portals[i].GetHashCode();

            return hash;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AcquirerBIN != null)
                    hashCode = hashCode * 59 + this.AcquirerBIN.GetHashCode();
                if (this.AcquirerMerchantID != null)
                    hashCode = hashCode * 59 + this.AcquirerMerchantID.GetHashCode();
                if (this.AuthenticationOnly != null)
                    hashCode = hashCode * 59 + this.AuthenticationOnly.GetHashCode();
                if (this.ChallengeIndicator != null)
                    hashCode = hashCode * 59 + this.ChallengeIndicator.GetHashCode();
                if (this.DeviceChannel != null)
                    hashCode = hashCode * 59 + this.DeviceChannel.GetHashCode();
                if (this.DeviceRenderOptions != null)
                    hashCode = hashCode * 59 + this.DeviceRenderOptions.GetHashCode();
                if (this.Mcc != null)
                    hashCode = hashCode * 59 + this.Mcc.GetHashCode();
                if (this.MerchantName != null)
                    hashCode = hashCode * 59 + this.MerchantName.GetHashCode();
                if (this.MessageVersion != null)
                    hashCode = hashCode * 59 + this.MessageVersion.GetHashCode();
                if (this.NotificationURL != null)
                    hashCode = hashCode * 59 + this.NotificationURL.GetHashCode();
                if (this.SdkAppID != null)
                    hashCode = hashCode * 59 + this.SdkAppID.GetHashCode();
                if (this.SdkEncData != null)
                    hashCode = hashCode * 59 + this.SdkEncData.GetHashCode();
                if (this.SdkEphemPubKey != null)
                    hashCode = hashCode * 59 + this.SdkEphemPubKey.GetHashCode();
                if (this.SdkMaxTimeout != null)
                    hashCode = hashCode * 59 + this.SdkMaxTimeout.GetHashCode();
                if (this.SdkReferenceNumber != null)
                    hashCode = hashCode * 59 + this.SdkReferenceNumber.GetHashCode();
                if (this.SdkTransID != null)
                    hashCode = hashCode * 59 + this.SdkTransID.GetHashCode();
                if (this.ThreeDSCompInd != null)
                    hashCode = hashCode * 59 + this.ThreeDSCompInd.GetHashCode();
                if (this.ThreeDSRequestorID != null)
                    hashCode = hashCode * 59 + this.ThreeDSRequestorID.GetHashCode();
                if (this.ThreeDSRequestorName != null)
                    hashCode = hashCode * 59 + this.ThreeDSRequestorName.GetHashCode();
                if (this.ThreeDSRequestorURL != null)
                    hashCode = hashCode * 59 + this.ThreeDSRequestorURL.GetHashCode();
                if (this.TransactionType != null)
                    hashCode = hashCode * 59 + this.TransactionType.GetHashCode();
                if (this.WhiteListStatus != null)
                    hashCode = hashCode * 59 + this.WhiteListStatus.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AddressMatch != null)
                    hashCode = hashCode * 59 + this.AddressMatch.GetHashCode();
                if (this.DeliveryAddressIndicator != null)
                    hashCode = hashCode * 59 + this.DeliveryAddressIndicator.GetHashCode();
                if (this.DeliveryEmail != null)
                    hashCode = hashCode * 59 + this.DeliveryEmail.GetHashCode();
                if (this.DeliveryTimeframe != null)
                    hashCode = hashCode * 59 + this.DeliveryTimeframe.GetHashCode();
                if (this.GiftCardAmount != null)
                    hashCode = hashCode * 59 + this.GiftCardAmount.GetHashCode();
                if (this.GiftCardCount != null)
                    hashCode = hashCode * 59 + this.GiftCardCount.GetHashCode();
                if (this.PreOrderDate != null)
                    hashCode = hashCode * 59 + this.PreOrderDate.GetHashCode();
                if (this.PreOrderPurchase != null)
                    hashCode = hashCode * 59 + this.PreOrderPurchase.GetHashCode();
                if (this.ReorderItems != null)
                    hashCode = hashCode * 59 + this.ReorderItems.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            int hashCode = Scope.GetHashCode();
            hashCode = (hashCode * 499) ^ (ContainerName != null ? ContainerName.ToLowerInvariant().GetHashCode() : 0);
            hashCode = (hashCode * 499) ^ (ModifiedSince != null ? ModifiedSince.GetHashCode() : 0);
            hashCode = (hashCode * 499) ^ (ModifiedAfterRevision != null ? ModifiedAfterRevision.GetHashCode() : 0);
            hashCode = (hashCode * 499) ^ (CoreAttributes != null ? CoreAttributes.GetHashCode() : 0);

            return hashCode;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.KycCheckCode != null)
                    hashCode = hashCode * 59 + this.KycCheckCode.GetHashCode();
                if (this.KycCheckDescription != null)
                    hashCode = hashCode * 59 + this.KycCheckDescription.GetHashCode();
                return hashCode;
            }
        }

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Code != 0) hash ^= Code.GetHashCode();
      if (Message.Length != 0) hash ^= Message.GetHashCode();
      hash ^= details_.GetHashCode();
      return hash;
    }

public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;
                // Suitable nullity checks etc, of course :)

                if (this.AcceptHeader != null)
                    hash = hash * 59 + this.AcceptHeader.GetHashCode();
                if (this.UserAgent != null)
                    hash = hash * 59 + this.UserAgent.GetHashCode();
                if (this.Language != null)
                    hash = hash * 59 + this.Language.GetHashCode();
                hash = hash * 59 + this.ColorDepth.GetHashCode();
                hash = hash * 59 + this.ScreenHeight.GetHashCode();
                hash = hash * 59 + this.ScreenWidth.GetHashCode();
                hash = hash * 59 + this.TimeZoneOffset.GetHashCode();
                hash = hash * 59 + this.JavaEnabled.GetHashCode();

                return hash;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountScore != null)
                    hashCode = hashCode * 59 + this.AccountScore.GetHashCode();
                if (this.Results != null)
                    hashCode = hashCode * 59 + this.Results.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            return (x.GetHashCode() + 7 * 13) ^ y.GetHashCode();
        }

public override int GetHashCode()
        {
            return DPI.GetHashCode() ^
                PollRate.GetHashCode() ^
                ShowLastMouseMove.GetHashCode() ^
                ShowVelocityAndGain.GetHashCode() ^
                AutoWriteToDriverOnStartup.GetHashCode() ^
                StreamingMode.GetHashCode();
        }

public override int GetHashCode()
        {
            int hashCode = -1089996163;
            hashCode = hashCode * -1521134295 + EqualityComparer<BaseGGUUID>.Default.GetHashCode(Id);
            hashCode = hashCode * -1521134295 + Level.GetHashCode();
            return hashCode;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.PaymentData != null)
                    hashCode = hashCode * 59 + this.PaymentData.GetHashCode();
                if (this.PaymentMethodType != null)
                    hashCode = hashCode * 59 + this.PaymentMethodType.GetHashCode();
                if (this.Redirect != null)
                    hashCode = hashCode * 59 + this.Redirect.GetHashCode();
                if (this.ResendInterval != null)
                    hashCode = hashCode * 59 + this.ResendInterval.GetHashCode();
                if (this.ResendMaxAttempts != null)
                    hashCode = hashCode * 59 + this.ResendMaxAttempts.GetHashCode();
                if (this.ResendUrl != null)
                    hashCode = hashCode * 59 + this.ResendUrl.GetHashCode();
                if (this.Url != null)
                    hashCode = hashCode * 59 + this.Url.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountAgeIndicator != null)
                    hashCode = hashCode * 59 + this.AccountAgeIndicator.GetHashCode();
                if (this.AccountChangeDate != null)
                    hashCode = hashCode * 59 + this.AccountChangeDate.GetHashCode();
                if (this.AccountChangeIndicator != null)
                    hashCode = hashCode * 59 + this.AccountChangeIndicator.GetHashCode();
                if (this.AccountCreationDate != null)
                    hashCode = hashCode * 59 + this.AccountCreationDate.GetHashCode();
                if (this.AccountType != null)
                    hashCode = hashCode * 59 + this.AccountType.GetHashCode();
                if (this.AddCardAttemptsDay != null)
                    hashCode = hashCode * 59 + this.AddCardAttemptsDay.GetHashCode();
                if (this.DeliveryAddressUsageDate != null)
                    hashCode = hashCode * 59 + this.DeliveryAddressUsageDate.GetHashCode();
                if (this.DeliveryAddressUsageIndicator != null)
                    hashCode = hashCode * 59 + this.DeliveryAddressUsageIndicator.GetHashCode();
                if (this.HomePhone != null)
                    hashCode = hashCode * 59 + this.HomePhone.GetHashCode();
                if (this.MobilePhone != null)
                    hashCode = hashCode * 59 + this.MobilePhone.GetHashCode();
                if (this.PreplacedwordChangeDate != null)
                    hashCode = hashCode * 59 + this.PreplacedwordChangeDate.GetHashCode();
                if (this.PreplacedwordChangeIndicator != null)
                    hashCode = hashCode * 59 + this.PreplacedwordChangeIndicator.GetHashCode();
                if (this.PastTransactionsDay != null)
                    hashCode = hashCode * 59 + this.PastTransactionsDay.GetHashCode();
                if (this.PastTransactionsYear != null)
                    hashCode = hashCode * 59 + this.PastTransactionsYear.GetHashCode();
                if (this.PaymentAccountAge != null)
                    hashCode = hashCode * 59 + this.PaymentAccountAge.GetHashCode();
                if (this.PaymentAccountIndicator != null)
                    hashCode = hashCode * 59 + this.PaymentAccountIndicator.GetHashCode();
                if (this.PurchasesLast6Months != null)
                    hashCode = hashCode * 59 + this.PurchasesLast6Months.GetHashCode();
                if (this.SuspiciousActivity != null)
                    hashCode = hashCode * 59 + this.SuspiciousActivity.GetHashCode();
                if (this.WorkPhone != null)
                    hashCode = hashCode * 59 + this.WorkPhone.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
		{
			return unchecked(191 * column.GetHashCode() ^ line.GetHashCode());
		}

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.MaxNumberOfInstallments != null)
                    hashCode = hashCode * 59 + this.MaxNumberOfInstallments.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            int hash = 0;

            hash = (hash * 397) ^ PolyID.GetHashCode();
            hash = (hash * 397) ^ NumPoints.GetHashCode();
            hash = (hash * 397) ^ Stippling.GetHashCode();
            hash = (hash * 397) ^ SidesType.GetHashCode();
            hash = (hash * 397) ^ PosSurface.GetHashCode();
            hash = (hash * 397) ^ NegSurface.GetHashCode();

            for (var i = 0; i < NumPoints; i++)
            {
                hash = (hash * 397) ^ Vertices[i].GetHashCode();
                hash = (hash * 397) ^ VertexIDs[i].GetHashCode();
            }

            return hash;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountHolderCode != null)
                    hashCode = hashCode * 59 + this.AccountHolderCode.GetHashCode();
                hashCode = hashCode * 59 + this.AccountStateType.GetHashCode();
                if (this.Tier != null)
                    hashCode = hashCode * 59 + this.Tier.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.ClientData != null)
                    hashCode = hashCode * 59 + this.ClientData.GetHashCode();
                if (this.CustomFields != null)
                    hashCode = hashCode * 59 + this.CustomFields.GetHashCode();
                if (this.FraudOffset != null)
                    hashCode = hashCode * 59 + this.FraudOffset.GetHashCode();
                if (this.ProfileReference != null)
                    hashCode = hashCode * 59 + this.ProfileReference.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            var hash = 0;

            hash = (hash * 397) ^ SurfaceFormat.GetHashCode();
            hash = (hash * 397) ^ Width.GetHashCode();
            hash = (hash * 397) ^ Height.GetHashCode();

            return hash;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AllowPayout != null)
                    hashCode = hashCode * 59 + this.AllowPayout.GetHashCode();
                if (this.DisableReason != null)
                    hashCode = hashCode * 59 + this.DisableReason.GetHashCode();
                if (this.Disabled != null)
                    hashCode = hashCode * 59 + this.Disabled.GetHashCode();
                if (this.NotAllowedReason != null)
                    hashCode = hashCode * 59 + this.NotAllowedReason.GetHashCode();
                if (this.PayoutLimit != null)
                    hashCode = hashCode * 59 + this.PayoutLimit.GetHashCode();
                if (this.TierNumber != null)
                    hashCode = hashCode * 59 + this.TierNumber.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
		{
			int hashCode = isAtEndOfLine ? 115817 : 0;
			unchecked {
				hashCode += 1000000007 * Line.GetHashCode();
				hashCode += 1000000009 * Column.GetHashCode();
				hashCode += 1000000021 * VisualColumn.GetHashCode();
			}
			return hashCode;
		}

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountHolderCode != null)
                    hashCode = hashCode * 59 + this.AccountHolderCode.GetHashCode();
                if (this.AccountHolderDetails != null)
                    hashCode = hashCode * 59 + this.AccountHolderDetails.GetHashCode();
                if (this.CreateDefaultAccount != null)
                    hashCode = hashCode * 59 + this.CreateDefaultAccount.GetHashCode();
                if (this.Description != null)
                    hashCode = hashCode * 59 + this.Description.GetHashCode();
                hashCode = hashCode * 59 + this.LegalEnreplacedy.GetHashCode();
                if (this.PrimaryCurrency != null)
                    hashCode = hashCode * 59 + this.PrimaryCurrency.GetHashCode();
                if (this.ProcessingTier != null)
                    hashCode = hashCode * 59 + this.ProcessingTier.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode() {
				return this.LineIndex.GetHashCode();
			}

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.AccountCode != null)
                    hashCode = hashCode * 59 + this.AccountCode.GetHashCode();
                if (this.Page != null)
                    hashCode = hashCode * 59 + this.Page.GetHashCode();
                return hashCode;
            }
        }

public bool TryInvoke(string name, object[] args, out object result)
        {
            object obj = Object;

            // Compute key, and try to find an already computed delegate
            int key = Combine(Combine(ObjectTypeHash, name.GetHashCode()), args.Length.GetHashCode());
            var objType = obj.GetType();

            if (data.Invokers.TryGetValue(key, out var del))
            {
                result = del(obj, args);
                return true;
            }

            // Nothing already computed, compute it now
            MethodInfo mi = FindMatchingMethod(objType.GetMethods(ALL), name, args) as MethodInfo;

            if (mi == null)
            {
                result = null;
                return false;
            }

            result = mi.Invoke(obj, args);
            return true;

            // TODO: Fix this. I can't get it to work.
            //data.Invokers[key] = del = Helpers.MakeDelegate<Func<object, object[], object>>(name, il =>
            //{
            //    bool isStatic = mi.IsStatic;

            //    if (!isStatic)
            //    {
            //        Type declaringType = mi.DeclaringType;

            //        il.Emit(OpCodes.Ldarg_0);

            //        if (declaringType.GetTypeInfo().IsValueType)
            //        {
            //            LocalBuilder loc = il.DeclareLocal(declaringType, false);

            //            il.Emit(OpCodes.Unbox_Any, declaringType);
            //            il.Emit(OpCodes.Stloc, loc);
            //            il.Emit(OpCodes.Ldloca, loc);
            //        }
            //        else // Who the f proxies object? if (declaringType != typeof(object))
            //        {
            //            il.Emit(OpCodes.Castclreplaced, declaringType);
            //        }
            //    }

            //    for (int j = 0; j < parameters.Length; j++)
            //    {
            //        Type type = parameters[j].ParameterType;

            //        il.Emit(OpCodes.Ldarg_1);
            //        il.Emit(OpCodes.Ldc_I4, j);
            //        il.Emit(OpCodes.Ldelem_Ref);

            //        if (type.GetTypeInfo().IsValueType)
            //            il.Emit(OpCodes.Unbox_Any, type);
            //        else if (type != typeof(object))
            //            il.Emit(OpCodes.Castclreplaced, type);
            //    }

            //    il.Emit(isStatic || mi.DeclaringType.GetTypeInfo().IsValueType ? OpCodes.Call : OpCodes.Callvirt, mi);

            //    if (mi.ReturnType.GetTypeInfo().IsValueType)
            //    {
            //        il.Emit(OpCodes.Box, mi.ReturnType);
            //    }
            //    else if (mi.ReturnType == typeof(void))
            //    {
            //        il.Emit(OpCodes.Ldnull);
            //    }

            //    il.Emit(OpCodes.Ret);
            //}, mi.DeclaringType);

            //result = del(obj, args);
            //return true;
        }

public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;
                // Suitable nullity checks etc, of course :)
                hash = hash * 59 + this.Status.GetHashCode();
                if (this.ErrorCode != null)
                    hash = hash * 59 + this.ErrorCode.GetHashCode();
                if (this.Message != null)
                    hash = hash * 59 + this.Message.GetHashCode();
                if (this.ErrorType != null)
                    hash = hash * 59 + this.ErrorType.GetHashCode();
                if (this.PspReference != null)
                    hash = hash * 59 + this.PspReference.GetHashCode();
                return hash;
            }
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.Account != null)
                    hashCode = hashCode * 59 + this.Account.GetHashCode();
                if (this.AccountType != null)
                    hashCode = hashCode * 59 + this.AccountType.GetHashCode();
                if (this.BaseAmount != null)
                    hashCode = hashCode * 59 + this.BaseAmount.GetHashCode();
                if (this.BasePoints != null)
                    hashCode = hashCode * 59 + this.BasePoints.GetHashCode();
                if (this.Buy != null)
                    hashCode = hashCode * 59 + this.Buy.GetHashCode();
                if (this.Interbank != null)
                    hashCode = hashCode * 59 + this.Interbank.GetHashCode();
                if (this.Reference != null)
                    hashCode = hashCode * 59 + this.Reference.GetHashCode();
                if (this.Sell != null)
                    hashCode = hashCode * 59 + this.Sell.GetHashCode();
                if (this.Signature != null)
                    hashCode = hashCode * 59 + this.Signature.GetHashCode();
                if (this.Source != null)
                    hashCode = hashCode * 59 + this.Source.GetHashCode();
                if (this.Type != null)
                    hashCode = hashCode * 59 + this.Type.GetHashCode();
                if (this.ValidTill != null)
                    hashCode = hashCode * 59 + this.ValidTill.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;
                // Suitable nullity checks etc, of course :)
                if (this.AccountScore != null)
                    hash = hash * 59 + this.AccountScore.GetHashCode();
                return hash;
            }
        }

public override int GetHashCode()
        {
            var hash = base.GetHashCode();

            hash = (hash * 397) ^ LeafIdx.GetHashCode();
            hash = (hash * 397) ^ Solid.GetHashCode();

            return hash;
        }

public override int GetHashCode()
        {
            return Id.GetHashCode();
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.MaxValue != null)
                    hashCode = hashCode * 59 + this.MaxValue.GetHashCode();
                if (this.Plans != null)
                    hashCode = hashCode * 59 + this.Plans.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
		{
			return Number.GetHashCode();
		}

public override int GetHashCode()
        {
            int hashCode = -671859081;

            unchecked
            {
                hashCode = (hashCode * -1521134295) + this.Numerator.GetHashCode();
                hashCode = (hashCode * -1521134295) + this.Denominator.GetHashCode();
            }

            return hashCode;
        }

public int GetHashCode(Event obj)
            {
                return obj.value.GetHashCode() ^ obj.version.GetHashCode();
            }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.Plan != null)
                    hashCode = hashCode * 59 + this.Plan.GetHashCode();
                if (this.Value != null)
                    hashCode = hashCode * 59 + this.Value.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            int hash = 0;

            hash = (hash * 397) ^ PortalIdx.GetHashCode();
            hash = (hash * 397) ^ Portal.GetHashCode();

            return hash;
        }

public override int GetHashCode()
            {
                unchecked
                {
                    var hashCode = this.ParentId;
                    hashCode = (hashCode * 397) ^ this.PropertyName.GetHashCode();
                    hashCode = (hashCode * 397) ^ this.ArrayIndex.GetHashCode();
                    return hashCode;
                }
            }

public override int GetHashCode()
        {
            switch (NumberType)
            {
                case BssomNumberType.Byte:
                    return GetByte().GetHashCode();
                case BssomNumberType.SByte:
                    return GetSByte().GetHashCode();
                case BssomNumberType.Short:
                    return GetShort().GetHashCode();
                case BssomNumberType.Int:
                    return GetInt().GetHashCode();
                case BssomNumberType.Long:
                    return GetLong().GetHashCode();
                case BssomNumberType.UShort:
                    return GetUShort().GetHashCode();
                case BssomNumberType.UInt:
                    return GetUInt().GetHashCode();
                default://case BssomNumberType.ULong:
                    return GetULong().GetHashCode();
            }
        }

public override int GetHashCode()
		{
			int hashCode = 0;
			unchecked {
				if (name != null)
					hashCode += 1000000007 * name.GetHashCode();
				hashCode += 1000000009 * fontWeight.GetHashCode();
				hashCode += 1000000021 * fontStyle.GetHashCode();
				if (foreground != null)
					hashCode += 1000000033 * foreground.GetHashCode();
				if (background != null)
					hashCode += 1000000087 * background.GetHashCode();
				if (fontFamily != null)
					hashCode += 1000000123 * fontFamily.GetHashCode();
				if (fontSize != null)
					hashCode += 1000000167 * fontSize.GetHashCode();
			}
			return hashCode;
		}

public override int GetHashCode()
        {
            int hash = 0;

            hash = (hash * 397) ^ PolyID.GetHashCode();
            hash = (hash * 397) ^ Stippling.GetHashCode();
            hash = (hash * 397) ^ SidesType.GetHashCode();
            hash = (hash * 397) ^ PosSurface.GetHashCode();
            hash = (hash * 397) ^ NegSurface.GetHashCode();

            for (var i = 0; i < Vertices.Count; i++)
            {
                hash = (hash * 397) ^ Vertices[i].GetHashCode();
                hash = (hash * 397) ^ VertexIDs[i].GetHashCode();
            }

            return hash;
        }

public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                int hashCode = 41;
                if (this.ErrorCode != null)
                    hashCode = hashCode * 59 + this.ErrorCode.GetHashCode();
                if (this.ErrorDescription != null)
                    hashCode = hashCode * 59 + this.ErrorDescription.GetHashCode();
                if (this.FieldType != null)
                    hashCode = hashCode * 59 + this.FieldType.GetHashCode();
                return hashCode;
            }
        }