/// <summary>複製</summary>
public object Clone()
{
	MersenneTwister r = new MersenneTwister();
	r.mti = mti;
	r.mt = (uint[])mt.Clone();
	return r;
}
/// <summary>文字列表現</summary>
public string Expression
{
	get {return ToString();}
	set
	{
		if (value.Length != 4+N*4*8/6) throw new ArgumentException();
		mti = short.Parse(value.Substring(0, 4), System.Globalization.NumberStyles.HexNumber);
		byte[] b = Convert.FromBase64String(value.Substring(4));
		for (int i=0;i<mt.Length;++i) mt[i] = BitConverter.ToUInt32(b, i*4);
	}
}
/// <summary>文字列化</summary>
public override string ToString()
{
	byte[] b = new byte[mt.Length*4];
	for (int i=0;i<mt.Length;++i) BitConverter.GetBytes(mt[i]).CopyTo(b, 4*i);
	return mti.ToString("x4") + Convert.ToBase64String(b);
}

using System;
using System.Collections;
using System.Collections.Generic;

namespace CSTest
{
	/// <summary>ペア</summary>
	public struct Pair<T, U>
	{
		/// <summary>要素1</summary>
		public T First;
		/// <summary>要素2</summary>
		public U Second;
		/// <summary>コンストラクタ</summary>
		public Pair(T t) { First = t; Second = default(U); }
		/// <summary>コンストラクタ</summary>
		public Pair(T t, U u) { First = t; Second = u; }
		/// <summary>等値演算</summary>
		public override bool Equals(object obj)
		{
			Pair<T, U> pr = (Pair<T, U>)obj;
			return First.Equals(pr.First) && Second.Equals(pr.Second);
		}
		/// <summary>ハッシュコード</summary>
		public override int GetHashCode()
		{
			return First.GetHashCode() ^ Second.GetHashCode();
		}
		/// <summary>文字列化</summary>
		public override string ToString()
		{
			return First.ToString() + ", " + Second.ToString();
		}
	}
	/// <summary>Treeの要素</summary>
	public class TreeNode<T>
	{
		/// <summary>値</summary>
		public T Value;
		internal LinkedList<TreeNode<T>> _Nodes;
		/// <summary>子要素</summary>
		public LinkedList<TreeNode<T>> Nodes
		{
			get { return _Nodes; }
		}
		/// <summary>先頭</summary>
		public LinkedListNode<TreeNode<T>> First
		{
			get { return _Nodes.First; }
		}
		/// <summary>最後</summary>
		public LinkedListNode<TreeNode<T>> Last
		{
			get { return _Nodes.Last; }
		}
		/// <summary>子要素の数</summary>
		public int Count
		{
			get { return _Nodes.Count; }
		}
		/// <summary>コンストラクタ</summary>
		public TreeNode() : this(default(T)) { }
		/// <summary>コンストラクタ</summary>
		public TreeNode(T t) { Value = t; _Nodes = new LinkedList<TreeNode<T>>(); }
	}
	/// <summary>Tree</summary>
	public class Tree<T> : IEnumerable
	{
		private TreeNode<T> _Root;
		/// <summary>根</summary>
		public TreeNode<T> Root
		{
			get { return _Root; }
		}
		/// <summary>コンストラクタ</summary>
		public Tree()
		{
			_Root = new TreeNode<T>();
		}
		/// <summary>コンストラクタ</summary>
		public Tree(T t)
		{
			_Root = new TreeNode<T>(t);
		}
		/// <summary>追加</summary>
		public void Add(T t) { _Root._Nodes.AddLast(new TreeNode<T>(t)); }
		/// <summary>追加</summary>
		public void Add(LinkedListNode<TreeNode<T>> ln, T t) { ln.Value._Nodes.AddLast(new TreeNode<T>(t)); }
		/// <summary>削除</summary>
		public void Remove(LinkedListNode<TreeNode<T>> ln) { ln.List.Remove(ln); }
		internal IEnumerator GetEnumerator(int level, TreeNode<T> tn)
		{
			yield return new Pair<int, T>(level, tn.Value);
			LinkedListNode<TreeNode<T>> ln = tn.Nodes.First;
			while (ln != null)
			{
				IEnumerator en = GetEnumerator(level + 1, ln.Value);
				while (en.MoveNext()) yield return (Pair<int, T>)en.Current;
				ln = ln.Next;
			}
		}
		/// <summary>反復子</summary>
		public IEnumerator GetEnumerator() { return GetEnumerator(0, _Root); }
	}
	class Program
	{
		static void Main(string[] args)
		{
			Tree<int> t = new Tree<int>(123);
			t.Add(234);
			t.Add(t.Root.First, 345);
			t.Add(456);
			foreach (Pair<int, int> pr in t) // pr = (レベル, 値)
			{
				string s = pr.Second.ToString();
				Console.WriteLine(s.PadLeft((pr.First + 1) * 4));
			}
			// 出力
			//  123
			//     234
			//         345
			//     456
		}
	}
}

