Aug2021-Cpp2IL-Dump/mscorlib/System/String.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Text;
using Cpp2IlInjected;

namespace System
{
	/// <summary>Represents text as a sequence of UTF-16 code units.</summary>
	// Token: 0x02000139 RID: 313
	[Token(Token = "0x2000139")]
	[ComVisible(true)]
	[Serializable]
	public sealed class String : IComparable, ICloneable, IConvertible, IEnumerable, IComparable<string>, IEnumerable<char>, IEquatable<string>
	{
		/// <summary>Concatenates all the elements of a string array, using the specified separator between each element.</summary>
		/// <param name="separator">The string to use as a separator. <paramref name="separator" /> is included in the returned string only if <paramref name="value" /> has more than one element.</param>
		/// <param name="value">An array that contains the elements to concatenate.</param>
		/// <returns>A string that consists of the elements in <paramref name="value" /> delimited by the <paramref name="separator" /> string. If <paramref name="value" /> is an empty array, the method returns <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000BB9 RID: 3001 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BB9")]
		[Address(RVA = "0x2C4B8D0", Offset = "0x2C4A6D0", VA = "0x182C4B8D0")]
		public static string Join(string separator, params string[] value)
		{
			return null;
		}

		/// <summary>Concatenates the members of a collection, using the specified separator between each member.</summary>
		/// <param name="separator">The string to use as a separator.<paramref name="separator" /> is included in the returned string only if <paramref name="values" /> has more than one element.</param>
		/// <param name="values">A collection that contains the objects to concatenate.</param>
		/// <typeparam name="T">The type of the members of <paramref name="values" />.</typeparam>
		/// <returns>A string that consists of the members of <paramref name="values" /> delimited by the <paramref name="separator" /> string. If <paramref name="values" /> has no members, the method returns <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="values" /> is <see langword="null" />.</exception>
		// Token: 0x06000BBA RID: 3002 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BBA")]
		[Address(RVA = "0x1B5AE50", Offset = "0x1B59C50", VA = "0x181B5AE50")]
		[ComVisible(false)]
		public static string Join<T>(string separator, IEnumerable<T> values)
		{
			return null;
		}

		/// <summary>Concatenates the members of a constructed <see cref="T:System.Collections.Generic.IEnumerable`1" /> collection of type <see cref="T:System.String" />, using the specified separator between each member.</summary>
		/// <param name="separator">The string to use as a separator.<paramref name="separator" /> is included in the returned string only if <paramref name="values" /> has more than one element.</param>
		/// <param name="values">A collection that contains the strings to concatenate.</param>
		/// <returns>A string that consists of the members of <paramref name="values" /> delimited by the <paramref name="separator" /> string. If <paramref name="values" /> has no members, the method returns <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="values" /> is <see langword="null" />.</exception>
		// Token: 0x06000BBB RID: 3003 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BBB")]
		[Address(RVA = "0x2C4B650", Offset = "0x2C4A450", VA = "0x182C4B650")]
		[ComVisible(false)]
		public static string Join(string separator, IEnumerable<string> values)
		{
			return null;
		}

		/// <summary>Concatenates the specified elements of a string array, using the specified separator between each element.</summary>
		/// <param name="separator">The string to use as a separator. <paramref name="separator" /> is included in the returned string only if <paramref name="value" /> has more than one element.</param>
		/// <param name="value">An array that contains the elements to concatenate.</param>
		/// <param name="startIndex">The first element in <paramref name="value" /> to use.</param>
		/// <param name="count">The number of elements of <paramref name="value" /> to use.</param>
		/// <returns>A string that consists of the strings in <paramref name="value" /> delimited by the <paramref name="separator" /> string.  
		///  -or-  
		///  <see cref="F:System.String.Empty" /> if <paramref name="count" /> is zero, <paramref name="value" /> has no elements, or <paramref name="separator" /> and all the elements of <paramref name="value" /> are <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="count" /> is less than 0.  
		/// -or-  
		/// <paramref name="startIndex" /> plus <paramref name="count" /> is greater than the number of elements in <paramref name="value" />.</exception>
		/// <exception cref="T:System.OutOfMemoryException">Out of memory.</exception>
		// Token: 0x06000BBC RID: 3004 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BBC")]
		[Address(RVA = "0x2C4B960", Offset = "0x2C4A760", VA = "0x182C4B960")]
		public static string Join(string separator, string[] value, int startIndex, int count)
		{
			return null;
		}

		// Token: 0x06000BBD RID: 3005 RVA: 0x0000A368 File Offset: 0x00008568
		[Token(Token = "0x6000BBD")]
		[Address(RVA = "0x2C460D0", Offset = "0x2C44ED0", VA = "0x182C460D0")]
		private static int CompareOrdinalIgnoreCaseHelper(string strA, string strB)
		{
			return 0;
		}

