using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Humanizer.Bytes;
using Humanizer.Configuration;
using Humanizer.DateTimeHumanizeStrategy;
using Humanizer.Inflections;
using Humanizer.Localisation;
using Humanizer.Localisation.CollectionFormatters;
using Humanizer.Localisation.DateToOrdinalWords;
using Humanizer.Localisation.Formatters;
using Humanizer.Localisation.GrammaticalNumber;
using Humanizer.Localisation.NumberToWords;
using Humanizer.Localisation.NumberToWords.Italian;
using Humanizer.Localisation.NumberToWords.Romanian;
using Humanizer.Localisation.Ordinalizers;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("2.14.1.48190")]
[assembly: AssemblyInformationalVersion("2.14.1+3ebc38de58")]
[assembly: NeutralResourcesLanguage("en")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyMetadata("CommitHash", "3ebc38de585fc641a04b0e78ed69468453b0f8a1")]
[assembly: AssemblyCompany("Mehdi Khalili, Claire Novotny")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © .NET Foundation and Contributors")]
[assembly: AssemblyDescription("A micro-framework that turns your normal strings, type names, enum fields, date fields ETC into a human friendly format")]
[assembly: AssemblyProduct("Humanizer (netstandard2.0)")]
[assembly: AssemblyTitle("Humanizer")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Humanizr/Humanizer")]
[assembly: AssemblyVersion("2.14.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.4.255.64262")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "2.14.1.48190";

	internal const string AssemblyInformationalVersion = "2.14.1+3ebc38de58";

	internal const string AssemblyName = "Humanizer";

	internal const string AssemblyTitle = "Humanizer";

	internal const string AssemblyVersion = "2.14.0.0";

	internal static readonly DateTime GitCommitDate = new DateTime(637790650430000000L, DateTimeKind.Utc);

	internal const string GitCommitId = "3ebc38de585fc641a04b0e78ed69468453b0f8a1";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "0024000004800000940000000602000000240000525341310004000001000100f9104f5f9bdb168ae140366eb1cd84c469b020ea3423d5d29996d5214ce2bd9b7c0ba3ead1ca545c4399668ab8911e61cc1cc83c7df6d50fd6b781365b467e65173f40a11c957d27c5aa0cb0f8da9c91c988203cc8aef1468c74a472839d0fd870da8d13a4dc6b3aafdaf0384d8e18e393c613d88bf02a64467a119902204fcc";

	internal const string PublicKeyToken = "979442b78dfc278e";

	internal const string RootNamespace = "Humanizer";
}
namespace Humanizer
{
	public static class EnglishArticle
	{
		public static string[] AppendArticlePrefix(string[] items)
		{
			if (items.Length == 0)
			{
				throw new ArgumentOutOfRangeException("items");
			}
			Regex regex = new Regex("^((The)|(the)|(a)|(A)|(An)|(an))\\s\\w+");
			string[] array = new string[items.Length];
			for (int i = 0; i < items.Length; i++)
			{
				if (regex.IsMatch(items[i]))
				{
					string text = items[i].Substring(0, items[i].IndexOf(" ", StringComparison.CurrentCulture));
					string text2 = items[i].Remove(0, items[i].IndexOf(" ", StringComparison.CurrentCulture)) + " " + text;
					array[i] = text2.Trim();
				}
				else
				{
					array[i] = items[i].Trim();
				}
			}
			Array.Sort(array);
			return array;
		}

		public static string[] PrependArticleSuffix(string[] appended)
		{
			string[] array = new string[appended.Length];
			for (int i = 0; i < appended.Length; i++)
			{
				if (appended[i].EndsWith(EnglishArticles.The.ToString()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" The", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else if (appended[i].EndsWith(EnglishArticles.A.ToString()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" A", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else if (appended[i].EndsWith(EnglishArticles.An.ToString()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" An", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else if (appended[i].EndsWith(EnglishArticles.A.ToString().ToLowerInvariant()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" a", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else if (appended[i].EndsWith(EnglishArticles.An.ToString().ToLowerInvariant()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" an", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else if (appended[i].EndsWith(EnglishArticles.The.ToString().ToLowerInvariant()))
				{
					string suffix = appended[i].Substring(appended[i].IndexOf(" the", StringComparison.CurrentCulture));
					string text = ToOriginalFormat(appended, suffix, i);
					array[i] = text;
				}
				else
				{
					array[i] = appended[i];
				}
			}
			return array;
		}

		private static string ToOriginalFormat(string[] appended, string suffix, int i)
		{
			string text = appended[i].Remove(appended[i].IndexOf(suffix, StringComparison.CurrentCulture));
			return (suffix + " " + text).Trim();
		}
	}
	public enum EnglishArticles
	{
		A,
		An,
		The
	}
	public static class ByteSizeExtensions
	{
		public static ByteSize Bits(this byte input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this sbyte input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this short input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this ushort input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this int input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this uint input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bits(this long input)
		{
			return ByteSize.FromBits(input);
		}

		public static ByteSize Bytes(this byte input)
		{
			return ByteSize.FromBytes((int)input);
		}

		public static ByteSize Bytes(this sbyte input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Bytes(this short input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Bytes(this ushort input)
		{
			return ByteSize.FromBytes((int)input);
		}

		public static ByteSize Bytes(this int input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Bytes(this uint input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Bytes(this double input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Bytes(this long input)
		{
			return ByteSize.FromBytes(input);
		}

		public static ByteSize Kilobytes(this byte input)
		{
			return ByteSize.FromKilobytes((int)input);
		}

		public static ByteSize Kilobytes(this sbyte input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Kilobytes(this short input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Kilobytes(this ushort input)
		{
			return ByteSize.FromKilobytes((int)input);
		}

		public static ByteSize Kilobytes(this int input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Kilobytes(this uint input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Kilobytes(this double input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Kilobytes(this long input)
		{
			return ByteSize.FromKilobytes(input);
		}

		public static ByteSize Megabytes(this byte input)
		{
			return ByteSize.FromMegabytes((int)input);
		}

		public static ByteSize Megabytes(this sbyte input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Megabytes(this short input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Megabytes(this ushort input)
		{
			return ByteSize.FromMegabytes((int)input);
		}

		public static ByteSize Megabytes(this int input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Megabytes(this uint input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Megabytes(this double input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Megabytes(this long input)
		{
			return ByteSize.FromMegabytes(input);
		}

		public static ByteSize Gigabytes(this byte input)
		{
			return ByteSize.FromGigabytes((int)input);
		}

		public static ByteSize Gigabytes(this sbyte input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Gigabytes(this short input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Gigabytes(this ushort input)
		{
			return ByteSize.FromGigabytes((int)input);
		}

		public static ByteSize Gigabytes(this int input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Gigabytes(this uint input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Gigabytes(this double input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Gigabytes(this long input)
		{
			return ByteSize.FromGigabytes(input);
		}

		public static ByteSize Terabytes(this byte input)
		{
			return ByteSize.FromTerabytes((int)input);
		}

		public static ByteSize Terabytes(this sbyte input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static ByteSize Terabytes(this short input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static ByteSize Terabytes(this ushort input)
		{
			return ByteSize.FromTerabytes((int)input);
		}

		public static ByteSize Terabytes(this int input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static ByteSize Terabytes(this uint input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static ByteSize Terabytes(this double input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static ByteSize Terabytes(this long input)
		{
			return ByteSize.FromTerabytes(input);
		}

		public static string Humanize(this ByteSize input, string format = null)
		{
			if (!string.IsNullOrWhiteSpace(format))
			{
				return input.ToString(format);
			}
			return input.ToString();
		}

		public static string Humanize(this ByteSize input, IFormatProvider formatProvider)
		{
			return input.ToString(formatProvider);
		}

		public static string Humanize(this ByteSize input, string format, IFormatProvider formatProvider)
		{
			if (!string.IsNullOrWhiteSpace(format))
			{
				return input.ToString(format, formatProvider);
			}
			return input.ToString(formatProvider);
		}

		public static ByteRate Per(this ByteSize size, TimeSpan interval)
		{
			return new ByteRate(size, interval);
		}
	}
	public static class CasingExtensions
	{
		public static string ApplyCase(this string input, LetterCasing casing)
		{
			return casing switch
			{
				LetterCasing.Title => input.Transform(To.TitleCase), 
				LetterCasing.LowerCase => input.Transform(To.LowerCase), 
				LetterCasing.AllCaps => input.Transform(To.UpperCase), 
				LetterCasing.Sentence => input.Transform(To.SentenceCase), 
				_ => throw new ArgumentOutOfRangeException("casing"), 
			};
		}
	}
	public enum ClockNotationRounding
	{
		None,
		NearestFiveMinutes
	}
	public static class CollectionHumanizeExtensions
	{
		public static string Humanize<T>(this IEnumerable<T> collection)
		{
			return Configurator.CollectionFormatter.Humanize(collection);
		}

		public static string Humanize<T>(this IEnumerable<T> collection, Func<T, string> displayFormatter)
		{
			if (displayFormatter == null)
			{
				throw new ArgumentNullException("displayFormatter");
			}
			return Configurator.CollectionFormatter.Humanize(collection, displayFormatter);
		}

		public static string Humanize<T>(this IEnumerable<T> collection, Func<T, object> displayFormatter)
		{
			if (displayFormatter == null)
			{
				throw new ArgumentNullException("displayFormatter");
			}
			return Configurator.CollectionFormatter.Humanize(collection, displayFormatter);
		}

		public static string Humanize<T>(this IEnumerable<T> collection, string separator)
		{
			return Configurator.CollectionFormatter.Humanize(collection, separator);
		}

		public static string Humanize<T>(this IEnumerable<T> collection, Func<T, string> displayFormatter, string separator)
		{
			if (displayFormatter == null)
			{
				throw new ArgumentNullException("displayFormatter");
			}
			return Configurator.CollectionFormatter.Humanize(collection, displayFormatter, separator);
		}

		public static string Humanize<T>(this IEnumerable<T> collection, Func<T, object> displayFormatter, string separator)
		{
			if (displayFormatter == null)
			{
				throw new ArgumentNullException("displayFormatter");
			}
			return Configurator.CollectionFormatter.Humanize(collection, displayFormatter, separator);
		}
	}
	public static class DateHumanizeExtensions
	{
		public static string Humanize(this DateTime input, bool? utcDate = null, DateTime? dateToCompareAgainst = null, CultureInfo culture = null)
		{
			DateTime dateTime = (dateToCompareAgainst.HasValue ? dateToCompareAgainst.Value : DateTime.UtcNow);
			bool valueOrDefault = utcDate.GetValueOrDefault();
			if (!utcDate.HasValue)
			{
				valueOrDefault = input.Kind != DateTimeKind.Local;
				utcDate = valueOrDefault;
			}
			dateTime = (utcDate.Value ? dateTime.ToUniversalTime() : dateTime.ToLocalTime());
			return Configurator.DateTimeHumanizeStrategy.Humanize(input, dateTime, culture);
		}

		public static string Humanize(this DateTime? input, bool? utcDate = null, DateTime? dateToCompareAgainst = null, CultureInfo culture = null)
		{
			if (input.HasValue)
			{
				return input.Value.Humanize(utcDate, dateToCompareAgainst, culture);
			}
			return Configurator.GetFormatter(culture).DateHumanize_Never();
		}

		public static string Humanize(this DateTimeOffset input, DateTimeOffset? dateToCompareAgainst = null, CultureInfo culture = null)
		{
			DateTimeOffset comparisonBase = dateToCompareAgainst ?? DateTimeOffset.UtcNow;
			return Configurator.DateTimeOffsetHumanizeStrategy.Humanize(input, comparisonBase, culture);
		}

		public static string Humanize(this DateTimeOffset? input, DateTimeOffset? dateToCompareAgainst = null, CultureInfo culture = null)
		{
			if (input.HasValue)
			{
				return input.Value.Humanize(dateToCompareAgainst, culture);
			}
			return Configurator.GetFormatter(culture).DateHumanize_Never();
		}
	}
	public static class DateToOrdinalWordsExtensions
	{
		public static string ToOrdinalWords(this DateTime input)
		{
			return Configurator.DateToOrdinalWordsConverter.Convert(input);
		}

		public static string ToOrdinalWords(this DateTime input, GrammaticalCase grammaticalCase)
		{
			return Configurator.DateToOrdinalWordsConverter.Convert(input, grammaticalCase);
		}
	}
	public static class EnumDehumanizeExtensions
	{
		public static TTargetEnum DehumanizeTo<TTargetEnum>(this string input) where TTargetEnum : struct, IComparable, IFormattable
		{
			return (TTargetEnum)DehumanizeToPrivate(input, typeof(TTargetEnum), OnNoMatch.ThrowsException);
		}

		public static Enum DehumanizeTo(this string input, Type targetEnum, OnNoMatch onNoMatch = OnNoMatch.ThrowsException)
		{
			return (Enum)DehumanizeToPrivate(input, targetEnum, onNoMatch);
		}

		private static object DehumanizeToPrivate(string input, Type targetEnum, OnNoMatch onNoMatch)
		{
			Enum? @enum = Enum.GetValues(targetEnum).Cast<Enum>().FirstOrDefault((Enum value) => string.Equals(value.Humanize(), input, StringComparison.OrdinalIgnoreCase));
			if (@enum == null && onNoMatch == OnNoMatch.ThrowsException)
			{
				throw new NoMatchFoundException("Couldn't find any enum member that matches the string " + input);
			}
			return @enum;
		}
	}
	public static class EnumHumanizeExtensions
	{
		private const string DisplayAttributeTypeName = "System.ComponentModel.DataAnnotations.DisplayAttribute";

		private const string DisplayAttributeGetDescriptionMethodName = "GetDescription";

		private const string DisplayAttributeGetNameMethodName = "GetName";

		private static readonly Func<PropertyInfo, bool> StringTypedProperty = (PropertyInfo p) => p.PropertyType == typeof(string);

		public static string Humanize(this Enum input)
		{
			Type enumType = input.GetType();
			TypeInfo typeInfo = enumType.GetTypeInfo();
			if (IsBitFieldEnum(typeInfo) && !Enum.IsDefined(enumType, input))
			{
				return (from e in (from Enum e in Enum.GetValues(enumType)
						where e.CompareTo(Convert.ChangeType(Enum.ToObject(enumType, 0), enumType)) != 0
						select e).Where(input.HasFlag)
					select e.Humanize()).Humanize();
			}
			string text = input.ToString();
			FieldInfo declaredField = typeInfo.GetDeclaredField(text);
			if (declaredField != null)
			{
				string customDescription = GetCustomDescription(declaredField);
				if (customDescription != null)
				{
					return customDescription;
				}
			}
			return text.Humanize();
		}

		private static bool IsBitFieldEnum(TypeInfo typeInfo)
		{
			return typeInfo.GetCustomAttribute(typeof(FlagsAttribute)) != null;
		}

		private static string GetCustomDescription(MemberInfo memberInfo)
		{
			object[] customAttributes = memberInfo.GetCustomAttributes(inherit: true);
			foreach (object obj in customAttributes)
			{
				Type type = obj.GetType();
				if (type.FullName == "System.ComponentModel.DataAnnotations.DisplayAttribute")
				{
					MethodInfo runtimeMethod = type.GetRuntimeMethod("GetDescription", new Type[0]);
					if (runtimeMethod != null)
					{
						object obj2 = runtimeMethod.Invoke(obj, new object[0]);
						if (obj2 != null)
						{
							return obj2.ToString();
						}
					}
					MethodInfo runtimeMethod2 = type.GetRuntimeMethod("GetName", new Type[0]);
					if (runtimeMethod2 != null)
					{
						object obj3 = runtimeMethod2.Invoke(obj, new object[0]);
						if (obj3 != null)
						{
							return obj3.ToString();
						}
					}
					return null;
				}
				PropertyInfo propertyInfo = type.GetRuntimeProperties().Where(StringTypedProperty).FirstOrDefault(Configurator.EnumDescriptionPropertyLocator);
				if (propertyInfo != null)
				{
					return propertyInfo.GetValue(obj, null).ToString();
				}
			}
			return null;
		}

		public static string Humanize(this Enum input, LetterCasing casing)
		{
			return input.Humanize().ApplyCase(casing);
		}
	}
	public class In
	{
		public static class One
		{
			public static DateTime Second => DateTime.UtcNow.AddSeconds(1.0);

			public static DateTime Minute => DateTime.UtcNow.AddMinutes(1.0);

			public static DateTime Hour => DateTime.UtcNow.AddHours(1.0);

			public static DateTime Day => DateTime.UtcNow.AddDays(1.0);

			public static DateTime Week => DateTime.UtcNow.AddDays(7.0);

			public static DateTime Month => DateTime.UtcNow.AddMonths(1);

			public static DateTime Year => DateTime.UtcNow.AddYears(1);

			public static DateTime SecondFrom(DateTime date)
			{
				return date.AddSeconds(1.0);
			}

			public static DateTime MinuteFrom(DateTime date)
			{
				return date.AddMinutes(1.0);
			}

			public static DateTime HourFrom(DateTime date)
			{
				return date.AddHours(1.0);
			}

			public static DateTime DayFrom(DateTime date)
			{
				return date.AddDays(1.0);
			}

			public static DateTime WeekFrom(DateTime date)
			{
				return date.AddDays(7.0);
			}

			public static DateTime MonthFrom(DateTime date)
			{
				return date.AddMonths(1);
			}

			public static DateTime YearFrom(DateTime date)
			{
				return date.AddYears(1);
			}
		}

		public static class Two
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(2.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(2.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(2.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(2.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(14.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(2);

			public static DateTime Years => DateTime.UtcNow.AddYears(2);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(2.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(2.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(2.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(2.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(14.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(2);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(2);
			}
		}

		public static class Three
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(3.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(3.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(3.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(3.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(21.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(3);

			public static DateTime Years => DateTime.UtcNow.AddYears(3);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(3.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(3.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(3.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(3.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(21.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(3);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(3);
			}
		}

		public static class Four
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(4.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(4.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(4.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(4.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(28.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(4);

			public static DateTime Years => DateTime.UtcNow.AddYears(4);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(4.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(4.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(4.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(4.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(28.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(4);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(4);
			}
		}

		public static class Five
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(5.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(5.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(5.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(5.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(35.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(5);

			public static DateTime Years => DateTime.UtcNow.AddYears(5);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(5.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(5.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(5.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(5.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(35.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(5);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(5);
			}
		}

		public static class Six
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(6.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(6.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(6.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(6.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(42.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(6);

			public static DateTime Years => DateTime.UtcNow.AddYears(6);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(6.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(6.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(6.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(6.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(42.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(6);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(6);
			}
		}

		public static class Seven
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(7.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(7.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(7.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(7.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(49.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(7);

			public static DateTime Years => DateTime.UtcNow.AddYears(7);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(7.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(7.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(7.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(7.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(49.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(7);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(7);
			}
		}

		public static class Eight
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(8.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(8.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(8.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(8.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(56.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(8);

			public static DateTime Years => DateTime.UtcNow.AddYears(8);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(8.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(8.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(8.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(8.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(56.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(8);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(8);
			}
		}

		public static class Nine
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(9.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(9.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(9.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(9.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(63.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(9);

			public static DateTime Years => DateTime.UtcNow.AddYears(9);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(9.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(9.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(9.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(9.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(63.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(9);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(9);
			}
		}

		public static class Ten
		{
			public static DateTime Seconds => DateTime.UtcNow.AddSeconds(10.0);

			public static DateTime Minutes => DateTime.UtcNow.AddMinutes(10.0);

			public static DateTime Hours => DateTime.UtcNow.AddHours(10.0);

			public static DateTime Days => DateTime.UtcNow.AddDays(10.0);

			public static DateTime Weeks => DateTime.UtcNow.AddDays(70.0);

			public static DateTime Months => DateTime.UtcNow.AddMonths(10);

			public static DateTime Years => DateTime.UtcNow.AddYears(10);

			public static DateTime SecondsFrom(DateTime date)
			{
				return date.AddSeconds(10.0);
			}

			public static DateTime MinutesFrom(DateTime date)
			{
				return date.AddMinutes(10.0);
			}

			public static DateTime HoursFrom(DateTime date)
			{
				return date.AddHours(10.0);
			}

			public static DateTime DaysFrom(DateTime date)
			{
				return date.AddDays(10.0);
			}

			public static DateTime WeeksFrom(DateTime date)
			{
				return date.AddDays(70.0);
			}

			public static DateTime MonthsFrom(DateTime date)
			{
				return date.AddMonths(10);
			}

			public static DateTime YearsFrom(DateTime date)
			{
				return date.AddYears(10);
			}
		}

		public static DateTime January => new DateTime(DateTime.UtcNow.Year, 1, 1);

		public static DateTime February => new DateTime(DateTime.UtcNow.Year, 2, 1);

		public static DateTime March => new DateTime(DateTime.UtcNow.Year, 3, 1);

		public static DateTime April => new DateTime(DateTime.UtcNow.Year, 4, 1);

		public static DateTime May => new DateTime(DateTime.UtcNow.Year, 5, 1);

		public static DateTime June => new DateTime(DateTime.UtcNow.Year, 6, 1);

		public static DateTime July => new DateTime(DateTime.UtcNow.Year, 7, 1);

		public static DateTime August => new DateTime(DateTime.UtcNow.Year, 8, 1);

		public static DateTime September => new DateTime(DateTime.UtcNow.Year, 9, 1);

		public static DateTime October => new DateTime(DateTime.UtcNow.Year, 10, 1);

		public static DateTime November => new DateTime(DateTime.UtcNow.Year, 11, 1);

		public static DateTime December => new DateTime(DateTime.UtcNow.Year, 12, 1);

		public static DateTime TheYear(int year)
		{
			return new DateTime(year, 1, 1);
		}

		public static DateTime JanuaryOf(int year)
		{
			return new DateTime(year, 1, 1);
		}

		public static DateTime FebruaryOf(int year)
		{
			return new DateTime(year, 2, 1);
		}

		public static DateTime MarchOf(int year)
		{
			return new DateTime(year, 3, 1);
		}

		public static DateTime AprilOf(int year)
		{
			return new DateTime(year, 4, 1);
		}

		public static DateTime MayOf(int year)
		{
			return new DateTime(year, 5, 1);
		}

		public static DateTime JuneOf(int year)
		{
			return new DateTime(year, 6, 1);
		}

		public static DateTime JulyOf(int year)
		{
			return new DateTime(year, 7, 1);
		}

		public static DateTime AugustOf(int year)
		{
			return new DateTime(year, 8, 1);
		}

		public static DateTime SeptemberOf(int year)
		{
			return new DateTime(year, 9, 1);
		}

		public static DateTime OctoberOf(int year)
		{
			return new DateTime(year, 10, 1);
		}

		public static DateTime NovemberOf(int year)
		{
			return new DateTime(year, 11, 1);
		}

		public static DateTime DecemberOf(int year)
		{
			return new DateTime(year, 12, 1);
		}
	}
	public class On
	{
		public class January
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 1, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 1, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 1, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 1, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 1, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 1, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 1, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 1, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 1, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 1, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 1, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 1, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 1, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 1, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 1, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 1, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 1, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 1, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 1, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 1, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 1, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 1, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 1, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 1, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 1, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 1, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 1, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 1, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 1, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 1, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 1, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 1, dayNumber);
			}
		}

		public class February
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 2, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 2, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 2, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 2, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 2, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 2, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 2, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 2, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 2, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 2, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 2, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 2, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 2, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 2, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 2, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 2, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 2, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 2, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 2, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 2, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 2, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 2, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 2, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 2, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 2, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 2, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 2, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 2, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 2, 29);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 2, dayNumber);
			}
		}

		public class March
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 3, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 3, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 3, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 3, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 3, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 3, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 3, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 3, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 3, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 3, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 3, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 3, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 3, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 3, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 3, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 3, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 3, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 3, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 3, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 3, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 3, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 3, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 3, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 3, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 3, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 3, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 3, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 3, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 3, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 3, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 3, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 3, dayNumber);
			}
		}

		public class April
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 4, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 4, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 4, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 4, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 4, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 4, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 4, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 4, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 4, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 4, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 4, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 4, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 4, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 4, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 4, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 4, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 4, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 4, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 4, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 4, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 4, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 4, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 4, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 4, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 4, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 4, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 4, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 4, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 4, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 4, 30);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 4, dayNumber);
			}
		}

		public class May
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 5, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 5, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 5, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 5, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 5, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 5, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 5, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 5, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 5, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 5, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 5, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 5, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 5, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 5, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 5, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 5, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 5, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 5, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 5, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 5, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 5, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 5, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 5, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 5, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 5, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 5, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 5, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 5, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 5, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 5, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 5, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 5, dayNumber);
			}
		}

		public class June
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 6, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 6, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 6, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 6, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 6, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 6, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 6, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 6, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 6, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 6, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 6, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 6, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 6, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 6, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 6, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 6, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 6, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 6, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 6, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 6, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 6, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 6, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 6, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 6, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 6, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 6, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 6, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 6, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 6, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 6, 30);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 6, dayNumber);
			}
		}

		public class July
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 7, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 7, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 7, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 7, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 7, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 7, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 7, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 7, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 7, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 7, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 7, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 7, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 7, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 7, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 7, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 7, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 7, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 7, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 7, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 7, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 7, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 7, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 7, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 7, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 7, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 7, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 7, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 7, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 7, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 7, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 7, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 7, dayNumber);
			}
		}

		public class August
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 8, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 8, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 8, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 8, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 8, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 8, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 8, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 8, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 8, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 8, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 8, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 8, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 8, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 8, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 8, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 8, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 8, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 8, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 8, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 8, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 8, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 8, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 8, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 8, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 8, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 8, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 8, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 8, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 8, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 8, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 8, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 8, dayNumber);
			}
		}

		public class September
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 9, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 9, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 9, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 9, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 9, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 9, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 9, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 9, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 9, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 9, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 9, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 9, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 9, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 9, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 9, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 9, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 9, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 9, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 9, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 9, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 9, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 9, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 9, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 9, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 9, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 9, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 9, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 9, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 9, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 9, 30);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 9, dayNumber);
			}
		}

		public class October
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 10, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 10, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 10, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 10, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 10, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 10, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 10, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 10, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 10, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 10, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 10, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 10, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 10, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 10, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 10, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 10, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 10, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 10, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 10, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 10, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 10, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 10, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 10, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 10, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 10, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 10, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 10, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 10, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 10, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 10, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 10, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 10, dayNumber);
			}
		}

		public class November
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 11, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 11, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 11, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 11, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 11, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 11, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 11, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 11, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 11, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 11, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 11, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 11, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 11, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 11, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 11, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 11, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 11, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 11, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 11, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 11, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 11, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 11, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 11, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 11, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 11, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 11, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 11, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 11, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 11, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 11, 30);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 11, dayNumber);
			}
		}

		public class December
		{
			public static DateTime The1st => new DateTime(DateTime.Now.Year, 12, 1);

			public static DateTime The2nd => new DateTime(DateTime.Now.Year, 12, 2);

			public static DateTime The3rd => new DateTime(DateTime.Now.Year, 12, 3);

			public static DateTime The4th => new DateTime(DateTime.Now.Year, 12, 4);

			public static DateTime The5th => new DateTime(DateTime.Now.Year, 12, 5);

			public static DateTime The6th => new DateTime(DateTime.Now.Year, 12, 6);

			public static DateTime The7th => new DateTime(DateTime.Now.Year, 12, 7);

			public static DateTime The8th => new DateTime(DateTime.Now.Year, 12, 8);

			public static DateTime The9th => new DateTime(DateTime.Now.Year, 12, 9);

			public static DateTime The10th => new DateTime(DateTime.Now.Year, 12, 10);

			public static DateTime The11th => new DateTime(DateTime.Now.Year, 12, 11);

			public static DateTime The12th => new DateTime(DateTime.Now.Year, 12, 12);

			public static DateTime The13th => new DateTime(DateTime.Now.Year, 12, 13);

			public static DateTime The14th => new DateTime(DateTime.Now.Year, 12, 14);

			public static DateTime The15th => new DateTime(DateTime.Now.Year, 12, 15);

			public static DateTime The16th => new DateTime(DateTime.Now.Year, 12, 16);

			public static DateTime The17th => new DateTime(DateTime.Now.Year, 12, 17);

			public static DateTime The18th => new DateTime(DateTime.Now.Year, 12, 18);

			public static DateTime The19th => new DateTime(DateTime.Now.Year, 12, 19);

			public static DateTime The20th => new DateTime(DateTime.Now.Year, 12, 20);

			public static DateTime The21st => new DateTime(DateTime.Now.Year, 12, 21);

			public static DateTime The22nd => new DateTime(DateTime.Now.Year, 12, 22);

			public static DateTime The23rd => new DateTime(DateTime.Now.Year, 12, 23);

			public static DateTime The24th => new DateTime(DateTime.Now.Year, 12, 24);

			public static DateTime The25th => new DateTime(DateTime.Now.Year, 12, 25);

			public static DateTime The26th => new DateTime(DateTime.Now.Year, 12, 26);

			public static DateTime The27th => new DateTime(DateTime.Now.Year, 12, 27);

			public static DateTime The28th => new DateTime(DateTime.Now.Year, 12, 28);

			public static DateTime The29th => new DateTime(DateTime.Now.Year, 12, 29);

			public static DateTime The30th => new DateTime(DateTime.Now.Year, 12, 30);

			public static DateTime The31st => new DateTime(DateTime.Now.Year, 12, 31);

			public static DateTime The(int dayNumber)
			{
				return new DateTime(DateTime.Now.Year, 12, dayNumber);
			}
		}
	}
	public static class PrepositionsExtensions
	{
		public static DateTime At(this DateTime date, int hour, int min = 0, int second = 0, int millisecond = 0)
		{
			return new DateTime(date.Year, date.Month, date.Day, hour, min, second, millisecond);
		}

		public static DateTime AtMidnight(this DateTime date)
		{
			return date.At(0);
		}

		public static DateTime AtNoon(this DateTime date)
		{
			return date.At(12);
		}

		public static DateTime In(this DateTime date, int year)
		{
			return new DateTime(year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Millisecond);
		}
	}
	public enum GrammaticalCase
	{
		Nominative,
		Genitive,
		Dative,
		Accusative,
		Instrumental,
		Prepositional
	}
	public enum GrammaticalGender
	{
		Masculine,
		Feminine,
		Neuter
	}
	public enum HeadingStyle
	{
		Abbreviated,
		Full
	}
	public static class HeadingExtensions
	{
		internal static readonly string[] headings = new string[16]
		{
			"N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSW",
			"SW", "WSW", "W", "WNW", "NW", "NNW"
		};

		internal static readonly char[] headingArrows = new char[8] { '↑', '↗', '→', '↘', '↓', '↙', '←', '↖' };

		public static string ToHeading(this double heading, HeadingStyle style = HeadingStyle.Abbreviated, CultureInfo culture = null)
		{
			int num = (int)(heading / 22.5 + 0.5);
			string text = headings[num % 16];
			if (style == HeadingStyle.Abbreviated)
			{
				return Resources.GetResource(text + "_Short", culture);
			}
			return Resources.GetResource(text, culture);
		}

		public static char ToHeadingArrow(this double heading)
		{
			int num = (int)(heading / 45.0 + 0.5);
			return headingArrows[num % 8];
		}

		public static double FromAbbreviatedHeading(this string heading)
		{
			return heading.FromAbbreviatedHeading(null);
		}

		public static double FromAbbreviatedHeading(this string heading, CultureInfo culture = null)
		{
			if (heading == null)
			{
				throw new ArgumentNullException("heading");
			}
			if (culture == null)
			{
				culture = CultureInfo.CurrentCulture;
			}
			string @string = culture.TextInfo.ToUpper(heading);
			for (int i = 0; i < headings.Length; i++)
			{
				string resource = Resources.GetResource(headings[i] + "_Short", culture);
				if (culture.CompareInfo.Compare(@string, resource) == 0)
				{
					return (double)i * 22.5;
				}
			}
			return -1.0;
		}

		public static double FromHeadingArrow(this char heading)
		{
			int num = Array.IndexOf(headingArrows, heading);
			if (num == -1)
			{
				return -1.0;
			}
			return (double)num * 45.0;
		}

		public static double FromHeadingArrow(this string heading)
		{
			if (heading == null)
			{
				throw new ArgumentNullException("heading");
			}
			if (heading.Length != 1)
			{
				return -1.0;
			}
			return heading[0].FromHeadingArrow();
		}
	}
	public static class InflectorExtensions
	{
		public static string Pluralize(this string word, bool inputIsKnownToBeSingular = true)
		{
			return Vocabularies.Default.Pluralize(word, inputIsKnownToBeSingular);
		}

		public static string Singularize(this string word, bool inputIsKnownToBePlural = true, bool skipSimpleWords = false)
		{
			return Vocabularies.Default.Singularize(word, inputIsKnownToBePlural, skipSimpleWords);
		}

		public static string Titleize(this string input)
		{
			return input.Humanize(LetterCasing.Title);
		}

		public static string Pascalize(this string input)
		{
			return Regex.Replace(input, "(?:^|_| +)(.)", (Match match) => match.Groups[1].Value.ToUpper());
		}

		public static string Camelize(this string input)
		{
			string text = input.Pascalize();
			if (text.Length <= 0)
			{
				return text;
			}
			return text.Substring(0, 1).ToLower() + text.Substring(1);
		}

		public static string Underscore(this string input)
		{
			return Regex.Replace(Regex.Replace(Regex.Replace(input, "([\\p{Lu}]+)([\\p{Lu}][\\p{Ll}])", "$1_$2"), "([\\p{Ll}\\d])([\\p{Lu}])", "$1_$2"), "[-\\s]", "_").ToLower();
		}

		public static string Dasherize(this string underscoredWord)
		{
			return underscoredWord.Replace('_', '-');
		}

		public static string Hyphenate(this string underscoredWord)
		{
			return underscoredWord.Dasherize();
		}

		public static string Kebaberize(this string input)
		{
			return input.Underscore().Dasherize();
		}
	}
	public enum LetterCasing
	{
		Title,
		AllCaps,
		LowerCase,
		Sentence
	}
	public static class MetricNumeralExtensions
	{
		private struct UnitPrefix
		{
			private readonly string _longScaleWord;

			public string Name { get; }

			public string ShortScaleWord { get; }

			public string LongScaleWord => _longScaleWord ?? ShortScaleWord;

			public UnitPrefix(string name, string shortScaleWord, string longScaleWord = null)
			{
				Name = name;
				ShortScaleWord = shortScaleWord;
				_longScaleWord = longScaleWord;
			}
		}

		private static readonly double BigLimit;

		private static readonly double SmallLimit;

		private static readonly List<char>[] Symbols;

		private static readonly Dictionary<char, UnitPrefix> UnitPrefixes;

		static MetricNumeralExtensions()
		{
			Symbols = new List<char>[2]
			{
				new List<char> { 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' },
				new List<char> { 'm', 'μ', 'n', 'p', 'f', 'a', 'z', 'y' }
			};
			UnitPrefixes = new Dictionary<char, UnitPrefix>
			{
				{
					'Y',
					new UnitPrefix("yotta", "septillion", "quadrillion")
				},
				{
					'Z',
					new UnitPrefix("zetta", "sextillion", "trilliard")
				},
				{
					'E',
					new UnitPrefix("exa", "quintillion", "trillion")
				},
				{
					'P',
					new UnitPrefix("peta", "quadrillion", "billiard")
				},
				{
					'T',
					new UnitPrefix("tera", "trillion", "billion")
				},
				{
					'G',
					new UnitPrefix("giga", "billion", "milliard")
				},
				{
					'M',
					new UnitPrefix("mega", "million")
				},
				{
					'k',
					new UnitPrefix("kilo", "thousand")
				},
				{
					'm',
					new UnitPrefix("milli", "thousandth")
				},
				{
					'μ',
					new UnitPrefix("micro", "millionth")
				},
				{
					'n',
					new UnitPrefix("nano", "billionth", "milliardth")
				},
				{
					'p',
					new UnitPrefix("pico", "trillionth", "billionth")
				},
				{
					'f',
					new UnitPrefix("femto", "quadrillionth", "billiardth")
				},
				{
					'a',
					new UnitPrefix("atto", "quintillionth", "trillionth")
				},
				{
					'z',
					new UnitPrefix("zepto", "sextillionth", "trilliardth")
				},
				{
					'y',
					new UnitPrefix("yocto", "septillionth", "quadrillionth")
				}
			};
			BigLimit = Math.Pow(10.0, 27.0);
			SmallLimit = Math.Pow(10.0, -27.0);
		}

		public static double FromMetric(this string input)
		{
			input = CleanRepresentation(input);
			return BuildNumber(input, input[input.Length - 1]);
		}

		[Obsolete("Please use overload with MetricNumeralFormats")]
		public static string ToMetric(this int input, bool hasSpace, bool useSymbol = true, int? decimals = null)
		{
			return ((double)input).ToMetric(hasSpace, useSymbol, decimals);
		}

		public static string ToMetric(this int input, MetricNumeralFormats? formats = null, int? decimals = null)
		{
			return ((double)input).ToMetric(formats, decimals);
		}

		[Obsolete("Please use overload with MetricNumeralFormats")]
		public static string ToMetric(this double input, bool hasSpace, bool useSymbol = true, int? decimals = null)
		{
			MetricNumeralFormats? metricNumeralFormats = null;
			if (hasSpace)
			{
				metricNumeralFormats = MetricNumeralFormats.WithSpace;
			}
			if (!useSymbol)
			{
				metricNumeralFormats = ((!metricNumeralFormats.HasValue) ? new MetricNumeralFormats?(MetricNumeralFormats.UseName) : (metricNumeralFormats | MetricNumeralFormats.UseName));
			}
			return input.ToMetric(metricNumeralFormats, decimals);
		}

		public static string ToMetric(this double input, MetricNumeralFormats? formats = null, int? decimals = null)
		{
			if (input.Equals(0.0))
			{
				return input.ToString();
			}
			if (input.IsOutOfRange())
			{
				throw new ArgumentOutOfRangeException("input");
			}
			return BuildRepresentation(input, formats, decimals);
		}

		private static string CleanRepresentation(string input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			input = input.Trim();
			input = ReplaceNameBySymbol(input);
			if (input.Length == 0 || input.IsInvalidMetricNumeral())
			{
				throw new ArgumentException("Empty or invalid Metric string.", "input");
			}
			return input.Replace(" ", string.Empty);
		}

		private static double BuildNumber(string input, char last)
		{
			if (!char.IsLetter(last))
			{
				return double.Parse(input);
			}
			return BuildMetricNumber(input, last);
		}

		private static double BuildMetricNumber(string input, char last)
		{
			double num = double.Parse(input.Remove(input.Length - 1));
			double num2 = Math.Pow(10.0, Symbols[0].Contains(last) ? getExponent(Symbols[0]) : (0.0 - getExponent(Symbols[1])));
			return num * num2;
			double getExponent(List<char> symbols)
			{
				return (symbols.IndexOf(last) + 1) * 3;
			}
		}

		private static string ReplaceNameBySymbol(string input)
		{
			return UnitPrefixes.Aggregate(input, (string current, KeyValuePair<char, UnitPrefix> unitPrefix) => current.Replace(unitPrefix.Value.Name, unitPrefix.Key.ToString()));
		}

		private static string BuildRepresentation(double input, MetricNumeralFormats? formats, int? decimals)
		{
			int exponent = (int)Math.Floor(Math.Log10(Math.Abs(input)) / 3.0);
			if (!exponent.Equals(0))
			{
				return BuildMetricRepresentation(input, exponent, formats, decimals);
			}
			string text = (decimals.HasValue ? Math.Round(input, decimals.Value).ToString() : input.ToString());
			if (((uint?)formats & 8u) == 8)
			{
				text += " ";
			}
			return text;
		}

		private static string BuildMetricRepresentation(double input, int exponent, MetricNumeralFormats? formats, int? decimals)
		{
			double value = input * Math.Pow(1000.0, -exponent);
			if (decimals.HasValue)
			{
				value = Math.Round(value, decimals.Value);
			}
			char symbol = ((Math.Sign(exponent) == 1) ? Symbols[0][exponent - 1] : Symbols[1][-exponent - 1]);
			return value.ToString("G15") + ((formats.HasValue && formats.Value.HasFlag(MetricNumeralFormats.WithSpace)) ? " " : string.Empty) + GetUnitText(symbol, formats);
		}

		private static string GetUnitText(char symbol, MetricNumeralFormats? formats)
		{
			if (formats.HasValue && formats.Value.HasFlag(MetricNumeralFormats.UseName))
			{
				return UnitPrefixes[symbol].Name;
			}
			if (formats.HasValue && formats.Value.HasFlag(MetricNumeralFormats.UseShortScaleWord))
			{
				return UnitPrefixes[symbol].ShortScaleWord;
			}
			if (formats.HasValue && formats.Value.HasFlag(MetricNumeralFormats.UseLongScaleWord))
			{
				return UnitPrefixes[symbol].LongScaleWord;
			}
			return symbol.ToString();
		}

		private static bool IsOutOfRange(this double input)
		{
			if (Math.Sign(input) != 1 || !outside(SmallLimit, BigLimit))
			{
				if (Math.Sign(input) == -1)
				{
					return outside(0.0 - BigLimit, 0.0 - SmallLimit);
				}
				return false;
			}
			return true;
			bool outside(double min, double max)
			{
				if (max > input)
				{
					return !(input > min);
				}
				return true;
			}
		}

		private static bool IsInvalidMetricNumeral(this string input)
		{
			int num = input.Length - 1;
			char item = input[num];
			double result;
			return !double.TryParse((Symbols[0].Contains(item) || Symbols[1].Contains(item)) ? input.Remove(num) : input, out result);
		}
	}
	[Flags]
	public enum MetricNumeralFormats
	{
		UseLongScaleWord = 1,
		UseName = 2,
		UseShortScaleWord = 4,
		WithSpace = 8
	}
	public class NoMatchFoundException : Exception
	{
		public NoMatchFoundException()
		{
		}

		public NoMatchFoundException(string message)
			: base(message)
		{
		}

		public NoMatchFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	public static class NumberToNumberExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Tens(this int input)
		{
			return input * 10;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Tens(this uint input)
		{
			return input * 10;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Tens(this long input)
		{
			return input * 10;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Tens(this ulong input)
		{
			return input * 10;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Tens(this double input)
		{
			return input * 10.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Hundreds(this int input)
		{
			return input * 100;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Hundreds(this uint input)
		{
			return input * 100;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Hundreds(this long input)
		{
			return input * 100;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Hundreds(this ulong input)
		{
			return input * 100;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Hundreds(this double input)
		{
			return input * 100.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Thousands(this int input)
		{
			return input * 1000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Thousands(this uint input)
		{
			return input * 1000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Thousands(this long input)
		{
			return input * 1000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Thousands(this ulong input)
		{
			return input * 1000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Thousands(this double input)
		{
			return input * 1000.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Millions(this int input)
		{
			return input * 1000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Millions(this uint input)
		{
			return input * 1000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Millions(this long input)
		{
			return input * 1000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Millions(this ulong input)
		{
			return input * 1000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Millions(this double input)
		{
			return input * 1000000.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Billions(this int input)
		{
			return input * 1000000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Billions(this uint input)
		{
			return input * 1000000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Billions(this long input)
		{
			return input * 1000000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Billions(this ulong input)
		{
			return input * 1000000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Billions(this double input)
		{
			return input * 1000000000.0;
		}
	}
	public static class NumberToTimeSpanExtensions
	{
		public static TimeSpan Milliseconds(this byte ms)
		{
			return ((double)(int)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this sbyte ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this short ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this ushort ms)
		{
			return ((double)(int)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this int ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this uint ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this long ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this ulong ms)
		{
			return ((double)ms).Milliseconds();
		}

		public static TimeSpan Milliseconds(this double ms)
		{
			return TimeSpan.FromMilliseconds(ms);
		}

		public static TimeSpan Seconds(this byte seconds)
		{
			return ((double)(int)seconds).Seconds();
		}

		public static TimeSpan Seconds(this sbyte seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this short seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this ushort seconds)
		{
			return ((double)(int)seconds).Seconds();
		}

		public static TimeSpan Seconds(this int seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this uint seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this long seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this ulong seconds)
		{
			return ((double)seconds).Seconds();
		}

		public static TimeSpan Seconds(this double seconds)
		{
			return TimeSpan.FromSeconds(seconds);
		}

		public static TimeSpan Minutes(this byte minutes)
		{
			return ((double)(int)minutes).Minutes();
		}

		public static TimeSpan Minutes(this sbyte minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this short minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this ushort minutes)
		{
			return ((double)(int)minutes).Minutes();
		}

		public static TimeSpan Minutes(this int minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this uint minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this long minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this ulong minutes)
		{
			return ((double)minutes).Minutes();
		}

		public static TimeSpan Minutes(this double minutes)
		{
			return TimeSpan.FromMinutes(minutes);
		}

		public static TimeSpan Hours(this byte hours)
		{
			return ((double)(int)hours).Hours();
		}

		public static TimeSpan Hours(this sbyte hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this short hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this ushort hours)
		{
			return ((double)(int)hours).Hours();
		}

		public static TimeSpan Hours(this int hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this uint hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this long hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this ulong hours)
		{
			return ((double)hours).Hours();
		}

		public static TimeSpan Hours(this double hours)
		{
			return TimeSpan.FromHours(hours);
		}

		public static TimeSpan Days(this byte days)
		{
			return ((double)(int)days).Days();
		}

		public static TimeSpan Days(this sbyte days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this short days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this ushort days)
		{
			return ((double)(int)days).Days();
		}

		public static TimeSpan Days(this int days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this uint days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this long days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this ulong days)
		{
			return ((double)days).Days();
		}

		public static TimeSpan Days(this double days)
		{
			return TimeSpan.FromDays(days);
		}

		public static TimeSpan Weeks(this byte input)
		{
			return ((double)(int)input).Weeks();
		}

		public static TimeSpan Weeks(this sbyte input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this short input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this ushort input)
		{
			return ((double)(int)input).Weeks();
		}

		public static TimeSpan Weeks(this int input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this uint input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this long input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this ulong input)
		{
			return ((double)input).Weeks();
		}

		public static TimeSpan Weeks(this double input)
		{
			return (7.0 * input).Days();
		}
	}
	public static class NumberToWordsExtension
	{
		public static string ToOrdinalWords(this int number, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).ConvertToOrdinal(number);
		}

		public static string ToOrdinalWords(this int number, WordForm wordForm, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).ConvertToOrdinal(number, wordForm);
		}

		public static string ToOrdinalWords(this int number, GrammaticalGender gender, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).ConvertToOrdinal(number, gender);
		}

		public static string ToOrdinalWords(this int number, GrammaticalGender gender, WordForm wordForm, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).ConvertToOrdinal(number, gender, wordForm);
		}

		public static string ToTuple(this int number, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).ConvertToTuple(number);
		}

		public static string ToWords(this int number, CultureInfo culture = null)
		{
			return ToWords(number, culture, addAnd: true);
		}

		public static string ToWords(this int number, WordForm wordForm, CultureInfo culture = null)
		{
			return ToWords(number, wordForm, culture, addAnd: false);
		}

		public static string ToWords(this int number, bool addAnd, CultureInfo culture = null)
		{
			return ToWords(number, culture, addAnd);
		}

		public static string ToWords(this int number, bool addAnd, WordForm wordForm, CultureInfo culture = null)
		{
			return ToWords(number, wordForm, culture, addAnd);
		}

		public static string ToWords(this int number, GrammaticalGender gender, CultureInfo culture = null)
		{
			return ((long)number).ToWords(gender, culture);
		}

		public static string ToWords(this int number, WordForm wordForm, GrammaticalGender gender, CultureInfo culture = null)
		{
			return ((long)number).ToWords(wordForm, gender, culture);
		}

		public static string ToWords(this long number, CultureInfo culture = null, bool addAnd = true)
		{
			return Configurator.GetNumberToWordsConverter(culture).Convert(number, addAnd);
		}

		public static string ToWords(this long number, WordForm wordForm, CultureInfo culture = null, bool addAnd = false)
		{
			return Configurator.GetNumberToWordsConverter(culture).Convert(number, addAnd, wordForm);
		}

		public static string ToWords(this long number, GrammaticalGender gender, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).Convert(number, gender);
		}

		public static string ToWords(this long number, WordForm wordForm, GrammaticalGender gender, CultureInfo culture = null)
		{
			return Configurator.GetNumberToWordsConverter(culture).Convert(number, wordForm, gender);
		}
	}
	public enum OnNoMatch
	{
		ThrowsException,
		ReturnsNull
	}
	public static class OrdinalizeExtensions
	{
		public static string Ordinalize(this string numberString)
		{
			return Configurator.Ordinalizer.Convert(int.Parse(numberString), numberString);
		}

		public static string Ordinalize(this string numberString, WordForm wordForm)
		{
			return Configurator.Ordinalizer.Convert(int.Parse(numberString), numberString, wordForm);
		}

		public static string Ordinalize(this string numberString, CultureInfo culture)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(int.Parse(numberString, culture), numberString);
		}

		public static string Ordinalize(this string numberString, CultureInfo culture, WordForm wordForm)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(int.Parse(numberString, culture), numberString, wordForm);
		}

		public static string Ordinalize(this string numberString, GrammaticalGender gender)
		{
			return Configurator.Ordinalizer.Convert(int.Parse(numberString), numberString, gender);
		}

		public static string Ordinalize(this string numberString, GrammaticalGender gender, WordForm wordForm)
		{
			return Configurator.Ordinalizer.Convert(int.Parse(numberString), numberString, gender, wordForm);
		}

		public static string Ordinalize(this string numberString, GrammaticalGender gender, CultureInfo culture)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(int.Parse(numberString, culture), numberString, gender);
		}

		public static string Ordinalize(this string numberString, GrammaticalGender gender, CultureInfo culture, WordForm wordForm)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(int.Parse(numberString, culture), numberString, gender, wordForm);
		}

		public static string Ordinalize(this int number)
		{
			return Configurator.Ordinalizer.Convert(number, number.ToString(CultureInfo.InvariantCulture));
		}

		public static string Ordinalize(this int number, WordForm wordForm)
		{
			return Configurator.Ordinalizer.Convert(number, number.ToString(CultureInfo.InvariantCulture), wordForm);
		}

		public static string Ordinalize(this int number, CultureInfo culture)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(number, number.ToString(culture));
		}

		public static string Ordinalize(this int number, CultureInfo culture, WordForm wordForm)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(number, number.ToString(culture), wordForm);
		}

		public static string Ordinalize(this int number, GrammaticalGender gender)
		{
			return Configurator.Ordinalizer.Convert(number, number.ToString(CultureInfo.InvariantCulture), gender);
		}

		public static string Ordinalize(this int number, GrammaticalGender gender, WordForm wordForm)
		{
			return Configurator.Ordinalizer.Convert(number, number.ToString(CultureInfo.InvariantCulture), gender, wordForm);
		}

		public static string Ordinalize(this int number, GrammaticalGender gender, CultureInfo culture)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(number, number.ToString(culture), gender);
		}

		public static string Ordinalize(this int number, GrammaticalGender gender, CultureInfo culture, WordForm wordForm)
		{
			return Configurator.Ordinalizers.ResolveForCulture(culture).Convert(number, number.ToString(culture), gender, wordForm);
		}
	}
	public enum Plurality
	{
		Singular,
		Plural,
		CouldBeEither
	}
	internal static class RegexOptionsUtil
	{
		public static RegexOptions Compiled { get; }

		static RegexOptionsUtil()
		{
			Compiled = (Enum.TryParse<RegexOptions>("Compiled", out var result) ? result : RegexOptions.None);
		}
	}
	public static class RomanNumeralExtensions
	{
		private const int NumberOfRomanNumeralMaps = 13;

		private static readonly IDictionary<string, int> RomanNumerals = new Dictionary<string, int>(13)
		{
			{ "M", 1000 },
			{ "CM", 900 },
			{ "D", 500 },
			{ "CD", 400 },
			{ "C", 100 },
			{ "XC", 90 },
			{ "L", 50 },
			{ "XL", 40 },
			{ "X", 10 },
			{ "IX", 9 },
			{ "V", 5 },
			{ "IV", 4 },
			{ "I", 1 }
		};

		private static readonly Regex ValidRomanNumeral = new Regex("^(?i:(?=[MDCLXVI])((M{0,3})((C[DM])|(D?C{0,3}))?((X[LC])|(L?XX{0,2})|L)?((I[VX])|(V?(II{0,2}))|V)?))$", RegexOptionsUtil.Compiled);

		public static int FromRoman(this string input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			input = input.Trim().ToUpperInvariant();
			int length = input.Length;
			if (length == 0 || IsInvalidRomanNumeral(input))
			{
				throw new ArgumentException("Empty or invalid Roman numeral string.", "input");
			}
			int num = 0;
			int num2 = length;
			while (num2 > 0)
			{
				int num3 = RomanNumerals[input[--num2].ToString()];
				if (num2 > 0)
				{
					int num4 = RomanNumerals[input[num2 - 1].ToString()];
					if (num4 < num3)
					{
						num3 -= num4;
						num2--;
					}
				}
				num += num3;
			}
			return num;
		}

		public static string ToRoman(this int input)
		{
			if (input < 1 || input > 3999)
			{
				throw new ArgumentOutOfRangeException();
			}
			StringBuilder stringBuilder = new StringBuilder(15);
			foreach (KeyValuePair<string, int> romanNumeral in RomanNumerals)
			{
				while (input / romanNumeral.Value > 0)
				{
					stringBuilder.Append(romanNumeral.Key);
					input -= romanNumeral.Value;
				}
			}
			return stringBuilder.ToString();
		}

		private static bool IsInvalidRomanNumeral(string input)
		{
			return !ValidRomanNumeral.IsMatch(input);
		}
	}
	public static class StringDehumanizeExtensions
	{
		public static string Dehumanize(this string input)
		{
			IEnumerable<string> values = from word in input.Split(new char[1] { ' ' })
				select word.Humanize().Pascalize();
			return string.Join("", values).Replace(" ", "");
		}
	}
	public static class StringExtensions
	{
		public static string FormatWith(this string format, params object[] args)
		{
			return string.Format(format, args);
		}

		public static string FormatWith(this string format, IFormatProvider provider, params object[] args)
		{
			return string.Format(provider, format, args);
		}
	}
	public static class StringHumanizeExtensions
	{
		private static readonly Regex PascalCaseWordPartsRegex;

		private static readonly Regex FreestandingSpacingCharRegex;

		static StringHumanizeExtensions()
		{
			PascalCaseWordPartsRegex = new Regex("[\\p{Lu}]?[\\p{Ll}]+|[0-9]+[\\p{Ll}]*|[\\p{Lu}]+(?=[\\p{Lu}][\\p{Ll}]|[0-9]|\\b)|[\\p{Lo}]+", RegexOptions.ExplicitCapture | RegexOptions.IgnorePatternWhitespace | RegexOptionsUtil.Compiled);
			FreestandingSpacingCharRegex = new Regex("\\s[-_]|[-_]\\s", RegexOptionsUtil.Compiled);
		}

		private static string FromUnderscoreDashSeparatedWords(string input)
		{
			return string.Join(" ", input.Split('_', '-'));
		}

		private static string FromPascalCase(string input)
		{
			string text = string.Join(" ", from Match match in PascalCaseWordPartsRegex.Matches(input)
				select (!match.Value.ToCharArray().All(char.IsUpper) || (match.Value.Length <= 1 && (match.Index <= 0 || input[match.Index - 1] != ' ') && !(match.Value == "I"))) ? match.Value.ToLower() : match.Value);
			if (text.Replace(" ", "").ToCharArray().All((char c) => char.IsUpper(c)) && text.Contains(" "))
			{
				text = text.ToLower();
			}
			if (text.Length <= 0)
			{
				return text;
			}
			return char.ToUpper(text[0]) + text.Substring(1, text.Length - 1);
		}

		public static string Humanize(this string input)
		{
			if (input.ToCharArray().All(char.IsUpper))
			{
				return input;
			}
			if (FreestandingSpacingCharRegex.IsMatch(input))
			{
				return FromPascalCase(FromUnderscoreDashSeparatedWords(input));
			}
			if (input.Contains("_") || input.Contains("-"))
			{
				return FromUnderscoreDashSeparatedWords(input);
			}
			return FromPascalCase(input);
		}

		public static string Humanize(this string input, LetterCasing casing)
		{
			return input.Humanize().ApplyCase(casing);
		}
	}
	public static class TimeSpanHumanizeExtensions
	{
		private const int _daysInAWeek = 7;

		private const double _daysInAYear = 365.2425;

		private const double _daysInAMonth = 30.436875;

		public static string Humanize(this TimeSpan timeSpan, int precision = 1, CultureInfo culture = null, TimeUnit maxUnit = TimeUnit.Week, TimeUnit minUnit = TimeUnit.Millisecond, string collectionSeparator = ", ", bool toWords = false)
		{
			return timeSpan.Humanize(precision, countEmptyUnits: false, culture, maxUnit, minUnit, collectionSeparator, toWords);
		}

		public static string Humanize(this TimeSpan timeSpan, int precision, bool countEmptyUnits, CultureInfo culture = null, TimeUnit maxUnit = TimeUnit.Week, TimeUnit minUnit = TimeUnit.Millisecond, string collectionSeparator = ", ", bool toWords = false)
		{
			return ConcatenateTimeSpanParts(SetPrecisionOfTimeSpan(CreateTheTimePartsWithUpperAndLowerLimits(timeSpan, culture, maxUnit, minUnit, toWords), precision, countEmptyUnits), culture, collectionSeparator);
		}

		private static IEnumerable<string> CreateTheTimePartsWithUpperAndLowerLimits(TimeSpan timespan, CultureInfo culture, TimeUnit maxUnit, TimeUnit minUnit, bool toWords = false)
		{
			IFormatter formatter = Configurator.GetFormatter(culture);
			bool flag = false;
			IEnumerable<TimeUnit> enumTypesForTimeUnit = GetEnumTypesForTimeUnit();
			List<string> list = new List<string>();
			foreach (TimeUnit item in enumTypesForTimeUnit)
			{
				string timeUnitPart = GetTimeUnitPart(item, timespan, maxUnit, minUnit, formatter, toWords);
				if (timeUnitPart != null || flag)
				{
					flag = true;
					list.Add(timeUnitPart);
				}
			}
			if (IsContainingOnlyNullValue(list))
			{
				list = CreateTimePartsWithNoTimeValue(toWords ? formatter.TimeSpanHumanize_Zero() : formatter.TimeSpanHumanize(minUnit, 0, toWords));
			}
			return list;
		}

		private static IEnumerable<TimeUnit> GetEnumTypesForTimeUnit()
		{
			return ((IEnumerable<TimeUnit>)Enum.GetValues(typeof(TimeUnit))).Reverse();
		}

		private static string GetTimeUnitPart(TimeUnit timeUnitToGet, TimeSpan timespan, TimeUnit maximumTimeUnit, TimeUnit minimumTimeUnit, IFormatter cultureFormatter, bool toWords = false)
		{
			if (timeUnitToGet <= maximumTimeUnit && timeUnitToGet >= minimumTimeUnit)
			{
				int timeUnitNumericalValue = GetTimeUnitNumericalValue(timeUnitToGet, timespan, maximumTimeUnit);
				return BuildFormatTimePart(cultureFormatter, timeUnitToGet, timeUnitNumericalValue, toWords);
			}
			return null;
		}

		private static int GetTimeUnitNumericalValue(TimeUnit timeUnitToGet, TimeSpan timespan, TimeUnit maximumTimeUnit)
		{
			bool isTimeUnitToGetTheMaximumTimeUnit = timeUnitToGet == maximumTimeUnit;
			return timeUnitToGet switch
			{
				TimeUnit.Millisecond => GetNormalCaseTimeAsInteger(timespan.Milliseconds, timespan.TotalMilliseconds, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Second => GetNormalCaseTimeAsInteger(timespan.Seconds, timespan.TotalSeconds, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Minute => GetNormalCaseTimeAsInteger(timespan.Minutes, timespan.TotalMinutes, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Hour => GetNormalCaseTimeAsInteger(timespan.Hours, timespan.TotalHours, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Day => GetSpecialCaseDaysAsInteger(timespan, maximumTimeUnit), 
				TimeUnit.Week => GetSpecialCaseWeeksAsInteger(timespan, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Month => GetSpecialCaseMonthAsInteger(timespan, isTimeUnitToGetTheMaximumTimeUnit), 
				TimeUnit.Year => GetSpecialCaseYearAsInteger(timespan), 
				_ => 0, 
			};
		}

		private static int GetSpecialCaseMonthAsInteger(TimeSpan timespan, bool isTimeUnitToGetTheMaximumTimeUnit)
		{
			if (isTimeUnitToGetTheMaximumTimeUnit)
			{
				return (int)((double)timespan.Days / 30.436875);
			}
			return (int)((double)timespan.Days % 365.2425 / 30.436875);
		}

		private static int GetSpecialCaseYearAsInteger(TimeSpan timespan)
		{
			return (int)((double)timespan.Days / 365.2425);
		}

		private static int GetSpecialCaseWeeksAsInteger(TimeSpan timespan, bool isTimeUnitToGetTheMaximumTimeUnit)
		{
			if (isTimeUnitToGetTheMaximumTimeUnit || (double)timespan.Days < 30.436875)
			{
				return timespan.Days / 7;
			}
			return 0;
		}

		private static int GetSpecialCaseDaysAsInteger(TimeSpan timespan, TimeUnit maximumTimeUnit)
		{
			if (maximumTimeUnit == TimeUnit.Day)
			{
				return timespan.Days;
			}
			if ((double)timespan.Days < 30.436875 || maximumTimeUnit == TimeUnit.Week)
			{
				return timespan.Days % 7;
			}
			return (int)((double)timespan.Days % 30.436875);
		}

		private static int GetNormalCaseTimeAsInteger(int timeNumberOfUnits, double totalTimeNumberOfUnits, bool isTimeUnitToGetTheMaximumTimeUnit)
		{
			if (isTimeUnitToGetTheMaximumTimeUnit)
			{
				try
				{
					return (int)totalTimeNumberOfUnits;
				}
				catch
				{
					return 0;
				}
			}
			return timeNumberOfUnits;
		}

		private static string BuildFormatTimePart(IFormatter cultureFormatter, TimeUnit timeUnitType, int amountOfTimeUnits, bool toWords = false)
		{
			if (amountOfTimeUnits == 0)
			{
				return null;
			}
			return cultureFormatter.TimeSpanHumanize(timeUnitType, Math.Abs(amountOfTimeUnits), toWords);
		}

		private static List<string> CreateTimePartsWithNoTimeValue(string noTimeValue)
		{
			return new List<string> { noTimeValue };
		}

		private static bool IsContainingOnlyNullValue(IEnumerable<string> timeParts)
		{
			return timeParts.Count((string x) => x != null) == 0;
		}

		private static IEnumerable<string> SetPrecisionOfTimeSpan(IEnumerable<string> timeParts, int precision, bool countEmptyUnits)
		{
			if (!countEmptyUnits)
			{
				timeParts = timeParts.Where((string x) => x != null);
			}
			timeParts = timeParts.Take(precision);
			if (countEmptyUnits)
			{
				timeParts = timeParts.Where((string x) => x != null);
			}
			return timeParts;
		}

		private static string ConcatenateTimeSpanParts(IEnumerable<string> timeSpanParts, CultureInfo culture, string collectionSeparator)
		{
			if (collectionSeparator == null)
			{
				return Configurator.CollectionFormatters.ResolveForCulture(culture).Humanize(timeSpanParts);
			}
			return string.Join(collectionSeparator, timeSpanParts);
		}
	}
	public static class TimeUnitToSymbolExtensions
	{
		public static string ToSymbol(this TimeUnit unit, CultureInfo culture = null)
		{
			return Configurator.GetFormatter(culture).TimeUnitHumanize(unit);
		}
	}
	public enum ShowQuantityAs
	{
		None,
		Numeric,
		Words
	}
	public static class ToQuantityExtensions
	{
		public static string ToQuantity(this string input, int quantity, ShowQuantityAs showQuantityAs = ShowQuantityAs.Numeric)
		{
			return input.ToQuantity(quantity, showQuantityAs, null, null);
		}

		public static string ToQuantity(this string input, int quantity, string format, IFormatProvider formatProvider = null)
		{
			return input.ToQuantity(quantity, ShowQuantityAs.Numeric, format, formatProvider);
		}

		public static string ToQuantity(this string input, long quantity, ShowQuantityAs showQuantityAs = ShowQuantityAs.Numeric)
		{
			return input.ToQuantity(quantity, showQuantityAs, null, null);
		}

		public static string ToQuantity(this string input, long qu