// CharTest.cs - NUnit Test Cases for the System.Char struct
//
// David Brandt (bucky@keystreams.com)
//
// (C) Ximian, Inc.  http://www.ximian.com
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
// 

using NUnit.Framework;
using System;
using System.Globalization;

namespace MonoTests.System
{
[TestFixture]
public class CharTest
{
	[Test]
	public void TestCompareTo()
	{
		Char c1 = 'a';
		Char c2 = 'b';
		Char c3 = 'b';
		Assert.IsTrue(c1.CompareTo(c2) == -1, "Less than");
		Assert.IsTrue(c2.CompareTo(c1) == 1, "Greater than");
		Assert.IsTrue(c2.CompareTo(c3) == 0, "Equal 1");
		Assert.IsTrue(c1.CompareTo(c1) == 0, "Equal 2");
	}

	[Test]	
	public void TestEquals()
	{
		Char c1 = 'a';
		Char c2 = 'b';
		Char c3 = 'b';
		Assert.IsTrue(c1.Equals(c1), "Same");
		Assert.IsTrue(c2.Equals(c3), "Same value");
		Assert.IsTrue(!c1.Equals(c2), "Not same");
	}

	[Test]
	public void TestGetHashValue()
	{
		Char c1 = ' ';
		Assert.AreEqual(c1.GetHashCode(), c1.GetHashCode(), "deterministic hash code ");
		// TODO - the spec doesn't say what algorithm is used to get hash codes.  So far, just a weak test for determinism and mostly-uniqueness.
	}