		// Token: 0x06000BBE RID: 3006 RVA: 0x0000A380 File Offset: 0x00008580
		[Token(Token = "0x6000BBE")]
		[Address(RVA = "0x2C49320", Offset = "0x2C48120", VA = "0x182C49320")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		private static bool EqualsHelper(string strA, string strB)
		{
			return default(bool);
		}

		// Token: 0x06000BBF RID: 3007 RVA: 0x0000A398 File Offset: 0x00008598
		[Token(Token = "0x6000BBF")]
		[Address(RVA = "0x2C45F20", Offset = "0x2C44D20", VA = "0x182C45F20")]
		private static int CompareOrdinalHelper(string strA, string strB)
		{
			return 0;
		}

		/// <summary>Determines whether this instance and a specified object, which must also be a <see cref="T:System.String" /> object, have the same value.</summary>
		/// <param name="obj">The string to compare to this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="obj" /> is a <see cref="T:System.String" /> and its value is the same as this instance; otherwise, <see langword="false" />.  If <paramref name="obj" /> is <see langword="null" />, the method returns <see langword="false" />.</returns>
		// Token: 0x06000BC0 RID: 3008 RVA: 0x0000A3B0 File Offset: 0x000085B0
		[Token(Token = "0x6000BC0")]
		[Address(RVA = "0x2C49740", Offset = "0x2C48540", VA = "0x182C49740", Slot = "0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public override bool Equals(object obj)
		{
			return default(bool);
		}

		/// <summary>Determines whether this instance and another specified <see cref="T:System.String" /> object have the same value.</summary>
		/// <param name="value">The string to compare to this instance.</param>
		/// <returns>
		///   <see langword="true" /> if the value of the <paramref name="value" /> parameter is the same as the value of this instance; otherwise, <see langword="false" />. If <paramref name="value" /> is <see langword="null" />, the method returns <see langword="false" />.</returns>
		// Token: 0x06000BC1 RID: 3009 RVA: 0x0000A3C8 File Offset: 0x000085C8
		[Token(Token = "0x6000BC1")]
		[Address(RVA = "0x2C49820", Offset = "0x2C48620", VA = "0x182C49820", Slot = "26")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public bool Equals(string value)
		{
			return default(bool);
		}

		/// <summary>Determines whether this string and a specified <see cref="T:System.String" /> object have the same value. A parameter specifies the culture, case, and sort rules used in the comparison.</summary>
		/// <param name="value">The string to compare to this instance.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies how the strings will be compared.</param>
		/// <returns>
		///   <see langword="true" /> if the value of the <paramref name="value" /> parameter is the same as this string; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000BC2 RID: 3010 RVA: 0x0000A3E0 File Offset: 0x000085E0
		[Token(Token = "0x6000BC2")]
		[Address(RVA = "0x2C498C0", Offset = "0x2C486C0", VA = "0x182C498C0")]
		public bool Equals(string value, StringComparison comparisonType)
		{
			return default(bool);
		}

		/// <summary>Determines whether two specified <see cref="T:System.String" /> objects have the same value.</summary>
		/// <param name="a">The first string to compare, or <see langword="null" />.</param>
		/// <param name="b">The second string to compare, or <see langword="null" />.</param>
		/// <returns>
		///   <see langword="true" /> if the value of <paramref name="a" /> is the same as the value of <paramref name="b" />; otherwise, <see langword="false" />. If both <paramref name="a" /> and <paramref name="b" /> are <see langword="null" />, the method returns <see langword="true" />.</returns>
		// Token: 0x06000BC3 RID: 3011 RVA: 0x0000A3F8 File Offset: 0x000085F8
		[Token(Token = "0x6000BC3")]
		[Address(RVA = "0x2C497F0", Offset = "0x2C485F0", VA = "0x182C497F0")]
		public static bool Equals(string a, string b)
		{
			return default(bool);
		}

		/// <summary>Determines whether two specified <see cref="T:System.String" /> objects have the same value. A parameter specifies the culture, case, and sort rules used in the comparison.</summary>
		/// <param name="a">The first string to compare, or <see langword="null" />.</param>
		/// <param name="b">The second string to compare, or <see langword="null" />.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the comparison.</param>
		/// <returns>
		///   <see langword="true" /> if the value of the <paramref name="a" /> parameter is equal to the value of the <paramref name="b" /> parameter; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000BC4 RID: 3012 RVA: 0x0000A410 File Offset: 0x00008610
		[Token(Token = "0x6000BC4")]
		[Address(RVA = "0x2C49430", Offset = "0x2C48230", VA = "0x182C49430")]
		public static bool Equals(string a, string b, StringComparison comparisonType)
		{
			return default(bool);
		}

		/// <summary>Determines whether two specified strings have the same value.</summary>
		/// <param name="a">The first string to compare, or <see langword="null" />.</param>
		/// <param name="b">The second string to compare, or <see langword="null" />.</param>
		/// <returns>
		///   <see langword="true" /> if the value of <paramref name="a" /> is the same as the value of <paramref name="b" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000BC5 RID: 3013 RVA: 0x0000A428 File Offset: 0x00008628
		[Token(Token = "0x6000BC5")]
		[Address(RVA = "0x2C497F0", Offset = "0x2C485F0", VA = "0x182C497F0")]
		public static bool operator ==(string a, string b)
		{
			return default(bool);
		}

		/// <summary>Determines whether two specified strings have different values.</summary>
		/// <param name="a">The first string to compare, or <see langword="null" />.</param>
		/// <param name="b">The second string to compare, or <see langword="null" />.</param>
		/// <returns>
		///   <see langword="true" /> if the value of <paramref name="a" /> is different from the value of <paramref name="b" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000BC6 RID: 3014 RVA: 0x0000A440 File Offset: 0x00008640
		[Token(Token = "0x6000BC6")]
		[Address(RVA = "0x2C4F920", Offset = "0x2C4E720", VA = "0x182C4F920")]
		public static bool operator !=(string a, string b)
		{
			return default(bool);
		}

		/// <summary>Gets the <see cref="T:System.Char" /> object at a specified position in the current <see cref="T:System.String" /> object.</summary>
		/// <param name="index">A position in the current string.</param>
		/// <returns>The object at position <paramref name="index" />.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index" /> is greater than or equal to the length of this object or less than zero.</exception>
		// Token: 0x170000F5 RID: 245
		[Token(Token = "0x170000F5")]
		[IndexerName("Chars")]
		public char this[int index]
		{
			[Token(Token = "0x6000BC7")]
			[Address(RVA = "0x2C4F600", Offset = "0x2C4E400", VA = "0x182C4F600")]
			get
			{
				return '\0';
			}
		}

		/// <summary>Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.</summary>
		/// <param name="sourceIndex">The index of the first character in this instance to copy.</param>
		/// <param name="destination">An array of Unicode characters to which characters in this instance are copied.</param>
		/// <param name="destinationIndex">The index in <paramref name="destination" /> at which the copy operation begins.</param>
		/// <param name="count">The number of characters in this instance to copy to <paramref name="destination" />.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="destination" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="sourceIndex" />, <paramref name="destinationIndex" />, or <paramref name="count" /> is negative  
		/// -or-  
		/// <paramref name="sourceIndex" /> does not identify a position in the current instance.  
		/// -or-  
		/// <paramref name="destinationIndex" /> does not identify a valid index in the <paramref name="destination" /> array.  
		/// -or-  
		/// <paramref name="count" /> is greater than the length of the substring from <paramref name="sourceIndex" /> to the end of this instance  
		/// -or-  
		/// <paramref name="count" /> is greater than the length of the subarray from <paramref name="destinationIndex" /> to the end of the <paramref name="destination" /> array.</exception>
		// Token: 0x06000BC8 RID: 3016 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BC8")]
		[Address(RVA = "0x2C48020", Offset = "0x2C46E20", VA = "0x182C48020")]
		public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
		{
		}

		/// <summary>Copies the characters in this instance to a Unicode character array.</summary>
		/// <returns>A Unicode character array whose elements are the individual characters of this instance. If this instance is an empty string, the returned array is empty and has a zero length.</returns>
		// Token: 0x06000BC9 RID: 3017 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BC9")]
		[Address(RVA = "0x2C4EE40", Offset = "0x2C4DC40", VA = "0x182C4EE40")]
		public char[] ToCharArray()
		{
			return null;
		}

		/// <summary>Copies the characters in a specified substring in this instance to a Unicode character array.</summary>
		/// <param name="startIndex">The starting position of a substring in this instance.</param>
		/// <param name="length">The length of the substring in this instance.</param>
		/// <returns>A Unicode character array whose elements are the <paramref name="length" /> number of characters in this instance starting from character position <paramref name="startIndex" />.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="length" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> plus <paramref name="length" /> is greater than the length of this instance.</exception>
		// Token: 0x06000BCA RID: 3018 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BCA")]
		[Address(RVA = "0x2C4ED00", Offset = "0x2C4DB00", VA = "0x182C4ED00")]
		public char[] ToCharArray(int startIndex, int length)
		{
			return null;
		}

		/// <summary>Indicates whether the specified string is <see langword="null" /> or an empty string ("").</summary>
		/// <param name="value">The string to test.</param>
		/// <returns>
		///   <see langword="true" /> if the <paramref name="value" /> parameter is <see langword="null" /> or an empty string (""); otherwise, <see langword="false" />.</returns>
		// Token: 0x06000BCB RID: 3019 RVA: 0x0000A470 File Offset: 0x00008670
		[Token(Token = "0x6000BCB")]
		[Address(RVA = "0x2633BA0", Offset = "0x26329A0", VA = "0x182633BA0")]
		public static bool IsNullOrEmpty(string value)
		{
			return default(bool);
		}

		/// <summary>Indicates whether a specified string is <see langword="null" />, empty, or consists only of white-space characters.</summary>
		/// <param name="value">The string to test.</param>
		/// <returns>
		///   <see langword="true" /> if the <paramref name="value" /> parameter is <see langword="null" /> or <see cref="F:System.String.Empty" />, or if <paramref name="value" /> consists exclusively of white-space characters.</returns>
		// Token: 0x06000BCC RID: 3020 RVA: 0x0000A488 File Offset: 0x00008688
		[Token(Token = "0x6000BCC")]
		[Address(RVA = "0x2C4B5B0", Offset = "0x2C4A3B0", VA = "0x182C4B5B0")]
		public static bool IsNullOrWhiteSpace(string value)
		{
			return default(bool);
		}

		/// <summary>Returns the hash code for this string.</summary>
		/// <returns>A 32-bit signed integer hash code.</returns>
		// Token: 0x06000BCD RID: 3021 RVA: 0x0000A4A0 File Offset: 0x000086A0
		[Token(Token = "0x6000BCD")]
		[Address(RVA = "0x2C4A1A0", Offset = "0x2C48FA0", VA = "0x182C4A1A0", Slot = "2")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x06000BCE RID: 3022 RVA: 0x0000A4B8 File Offset: 0x000086B8
		[Token(Token = "0x6000BCE")]
		[Address(RVA = "0x2C4A1A0", Offset = "0x2C48FA0", VA = "0x182C4A1A0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		internal int GetLegacyNonRandomizedHashCode()
		{
			return 0;
		}

		/// <summary>Splits a string into substrings that are based on the characters in an array.</summary>
		/// <param name="separator">A character array that delimits the substrings in this string, an empty array that contains no delimiters, or <see langword="null" />.</param>
		/// <returns>An array whose elements contain the substrings from this instance that are delimited by one or more characters in <paramref name="separator" />. For more information, see the Remarks section.</returns>
		// Token: 0x06000BCF RID: 3023 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BCF")]
		[Address(RVA = "0x2C4DBD0", Offset = "0x2C4C9D0", VA = "0x182C4DBD0")]
		public string[] Split(params char[] separator)
		{
			return null;
		}

		/// <summary>Splits a string into a maximum number of substrings based on the characters in an array. You also specify the maximum number of substrings to return.</summary>
		/// <param name="separator">A character array that delimits the substrings in this string, an empty array that contains no delimiters, or <see langword="null" />.</param>
		/// <param name="count">The maximum number of substrings to return.</param>
		/// <returns>An array whose elements contain the substrings in this instance that are delimited by one or more characters in <paramref name="separator" />. For more information, see the Remarks section.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is negative.</exception>
		// Token: 0x06000BD0 RID: 3024 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD0")]
		[Address(RVA = "0x2C4DFC0", Offset = "0x2C4CDC0", VA = "0x182C4DFC0")]
		public string[] Split(char[] separator, int count)
		{
			return null;
		}

		/// <summary>Splits a string into substrings based on the characters in an array. You can specify whether the substrings include empty array elements.</summary>
		/// <param name="separator">A character array that delimits the substrings in this string, an empty array that contains no delimiters, or <see langword="null" />.</param>
		/// <param name="options">
		///   <see cref="F:System.StringSplitOptions.RemoveEmptyEntries" /> to omit empty array elements from the array returned; or <see cref="F:System.StringSplitOptions.None" /> to include empty array elements in the array returned.</param>
		/// <returns>An array whose elements contain the substrings in this string that are delimited by one or more characters in <paramref name="separator" />. For more information, see the Remarks section.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not one of the <see cref="T:System.StringSplitOptions" /> values.</exception>
		// Token: 0x06000BD1 RID: 3025 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD1")]
		[Address(RVA = "0x2C4DBF0", Offset = "0x2C4C9F0", VA = "0x182C4DBF0")]
		[ComVisible(false)]
		public string[] Split(char[] separator, StringSplitOptions options)
		{
			return null;
		}

		// Token: 0x06000BD2 RID: 3026 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD2")]
		[Address(RVA = "0x2C4D9B0", Offset = "0x2C4C7B0", VA = "0x182C4D9B0")]
		[ComVisible(false)]
		internal string[] SplitInternal(char[] separator, int count, StringSplitOptions options)
		{
			return null;
		}

		/// <summary>Splits a string into substrings based on the strings in an array. You can specify whether the substrings include empty array elements.</summary>
		/// <param name="separator">A string array that delimits the substrings in this string, an empty array that contains no delimiters, or <see langword="null" />.</param>
		/// <param name="options">
		///   <see cref="F:System.StringSplitOptions.RemoveEmptyEntries" /> to omit empty array elements from the array returned; or <see cref="F:System.StringSplitOptions.None" /> to include empty array elements in the array returned.</param>
		/// <returns>An array whose elements contain the substrings in this string that are delimited by one or more strings in <paramref name="separator" />. For more information, see the Remarks section.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not one of the <see cref="T:System.StringSplitOptions" /> values.</exception>
		// Token: 0x06000BD3 RID: 3027 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD3")]
		[Address(RVA = "0x2C4DBB0", Offset = "0x2C4C9B0", VA = "0x182C4DBB0")]
		[ComVisible(false)]
		public string[] Split(string[] separator, StringSplitOptions options)
		{
			return null;
		}

		/// <summary>Splits a string into a maximum number of substrings based on the strings in an array. You can specify whether the substrings include empty array elements.</summary>
		/// <param name="separator">A string array that delimits the substrings in this string, an empty array that contains no delimiters, or <see langword="null" />.</param>
		/// <param name="count">The maximum number of substrings to return.</param>
		/// <param name="options">
		///   <see cref="F:System.StringSplitOptions.RemoveEmptyEntries" /> to omit empty array elements from the array returned; or <see cref="F:System.StringSplitOptions.None" /> to include empty array elements in the array returned.</param>
		/// <returns>An array whose elements contain the substrings in this string that are delimited by one or more strings in <paramref name="separator" />. For more information, see the Remarks section.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is negative.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not one of the <see cref="T:System.StringSplitOptions" /> values.</exception>
		// Token: 0x06000BD4 RID: 3028 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD4")]
		[Address(RVA = "0x2C4DC10", Offset = "0x2C4CA10", VA = "0x182C4DC10")]
		[ComVisible(false)]
		public string[] Split(string[] separator, int count, StringSplitOptions options)
		{
			return null;
		}

		// Token: 0x06000BD5 RID: 3029 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD5")]
		[Address(RVA = "0x2C4AF30", Offset = "0x2C49D30", VA = "0x182C4AF30")]
		private string[] InternalSplitKeepEmptyEntries(int[] sepList, int[] lengthList, int numReplaces, int count)
		{
			return null;
		}

		// Token: 0x06000BD6 RID: 3030 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD6")]
		[Address(RVA = "0x2C4B1D0", Offset = "0x2C49FD0", VA = "0x182C4B1D0")]
		private string[] InternalSplitOmitEmptyEntries(int[] sepList, int[] lengthList, int numReplaces, int count)
		{
			return null;
		}

		// Token: 0x06000BD7 RID: 3031 RVA: 0x0000A4D0 File Offset: 0x000086D0
		[Token(Token = "0x6000BD7")]
		[Address(RVA = "0x2C4C690", Offset = "0x2C4B490", VA = "0x182C4C690")]
		private int MakeSeparatorList(char[] separator, ref int[] sepList)
		{
			return 0;
		}

		// Token: 0x06000BD8 RID: 3032 RVA: 0x0000A4E8 File Offset: 0x000086E8
		[Token(Token = "0x6000BD8")]
		[Address(RVA = "0x2C4C830", Offset = "0x2C4B630", VA = "0x182C4C830")]
		private int MakeSeparatorList(string[] separators, ref int[] sepList, ref int[] lengthList)
		{
			return 0;
		}

		/// <summary>Retrieves a substring from this instance. The substring starts at a specified character position and continues to the end of the string.</summary>
		/// <param name="startIndex">The zero-based starting character position of a substring in this instance.</param>
		/// <returns>A string that is equivalent to the substring that begins at <paramref name="startIndex" /> in this instance, or <see cref="F:System.String.Empty" /> if <paramref name="startIndex" /> is equal to the length of this instance.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is less than zero or greater than the length of this instance.</exception>
		// Token: 0x06000BD9 RID: 3033 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BD9")]
		[Address(RVA = "0x2C4E3B0", Offset = "0x2C4D1B0", VA = "0x182C4E3B0")]
		public string Substring(int startIndex)
		{
			return null;
		}

		/// <summary>Retrieves a substring from this instance. The substring starts at a specified character position and has a specified length.</summary>
		/// <param name="startIndex">The zero-based starting character position of a substring in this instance.</param>
		/// <param name="length">The number of characters in the substring.</param>
		/// <returns>A string that is equivalent to the substring of length <paramref name="length" /> that begins at <paramref name="startIndex" /> in this instance, or <see cref="F:System.String.Empty" /> if <paramref name="startIndex" /> is equal to the length of this instance and <paramref name="length" /> is zero.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> plus <paramref name="length" /> indicates a position not within this instance.  
		/// -or-  
		/// <paramref name="startIndex" /> or <paramref name="length" /> is less than zero.</exception>
		// Token: 0x06000BDA RID: 3034 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BDA")]
		[Address(RVA = "0x2C4E3C0", Offset = "0x2C4D1C0", VA = "0x182C4E3C0")]
		public string Substring(int startIndex, int length)
		{
			return null;
		}

		// Token: 0x06000BDB RID: 3035 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BDB")]
		[Address(RVA = "0x2C4B510", Offset = "0x2C4A310", VA = "0x182C4B510")]
		private string InternalSubString(int startIndex, int length)
		{
			return null;
		}

		/// <summary>Removes all leading and trailing occurrences of a set of characters specified in an array from the current <see cref="T:System.String" /> object.</summary>
		/// <param name="trimChars">An array of Unicode characters to remove, or <see langword="null" />.</param>
		/// <returns>The string that remains after all occurrences of the characters in the <paramref name="trimChars" /> parameter are removed from the start and end of the current string. If <paramref name="trimChars" /> is <see langword="null" /> or an empty array, white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged.</returns>
		// Token: 0x06000BDC RID: 3036 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BDC")]
		[Address(RVA = "0x2C4F4F0", Offset = "0x2C4E2F0", VA = "0x182C4F4F0")]
		public string Trim(params char[] trimChars)
		{
			return null;
		}

		/// <summary>Removes all leading occurrences of a set of characters specified in an array from the current <see cref="T:System.String" /> object.</summary>
		/// <param name="trimChars">An array of Unicode characters to remove, or <see langword="null" />.</param>
		/// <returns>The string that remains after all occurrences of characters in the <paramref name="trimChars" /> parameter are removed from the start of the current string. If <paramref name="trimChars" /> is <see langword="null" /> or an empty array, white-space characters are removed instead.</returns>
		// Token: 0x06000BDD RID: 3037 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BDD")]
		[Address(RVA = "0x2C4F4C0", Offset = "0x2C4E2C0", VA = "0x182C4F4C0")]
		public string TrimStart(params char[] trimChars)
		{
			return null;
		}

		/// <summary>Removes all trailing occurrences of a set of characters specified in an array from the current <see cref="T:System.String" /> object.</summary>
		/// <param name="trimChars">An array of Unicode characters to remove, or <see langword="null" />.</param>
		/// <returns>The string that remains after all occurrences of the characters in the <paramref name="trimChars" /> parameter are removed from the end of the current string. If <paramref name="trimChars" /> is <see langword="null" /> or an empty array, Unicode white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged.</returns>
		// Token: 0x06000BDE RID: 3038 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BDE")]
		[Address(RVA = "0x2C4F180", Offset = "0x2C4DF80", VA = "0x182C4F180")]
		public string TrimEnd(params char[] trimChars)
		{
			return null;
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a specified pointer to an array of Unicode characters.</summary>
		/// <param name="value">A pointer to a null-terminated array of Unicode characters.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current process does not have read access to all the addressed characters.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="value" /> specifies an array that contains an invalid Unicode character, or <paramref name="value" /> specifies an address less than 64000.</exception>
		// Token: 0x06000BDF RID: 3039 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BDF")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		[CLSCompliant(false)]
		public unsafe String(char* value)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.</summary>
		/// <param name="value">A pointer to an array of Unicode characters.</param>
		/// <param name="startIndex">The starting position within <paramref name="value" />.</param>
		/// <param name="length">The number of characters within <paramref name="value" /> to use.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="length" /> is less than zero, <paramref name="value" /> + <paramref name="startIndex" /> cause a pointer overflow, or the current process does not have read access to all the addressed characters.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="value" /> specifies an array that contains an invalid Unicode character, or <paramref name="value" /> + <paramref name="startIndex" /> specifies an address less than 64000.</exception>
		// Token: 0x06000BE0 RID: 3040 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE0")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		[CLSCompliant(false)]
		public unsafe String(char* value, int startIndex, int length)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a pointer to an array of 8-bit signed integers.</summary>
		/// <param name="value">A pointer to a null-terminated array of 8-bit signed integers. The integers are interpreted using the current system code page encoding (that is, the encoding specified by <see cref="P:System.Text.Encoding.Default" />).</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">A new instance of <see cref="T:System.String" /> could not be initialized using <paramref name="value" />, assuming <paramref name="value" /> is encoded in ANSI.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The length of the new string to initialize, which is determined by the null termination character of <paramref name="value" />, is too large to allocate.</exception>
		/// <exception cref="T:System.AccessViolationException">
		///   <paramref name="value" /> specifies an invalid address.</exception>
		// Token: 0x06000BE1 RID: 3041 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE1")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		[CLSCompliant(false)]
		public unsafe String(sbyte* value)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.</summary>
		/// <param name="value">A pointer to an array of 8-bit signed integers. The integers are interpreted using the current system code page encoding (that is, the encoding specified by <see cref="P:System.Text.Encoding.Default" />).</param>
		/// <param name="startIndex">The starting position within <paramref name="value" />.</param>
		/// <param name="length">The number of characters within <paramref name="value" /> to use.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="length" /> is less than zero.  
		/// -or-  
		/// The address specified by <paramref name="value" /> + <paramref name="startIndex" /> is too large for the current platform; that is, the address calculation overflowed.  
		/// -or-  
		/// The length of the new string to initialize is too large to allocate.</exception>
		/// <exception cref="T:System.ArgumentException">The address specified by <paramref name="value" /> + <paramref name="startIndex" /> is less than 64K.  
		///  -or-  
		///  A new instance of <see cref="T:System.String" /> could not be initialized using <paramref name="value" />, assuming <paramref name="value" /> is encoded in ANSI.</exception>
		/// <exception cref="T:System.AccessViolationException">
		///   <paramref name="value" />, <paramref name="startIndex" />, and <paramref name="length" /> collectively specify an invalid address.</exception>
		// Token: 0x06000BE2 RID: 3042 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE2")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		[CLSCompliant(false)]
		public unsafe String(sbyte* value, int startIndex, int length)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an <see cref="T:System.Text.Encoding" /> object.</summary>
		/// <param name="value">A pointer to an array of 8-bit signed integers.</param>
		/// <param name="startIndex">The starting position within <paramref name="value" />.</param>
		/// <param name="length">The number of characters within <paramref name="value" /> to use.</param>
		/// <param name="enc">An object that specifies how the array referenced by <paramref name="value" /> is encoded. If <paramref name="enc" /> is <see langword="null" />, ANSI encoding is assumed.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="length" /> is less than zero.  
		/// -or-  
		/// The address specified by <paramref name="value" /> + <paramref name="startIndex" /> is too large for the current platform; that is, the address calculation overflowed.  
		/// -or-  
		/// The length of the new string to initialize is too large to allocate.</exception>
		/// <exception cref="T:System.ArgumentException">The address specified by <paramref name="value" /> + <paramref name="startIndex" /> is less than 64K.  
		///  -or-  
		///  A new instance of <see cref="T:System.String" /> could not be initialized using <paramref name="value" />, assuming <paramref name="value" /> is encoded as specified by <paramref name="enc" />.</exception>
		/// <exception cref="T:System.AccessViolationException">
		///   <paramref name="value" />, <paramref name="startIndex" />, and <paramref name="length" /> collectively specify an invalid address.</exception>
		// Token: 0x06000BE3 RID: 3043 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE3")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		[CLSCompliant(false)]
		public unsafe String(sbyte* value, int startIndex, int length, Encoding enc)
		{
		}

		// Token: 0x06000BE4 RID: 3044 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BE4")]
		[Address(RVA = "0x2C482D0", Offset = "0x2C470D0", VA = "0x182C482D0")]
		internal unsafe static string CreateStringFromEncoding(byte* bytes, int byteLength, Encoding encoding)
		{
			return null;
		}

		/// <summary>Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.</summary>
		/// <param name="normalizationForm">A Unicode normalization form.</param>
		/// <returns>A new string whose textual value is the same as this string, but whose binary representation is in the normalization form specified by the <paramref name="normalizationForm" /> parameter.</returns>
		/// <exception cref="T:System.ArgumentException">The current instance contains invalid Unicode characters.</exception>
		// Token: 0x06000BE5 RID: 3045 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BE5")]
		[Address(RVA = "0x2C4C9B0", Offset = "0x2C4B7B0", VA = "0x182C4C9B0")]
		public string Normalize(NormalizationForm normalizationForm)
		{
			return null;
		}

		// Token: 0x06000BE6 RID: 3046 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BE6")]
		[Address(RVA = "0x2C49BD0", Offset = "0x2C489D0", VA = "0x182C49BD0")]
		internal static string FastAllocateString(int length)
		{
			return null;
		}

		// Token: 0x06000BE7 RID: 3047 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE7")]
		[Address(RVA = "0x2C49BE0", Offset = "0x2C489E0", VA = "0x182C49BE0")]
		private static void FillStringChecked(string dest, int destPos, string src)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.</summary>
		/// <param name="value">An array of Unicode characters.</param>
		/// <param name="startIndex">The starting position within <paramref name="value" />.</param>
		/// <param name="length">The number of characters within <paramref name="value" /> to use.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> or <paramref name="length" /> is less than zero.  
		/// -or-  
		/// The sum of <paramref name="startIndex" /> and <paramref name="length" /> is greater than the number of elements in <paramref name="value" />.</exception>
		// Token: 0x06000BE8 RID: 3048 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE8")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		public String(char[] value, int startIndex, int length)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by an array of Unicode characters.</summary>
		/// <param name="value">An array of Unicode characters.</param>
		// Token: 0x06000BE9 RID: 3049 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BE9")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		public String(char[] value)
		{
		}

		// Token: 0x06000BEA RID: 3050 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BEA")]
		[Address(RVA = "0x2C4F9C0", Offset = "0x2C4E7C0", VA = "0x182C4F9C0")]
		internal unsafe static void wstrcpy(char* dmem, char* smem, int charCount)
		{
		}

		// Token: 0x06000BEB RID: 3051 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BEB")]
		[Address(RVA = "0x2C48B90", Offset = "0x2C47990", VA = "0x182C48B90")]
		private string CtorCharArray(char[] value)
		{
			return null;
		}

		// Token: 0x06000BEC RID: 3052 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BEC")]
		[Address(RVA = "0x2C489B0", Offset = "0x2C477B0", VA = "0x182C489B0")]
		private string CtorCharArrayStartLength(char[] value, int startIndex, int length)
		{
			return null;
		}

		// Token: 0x06000BED RID: 3053 RVA: 0x0000A500 File Offset: 0x00008700
		[Token(Token = "0x6000BED")]
		[Address(RVA = "0x2C4F960", Offset = "0x2C4E760", VA = "0x182C4F960")]
		private unsafe static int wcslen(char* ptr)
		{
			return 0;
		}

		// Token: 0x06000BEE RID: 3054 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BEE")]
		[Address(RVA = "0x2C48E40", Offset = "0x2C47C40", VA = "0x182C48E40")]
		private unsafe string CtorCharPtr(char* ptr)
		{
			return null;
		}

		// Token: 0x06000BEF RID: 3055 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000BEF")]
		[Address(RVA = "0x2C48C30", Offset = "0x2C47A30", VA = "0x182C48C30")]
		private unsafe string CtorCharPtrStartLength(char* ptr, int startIndex, int length)
		{
			return null;
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.String" /> class to the value indicated by a specified Unicode character repeated a specified number of times.</summary>
		/// <param name="c">A Unicode character.</param>
		/// <param name="count">The number of times <paramref name="c" /> occurs.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is less than zero.</exception>
		// Token: 0x06000BF0 RID: 3056 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000BF0")]
		[Address(RVA = "0x2C4F530", Offset = "0x2C4E330", VA = "0x182C4F530")]
		public String(char c, int count)
		{
		}

		/// <summary>Compares two specified <see cref="T:System.String" /> objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.</summary>
		/// <param name="strA">The first string to compare.</param>
		/// <param name="strB">The second string to compare.</param>
		/// <param name="ignoreCase">
		///   <see langword="true" /> to ignore case during the comparison; otherwise, <see langword="false" />.</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///  <paramref name="strA" /> precedes <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///  <paramref name="strA" /> occurs in the same position as <paramref name="strB" /> in the sort order.  
		///
		///   Greater than zero  
		///
		///  <paramref name="strA" /> follows <paramref name="strB" /> in the sort order.</returns>
		// Token: 0x06000BF1 RID: 3057 RVA: 0x0000A518 File Offset: 0x00008718
		[Token(Token = "0x6000BF1")]
		[Address(RVA = "0x2C46F50", Offset = "0x2C45D50", VA = "0x182C46F50")]
		public static int Compare(string strA, string strB, bool ignoreCase)
		{
			return 0;
		}

		/// <summary>Compares two specified <see cref="T:System.String" /> objects using the specified rules, and returns an integer that indicates their relative position in the sort order.</summary>
		/// <param name="strA">The first string to compare.</param>
		/// <param name="strB">The second string to compare.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules to use in the comparison.</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///  <paramref name="strA" /> precedes <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///  <paramref name="strA" /> is in the same position as <paramref name="strB" /> in the sort order.  
		///
		///   Greater than zero  
		///
		///  <paramref name="strA" /> follows <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <see cref="T:System.StringComparison" /> is not supported.</exception>
		// Token: 0x06000BF2 RID: 3058 RVA: 0x0000A530 File Offset: 0x00008730
		[Token(Token = "0x6000BF2")]
		[Address(RVA = "0x2C46C20", Offset = "0x2C45A20", VA = "0x182C46C20")]
		public static int Compare(string strA, string strB, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Compares two specified <see cref="T:System.String" /> objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.</summary>
		/// <param name="strA">The first string to compare.</param>
		/// <param name="strB">The second string to compare.</param>
		/// <param name="culture">The culture that supplies culture-specific comparison information.</param>
		/// <param name="options">Options to use when performing the comparison (such as ignoring case or symbols).</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between <paramref name="strA" /> and <paramref name="strB" />, as shown in the following table  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///  <paramref name="strA" /> precedes <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///  <paramref name="strA" /> occurs in the same position as <paramref name="strB" /> in the sort order.  
		///
		///   Greater than zero  
		///
		///  <paramref name="strA" /> follows <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not a <see cref="T:System.Globalization.CompareOptions" /> value.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="culture" /> is <see langword="null" />.</exception>
		// Token: 0x06000BF3 RID: 3059 RVA: 0x0000A548 File Offset: 0x00008748
		[Token(Token = "0x6000BF3")]
		[Address(RVA = "0x2C47240", Offset = "0x2C46040", VA = "0x182C47240")]
		public static int Compare(string strA, string strB, CultureInfo culture, CompareOptions options)
		{
			return 0;
		}

		/// <summary>Compares two specified <see cref="T:System.String" /> objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.</summary>
		/// <param name="strA">The first string to compare.</param>
		/// <param name="strB">The second string to compare.</param>
		/// <param name="ignoreCase">
		///   <see langword="true" /> to ignore case during the comparison; otherwise, <see langword="false" />.</param>
		/// <param name="culture">An object that supplies culture-specific comparison information.</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///  <paramref name="strA" /> precedes <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///  <paramref name="strA" /> occurs in the same position as <paramref name="strB" /> in the sort order.  
		///
		///   Greater than zero  
		///
		///  <paramref name="strA" /> follows <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="culture" /> is <see langword="null" />.</exception>
		// Token: 0x06000BF4 RID: 3060 RVA: 0x0000A560 File Offset: 0x00008760
		[Token(Token = "0x6000BF4")]
		[Address(RVA = "0x2C47160", Offset = "0x2C45F60", VA = "0x182C47160")]
		public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture)
		{
			return 0;
		}

		/// <summary>Compares substrings of two specified <see cref="T:System.String" /> objects and returns an integer that indicates their relative position in the sort order.</summary>
		/// <param name="strA">The first string to use in the comparison.</param>
		/// <param name="indexA">The position of the substring within <paramref name="strA" />.</param>
		/// <param name="strB">The second string to use in the comparison.</param>
		/// <param name="indexB">The position of the substring within <paramref name="strB" />.</param>
		/// <param name="length">The maximum number of characters in the substrings to compare.</param>
		/// <returns>A 32-bit signed integer indicating the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   The substring in <paramref name="strA" /> precedes the substring in <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///   The substrings occur in the same position in the sort order, or <paramref name="length" /> is zero.  
		///
		///   Greater than zero  
		///
		///   The substring in <paramref name="strA" /> follows the substring in <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="indexA" /> is greater than <paramref name="strA" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="indexB" /> is greater than <paramref name="strB" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="indexA" />, <paramref name="indexB" />, or <paramref name="length" /> is negative.  
		/// -or-  
		/// Either <paramref name="indexA" /> or <paramref name="indexB" /> is <see langword="null" />, and <paramref name="length" /> is greater than zero.</exception>
		// Token: 0x06000BF5 RID: 3061 RVA: 0x0000A578 File Offset: 0x00008778
		[Token(Token = "0x6000BF5")]
		[Address(RVA = "0x2C47050", Offset = "0x2C45E50", VA = "0x182C47050")]
		public static int Compare(string strA, int indexA, string strB, int indexB, int length)
		{
			return 0;
		}

		/// <summary>Compares substrings of two specified <see cref="T:System.String" /> objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.</summary>
		/// <param name="strA">The first string to use in the comparison.</param>
		/// <param name="indexA">The starting position of the substring within <paramref name="strA" />.</param>
		/// <param name="strB">The second string to use in the comparison.</param>
		/// <param name="indexB">The starting position of the substring within <paramref name="strB" />.</param>
		/// <param name="length">The maximum number of characters in the substrings to compare.</param>
		/// <param name="culture">An object that supplies culture-specific comparison information.</param>
		/// <param name="options">Options to use when performing the comparison (such as ignoring case or symbols).</param>
		/// <returns>An integer that indicates the lexical relationship between the two substrings, as shown in the following table.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   The substring in <paramref name="strA" /> precedes the substring in <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///   The substrings occur in the same position in the sort order, or <paramref name="length" /> is zero.  
		///
		///   Greater than zero  
		///
		///   The substring in <paramref name="strA" /> follows the substring in <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not a <see cref="T:System.Globalization.CompareOptions" /> value.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="indexA" /> is greater than <paramref name="strA" /><see langword=".Length" />.  
		/// -or-  
		/// <paramref name="indexB" /> is greater than <paramref name="strB" /><see langword=".Length" />.  
		/// -or-  
		/// <paramref name="indexA" />, <paramref name="indexB" />, or <paramref name="length" /> is negative.  
		/// -or-  
		/// Either <paramref name="strA" /> or <paramref name="strB" /> is <see langword="null" />, and <paramref name="length" /> is greater than zero.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="culture" /> is <see langword="null" />.</exception>
		// Token: 0x06000BF6 RID: 3062 RVA: 0x0000A590 File Offset: 0x00008790
		[Token(Token = "0x6000BF6")]
		[Address(RVA = "0x2C46B00", Offset = "0x2C45900", VA = "0x182C46B00")]
		public static int Compare(string strA, int indexA, string strB, int indexB, int length, CultureInfo culture, CompareOptions options)
		{
			return 0;
		}

		/// <summary>Compares substrings of two specified <see cref="T:System.String" /> objects using the specified rules, and returns an integer that indicates their relative position in the sort order.</summary>
		/// <param name="strA">The first string to use in the comparison.</param>
		/// <param name="indexA">The position of the substring within <paramref name="strA" />.</param>
		/// <param name="strB">The second string to use in the comparison.</param>
		/// <param name="indexB">The position of the substring within <paramref name="strB" />.</param>
		/// <param name="length">The maximum number of characters in the substrings to compare.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules to use in the comparison.</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   The substring in <paramref name="strA" /> precedes the substring in <paramref name="strB" /> in the sort order.  
		///
		///   Zero  
		///
		///   The substrings occur in the same position in the sort order, or the <paramref name="length" /> parameter is zero.  
		///
		///   Greater than zero  
		///
		///   The substring in <paramref name="strA" /> follllows the substring in <paramref name="strB" /> in the sort order.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="indexA" /> is greater than <paramref name="strA" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="indexB" /> is greater than <paramref name="strB" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="indexA" />, <paramref name="indexB" />, or <paramref name="length" /> is negative.  
		/// -or-  
		/// Either <paramref name="indexA" /> or <paramref name="indexB" /> is <see langword="null" />, and <paramref name="length" /> is greater than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000BF7 RID: 3063 RVA: 0x0000A5A8 File Offset: 0x000087A8
		[Token(Token = "0x6000BF7")]
		[Address(RVA = "0x2C46620", Offset = "0x2C45420", VA = "0x182C46620")]
		public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Compares this instance with a specified <see cref="T:System.Object" /> and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified <see cref="T:System.Object" />.</summary>
		/// <param name="value">An object that evaluates to a <see cref="T:System.String" />.</param>
		/// <returns>A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the <paramref name="value" /> parameter.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   This instance precedes <paramref name="value" />.  
		///
		///   Zero  
		///
		///   This instance has the same position in the sort order as <paramref name="value" />.  
		///
		///   Greater than zero  
		///
		///   This instance follows <paramref name="value" />.  
		///
		///  -or-  
		///
		///  <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="value" /> is not a <see cref="T:System.String" />.</exception>
		// Token: 0x06000BF8 RID: 3064 RVA: 0x0000A5C0 File Offset: 0x000087C0
		[Token(Token = "0x6000BF8")]
		[Address(RVA = "0x2C464A0", Offset = "0x2C452A0", VA = "0x182C464A0", Slot = "4")]
		public int CompareTo(object value)
		{
			return 0;
		}

		/// <summary>Compares this instance with a specified <see cref="T:System.String" /> object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.</summary>
		/// <param name="strB">The string to compare with this instance.</param>
		/// <returns>A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the <paramref name="strB" /> parameter.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   This instance precedes <paramref name="strB" />.  
		///
		///   Zero  
		///
		///   This instance has the same position in the sort order as <paramref name="strB" />.  
		///
		///   Greater than zero  
		///
		///   This instance follows <paramref name="strB" />.  
		///
		///  -or-  
		///
		///  <paramref name="strB" /> is <see langword="null" />.</returns>
		// Token: 0x06000BF9 RID: 3065 RVA: 0x0000A5D8 File Offset: 0x000087D8
		[Token(Token = "0x6000BF9")]
		[Address(RVA = "0x2C463E0", Offset = "0x2C451E0", VA = "0x182C463E0", Slot = "24")]
		public int CompareTo(string strB)
		{
			return 0;
		}

		/// <summary>Compares two specified <see cref="T:System.String" /> objects by evaluating the numeric values of the corresponding <see cref="T:System.Char" /> objects in each string.</summary>
		/// <param name="strA">The first string to compare.</param>
		/// <param name="strB">The second string to compare.</param>
		/// <returns>An integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///  <paramref name="strA" /> is less than <paramref name="strB" />.  
		///
		///   Zero  
		///
		///  <paramref name="strA" /> and <paramref name="strB" /> are equal.  
		///
		///   Greater than zero  
		///
		///  <paramref name="strA" /> is greater than <paramref name="strB" />.</returns>
		// Token: 0x06000BFA RID: 3066 RVA: 0x0000A5F0 File Offset: 0x000087F0
		[Token(Token = "0x6000BFA")]
		[Address(RVA = "0x2C46360", Offset = "0x2C45160", VA = "0x182C46360")]
		public static int CompareOrdinal(string strA, string strB)
		{
			return 0;
		}

		/// <summary>Compares substrings of two specified <see cref="T:System.String" /> objects by evaluating the numeric values of the corresponding <see cref="T:System.Char" /> objects in each substring.</summary>
		/// <param name="strA">The first string to use in the comparison.</param>
		/// <param name="indexA">The starting index of the substring in <paramref name="strA" />.</param>
		/// <param name="strB">The second string to use in the comparison.</param>
		/// <param name="indexB">The starting index of the substring in <paramref name="strB" />.</param>
		/// <param name="length">The maximum number of characters in the substrings to compare.</param>
		/// <returns>A 32-bit signed integer that indicates the lexical relationship between the two comparands.  
		///   Value  
		///
		///   Condition  
		///
		///   Less than zero  
		///
		///   The substring in <paramref name="strA" /> is less than the substring in <paramref name="strB" />.  
		///
		///   Zero  
		///
		///   The substrings are equal, or <paramref name="length" /> is zero.  
		///
		///   Greater than zero  
		///
		///   The substring in <paramref name="strA" /> is greater than the substring in <paramref name="strB" />.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="strA" /> is not <see langword="null" /> and <paramref name="indexA" /> is greater than <paramref name="strA" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="strB" /> is not <see langword="null" /> and <paramref name="indexB" /> is greater than <paramref name="strB" />.<see cref="P:System.String.Length" />.  
		/// -or-  
		/// <paramref name="indexA" />, <paramref name="indexB" />, or <paramref name="length" /> is negative.</exception>
		// Token: 0x06000BFB RID: 3067 RVA: 0x0000A608 File Offset: 0x00008808
		[Token(Token = "0x6000BFB")]
		[Address(RVA = "0x2C463A0", Offset = "0x2C451A0", VA = "0x182C463A0")]
		public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int length)
		{
			return 0;
		}

		/// <summary>Returns a value indicating whether a specified substring occurs within this string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <returns>
		///   <see langword="true" /> if the <paramref name="value" /> parameter occurs within this string, or if <paramref name="value" /> is the empty string (""); otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000BFC RID: 3068 RVA: 0x0000A620 File Offset: 0x00008820
		[Token(Token = "0x6000BFC")]
		[Address(RVA = "0x2C47FF0", Offset = "0x2C46DF0", VA = "0x182C47FF0")]
		public bool Contains(string value)
		{
			return default(bool);
		}

		/// <summary>Determines whether the end of this string instance matches the specified string.</summary>
		/// <param name="value">The string to compare to the substring at the end of this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> matches the end of this instance; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000BFD RID: 3069 RVA: 0x0000A638 File Offset: 0x00008838
		[Token(Token = "0x6000BFD")]
		[Address(RVA = "0x2C49310", Offset = "0x2C48110", VA = "0x182C49310")]
		public bool EndsWith(string value)
		{
			return default(bool);
		}

		/// <summary>Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.</summary>
		/// <param name="value">The string to compare to the substring at the end of this instance.</param>
		/// <param name="comparisonType">One of the enumeration values that determines how this string and <paramref name="value" /> are compared.</param>
		/// <returns>
		///   <see langword="true" /> if the <paramref name="value" /> parameter matches the end of this string; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000BFE RID: 3070 RVA: 0x0000A650 File Offset: 0x00008850
		[Token(Token = "0x6000BFE")]
		[Address(RVA = "0x2C49000", Offset = "0x2C47E00", VA = "0x182C49000")]
		[ComVisible(false)]
		public bool EndsWith(string value, StringComparison comparisonType)
		{
			return default(bool);
		}

		// Token: 0x06000BFF RID: 3071 RVA: 0x0000A668 File Offset: 0x00008868
		[Token(Token = "0x6000BFF")]
		[Address(RVA = "0x2C48FD0", Offset = "0x2C47DD0", VA = "0x182C48FD0")]
		internal bool EndsWith(char value)
		{
			return default(bool);
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified Unicode character in this string.</summary>
		/// <param name="value">A Unicode character to seek.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> if that character is found, or -1 if it is not.</returns>
		// Token: 0x06000C00 RID: 3072 RVA: 0x0000A680 File Offset: 0x00008880
		[Token(Token = "0x6000C00")]
		[Address(RVA = "0x2C4A910", Offset = "0x2C49710", VA = "0x182C4A910")]
		public int IndexOf(char value)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified Unicode character in this string. The search starts at a specified character position.</summary>
		/// <param name="value">A Unicode character to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> from the start of the string if that character is found, or -1 if it is not.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is less than 0 (zero) or greater than the length of the string.</exception>
		// Token: 0x06000C01 RID: 3073 RVA: 0x0000A698 File Offset: 0x00008898
		[Token(Token = "0x6000C01")]
		[Address(RVA = "0x2C4A960", Offset = "0x2C49760", VA = "0x182C4A960")]
		public int IndexOf(char value, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <returns>The zero-based index position of the first occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		// Token: 0x06000C02 RID: 3074 RVA: 0x0000A6B0 File Offset: 0x000088B0
		[Token(Token = "0x6000C02")]
		[Address(RVA = "0x2C4A330", Offset = "0x2C49130", VA = "0x182C4A330")]
		public int IndexOfAny(char[] anyOf)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <returns>The zero-based index position of the first occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is negative.  
		/// -or-  
		/// <paramref name="startIndex" /> is greater than the number of characters in this instance.</exception>
		// Token: 0x06000C03 RID: 3075 RVA: 0x0000A6C8 File Offset: 0x000088C8
		[Token(Token = "0x6000C03")]
		[Address(RVA = "0x2C4A350", Offset = "0x2C49150", VA = "0x182C4A350")]
		public int IndexOfAny(char[] anyOf, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified string in this instance.</summary>
		/// <param name="value">The string to seek.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is 0.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000C04 RID: 3076 RVA: 0x0000A6E0 File Offset: 0x000088E0
		[Token(Token = "0x6000C04")]
		[Address(RVA = "0x2C4A9A0", Offset = "0x2C497A0", VA = "0x182C4A9A0")]
		public int IndexOf(string value)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified string in this instance. The search starts at a specified character position.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> from the start of the current instance if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is <paramref name="startIndex" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is less than 0 (zero) or greater than the length of this string.</exception>
		// Token: 0x06000C05 RID: 3077 RVA: 0x0000A6F8 File Offset: 0x000088F8
		[Token(Token = "0x6000C05")]
		[Address(RVA = "0x2C4A980", Offset = "0x2C49780", VA = "0x182C4A980")]
		public int IndexOf(string value, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified string in the current <see cref="T:System.String" /> object. A parameter specifies the type of search to use for the specified string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
		/// <returns>The index position of the <paramref name="value" /> parameter if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is 0.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a valid <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C06 RID: 3078 RVA: 0x0000A710 File Offset: 0x00008910
		[Token(Token = "0x6000C06")]
		[Address(RVA = "0x2C4AD90", Offset = "0x2C49B90", VA = "0x182C4AD90")]
		public int IndexOf(string value, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified string in the current <see cref="T:System.String" /> object. Parameters specify the starting search position in the current string and the type of search to use for the specified string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
		/// <returns>The zero-based index position of the <paramref name="value" /> parameter from the start of the current instance if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is <paramref name="startIndex" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is less than 0 (zero) or greater than the length of this string.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a valid <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C07 RID: 3079 RVA: 0x0000A728 File Offset: 0x00008928
		[Token(Token = "0x6000C07")]
		[Address(RVA = "0x2C4A930", Offset = "0x2C49730", VA = "0x182C4A930")]
		public int IndexOf(string value, int startIndex, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified string in the current <see cref="T:System.String" /> object. Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
		/// <returns>The zero-based index position of the <paramref name="value" /> parameter from the start of the current instance if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is <paramref name="startIndex" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> or <paramref name="startIndex" /> is negative.  
		/// -or-  
		/// <paramref name="startIndex" /> is greater than the length of this instance.  
		/// -or-  
		/// <paramref name="count" /> is greater than the length of this string minus <paramref name="startIndex" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a valid <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C08 RID: 3080 RVA: 0x0000A740 File Offset: 0x00008940
		[Token(Token = "0x6000C08")]
		[Address(RVA = "0x2C4A9C0", Offset = "0x2C497C0", VA = "0x182C4A9C0")]
		public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.</summary>
		/// <param name="value">The Unicode character to seek.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> if that character is found, or -1 if it is not.</returns>
		// Token: 0x06000C09 RID: 3081 RVA: 0x0000A758 File Offset: 0x00008958
		[Token(Token = "0x6000C09")]
		[Address(RVA = "0x2C4C490", Offset = "0x2C4B290", VA = "0x182C4C490")]
		public int LastIndexOf(char value)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string.</summary>
		/// <param name="value">The Unicode character to seek.</param>
		/// <param name="startIndex">The starting position of the search. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> if that character is found, or -1 if it is not found or if the current instance equals <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is less than zero or greater than or equal to the length of this instance.</exception>
		// Token: 0x06000C0A RID: 3082 RVA: 0x0000A770 File Offset: 0x00008970
		[Token(Token = "0x6000C0A")]
		[Address(RVA = "0x2C4C500", Offset = "0x2C4B300", VA = "0x182C4C500")]
		public int LastIndexOf(char value, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <returns>The index position of the last occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		// Token: 0x06000C0B RID: 3083 RVA: 0x0000A788 File Offset: 0x00008988
		[Token(Token = "0x6000C0B")]
		[Address(RVA = "0x2C4BF30", Offset = "0x2C4AD30", VA = "0x182C4BF30")]
		public int LastIndexOfAny(char[] anyOf)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. The search starts at a specified character position and proceeds backward toward the beginning of the string.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <param name="startIndex">The search starting position. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <returns>The index position of the last occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found or if the current instance equals <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> specifies a position that is not within this instance.</exception>
		// Token: 0x06000C0C RID: 3084 RVA: 0x0000A7A0 File Offset: 0x000089A0
		[Token(Token = "0x6000C0C")]
		[Address(RVA = "0x2C4BF50", Offset = "0x2C4AD50", VA = "0x182C4BF50")]
		public int LastIndexOfAny(char[] anyOf, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of a specified string within this instance.</summary>
		/// <param name="value">The string to seek.</param>
		/// <returns>The zero-based starting index position of <paramref name="value" /> if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is the last index position in this instance.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000C0D RID: 3085 RVA: 0x0000A7B8 File Offset: 0x000089B8
		[Token(Token = "0x6000C0D")]
		[Address(RVA = "0x2C4C520", Offset = "0x2C4B320", VA = "0x182C4C520")]
		public int LastIndexOf(string value)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of a specified string within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="startIndex">The search starting position. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <returns>The zero-based starting index position of <paramref name="value" /> if that string is found, or -1 if it is not found or if the current instance equals <see cref="F:System.String.Empty" />. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is the smaller of <paramref name="startIndex" /> and the last index position in this instance.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is less than zero or greater than the length of the current instance.  
		///  -or-  
		///  The current instance equals <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is less than -1 or greater than zero.</exception>
		// Token: 0x06000C0E RID: 3086 RVA: 0x0000A7D0 File Offset: 0x000089D0
		[Token(Token = "0x6000C0E")]
		[Address(RVA = "0x2C4C4E0", Offset = "0x2C4B2E0", VA = "0x182C4C4E0")]
		public int LastIndexOf(string value, int startIndex)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the last occurrence of a specified string within the current <see cref="T:System.String" /> object. A parameter specifies the type of search to use for the specified string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
		/// <returns>The zero-based starting index position of the <paramref name="value" /> parameter if that string is found, or -1 if it is not. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is the last index position in this instance.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a valid <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C0F RID: 3087 RVA: 0x0000A7E8 File Offset: 0x000089E8
		[Token(Token = "0x6000C0F")]
		[Address(RVA = "0x2C4C4B0", Offset = "0x2C4B2B0", VA = "0x182C4C4B0")]
		public int LastIndexOf(string value, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of a specified string within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. A parameter specifies the type of comparison to perform when searching for the specified string.</summary>
		/// <param name="value">The string to seek.</param>
		/// <param name="startIndex">The search starting position. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
		/// <returns>The zero-based starting index position of the <paramref name="value" /> parameter if that string is found, or -1 if it is not found or if the current instance equals <see cref="F:System.String.Empty" />. If <paramref name="value" /> is <see cref="F:System.String.Empty" />, the return value is the smaller of <paramref name="startIndex" /> and the last index position in this instance.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is negative.  
		/// -or-  
		/// The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is negative.  
		/// -or-  
		/// The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is greater than the length of this instance.  
		/// -or-  
		/// The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> + 1 - <paramref name="count" /> specifies a position that is not within this instance.  
		/// -or-  
		/// The current instance equals <see cref="F:System.String.Empty" /> and <paramref name="start" /> is less than -1 or greater than zero.  
		/// -or-  
		/// The current instance equals <see cref="F:System.String.Empty" /> and <paramref name="count" /> is greater than 1.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a valid <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C10 RID: 3088 RVA: 0x0000A800 File Offset: 0x00008A00
		[Token(Token = "0x6000C10")]
		[Address(RVA = "0x2C4C080", Offset = "0x2C4AE80", VA = "0x182C4C080")]
		public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType)
		{
			return 0;
		}

		/// <summary>Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.</summary>
		/// <param name="totalWidth">The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.</param>
		/// <returns>A new string that is equivalent to this instance, but right-aligned and padded on the left with as many spaces as needed to create a length of <paramref name="totalWidth" />. However, if <paramref name="totalWidth" /> is less than the length of this instance, the method returns a reference to the existing instance. If <paramref name="totalWidth" /> is equal to the length of this instance, the method returns a new string that is identical to this instance.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="totalWidth" /> is less than zero.</exception>
		// Token: 0x06000C11 RID: 3089 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C11")]
		[Address(RVA = "0x2C4CC20", Offset = "0x2C4BA20", VA = "0x182C4CC20")]
		public string PadLeft(int totalWidth)
		{
			return null;
		}

		/// <summary>Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.</summary>
		/// <param name="totalWidth">The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.</param>
		/// <param name="paddingChar">A Unicode padding character.</param>
		/// <returns>A new string that is equivalent to this instance, but right-aligned and padded on the left with as many <paramref name="paddingChar" /> characters as needed to create a length of <paramref name="totalWidth" />. However, if <paramref name="totalWidth" /> is less than the length of this instance, the method returns a reference to the existing instance. If <paramref name="totalWidth" /> is equal to the length of this instance, the method returns a new string that is identical to this instance.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="totalWidth" /> is less than zero.</exception>
		// Token: 0x06000C12 RID: 3090 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C12")]
		[Address(RVA = "0x2C4CC40", Offset = "0x2C4BA40", VA = "0x182C4CC40")]
		public string PadLeft(int totalWidth, char paddingChar)
		{
			return null;
		}

		/// <summary>Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.</summary>
		/// <param name="totalWidth">The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.</param>
		/// <returns>A new string that is equivalent to this instance, but left-aligned and padded on the right with as many spaces as needed to create a length of <paramref name="totalWidth" />. However, if <paramref name="totalWidth" /> is less than the length of this instance, the method returns a reference to the existing instance. If <paramref name="totalWidth" /> is equal to the length of this instance, the method returns a new string that is identical to this instance.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="totalWidth" /> is less than zero.</exception>
		// Token: 0x06000C13 RID: 3091 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C13")]
		[Address(RVA = "0x2C4CC80", Offset = "0x2C4BA80", VA = "0x182C4CC80")]
		public string PadRight(int totalWidth)
		{
			return null;
		}

		/// <summary>Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.</summary>
		/// <param name="totalWidth">The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.</param>
		/// <param name="paddingChar">A Unicode padding character.</param>
		/// <returns>A new string that is equivalent to this instance, but left-aligned and padded on the right with as many <paramref name="paddingChar" /> characters as needed to create a length of <paramref name="totalWidth" />. However, if <paramref name="totalWidth" /> is less than the length of this instance, the method returns a reference to the existing instance. If <paramref name="totalWidth" /> is equal to the length of this instance, the method returns a new string that is identical to this instance.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="totalWidth" /> is less than zero.</exception>
		// Token: 0x06000C14 RID: 3092 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C14")]
		[Address(RVA = "0x2C4CC60", Offset = "0x2C4BA60", VA = "0x182C4CC60")]
		public string PadRight(int totalWidth, char paddingChar)
		{
			return null;
		}

		/// <summary>Determines whether the beginning of this string instance matches the specified string.</summary>
		/// <param name="value">The string to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> matches the beginning of this string; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		// Token: 0x06000C15 RID: 3093 RVA: 0x0000A818 File Offset: 0x00008A18
		[Token(Token = "0x6000C15")]
		[Address(RVA = "0x2C4E030", Offset = "0x2C4CE30", VA = "0x182C4E030")]
		public bool StartsWith(string value)
		{
			return default(bool);
		}

		/// <summary>Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.</summary>
		/// <param name="value">The string to compare.</param>
		/// <param name="comparisonType">One of the enumeration values that determines how this string and <paramref name="value" /> are compared.</param>
		/// <returns>
		///   <see langword="true" /> if this instance begins with <paramref name="value" />; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparisonType" /> is not a <see cref="T:System.StringComparison" /> value.</exception>
		// Token: 0x06000C16 RID: 3094 RVA: 0x0000A830 File Offset: 0x00008A30
		[Token(Token = "0x6000C16")]
		[Address(RVA = "0x2C4E0B0", Offset = "0x2C4CEB0", VA = "0x182C4E0B0")]
		[ComVisible(false)]
		public bool StartsWith(string value, StringComparison comparisonType)
		{
			return default(bool);
		}

		/// <summary>Returns a copy of this string converted to lowercase.</summary>
		/// <returns>A string in lowercase.</returns>
		// Token: 0x06000C17 RID: 3095 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C17")]
		[Address(RVA = "0x2C4EF20", Offset = "0x2C4DD20", VA = "0x182C4EF20")]
		public string ToLower()
		{
			return null;
		}

		/// <summary>Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.</summary>
		/// <param name="culture">An object that supplies culture-specific casing rules.</param>
		/// <returns>The lowercase equivalent of the current string.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="culture" /> is <see langword="null" />.</exception>
		// Token: 0x06000C18 RID: 3096 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C18")]
		[Address(RVA = "0x2C4EF80", Offset = "0x2C4DD80", VA = "0x182C4EF80")]
		public string ToLower(CultureInfo culture)
		{
			return null;
		}

		/// <summary>Returns a copy of this <see cref="T:System.String" /> object converted to lowercase using the casing rules of the invariant culture.</summary>
		/// <returns>The lowercase equivalent of the current string.</returns>
		// Token: 0x06000C19 RID: 3097 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C19")]
		[Address(RVA = "0x2C4EEC0", Offset = "0x2C4DCC0", VA = "0x182C4EEC0")]
		public string ToLowerInvariant()
		{
			return null;
		}

		/// <summary>Returns a copy of this string converted to uppercase.</summary>
		/// <returns>The uppercase equivalent of the current string.</returns>
		// Token: 0x06000C1A RID: 3098 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1A")]
		[Address(RVA = "0x2C4F080", Offset = "0x2C4DE80", VA = "0x182C4F080")]
		public string ToUpper()
		{
			return null;
		}

		/// <summary>Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.</summary>
		/// <param name="culture">An object that supplies culture-specific casing rules.</param>
		/// <returns>The uppercase equivalent of the current string.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="culture" /> is <see langword="null" />.</exception>
		// Token: 0x06000C1B RID: 3099 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1B")]
		[Address(RVA = "0x2C4F0E0", Offset = "0x2C4DEE0", VA = "0x182C4F0E0")]
		public string ToUpper(CultureInfo culture)
		{
			return null;
		}

		/// <summary>Returns a copy of this <see cref="T:System.String" /> object converted to uppercase using the casing rules of the invariant culture.</summary>
		/// <returns>The uppercase equivalent of the current string.</returns>
		// Token: 0x06000C1C RID: 3100 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1C")]
		[Address(RVA = "0x2C4F020", Offset = "0x2C4DE20", VA = "0x182C4F020")]
		public string ToUpperInvariant()
		{
			return null;
		}

		/// <summary>Returns this instance of <see cref="T:System.String" />; no actual conversion is performed.</summary>
		/// <returns>The current string.</returns>
		// Token: 0x06000C1D RID: 3101 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1D")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0", Slot = "3")]
		public override string ToString()
		{
			return null;
		}

		/// <summary>Returns this instance of <see cref="T:System.String" />; no actual conversion is performed.</summary>
		/// <param name="provider">(Reserved) An object that supplies culture-specific formatting information.</param>
		/// <returns>The current string.</returns>
		// Token: 0x06000C1E RID: 3102 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1E")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0", Slot = "21")]
		public string ToString(IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Returns a reference to this instance of <see cref="T:System.String" />.</summary>
		/// <returns>This instance of <see cref="T:System.String" />.</returns>
		// Token: 0x06000C1F RID: 3103 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C1F")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0", Slot = "5")]
		public object Clone()
		{
			return null;
		}

		// Token: 0x06000C20 RID: 3104 RVA: 0x0000A848 File Offset: 0x00008A48
		[Token(Token = "0x6000C20")]
		[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930")]
		private static bool IsBOMWhitespace(char c)
		{
			return default(bool);
		}

		/// <summary>Removes all leading and trailing white-space characters from the current <see cref="T:System.String" /> object.</summary>
		/// <returns>The string that remains after all white-space characters are removed from the start and end of the current string. If no characters can be trimmed from the current instance, the method returns the current instance unchanged.</returns>
		// Token: 0x06000C21 RID: 3105 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C21")]
		[Address(RVA = "0x2C4F520", Offset = "0x2C4E320", VA = "0x182C4F520")]
		public string Trim()
		{
			return null;
		}

		// Token: 0x06000C22 RID: 3106 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C22")]
		[Address(RVA = "0x2C4F320", Offset = "0x2C4E120", VA = "0x182C4F320")]
		private string TrimHelper(int trimType)
		{
			return null;
		}

		// Token: 0x06000C23 RID: 3107 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C23")]
		[Address(RVA = "0x2C4F1B0", Offset = "0x2C4DFB0", VA = "0x182C4F1B0")]
		private string TrimHelper(char[] trimChars, int trimType)
		{
			return null;
		}

		// Token: 0x06000C24 RID: 3108 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C24")]
		[Address(RVA = "0x2C48910", Offset = "0x2C47710", VA = "0x182C48910")]
		private string CreateTrimmedString(int start, int end)
		{
			return null;
		}

		/// <summary>Returns a new string in which a specified string is inserted at a specified index position in this instance.</summary>
		/// <param name="startIndex">The zero-based index position of the insertion.</param>
		/// <param name="value">The string to insert.</param>
		/// <returns>A new string that is equivalent to this instance, but with <paramref name="value" /> inserted at position <paramref name="startIndex" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is negative or greater than the length of this instance.</exception>
		// Token: 0x06000C25 RID: 3109 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C25")]
		[Address(RVA = "0x2C4ADC0", Offset = "0x2C49BC0", VA = "0x182C4ADC0")]
		public string Insert(int startIndex, string value)
		{
			return null;
		}

		/// <summary>Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.</summary>
		/// <param name="oldChar">The Unicode character to be replaced.</param>
		/// <param name="newChar">The Unicode character to replace all occurrences of <paramref name="oldChar" />.</param>
		/// <returns>A string that is equivalent to this instance except that all instances of <paramref name="oldChar" /> are replaced with <paramref name="newChar" />. If <paramref name="oldChar" /> is not found in the current instance, the method returns the current instance unchanged.</returns>
		// Token: 0x06000C26 RID: 3110 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C26")]
		[Address(RVA = "0x2C4D770", Offset = "0x2C4C570", VA = "0x182C4D770")]
		public string Replace(char oldChar, char newChar)
		{
			return null;
		}

		/// <summary>Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.</summary>
		/// <param name="oldValue">The string to be replaced.</param>
		/// <param name="newValue">The string to replace all occurrences of <paramref name="oldValue" />.</param>
		/// <returns>A string that is equivalent to the current string except that all instances of <paramref name="oldValue" /> are replaced with <paramref name="newValue" />. If <paramref name="oldValue" /> is not found in the current instance, the method returns the current instance unchanged.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="oldValue" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="oldValue" /> is the empty string ("").</exception>
		// Token: 0x06000C27 RID: 3111 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C27")]
		[Address(RVA = "0x2C4D8B0", Offset = "0x2C4C6B0", VA = "0x182C4D8B0")]
		public string Replace(string oldValue, string newValue)
		{
			return null;
		}

		/// <summary>Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.</summary>
		/// <param name="startIndex">The zero-based position to begin deleting characters.</param>
		/// <param name="count">The number of characters to delete.</param>
		/// <returns>A new string that is equivalent to this instance except for the removed characters.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Either <paramref name="startIndex" /> or <paramref name="count" /> is less than zero.  
		///  -or-  
		///  <paramref name="startIndex" /> plus <paramref name="count" /> specify a position outside this instance.</exception>
		// Token: 0x06000C28 RID: 3112 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C28")]
		[Address(RVA = "0x2C4CCA0", Offset = "0x2C4BAA0", VA = "0x182C4CCA0")]
		public string Remove(int startIndex, int count)
		{
			return null;
		}

		/// <summary>Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.</summary>
		/// <param name="startIndex">The zero-based position to begin deleting characters.</param>
		/// <returns>A new string that is equivalent to this string except for the removed characters.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> specifies a position that is not within this string.</exception>
		// Token: 0x06000C29 RID: 3113 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C29")]
		[Address(RVA = "0x2C4CE60", Offset = "0x2C4BC60", VA = "0x182C4CE60")]
		public string Remove(int startIndex)
		{
			return null;
		}

		/// <summary>Replaces one or more format items in a string with the string representation of a specified object.</summary>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which any format items are replaced by the string representation of <paramref name="arg0" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">The format item in <paramref name="format" /> is invalid.  
		///  -or-  
		///  The index of a format item is not zero.</exception>
		// Token: 0x06000C2A RID: 3114 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2A")]
		[Address(RVA = "0x2C49D60", Offset = "0x2C48B60", VA = "0x182C49D60")]
		public static string Format(string format, object arg0)
		{
			return null;
		}

		/// <summary>Replaces the format items in a string with the string representation of two specified objects.</summary>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The first object to format.</param>
		/// <param name="arg1">The second object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which format items are replaced by the string representations of <paramref name="arg0" /> and <paramref name="arg1" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is not zero or one.</exception>
		// Token: 0x06000C2B RID: 3115 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2B")]
		[Address(RVA = "0x2C49DC0", Offset = "0x2C48BC0", VA = "0x182C49DC0")]
		public static string Format(string format, object arg0, object arg1)
		{
			return null;
		}

		/// <summary>Replaces the format items in a string with the string representation of three specified objects.</summary>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The first object to format.</param>
		/// <param name="arg1">The second object to format.</param>
		/// <param name="arg2">The third object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which the format items have been replaced by the string representations of <paramref name="arg0" />, <paramref name="arg1" />, and <paramref name="arg2" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is less than zero, or greater than two.</exception>
		// Token: 0x06000C2C RID: 3116 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2C")]
		[Address(RVA = "0x2C49E20", Offset = "0x2C48C20", VA = "0x182C49E20")]
		public static string Format(string format, object arg0, object arg1, object arg2)
		{
			return null;
		}

		/// <summary>Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.</summary>
		/// <param name="format">A composite format string.</param>
		/// <param name="args">An object array that contains zero or more objects to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which the format items have been replaced by the string representation of the corresponding objects in <paramref name="args" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> or <paramref name="args" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is less than zero, or greater than or equal to the length of the <paramref name="args" /> array.</exception>
		// Token: 0x06000C2D RID: 3117 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2D")]
		[Address(RVA = "0x2C49F70", Offset = "0x2C48D70", VA = "0x182C49F70")]
		public static string Format(string format, params object[] args)
		{
			return null;
		}

		/// <summary>Replaces the format item or items in a specified string with the string representation of the corresponding object. A parameter supplies culture-specific formatting information.</summary>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which the format item or items have been replaced by the string representation of <paramref name="arg0" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is not zero.</exception>
		// Token: 0x06000C2E RID: 3118 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2E")]
		[Address(RVA = "0x2C49E80", Offset = "0x2C48C80", VA = "0x182C49E80")]
		public static string Format(IFormatProvider provider, string format, object arg0)
		{
			return null;
		}

		/// <summary>Replaces the format items in a string with the string representation of two specified objects. A parameter supplies culture-specific formatting information.</summary>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The first object to format.</param>
		/// <param name="arg1">The second object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which format items are replaced by the string representations of <paramref name="arg0" /> and <paramref name="arg1" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is not zero or one.</exception>
		// Token: 0x06000C2F RID: 3119 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C2F")]
		[Address(RVA = "0x2C49EF0", Offset = "0x2C48CF0", VA = "0x182C49EF0")]
		public static string Format(IFormatProvider provider, string format, object arg0, object arg1)
		{
			return null;
		}

		/// <summary>Replaces the format items in a string with the string representation of three specified objects. An parameter supplies culture-specific formatting information.</summary>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <param name="format">A composite format string.</param>
		/// <param name="arg0">The first object to format.</param>
		/// <param name="arg1">The second object to format.</param>
		/// <param name="arg2">The third object to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which the format items have been replaced by the string representations of <paramref name="arg0" />, <paramref name="arg1" />, and <paramref name="arg2" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is less than zero, or greater than two.</exception>
		// Token: 0x06000C30 RID: 3120 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C30")]
		[Address(RVA = "0x2C4A040", Offset = "0x2C48E40", VA = "0x182C4A040")]
		public static string Format(IFormatProvider provider, string format, object arg0, object arg1, object arg2)
		{
			return null;
		}

		/// <summary>Replaces the format items in a string with the string representations of corresponding objects in a specified array. A parameter supplies culture-specific formatting information.</summary>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <param name="format">A composite format string.</param>
		/// <param name="args">An object array that contains zero or more objects to format.</param>
		/// <returns>A copy of <paramref name="format" /> in which the format items have been replaced by the string representation of the corresponding objects in <paramref name="args" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="format" /> or <paramref name="args" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.  
		/// -or-  
		/// The index of a format item is less than zero, or greater than or equal to the length of the <paramref name="args" /> array.</exception>
		// Token: 0x06000C31 RID: 3121 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C31")]
		[Address(RVA = "0x2C4A0C0", Offset = "0x2C48EC0", VA = "0x182C4A0C0")]
		public static string Format(IFormatProvider provider, string format, params object[] args)
		{
			return null;
		}

		// Token: 0x06000C32 RID: 3122 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C32")]
		[Address(RVA = "0x2C49C80", Offset = "0x2C48A80", VA = "0x182C49C80")]
		private static string FormatHelper(IFormatProvider provider, string format, ParamsArray args)
		{
			return null;
		}

		/// <summary>Creates a new instance of <see cref="T:System.String" /> with the same value as a specified <see cref="T:System.String" />.</summary>
		/// <param name="str">The string to copy.</param>
		/// <returns>A new string with the same value as <paramref name="str" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="str" /> is <see langword="null" />.</exception>
		// Token: 0x06000C33 RID: 3123 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C33")]
		[Address(RVA = "0x2C48220", Offset = "0x2C47020", VA = "0x182C48220")]
		public static string Copy(string str)
		{
			return null;
		}

		/// <summary>Creates the string  representation of a specified object.</summary>
		/// <param name="arg0">The object to represent, or <see langword="null" />.</param>
		/// <returns>The string representation of the value of <paramref name="arg0" />, or <see cref="F:System.String.Empty" /> if <paramref name="arg0" /> is <see langword="null" />.</returns>
		// Token: 0x06000C34 RID: 3124 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C34")]
		[Address(RVA = "0x2C478A0", Offset = "0x2C466A0", VA = "0x182C478A0")]
		public static string Concat(object arg0)
		{
			return null;
		}

		/// <summary>Concatenates the string representations of two specified objects.</summary>
		/// <param name="arg0">The first object to concatenate.</param>
		/// <param name="arg1">The second object to concatenate.</param>
		/// <returns>The concatenated string representations of the values of <paramref name="arg0" /> and <paramref name="arg1" />.</returns>
		// Token: 0x06000C35 RID: 3125 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C35")]
		[Address(RVA = "0x2C47C00", Offset = "0x2C46A00", VA = "0x182C47C00")]
		public static string Concat(object arg0, object arg1)
		{
			return null;
		}

		/// <summary>Concatenates the string representations of three specified objects.</summary>
		/// <param name="arg0">The first object to concatenate.</param>
		/// <param name="arg1">The second object to concatenate.</param>
		/// <param name="arg2">The third object to concatenate.</param>
		/// <returns>The concatenated string representations of the values of <paramref name="arg0" />, <paramref name="arg1" />, and <paramref name="arg2" />.</returns>
		// Token: 0x06000C36 RID: 3126 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C36")]
		[Address(RVA = "0x2C475D0", Offset = "0x2C463D0", VA = "0x182C475D0")]
		public static string Concat(object arg0, object arg1, object arg2)
		{
			return null;
		}

		/// <summary>Concatenates the string representations of the elements in a specified <see cref="T:System.Object" /> array.</summary>
		/// <param name="args">An object array that contains the elements to concatenate.</param>
		/// <returns>The concatenated string representations of the values of the elements in <paramref name="args" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="args" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OutOfMemoryException">Out of memory.</exception>
		// Token: 0x06000C37 RID: 3127 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C37")]
		[Address(RVA = "0x2C479F0", Offset = "0x2C467F0", VA = "0x182C479F0")]
		public static string Concat(params object[] args)
		{
			return null;
		}

		/// <summary>Concatenates the members of a constructed <see cref="T:System.Collections.Generic.IEnumerable`1" /> collection of type <see cref="T:System.String" />.</summary>
		/// <param name="values">A collection object that implements <see cref="T:System.Collections.Generic.IEnumerable`1" /> and whose generic type argument is <see cref="T:System.String" />.</param>
		/// <returns>The concatenated strings in <paramref name="values" />, or <see cref="F:System.String.Empty" /> if <paramref name="values" /> is an empty <see langword="IEnumerable(Of String)" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="values" /> is <see langword="null" />.</exception>
		// Token: 0x06000C38 RID: 3128 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C38")]
		[Address(RVA = "0x2C476C0", Offset = "0x2C464C0", VA = "0x182C476C0")]
		[ComVisible(false)]
		public static string Concat(IEnumerable<string> values)
		{
			return null;
		}

		/// <summary>Concatenates two specified instances of <see cref="T:System.String" />.</summary>
		/// <param name="str0">The first string to concatenate.</param>
		/// <param name="str1">The second string to concatenate.</param>
		/// <returns>The concatenation of <paramref name="str0" /> and <paramref name="str1" />.</returns>
		// Token: 0x06000C39 RID: 3129 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C39")]
		[Address(RVA = "0x2C47900", Offset = "0x2C46700", VA = "0x182C47900")]
		public static string Concat(string str0, string str1)
		{
			return null;
		}

		/// <summary>Concatenates three specified instances of <see cref="T:System.String" />.</summary>
		/// <param name="str0">The first string to concatenate.</param>
		/// <param name="str1">The second string to concatenate.</param>
		/// <param name="str2">The third string to concatenate.</param>
		/// <returns>The concatenation of <paramref name="str0" />, <paramref name="str1" />, and <paramref name="str2" />.</returns>
		// Token: 0x06000C3A RID: 3130 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C3A")]
		[Address(RVA = "0x2C47E60", Offset = "0x2C46C60", VA = "0x182C47E60")]
		public static string Concat(string str0, string str1, string str2)
		{
			return null;
		}

		/// <summary>Concatenates four specified instances of <see cref="T:System.String" />.</summary>
		/// <param name="str0">The first string to concatenate.</param>
		/// <param name="str1">The second string to concatenate.</param>
		/// <param name="str2">The third string to concatenate.</param>
		/// <param name="str3">The fourth string to concatenate.</param>
		/// <returns>The concatenation of <paramref name="str0" />, <paramref name="str1" />, <paramref name="str2" />, and <paramref name="str3" />.</returns>
		// Token: 0x06000C3B RID: 3131 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C3B")]
		[Address(RVA = "0x2C47CB0", Offset = "0x2C46AB0", VA = "0x182C47CB0")]
		public static string Concat(string str0, string str1, string str2, string str3)
		{
			return null;
		}

		// Token: 0x06000C3C RID: 3132 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C3C")]
		[Address(RVA = "0x2C47310", Offset = "0x2C46110", VA = "0x182C47310")]
		private static string ConcatArray(string[] values, int totalLength)
		{
			return null;
		}

		/// <summary>Concatenates the elements of a specified <see cref="T:System.String" /> array.</summary>
		/// <param name="values">An array of string instances.</param>
		/// <returns>The concatenated elements of <paramref name="values" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="values" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OutOfMemoryException">Out of memory.</exception>
		// Token: 0x06000C3D RID: 3133 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C3D")]
		[Address(RVA = "0x2C47440", Offset = "0x2C46240", VA = "0x182C47440")]
		public static string Concat(params string[] values)
		{
			return null;
		}

		/// <summary>Returns the <see cref="T:System.TypeCode" /> for class <see cref="T:System.String" />.</summary>
		/// <returns>The enumerated constant, <see cref="F:System.TypeCode.String" />.</returns>
		// Token: 0x06000C3E RID: 3134 RVA: 0x0000A860 File Offset: 0x00008A60
		[Token(Token = "0x6000C3E")]
		[Address(RVA = "0x4B5B30", Offset = "0x4B4930", VA = "0x1804B5B30", Slot = "6")]
		public TypeCode GetTypeCode()
		{
			return TypeCode.Empty;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToBoolean(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>
		///   <see langword="true" /> if the value of the current string is <see cref="F:System.Boolean.TrueString" />; <see langword="false" /> if the value of the current string is <see cref="F:System.Boolean.FalseString" />.</returns>
		/// <exception cref="T:System.FormatException">The value of the current string is not <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</exception>
		// Token: 0x06000C3F RID: 3135 RVA: 0x0000A878 File Offset: 0x00008A78
		[Token(Token = "0x6000C3F")]
		[Address(RVA = "0x2C4E650", Offset = "0x2C4D450", VA = "0x182C4E650", Slot = "7")]
		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return default(bool);
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToChar(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The character at index 0 in the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C40 RID: 3136 RVA: 0x0000A890 File Offset: 0x00008A90
		[Token(Token = "0x6000C40")]
		[Address(RVA = "0x2C4E730", Offset = "0x2C4D530", VA = "0x182C4E730", Slot = "8")]
		char IConvertible.ToChar(IFormatProvider provider)
		{
			return '\0';
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToSByte(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000C41 RID: 3137 RVA: 0x0000A8A8 File Offset: 0x00008AA8
		[Token(Token = "0x6000C41")]
		[Address(RVA = "0x2C4EA50", Offset = "0x2C4D850", VA = "0x182C4EA50", Slot = "9")]
		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToByte(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number greater than <see cref="F:System.Byte.MaxValue" /> or less than <see cref="F:System.Byte.MinValue" />.</exception>
		// Token: 0x06000C42 RID: 3138 RVA: 0x0000A8C0 File Offset: 0x00008AC0
		[Token(Token = "0x6000C42")]
		[Address(RVA = "0x2C4E6C0", Offset = "0x2C4D4C0", VA = "0x182C4E6C0", Slot = "10")]
		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt16(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x06000C43 RID: 3139 RVA: 0x0000A8D8 File Offset: 0x00008AD8
		[Token(Token = "0x6000C43")]
		[Address(RVA = "0x2C4E900", Offset = "0x2C4D700", VA = "0x182C4E900", Slot = "11")]
		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToUInt16(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number greater than <see cref="F:System.UInt16.MaxValue" /> or less than <see cref="F:System.UInt16.MinValue" />.</exception>
		// Token: 0x06000C44 RID: 3140 RVA: 0x0000A8F0 File Offset: 0x00008AF0
		[Token(Token = "0x6000C44")]
		[Address(RVA = "0x2C4EBB0", Offset = "0x2C4D9B0", VA = "0x182C4EBB0", Slot = "12")]
		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt32(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C45 RID: 3141 RVA: 0x0000A908 File Offset: 0x00008B08
		[Token(Token = "0x6000C45")]
		[Address(RVA = "0x2C4E970", Offset = "0x2C4D770", VA = "0x182C4E970", Slot = "13")]
		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToUInt32(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number greater <see cref="F:System.UInt32.MaxValue" /> or less than <see cref="F:System.UInt32.MinValue" /></exception>
		// Token: 0x06000C46 RID: 3142 RVA: 0x0000A920 File Offset: 0x00008B20
		[Token(Token = "0x6000C46")]
		[Address(RVA = "0x2C4EC20", Offset = "0x2C4DA20", VA = "0x182C4EC20", Slot = "14")]
		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return 0U;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt64(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C47 RID: 3143 RVA: 0x0000A938 File Offset: 0x00008B38
		[Token(Token = "0x6000C47")]
		[Address(RVA = "0x2C4E9E0", Offset = "0x2C4D7E0", VA = "0x182C4E9E0", Slot = "15")]
		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return 0L;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToUInt64(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C48 RID: 3144 RVA: 0x0000A950 File Offset: 0x00008B50
		[Token(Token = "0x6000C48")]
		[Address(RVA = "0x2C4EC90", Offset = "0x2C4DA90", VA = "0x182C4EC90", Slot = "16")]
		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return 0UL;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToSingle(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C49 RID: 3145 RVA: 0x0000A968 File Offset: 0x00008B68
		[Token(Token = "0x6000C49")]
		[Address(RVA = "0x2C4EAC0", Offset = "0x2C4D8C0", VA = "0x182C4EAC0", Slot = "17")]
		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return 0f;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToDouble(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number less than <see cref="F:System.Double.MinValue" /> or greater than <see cref="F:System.Double.MaxValue" />.</exception>
		// Token: 0x06000C4A RID: 3146 RVA: 0x0000A980 File Offset: 0x00008B80
		[Token(Token = "0x6000C4A")]
		[Address(RVA = "0x2C4E890", Offset = "0x2C4D690", VA = "0x182C4E890", Slot = "18")]
		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return 0.0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToDecimal(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.FormatException">The value of the current <see cref="T:System.String" /> object cannot be parsed.</exception>
		/// <exception cref="T:System.OverflowException">The value of the current <see cref="T:System.String" /> object is a number less than <see cref="F:System.Decimal.MinValue" /> or than <see cref="F:System.Decimal.MaxValue" /> greater.</exception>
		// Token: 0x06000C4B RID: 3147 RVA: 0x0000A998 File Offset: 0x00008B98
		[Token(Token = "0x6000C4B")]
		[Address(RVA = "0x2C4E810", Offset = "0x2C4D610", VA = "0x182C4E810", Slot = "19")]
		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToDateTime(System.IFormatProvider)" />.</summary>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		// Token: 0x06000C4C RID: 3148 RVA: 0x0000A9B0 File Offset: 0x00008BB0
		[Token(Token = "0x6000C4C")]
		[Address(RVA = "0x2C4E7A0", Offset = "0x2C4D5A0", VA = "0x182C4E7A0", Slot = "20")]
		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			return default(DateTime);
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToType(System.Type,System.IFormatProvider)" />.</summary>
		/// <param name="type">The type of the returned object.</param>
		/// <param name="provider">An object that provides culture-specific formatting information.</param>
		/// <returns>The converted value of the current <see cref="T:System.String" /> object.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="type" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidCastException">The value of the current <see cref="T:System.String" /> object cannot be converted to the type specified by the <paramref name="type" /> parameter.</exception>
		// Token: 0x06000C4D RID: 3149 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C4D")]
		[Address(RVA = "0x2C4EB30", Offset = "0x2C4D930", VA = "0x182C4EB30", Slot = "22")]
		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return null;
		}

		// Token: 0x06000C4E RID: 3150 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C4E")]
		[Address(RVA = "0x2C4E590", Offset = "0x2C4D390", VA = "0x182C4E590", Slot = "25")]
		IEnumerator<char> IEnumerable<char>.GetEnumerator()
		{
			return null;
		}

		/// <summary>Returns an enumerator that iterates through the current <see cref="T:System.String" /> object.</summary>
		/// <returns>An enumerator that can be used to iterate through the current string.</returns>
		// Token: 0x06000C4F RID: 3151 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C4F")]
		[Address(RVA = "0x2C4E5F0", Offset = "0x2C4D3F0", VA = "0x182C4E5F0", Slot = "23")]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		/// <summary>Gets the number of characters in the current <see cref="T:System.String" /> object.</summary>
		/// <returns>The number of characters in the current string.</returns>
		// Token: 0x170000F6 RID: 246
		// (get) Token: 0x06000C50 RID: 3152 RVA: 0x0000A9C8 File Offset: 0x00008BC8
		[Token(Token = "0x170000F6")]
		public int Length
		{
			[Token(Token = "0x6000C50")]
			[Address(RVA = "0x3FA560", Offset = "0x3F9360", VA = "0x1803FA560")]
			get
			{
				return 0;
			}
		}

		// Token: 0x06000C51 RID: 3153 RVA: 0x0000A9E0 File Offset: 0x00008BE0
		[Token(Token = "0x6000C51")]
		[Address(RVA = "0x2C461D0", Offset = "0x2C44FD0", VA = "0x182C461D0")]
		internal static int CompareOrdinalUnchecked(string strA, int indexA, int lenA, string strB, int indexB, int lenB)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence of the specified character in this instance. The search starts at a specified character position and examines a specified number of character positions.</summary>
		/// <param name="value">A Unicode character to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> from the start of the string if that character is found, or -1 if it is not.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> or <paramref name="startIndex" /> is negative.  
		/// -or-  
		/// <paramref name="startIndex" /> is greater than the length of this string.  
		/// -or-  
		/// <paramref name="count" /> is greater than the length of this string minus <paramref name="startIndex" />.</exception>
		// Token: 0x06000C52 RID: 3154 RVA: 0x0000A9F8 File Offset: 0x00008BF8
		[Token(Token = "0x6000C52")]
		[Address(RVA = "0x2C4A7C0", Offset = "0x2C495C0", VA = "0x182C4A7C0")]
		public int IndexOf(char value, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C53 RID: 3155 RVA: 0x0000AA10 File Offset: 0x00008C10
		[Token(Token = "0x6000C53")]
		[Address(RVA = "0x2C4A570", Offset = "0x2C49370", VA = "0x182C4A570")]
		internal int IndexOfUnchecked(char value, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C54 RID: 3156 RVA: 0x0000AA28 File Offset: 0x00008C28
		[Token(Token = "0x6000C54")]
		[Address(RVA = "0x2C4A670", Offset = "0x2C49470", VA = "0x182C4A670")]
		internal int IndexOfUnchecked(string value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position and examines a specified number of character positions.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <param name="startIndex">The search starting position.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <returns>The zero-based index position of the first occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> or <paramref name="startIndex" /> is negative.  
		/// -or-  
		/// <paramref name="count" /> + <paramref name="startIndex" /> is greater than the number of characters in this instance.</exception>
		// Token: 0x06000C55 RID: 3157 RVA: 0x0000AA40 File Offset: 0x00008C40
		[Token(Token = "0x6000C55")]
		[Address(RVA = "0x2C4A370", Offset = "0x2C49170", VA = "0x182C4A370")]
		public int IndexOfAny(char[] anyOf, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C56 RID: 3158 RVA: 0x0000AA58 File Offset: 0x00008C58
		[Token(Token = "0x6000C56")]
		[Address(RVA = "0x2C4A200", Offset = "0x2C49000", VA = "0x182C4A200")]
		private int IndexOfAnyUnchecked(char[] anyOf, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.</summary>
		/// <param name="value">The Unicode character to seek.</param>
		/// <param name="startIndex">The starting position of the search. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <returns>The zero-based index position of <paramref name="value" /> if that character is found, or -1 if it is not found or if the current instance equals <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> is less than zero or greater than or equal to the length of this instance.  
		///  -or-  
		///  The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> - <paramref name="count" /> + 1 is less than zero.</exception>
		// Token: 0x06000C57 RID: 3159 RVA: 0x0000AA70 File Offset: 0x00008C70
		[Token(Token = "0x6000C57")]
		[Address(RVA = "0x2C4C550", Offset = "0x2C4B350", VA = "0x182C4C550")]
		public int LastIndexOf(char value, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C58 RID: 3160 RVA: 0x0000AA88 File Offset: 0x00008C88
		[Token(Token = "0x6000C58")]
		[Address(RVA = "0x2C4BF70", Offset = "0x2C4AD70", VA = "0x182C4BF70")]
		internal int LastIndexOfUnchecked(char value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.</summary>
		/// <param name="anyOf">A Unicode character array containing one or more characters to seek.</param>
		/// <param name="startIndex">The search starting position. The search proceeds from <paramref name="startIndex" /> toward the beginning of this instance.</param>
		/// <param name="count">The number of character positions to examine.</param>
		/// <returns>The index position of the last occurrence in this instance where any character in <paramref name="anyOf" /> was found; -1 if no character in <paramref name="anyOf" /> was found or if the current instance equals <see cref="F:System.String.Empty" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="anyOf" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="count" /> or <paramref name="startIndex" /> is negative.  
		///  -or-  
		///  The current instance does not equal <see cref="F:System.String.Empty" />, and <paramref name="startIndex" /> minus <paramref name="count" /> + 1 is less than zero.</exception>
		// Token: 0x06000C59 RID: 3161 RVA: 0x0000AAA0 File Offset: 0x00008CA0
		[Token(Token = "0x6000C59")]
		[Address(RVA = "0x2C4BD30", Offset = "0x2C4AB30", VA = "0x182C4BD30")]
		public int LastIndexOfAny(char[] anyOf, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C5A RID: 3162 RVA: 0x0000AAB8 File Offset: 0x00008CB8
		[Token(Token = "0x6000C5A")]
		[Address(RVA = "0x2C4BC70", Offset = "0x2C4AA70", VA = "0x182C4BC70")]
		private int LastIndexOfAnyUnchecked(char[] anyOf, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x06000C5B RID: 3163 RVA: 0x0000AAD0 File Offset: 0x00008CD0
		[Token(Token = "0x6000C5B")]
		[Address(RVA = "0x2C4F7A0", Offset = "0x2C4E5A0", VA = "0x182C4F7A0")]
		internal static int nativeCompareOrdinalEx(string strA, int indexA, string strB, int indexB, int count)
		{
			return 0;
		}

		// Token: 0x06000C5C RID: 3164 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C5C")]
		[Address(RVA = "0x2C4D0A0", Offset = "0x2C4BEA0", VA = "0x182C4D0A0")]
		private string ReplaceInternal(char oldChar, char newChar)
		{
			return null;
		}

		// Token: 0x06000C5D RID: 3165 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C5D")]
		[Address(RVA = "0x2C4D1C0", Offset = "0x2C4BFC0", VA = "0x182C4D1C0")]
		internal string ReplaceInternal(string oldValue, string newValue)
		{
			return null;
		}

		// Token: 0x06000C5E RID: 3166 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C5E")]
		[Address(RVA = "0x2C4D2C0", Offset = "0x2C4C0C0", VA = "0x182C4D2C0")]
		private string ReplaceUnchecked(string oldValue, string newValue)
		{
			return null;
		}

		// Token: 0x06000C5F RID: 3167 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C5F")]
		[Address(RVA = "0x2C4CF40", Offset = "0x2C4BD40", VA = "0x182C4CF40")]
		private string ReplaceFallback(string oldValue, string newValue, int testedCount)
		{
			return null;
		}

		// Token: 0x06000C60 RID: 3168 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C60")]
		[Address(RVA = "0x2C4CA60", Offset = "0x2C4B860", VA = "0x182C4CA60")]
		private string PadHelper(int totalWidth, char paddingChar, bool isRightPadded)
		{
			return null;
		}

		// Token: 0x06000C61 RID: 3169 RVA: 0x0000AAE8 File Offset: 0x00008CE8
		[Token(Token = "0x6000C61")]
		[Address(RVA = "0x2C4DFE0", Offset = "0x2C4CDE0", VA = "0x182C4DFE0")]
		internal bool StartsWithOrdinalUnchecked(string value)
		{
			return default(bool);
		}

		// Token: 0x06000C62 RID: 3170 RVA: 0x0000AB00 File Offset: 0x00008D00
		[Token(Token = "0x6000C62")]
		[Address(RVA = "0x2C4B580", Offset = "0x2C4A380", VA = "0x182C4B580")]
		internal bool IsAscii()
		{
			return default(bool);
		}

		// Token: 0x06000C63 RID: 3171 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C63")]
		[Address(RVA = "0x2C45ED0", Offset = "0x2C44CD0", VA = "0x182C45ED0")]
		internal unsafe static void CharCopy(char* dest, char* src, int count)
		{
		}

		// Token: 0x06000C64 RID: 3172 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C64")]
		[Address(RVA = "0x2C4F6C0", Offset = "0x2C4E4C0", VA = "0x182C4F6C0")]
		private unsafe static void memset(byte* dest, int val, int len)
		{
		}

		// Token: 0x06000C65 RID: 3173 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C65")]
		[Address(RVA = "0x2C4F6B0", Offset = "0x2C4E4B0", VA = "0x182C4F6B0")]
		private unsafe static void memcpy(byte* dest, byte* src, int size)
		{
		}

		// Token: 0x06000C66 RID: 3174 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C66")]
		[Address(RVA = "0x2C4F550", Offset = "0x2C4E350", VA = "0x182C4F550")]
		internal unsafe static void bzero(byte* dest, int len)
		{
		}

		// Token: 0x06000C67 RID: 3175 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C67")]
		[Address(RVA = "0x9B7550", Offset = "0x9B6350", VA = "0x1809B7550")]
		internal unsafe static void bzero_aligned_1(byte* dest, int len)
		{
		}

		// Token: 0x06000C68 RID: 3176 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C68")]
		[Address(RVA = "0x2C4F540", Offset = "0x2C4E340", VA = "0x182C4F540")]
		internal unsafe static void bzero_aligned_2(byte* dest, int len)
		{
		}

		// Token: 0x06000C69 RID: 3177 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C69")]
		[Address(RVA = "0x1404A70", Offset = "0x1403870", VA = "0x181404A70")]
		internal unsafe static void bzero_aligned_4(byte* dest, int len)
		{
		}

		// Token: 0x06000C6A RID: 3178 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C6A")]
		[Address(RVA = "0x164B120", Offset = "0x1649F20", VA = "0x18164B120")]
		internal unsafe static void bzero_aligned_8(byte* dest, int len)
		{
		}

		// Token: 0x06000C6B RID: 3179 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C6B")]
		[Address(RVA = "0x2C4F670", Offset = "0x2C4E470", VA = "0x182C4F670")]
		internal unsafe static void memcpy_aligned_1(byte* dest, byte* src, int size)
		{
		}

		// Token: 0x06000C6C RID: 3180 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C6C")]
		[Address(RVA = "0x2C4F680", Offset = "0x2C4E480", VA = "0x182C4F680")]
		internal unsafe static void memcpy_aligned_2(byte* dest, byte* src, int size)
		{
		}

		// Token: 0x06000C6D RID: 3181 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C6D")]
		[Address(RVA = "0x2C4F690", Offset = "0x2C4E490", VA = "0x182C4F690")]
		internal unsafe static void memcpy_aligned_4(byte* dest, byte* src, int size)
		{
		}

		// Token: 0x06000C6E RID: 3182 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000C6E")]
		[Address(RVA = "0x2C4F6A0", Offset = "0x2C4E4A0", VA = "0x182C4F6A0")]
		internal unsafe static void memcpy_aligned_8(byte* dest, byte* src, int size)
		{
		}

		// Token: 0x06000C6F RID: 3183 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C6F")]
		[Address(RVA = "0x2C48800", Offset = "0x2C47600", VA = "0x182C48800")]
		private unsafe string CreateString(sbyte* value)
		{
			return null;
		}

		// Token: 0x06000C70 RID: 3184 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C70")]
		[Address(RVA = "0x2C48560", Offset = "0x2C47360", VA = "0x182C48560")]
		private unsafe string CreateString(sbyte* value, int startIndex, int length)
		{
			return null;
		}

		// Token: 0x06000C71 RID: 3185 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C71")]
		[Address(RVA = "0x2C487F0", Offset = "0x2C475F0", VA = "0x182C487F0")]
		private unsafe string CreateString(char* value)
		{
			return null;
		}

		// Token: 0x06000C72 RID: 3186 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C72")]
		[Address(RVA = "0x2C488F0", Offset = "0x2C476F0", VA = "0x182C488F0")]
		private unsafe string CreateString(char* value, int startIndex, int length)
		{
			return null;
		}

		// Token: 0x06000C73 RID: 3187 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C73")]
		[Address(RVA = "0x2C48900", Offset = "0x2C47700", VA = "0x182C48900")]
		private string CreateString(char[] val, int startIndex, int length)
		{
			return null;
		}

		// Token: 0x06000C74 RID: 3188 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C74")]
		[Address(RVA = "0x2C484A0", Offset = "0x2C472A0", VA = "0x182C484A0")]
		private string CreateString(char[] val)
		{
			return null;
		}

		// Token: 0x06000C75 RID: 3189 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C75")]
		[Address(RVA = "0x2C483C0", Offset = "0x2C471C0", VA = "0x182C483C0")]
		private string CreateString(char c, int count)
		{
			return null;
		}

		// Token: 0x06000C76 RID: 3190 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000C76")]
		[Address(RVA = "0x2C48580", Offset = "0x2C47380", VA = "0x182C48580")]
		private unsafe string CreateString(sbyte* value, int startIndex, int length, Encoding enc)
		{
			return null;
		}

		// Token: 0x040004B4 RID: 1204
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
		[Token(Token = "0x40004B4")]
		[NonSerialized]
		private int m_stringLength;

		// Token: 0x040004B5 RID: 1205
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x14")]
		[Token(Token = "0x40004B5")]
		[NonSerialized]
		private char m_firstChar;

		// Token: 0x040004B6 RID: 1206
		[Token(Token = "0x40004B6")]
		private const int TrimHead = 0;

		// Token: 0x040004B7 RID: 1207
		[Token(Token = "0x40004B7")]
		private const int TrimTail = 1;

		// Token: 0x040004B8 RID: 1208
		[Token(Token = "0x40004B8")]
		private const int TrimBoth = 2;

		/// <summary>Represents the empty string. This field is read-only.</summary>
		// Token: 0x040004B9 RID: 1209
		[Token(Token = "0x40004B9")]
		public static readonly string Empty;

		// Token: 0x040004BA RID: 1210
		[Token(Token = "0x40004BA")]
		private const int charPtrAlignConst = 1;

		// Token: 0x040004BB RID: 1211
		[Token(Token = "0x40004BB")]
		private const int alignConst = 3;
	}
}