class Test
{
	private static double Calc(double[,,,] dd, int k, int i, int j, int cc)
	{
		double d = 0;
		// 1 の場合
		if (i >= 1) d += 1;
		else d -= dd[k, j, i+1, cc];
		// 2 の場合
		if (i >= 2) d += 1;
		else d -= dd[k, j, i+1, cc];
		// 3 の場合
		if (i >= 3) d += 1;
		else d -= dd[k, j, i+1, cc];
		// 4 の場合
		d -= dd[k, j - (j >= 1 ? 1 : 0), i, cc];
		// 5 の場合
		d -= dd[k, j - (j >= 2 ? 1 : 0), i, cc];
		// 6 の場合
		d -= dd[k, j - (j >= 3 ? 1 : 0), i, cc];
		return d / 6;
	}
	[STAThread]
	static void Main(string[] args)
	{
		// 0 me, 1: center, 2:you
		double[,,,] dd = new double[2,4,4,3];
		int[,,] db = new int[4,4,3];
		dd[0,0,0,0] = dd[0,0,0,1] = dd[0,0,0,2] = 1;
		int k = 0;
		for (int cnt=0;cnt<1000;++cnt)
		{
			int knxt = 1-k;
			for (int i=0;i<4;++i)			// 自分
			{
				for (int j=0;j<4;++j)		// 相手
				{
					for (int c=0;c<3;++c)	// キューブ
					{
						// ダブルしない
						double d = Calc(dd, k, i, j, 2-c);
						db[i, j, c] = 0;
						if (c != 2) // ダブルする
						{
							double e = Math.Min(1, 2 * Calc(dd, k, i, j, 0));
							if (e > d)
							{
								db[i, j, c] = 1;
								d = e;
							}
						}
						dd[knxt, i, j, c] = d;
					}
				}
			}
			double f = 0;
			for (int i=0;i<4;++i)
				for (int j=0;j<4;++j)
					for (int c=0;c<3;++c)
						f += Math.Abs(dd[0, i, j, c] - dd[1, i, j, c]);
			if (f < 1e-14) break;
			k = knxt;
		}
		//using (StreamWriter sw = new StreamWriter("../../res.txt", false, Encoding.Default))
		{
			for (int i=0;i<4;++i)
				for (int j=0;j<4;++j)
					for (int c=0;c<3;++c)
						Console.WriteLine("Me {0} You {1} Cube {2} Double?={3} Accept?={4} Prob={5}", 
							i, j, c, db[i, j, c] == 0 ? 'N' : 'Y', dd[0, j, i, 2] > 0.5 ? 'N' : 'Y', dd[0, i, j, c]);
		}
	}
}

// Shape.cs
public abstract partial class Shape
{
  public static void Check(Shape sh1, Shape sh2, Shape sh3)
  {
    sh1.Check(sh2, sh3);
  }
  public abstract void Check(Shape sh1, Shape sh2);
  public void Show(Shape sh1, Shape sh2)
  {
    System.Console.WriteLine("{0} {1} {2}",
      GetType().Name, sh1.GetType().Name, sh2.GetType().Name);
  }
}

// Circle.cs
public abstract partial class Shape
{
  public abstract void Check(Circle sh1, Shape sh2);
  public abstract void Check(Circle sh1, Circle sh2);
}
public partial class Circle : Shape
{
  public override void Check(Shape sh1, Shape sh2) { sh1.Check(this, sh2); }
  public override void Check(Circle sh1, Shape sh2) {sh2.Check(sh1, this);}
  public override void Check(Circle sh1, Circle sh2) { Show(sh1, sh2); }
}

// Rect.cs
public abstract partial class Shape
{
  public abstract void Check(Rect sh1, Shape sh2);
  public abstract void Check(Rect sh1, Circle sh2);
  public abstract void Check(Rect sh1, Rect sh2);
}
public partial class Circle : Shape
{
  public override void Check(Rect sh1, Shape sh2) { sh2.Check(sh1, this); }
  public override void Check(Rect sh1, Circle sh2) { sh1.Check(this, sh2); }
  public override void Check(Rect sh1, Rect sh2) { sh1.Check(sh2, this); }
}
public partial class Rect : Shape
{
  public override void Check(Shape sh1, Shape sh2) { sh1.Check(this, sh2); }
  public override void Check(Circle sh1, Shape sh2) { sh2.Check(this, sh1); }
  public override void Check(Circle sh1, Circle sh2) { Show(sh1, sh2); }
  public override void Check(Rect sh1, Shape sh2) { sh2.Check(sh1, this); }
  public override void Check(Rect sh1, Circle sh2) { Show(sh1, sh2); }
  public override void Check(Rect sh1, Rect sh2) { Show(sh1, sh2); }
}