	[Test]
	public void TestGetNumericValue()
	{
		Char c1 = ' ';
		Char c2 = '3';
		Assert.AreEqual(-1.0, Char.GetNumericValue(c1), 0.1, "code 1");
		Assert.AreEqual(3.0, Char.GetNumericValue(c2), 0.1, "code 2");

		string s1 = " 3 ";
		Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 0), 0.1, "space not number");
		Assert.AreEqual(3.0, Char.GetNumericValue(s1, 1), 0.1, "space not number");
		Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 2), 0.1, "space not number");
	}

	[Test]
	public void TestGetUnicodeCategory()
	{
		{
			char Pe1 = ']';
			char Pe2 = '}';
			char Pe3 = ')';
			Assert.AreEqual(UnicodeCategory.ClosePunctuation, 
							Char.GetUnicodeCategory(Pe1),
							"Close Punctuation");
			Assert.AreEqual(UnicodeCategory.ClosePunctuation, 
							Char.GetUnicodeCategory(Pe2),
							"Close Punctuation");
			Assert.AreEqual(UnicodeCategory.ClosePunctuation, 
							Char.GetUnicodeCategory(Pe3),
							"Close Punctuation");
		}
		// TODO - ConnectorPunctuation
		{
			char c1 = (char)0; // 0000-001F, 007F-009F
			char c2 = (char)0x001F;
			char c3 = (char)0x007F;
			char c4 = (char)0x00F;
			Assert.AreEqual(UnicodeCategory.Control, 
							Char.GetUnicodeCategory(c1),
							"Control");
			Assert.AreEqual(UnicodeCategory.Control, 
							Char.GetUnicodeCategory(c2),
							"Control");
			Assert.AreEqual(UnicodeCategory.Control,
							Char.GetUnicodeCategory(c3),
							"Control");
			Assert.AreEqual(UnicodeCategory.Control,
							Char.GetUnicodeCategory(c4),
							"Control");
		}
		{
			// TODO - more currencies?
			char c1 = '$';
			Assert.AreEqual(
				     UnicodeCategory.CurrencySymbol,
				     Char.GetUnicodeCategory(c1),
					 "Currency");
		}
		{
			char c1 = '-';
			Assert.AreEqual(UnicodeCategory.DashPunctuation,
							Char.GetUnicodeCategory(c1),
							"Dash Punctuation");
		}
		{
			char c1 = '2';
			char c2 = '7';
			Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
							Char.GetUnicodeCategory(c1),
							"Decimal Digit");
			Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
							Char.GetUnicodeCategory(c2),
							"Decimal Digit");
		}
		// TODO - EnclosingMark
		// TODO - FinalQuotePunctuation
		// TODO - Format
		// TODO - InitialQuotePunctuation
		// TODO - LetterNumber
		// TODO - LineSeparator (not '\n', that's a control char)
		{
			char c1 = 'a';
			char c2 = 'z';
			Assert.AreEqual(UnicodeCategory.LowercaseLetter,
							Char.GetUnicodeCategory(c1),
							"LowercaseLetter");
			Assert.AreEqual(UnicodeCategory.LowercaseLetter, 
							Char.GetUnicodeCategory(c2),
							"LowercaseLetter");
		}
		{
			char c1 = '+';
			char c2 = '=';
			Assert.AreEqual(UnicodeCategory.MathSymbol,
							Char.GetUnicodeCategory(c1),
							"MathSymbol");
			Assert.AreEqual(UnicodeCategory.MathSymbol,
							Char.GetUnicodeCategory(c2),
							"MathSymbol");
		}
		// TODO - ModifierSymbol
		// TODO - NonSpacingMark
		// TODO - OpenPunctuation
		{
			char c1 = '[';
			char c2 = '{';
			char c3 = '(';
			Assert.AreEqual(UnicodeCategory.OpenPunctuation,
							Char.GetUnicodeCategory(c1),
							"OpenPunctuation");
			Assert.AreEqual(UnicodeCategory.OpenPunctuation, 
							Char.GetUnicodeCategory(c2),
							"OpenPunctuation");
			Assert.AreEqual(UnicodeCategory.OpenPunctuation,
							Char.GetUnicodeCategory(c3),
							"OpenPunctuation");
		}
		// TODO - OtherLetter
		// TODO - OtherNotAssigned
		// TODO - OtherNumber
		{
			char c1 = '/';
			Assert.AreEqual(UnicodeCategory.OtherPunctuation,
							Char.GetUnicodeCategory(c1),
							"OtherPunctuation");
		}
		// TODO - OtherSymbol
		// TODO - ParagraphSeparator
		// TODO - PrivateUse
		{
			char c1 = ' ';
			Assert.AreEqual(UnicodeCategory.SpaceSeparator,
							Char.GetUnicodeCategory(c1),
							"SpaceSeparator");
		}
		// TODO - SpacingCombiningMark
		{
			char c1 = (char)0xD800; // D800-DBFF
			char c2 = (char)0xDBFF; // D800-DBFF
			char c3 = (char)0xDC01; // DC00-DEFF
			char c4 = (char)0xDEFF; // DC00-DEFF
			Assert.AreEqual(UnicodeCategory.Surrogate,
							Char.GetUnicodeCategory(c1),
							"High Surrogate");
			Assert.AreEqual(UnicodeCategory.Surrogate,
							Char.GetUnicodeCategory(c2),
							"High Surrogate");
			Assert.AreEqual(UnicodeCategory.Surrogate,
							Char.GetUnicodeCategory(c3),
							"Low Surrogate");
			Assert.AreEqual(UnicodeCategory.Surrogate,
							Char.GetUnicodeCategory(c4),
							"Low Surrogate");
		}
		// TODO - TitlecaseLetter
		// TODO - UppercaseLetter
		{
			char c1 = 'A';
			char c2 = 'Z';
			Assert.AreEqual(UnicodeCategory.UppercaseLetter,
							Char.GetUnicodeCategory(c1),
							"UppercaseLetter");
			Assert.AreEqual(UnicodeCategory.UppercaseLetter,
							Char.GetUnicodeCategory(c2),
							"UppercaseLetter");
		}
	}

	[Test]
	public void TestGetUnicodeCategoryStringIndex ()
	{
		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 0), UnicodeCategory.OtherLetter, "#C01");
		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 1), UnicodeCategory.Surrogate, "#C02");
		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800", 0), UnicodeCategory.Surrogate, "#C03");
		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800!", 0), UnicodeCategory.Surrogate, "#C04");
		Assert.AreEqual (Char.GetUnicodeCategory ("!", 0), UnicodeCategory.OtherPunctuation, "#C05");
		Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800", 1), UnicodeCategory.Surrogate, "#C06");
		Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800\uDF80", 1), UnicodeCategory.OtherLetter, "#C07");
	}

	[Test]
	public void TestGetUnicodeCategoryAstralPlanes ()
	{
		const int up_to = 0x10ffff;
		// const int increment = 1;
		const int increment = 0x1000 + 17;

		for (int codepoint = 0x10000; codepoint < up_to; codepoint += increment) {
			string combined = Char.ConvertFromUtf32 (codepoint);

			Assert.AreEqual (combined.Length, 2, "#D01");
			Assert.AreEqual (Char.GetUnicodeCategory (combined [0]), UnicodeCategory.Surrogate, "#D02");
			Assert.AreEqual (Char.GetUnicodeCategory (combined [1]), UnicodeCategory.Surrogate, "#D03");
			Assert.AreNotEqual (Char.GetUnicodeCategory (combined, 0), UnicodeCategory.Surrogate, "#D04");
		}
	}

	[Test]
	public void TestIsControl()
	{
		// control is 0000-001F, 007F-009F
		char c1 = (char)0;
		char c2 = (char)0x001F;
		char c3 = (char)0x007F;
		char c4 = (char)0x009F;
		Assert.IsTrue(!Char.IsControl(' '), "Not control");
		Assert.IsTrue(Char.IsControl(c1), "control");
		Assert.IsTrue(Char.IsControl(c2), "control");
		Assert.IsTrue(Char.IsControl(c3), "control");
		Assert.IsTrue(Char.IsControl(c4), "control");

		string s1 = " " + c1 + c2 + c3 + c4;
		Assert.IsTrue(!Char.IsControl(s1, 0), "Not control");
		Assert.IsTrue(Char.IsControl(s1, 1), "control");
		Assert.IsTrue(Char.IsControl(s1, 2), "control");
		Assert.IsTrue(Char.IsControl(s1, 3), "control");
		Assert.IsTrue(Char.IsControl(s1, 4), "control");
	}

	[Test]
	public void TestIsDigit()
	{
		char c1 = '0';
		char c2 = '9';
		Assert.IsTrue(!Char.IsDigit(' '), "Not digit");
		Assert.IsTrue(Char.IsDigit(c1), "digit");
		Assert.IsTrue(Char.IsDigit(c2), "digit");

		string s1 = " " + c1 + c2;
		Assert.IsTrue(!Char.IsDigit(s1, 0), "Not digit");
		Assert.IsTrue(Char.IsDigit(s1, 1), "digit");
		Assert.IsTrue(Char.IsDigit(s1, 2), "digit");
	}

	[Test]
	public void TestIsLetter()
	{
		char c1 = 'a';
		char c2 = 'z';
		char c3 = 'A';
		char c4 = 'Z';
		Assert.IsTrue(!Char.IsLetter(' '), "Not letter");
		Assert.IsTrue(Char.IsLetter(c1), "letter");
		Assert.IsTrue(Char.IsLetter(c2), "letter");
		Assert.IsTrue(Char.IsLetter(c3), "letter");
		Assert.IsTrue(Char.IsLetter(c4), "letter");

		string s1 = " " + c1 + c2 + c3 + c4;
		Assert.IsTrue(!Char.IsLetter(s1, 0), "Not letter");
		Assert.IsTrue(Char.IsLetter(s1, 1), "letter");
		Assert.IsTrue(Char.IsLetter(s1, 2), "letter");
		Assert.IsTrue(Char.IsLetter(s1, 3), "letter");
		Assert.IsTrue(Char.IsLetter(s1, 4), "letter");
	}

	[Test]
	public void TestIsLetterOrDigit()
	{
		char c1 = 'a';
		char c2 = 'z';
		char c3 = 'A';
		char c4 = 'Z';
		char c5 = '0';
		char c6 = '9';
		Assert.IsTrue(!Char.IsLetterOrDigit(' '), "Not letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c1), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c2), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c3), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c4), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c5), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(c6), "letterordigit");

		string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;
		Assert.IsTrue(!Char.IsLetterOrDigit(s1, 0), "Not letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 1), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 2), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 3), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 4), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 5), "letterordigit");
		Assert.IsTrue(Char.IsLetterOrDigit(s1, 6), "letterordigit");
	}

	[Test]
	public void TestIsLower()
	{
		char c1 = 'a';
		char c2 = 'z';
		Assert.IsTrue(!Char.IsLower(' '), "Not lower");
		Assert.IsTrue(Char.IsLower(c1), "lower");
		Assert.IsTrue(Char.IsLower(c2), "lower");

		string s1 = " " + c1 + c2;
		Assert.IsTrue(!Char.IsLower(s1, 0), "Not lower");
		Assert.IsTrue(Char.IsLower(s1, 1), "lower");
		Assert.IsTrue(Char.IsLower(s1, 2), "lower");
	}

	[Test]
	public void TestIsNumber()
	{
		char c1 = '0';
		char c2 = '9';
		// TODO - IsNumber of less obvious characters

		Assert.IsTrue(!Char.IsNumber(' '), "Not number");
		Assert.IsTrue(Char.IsNumber(c1), "number");
		Assert.IsTrue(Char.IsNumber(c2), "number");

		string s1 = " " + c1 + c2;
		Assert.IsTrue(!Char.IsNumber(s1, 0), "Not number");
		Assert.IsTrue(Char.IsNumber(s1, 1), "number");
		Assert.IsTrue(Char.IsNumber(s1, 2), "number");
	}

	[Test]
	public void TestIsPunctuation()
	{
		char c1 = '.';
		char c2 = '?';
		Assert.IsTrue(!Char.IsPunctuation(' '), "Not punctuation");
		Assert.IsTrue(Char.IsPunctuation(c1), "punctuation");
		Assert.IsTrue(Char.IsPunctuation(c2), "punctuation");

		string s1 = " " + c1 + c2;
		Assert.IsTrue(!Char.IsPunctuation(s1, 0), "Not punctuation");
		Assert.IsTrue(Char.IsPunctuation(s1, 1), "punctuation");
		Assert.IsTrue(Char.IsPunctuation(s1, 2), "punctuation");
	}

	[Test]
	public void TestIsSeparator()
	{
		char c1 = ' ';

		Assert.IsTrue(!Char.IsSeparator('.'), "Not separator");
		Assert.IsTrue(Char.IsSeparator(c1), "separator1");

		string s1 = "." + c1;
		Assert.IsTrue(!Char.IsSeparator(s1, 0), "Not separator");
		Assert.IsTrue(Char.IsSeparator(s1, 1), "separator1-2");
	}

	[Test]
	public void TestIsSurrogate()
	{
		// high surrogate - D800-DBFF
		// low surrogate - DC00-DEFF
		char c1 = (char)0xD800;
		char c2 = (char)0xDBFF;
		char c3 = (char)0xDC00;
		char c4 = (char)0xDEFF;
		Assert.IsTrue(!Char.IsSurrogate(' '), "Not surrogate");
		Assert.IsTrue(Char.IsSurrogate(c1), "surrogate1");
		Assert.IsTrue(Char.IsSurrogate(c2), "surrogate2");
		Assert.IsTrue(Char.IsSurrogate(c3), "surrogate3");
		Assert.IsTrue(Char.IsSurrogate(c4), "surrogate4");

		string s1 = " " + c1 + c2 + c3 + c4;
		Assert.IsTrue(!Char.IsSurrogate(s1, 0), "Not surrogate");
		Assert.IsTrue(Char.IsSurrogate(s1, 1), "surrogate1-2");
		Assert.IsTrue(Char.IsSurrogate(s1, 2), "surrogate2-2");
		Assert.IsTrue(Char.IsSurrogate(s1, 3), "surrogate3-2");
		Assert.IsTrue(Char.IsSurrogate(s1, 4), "surrogate4-2");
	}

	[Test]
	public void TestIsSymbol()
	{
		char c1 = '+';
		char c2 = '=';
		Assert.IsTrue(!Char.IsSymbol(' '), "Not symbol");
		Assert.IsTrue(Char.IsSymbol(c1), "symbol");
		Assert.IsTrue(Char.IsSymbol(c2), "symbol");

		string s1 = " " + c1 + c2;
		Assert.IsTrue(!Char.IsSymbol(s1, 0), "Not symbol");
		Assert.IsTrue(Char.IsSymbol(s1, 1), "symbol");
		Assert.IsTrue(Char.IsSymbol(s1, 2), "symbol");
	}

	[Test]
	public void TestIsUpper()
	{
		char c1 = 'A';
		char c2 = 'Z';
		Assert.IsTrue(!Char.IsUpper('a'), "Not upper");
		Assert.IsTrue(Char.IsUpper(c1), "upper");
		Assert.IsTrue(Char.IsUpper(c2), "upper");

		string s1 = "a" + c1 + c2;
		Assert.IsTrue(!Char.IsUpper(s1, 0), "Not upper");
		Assert.IsTrue(Char.IsUpper(s1, 1), "upper");
		Assert.IsTrue(Char.IsUpper(s1, 2), "upper");
	}

	[Test]
	public void TestIsWhiteSpace()
	{
		char c1 = ' ';
		char c2 = '\n';
		char c3 = '\t';

		Assert.IsTrue(!Char.IsWhiteSpace('.'), "Not whitespace");
		Assert.IsTrue(Char.IsWhiteSpace(c1), "whitespace1");
		Assert.IsTrue(Char.IsWhiteSpace(c2), "whitespace2");
		Assert.IsTrue(Char.IsWhiteSpace(c3), "whitespace3");

		string s1 = "." + c1 + c2 + c3;
		Assert.IsTrue(!Char.IsWhiteSpace(s1, 0), "Not whitespace");
		Assert.IsTrue(Char.IsWhiteSpace(s1, 1), "whitespace1-2");
		Assert.IsTrue(Char.IsWhiteSpace(s1, 2), "whitespace2-2");
		Assert.IsTrue(Char.IsWhiteSpace(s1, 3), "whitespace3-2");

		for (int i = 0; i < ushort.MaxValue; ++i ) {
			switch (i) {
			case '\x9':
			case '\xa':
			case '\xb':
			case '\xc':
			case '\xd':
			case '\x20':
			case '\x85':
			case '\xa0':
			case '\x1680':
			case '\x2000':
			case '\x2001':
			case '\x2002':
			case '\x2003':
			case '\x2004':
			case '\x2005':
			case '\x2006':
			case '\x2007':
			case '\x2008':
			case '\x2009':
			case '\x200a':
			case '\x2028':
			case '\x2029':
			case '\x202f':
			case '\x205f':
			case '\x3000':
				Assert.IsTrue (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
				break;
			default:
				Assert.IsFalse (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
				break;
			}
		}
	}

	[Test]
	public void TestParse()
	{
		char c1 = 'a';
		string s1 = "a";
		Assert.IsTrue(c1.Equals(Char.Parse(s1)));
	}	

	[Test]
	public void TestTryParseValid ()
	{
		char c1 = 'a';
		string s1 = "a";
		char c2;

		Assert.AreEqual (true, Char.TryParse (s1, out c2), "TryParse1");
		Assert.AreEqual (c2, c1, "TryParse2");
	}

	[Test]
	public void TestTryParseInvalid ()
	{
		string s = "abc";
		char c;
		Assert.AreEqual (false, Char.TryParse (s, out c), "TryParse3");
		Assert.AreEqual ('\0', c, "TryParse4");
	}

	[Test]	
	public void TestToLower()
	{
		char a1 = 'a';
		char a2 = 'A';
		char a3 = 'z';
		char a4 = 'Z';
		char a5 = ' ';
		char a6 = '+';
		char b1 = 'a';
		char b2 = 'a';
		char b3 = 'z';
		char b4 = 'z';
		char b5 = ' ';
		char b6 = '+';
		Assert.AreEqual(b1, Char.ToLower(a1), "char lowered");
		Assert.AreEqual(b2, Char.ToLower(a2), "char lowered");
		Assert.AreEqual(b3, Char.ToLower(a3), "char lowered");
		Assert.AreEqual(b4, Char.ToLower(a4), "char lowered");
		Assert.AreEqual(b5, Char.ToLower(a5), "char lowered");
		Assert.AreEqual(b6, Char.ToLower(a6), "char lowered");
	}

	[Test]
	public void TestToUpper()
	{
		char a1 = 'a';
		char a2 = 'A';
		char a3 = 'z';
		char a4 = 'Z';
		char a5 = ' ';
		char a6 = '+';
		char b1 = 'A';
		char b2 = 'A';
		char b3 = 'Z';
		char b4 = 'Z';
		char b5 = ' ';
		char b6 = '+';
		Assert.AreEqual(b1, Char.ToUpper(a1), "char uppered");
		Assert.AreEqual(b2, Char.ToUpper(a2), "char uppered");
		Assert.AreEqual(b3, Char.ToUpper(a3), "char uppered");
		Assert.AreEqual(b4, Char.ToUpper(a4), "char uppered");
		Assert.AreEqual(b5, Char.ToUpper(a5), "char uppered");
		Assert.AreEqual(b6, Char.ToUpper(a6), "char uppered");
	}

	[Test]
	public void TestToUpperInvariant ()
	{
		Assert.AreEqual ('\u01c5', char.ToUpperInvariant ('\u01c5'));
	}

	[Test]
	public void TestToString()
	{
		char c1 = 'a';
		string s1 = "a";
		Assert.IsTrue(s1.Equals(c1.ToString()));
	}

	[Test]
	public void TestGetTypeCode()
	{
		char c1 = 'a';
		Assert.IsTrue(c1.GetTypeCode().Equals(TypeCode.Char));
	}

	[Test]
	public void TestConvertFromUtf32 ()
	{
		Assert.AreEqual ("A", Char.ConvertFromUtf32 (0x41), "#1");
		Assert.AreEqual ("\uD800\uDC00", Char.ConvertFromUtf32 (0x10000), "#2");
	}

	[Test]
	[ExpectedException (typeof (ArgumentOutOfRangeException))]
	public void TestConvertFromUtf32Fail1 ()
	{
		Char.ConvertFromUtf32 (-1);
	}

	[Test]
	[ExpectedException (typeof (ArgumentOutOfRangeException))]
	public void TestConvertFromUtf32Fail2 ()
	{
		Char.ConvertFromUtf32 (0x110001);
	}

	[Test]
	[ExpectedException (typeof (ArgumentOutOfRangeException))]
	public void TestConvertFromUtf32Fail3 ()
	{
		Char.ConvertFromUtf32 (0xD800);
	}

	[Test]
	public void TestConvertToUtf32 ()
	{
		Assert.AreEqual (0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'), "#1");
		Assert.AreEqual (0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'), "#2");
	}

	[Test]
	[ExpectedException (typeof (ArgumentOutOfRangeException))]
	public void TestConvertToUtf32Fail1 ()
	{
		Char.ConvertToUtf32 ('A', '\uDC00');
	}

	[Test]
	[ExpectedException (typeof (ArgumentOutOfRangeException))]
	public void TestConvertUtf32Fail2 ()
	{
		Char.ConvertToUtf32 ('\uD800', '\uD800');
	}
}

}