// Polygon.cs
public abstract partial class Shape
{
  public abstract void Check(Polygon sh1, Shape sh2);
  public abstract void Check(Polygon sh1, Circle sh2);
  public abstract void Check(Polygon sh1, Rect sh2);
  public abstract void Check(Polygon sh1, Polygon sh2);
}
public partial class Circle : Shape
{
  public override void Check(Polygon sh1, Shape sh2) { sh2.Check(sh1, this); }
  public override void Check(Polygon sh1, Circle sh2) { sh1.Check(this, sh2); }
  public override void Check(Polygon sh1, Rect sh2) { sh1.Check(sh2, this); }
  public override void Check(Polygon sh1, Polygon sh2) { sh1.Check(sh2, this); }
}
public partial class Rect : Shape
{
  public override void Check(Polygon sh1, Shape sh2) { sh2.Check(sh1, this); }
  public override void Check(Polygon sh1, Circle sh2) { sh1.Check(this, sh2); }
  public override void Check(Polygon sh1, Rect sh2) { sh1.Check(this, sh2); }
  public override void Check(Polygon sh1, Polygon sh2) { sh1.Check(sh2, this); }
}
public partial class Polygon : Shape
{
  public override void Check(Shape sh1, Shape sh2) { sh1.Check(this, sh2); }
  public override void Check(Circle sh1, Shape sh2) { sh2.Check(this, sh1); }
  public override void Check(Circle sh1, Circle sh2) { Show(sh1, sh2); }
  public override void Check(Rect sh1, Shape sh2) { sh2.Check(this, sh1); }
  public override void Check(Rect sh1, Circle sh2) { Show(sh1, sh2); }
  public override void Check(Rect sh1, Rect sh2) { Show(sh1, sh2); }
  public override void Check(Polygon sh1, Shape sh2) { sh2.Check(sh1, this); }
  public override void Check(Polygon sh1, Circle sh2) { Show(sh1, sh2); }
  public override void Check(Polygon sh1, Rect sh2) { Show(sh1, sh2); }
  public override void Check(Polygon sh1, Polygon sh2) { Show(sh1, sh2); }
}

// Program.cs
public class Test
{
  [STAThread]
  public static void Main(string[] args)
  {
    List<Shape> l = new List<Shape>();
    foreach (Type t in Assembly.GetExecutingAssembly().GetTypes())
      if (t.IsSubclassOf(typeof(Shape))) 
        l.Add((Shape)Activator.CreateInstance(t));
    foreach (Shape s1 in l)
      foreach (Shape s2 in l)
        foreach (Shape s3 in l)
          Shape.Check(s1, s2, s3);
  }
}

/// <summary>[DP]シングルトン</summary>
public static class Singleton<T> where T : new()
{
	private static readonly T _Instance = new T();
	public static T Instance {get { return _Instance; } }
}

/// <summary>
/// グラフ上の最長路のホップ数を返す
/// (有向アークが含まれていてはいけない)
/// </summary>
public static int GetLongestPath<TN, TA>(Graph<TN, TA> grp)
{
	foreach (ArcTag<TN, TA> at in grp.ArcTags)
		if (at.IsEnable && at.IsDirected) throw new ApplicationException("Exist directed arc");
	bool[] unchk = new bool[grp.ArcsCount]; // 未チェックのアークか
	int[] degree = new int[grp.NodesCount]; // ノードの次数
	foreach (ArcTag<TN, TA> at in grp.ArcTags)
	{
		if (unchk[at.Index] = (at.IsEnable && at.LeftTag.IsEnable && at.RightTag.IsEnable))
		{
			++degree[at.LeftID];
			++degree[at.RightID];
		}
	}
	List<GLPData> dt = new List<GLPData>(); // 次数が2のノードを縮約した後のリンクの集合
	GLPData gd = new GLPData();
	Dictionary<int, int> dic = new Dictionary<int, int>(); // ノードIndex→縮約後のノードIndex
	// 縮約する
	while (true)
	{
		ArcTag<TN, TA> fnd = null, fst = null;
		for (int i = 0; i < grp.ArcsCount; ++i)
		{
			if (!unchk[i]) continue;
			ArcTag<TN, TA> at = grp.ArcTag(i);
			if (fst == null) fst = at;
			if (degree[at.LeftID] == 2 && degree[at.RightID] == 2) continue;
			fnd = at;
			break;
		}
		if (fnd == null && (fnd = fst) == null) break;
		// 縮約後のノード数が31以上なら求められない
		if (dt.Count >= 31) throw new ApplicationException("Too complex");
		NodeTag<TN, TA> nt = degree[fnd.RightID] != 2 ? fnd.RightTag : fnd.LeftTag;
		gd.len = 0;
		gd.node1 = GetIndex(dic, nt.Index);
		while (true)
		{
			unchk[fnd.Index] = false;
			++gd.len;
			nt = grp.NodeTag(fnd.AnotherID(nt.Index));
			if (degree[nt.Index] != 2) break;
			foreach (ArcTag<TN, TA> act in nt.InArcTags)
			{
				if (act.IsEnable && act != fnd)
				{
					fnd = act;
					break;
				}
			}
			if (!unchk[fnd.Index]) break;
		}
		gd.node2 = GetIndex(dic, nt.Index);
		dt.Add(gd);
	}
	if (dt.Count == 0) return 0;
	int[] con = new int[dic.Count]; // 縮約後のノードの次数
	int[] src = new int[dic.Count]; // 0:非対象、1:未チェック、2:チェック済み
	bool[] bUse = new bool[dt.Count]; // 縮約後のリンクのON/OFF
	int max = 0, cur = 0, odd = 0;
	uint n = 1U << dt.Count;
	// リンクのON/OFFの全組合せをチェック
	for (uint i = 0; i < n - 1; ++i)
	{
		int k = (int)Math.Log((i | ~(~i - 1)) - i, 2);
		gd = dt[k];
		int sgn = (bUse[k] = !bUse[k]) ? 1 : -1;
		cur += sgn * gd.len;
		odd += (con[gd.node1] += sgn) % 2 == 0 ? -1 : 1;
		odd += (con[gd.node2] += sgn) % 2 == 0 ? -1 : 1;
		// 次数が奇数の数が3以上なら一筆書きでない
		if (odd > 2 || cur <= max) continue;
		// 連結性のチェック
		bool bFound = false;
		for (int h = 0; h < src.Length; ++h)
		{
			src[h] = con[h] == 0 ? 0 : (bFound ? 1 : 2);
			if (src[h] > 0) bFound = true;
		}
		while (bFound)
		{
			bFound = false;
			foreach (GLPData gld in dt)
			{
				if (src[gld.node1] + src[gld.node2] == 3)
				{
					bFound = true;
					src[gld.node1] = src[gld.node2] = 2;
				}
			}
		}
		for (int h = 0; h < src.Length; ++h)
			if (bFound = src[h] == 1) break;
		if (!bFound) max = cur;
	}
	return max;
}
private struct GLPData
{
	public int len;
	public int node1;
	public int node2;
}
private static int GetIndex(Dictionary<int, int> dic, int i)
{
	int k;
	if (!dic.TryGetValue(i, out k))
		dic.Add(i, k = dic.Count);
	return k;
}

private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
	if (e.KeyCode != Keys.Enter) return;
	svr.Add(textBox1.Text + "\r\n");
	textBox1.Text = "";
}
public class Server : MarshalByRefObject
{
	private string data = "";
	public string Data { get { return data; } }
	public void Add(string s) { data += s; }
}
Server svr;
private void Form1_Load(object sender, EventArgs e)
{
	const int portno = 8100;
	System.Diagnostics.Process[] prcs = System.Diagnostics.Process.GetProcessesByName("SimpleChat");
	if (prcs.Length == 1)
	{
		System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(
			new System.Runtime.Remoting.Channels.Tcp.TcpChannel(portno), false);
		backgroundWorker1.RunWorkerAsync();
		System.Threading.Thread.Sleep(100);
	}
	svr = (Server)Activator.GetObject(typeof(Server), "tcp://localhost:" + portno + "/SimpleChat");
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
	System.Runtime.Remoting.RemotingConfiguration.RegisterWellKnownServiceType(
		typeof(Server), "SimpleChat", System.Runtime.Remoting.WellKnownObjectMode.Singleton);
}
private void timer1_Tick(object sender, EventArgs e)
{
	timer1.Stop();
	string s = svr.Data;
	if (textBox2.Text != s) textBox2.Text = s;
	timer1.Start();
}