잡다한 인생

		//
		//	Look for lone rangers in minigrid
		//
		public bool LookForLoneRangersinMinigrids()
		{
			bool changes = false;
			bool NextMiniGrid;
			int occurrence;
			int cPos = 0;
			int rPos = 0;


			//	check for each number from 1 to 9
			for ( int n = 1; n < 10; n++ )
			{
				//	check the 9 minigrids
				for ( int r = 1; r < 10; r = r + 3 )
				{
					for ( int c = 1; c < 10; c = c + 3 )
					{
						NextMiniGrid = false;

						//	check within the minigrid
						occurrence = 0;

						for ( int rr = 0; rr < 3; rr++ )
						{
							for ( int cc = 0; cc < 3; cc++ )
							{
								if ( (actual[c + cc, r + rr] == 0) &&
									possible[c + cc, r + rr].Contains(n.ToString()) )
								{
									occurrence += 1;
									cPos = c + cc;
									rPos = r + rr;

									if ( occurrence > 1 )
									{
										NextMiniGrid = true;
										break;
									}

								}
							}

							if ( NextMiniGrid )
								break;
						}

						if ( ( !NextMiniGrid ) && ( occurrence == 1 ) )
						{
							//	that means number is confirmed
							SetCell( cPos, rPos, n, 1 );
							SetToolTip( cPos, rPos, n.ToString() );

							//	save the moves into the stack
							Moves.Push( cPos.ToString() + rPos.ToString() + n.ToString() );
							DisplayActivity( "Look for Lone Rangers in Minigrid", false );
							DisplayActivity( "===================", false );
							DisplayActivity( "Inserted value " + n.ToString() + " in (" + cPos + ", " + rPos + ")", false );

							Application.DoEvents();
							changes = true;

							// if user clicks the hint button, exit the function
							if (HintMode)
								return true;
						}
					}
				}
			}

			return changes;
		}

		//
		//	Look for Lone Rangers in Rows
		//
		public bool LookForLoneRangersinRows()
		{
			bool changes = false;
			int occurrence;
			int cPos = 0;
			int rPos = 0;

			
			//	check by row
			for ( int r = 1; r < 10; r++ )
			{
				for ( int n = 1; n < 10; n++ )
				{
					occurrence = 0;

					for ( int c = 1; c < 10; c++ )
					{
						if ( ( actual[c, r] == 0 ) &&
							possible[c, r].Contains( n.ToString() ) )
						{
							occurrence += 1;

							//	if multiple occurrence, not a lone any more
							if ( occurrence > 1 )
								break;

							cPos = c;
							rPos = r;

						}
					}

					if ( occurrence == 1 )
					{
						//	number is confirmed
						SetCell( cPos, rPos, n, 1 );
						SetToolTip( cPos, rPos, n.ToString() );

						//	save the move into the stack
						Moves.Push( cPos.ToString() + rPos.ToString() + n.ToString() );

						DisplayActivity( "Look for Lone Ranges in Rows", false );
						DisplayActivity( "===================", false );
						DisplayActivity( "Inserted value " + n.ToString() + " in (" + cPos + rPos + ")", false );

						Application.DoEvents();
						changes = true;

						//	if user clicks the Hint button, exit function
						if ( HintMode )
							return true;

					}
				}
			

			}
			return changes;
		}

		//
		//	Look for Lone Rangers in Columns
		//
		public bool LookForLoneRangersinColumns()
		{
			bool changes = false;
			int occurrence;
			int cPos = 0;
			int rPos = 0;


			//	check by column
			for ( int c = 1; c < 10; c++ )
			{
				for ( int n = 1; n < 10; n++ )
				{
					occurrence = 0;

					for ( int r = 1; r < 10; r++ )
					{
						if ( ( actual[c, r] == 0 ) &&
							possible[c, r].Contains( n.ToString() ) )
						{
							occurrence += 1;

							//	if multiple occurrence, not a lone any more
							if ( occurrence > 1 )
								break;

							cPos = c;
							rPos = r;

						}
					}

					if ( occurrence == 1 )
					{
						//	number is confirmed
						SetCell( cPos, rPos, n, 1 );
						SetToolTip( cPos, rPos, n.ToString() );

						//	save the move into the stack
						Moves.Push( cPos.ToString() + rPos.ToString() + n.ToString() );

						DisplayActivity( "Look for Lone Ranges in Columns", false );
						DisplayActivity( "===================", false );
						DisplayActivity( "Inserted value " + n.ToString() + " in (" + cPos + ", " + rPos + ")", false );

						Application.DoEvents();
						changes = true;

						//	if user clicks the Hint button, exit function
						if ( HintMode )
							return true;

					}
				}
			}
			return changes;
		}

		//
		//	Steps to solve the puzzle
		//
		public bool SolvePuzzle()
		{
			bool changes = false;
			bool ExitLoop = false;


			//	if game is not started, return
			if ( !GameStarted )
				return false;

			try
			{
				do
				{
					do
					{
						do
						{
							do
							{

								//	perform Col/Row and Minigrid Elimination (CRME)
								changes = CheckColumsAndRows();

								if ( ( HintMode && changes ) || IsPuzzleSolved() )
								{
									ExitLoop = true;
									break;
								}

							} while ( changes );

							if ( ExitLoop )
								break;

							//	look for lone rangers in minigrids
							changes = LookForLoneRangersinMinigrids();

							if ( ( HintMode && changes ) || IsPuzzleSolved() )
							{
								ExitLoop = true;
								break;
							}

						} while ( changes );

						if ( ExitLoop )
							break;

						//	look for lone rangers in rows
						changes = LookForLoneRangersinRows();

						if ( ( HintMode && changes ) || IsPuzzleSolved() )
						{
							ExitLoop = true;
							break;
						}

					} while ( changes );

					if ( ExitLoop )
						break;

					//	look for lone rangers in Columns
					changes = LookForLoneRangersinColumns();

					if ( ( HintMode && changes ) || IsPuzzleSolved() )
					{
						ExitLoop = true;
						break;
					}

				} while ( changes );

			}

			catch
			{
				throw new Exception( "Invalid Move" );
			}

			if ( IsPuzzleSolved() )
			{
				timer1.Enabled = false;
				Console.Beep();
				toolStripStatusLabel1.Text = "**** Puzzle Solved ****";
				MessageBox.Show( "Puzzle Solved" );
				return true;
			}
			else
				return false;

		}

Scan each cell in the grid from left to right, top to bottom

	For each cell:

		Set possible values for each cell to 123456789

		Scan its column and eliminate the values already present in the column
		Scan its row and eliminate the values already present in the row
		Scan its minigrid and eliminate the values already present in the minigrid

		If there is only one possible value for the cell,
			the number for the cell is confirmed

Until no more cells can be confirmed

		//	for CRME technique
		private String [,] possible = new String[9, 9];
		private Boolean HintMode;

		//
		//	set a cell to a given value
		//
		public void SetCell( int col, int row, int value, int erasable )
		{
			//	locate particular Label control
			Control [] lbl = this.Controls.Find( col.ToString() + row.ToString(), true );
			Label cellLabel = lbl[0] as Label;

			//	save the value in the array
			actual[col, row] = value;

			//	if erasing a cell, you need to reset the possible values
			//		for all cells
			//	(추가 부분)
			if ( value == 0 )
				for ( int r = 1; r < 10; r++ )
					for ( int c = 1; c < 10; c++ )
						if ( actual[c, r] == 0 )
							possible[c, r] = String.Empty;


			//	set the appearance for the Label control
			if ( value == 0 )		//	erasing the cell
			{
				cellLabel.Text = String.Empty;
				cellLabel.Tag = erasable;
				cellLabel.BackColor = DEFAULT_BACKCOLOR;
			}
			else
			{
				if ( erasable == 0 )
				{
					//	means default puzzle values
					cellLabel.BackColor = FIXED_BACKCOLOR;
					cellLabel.ForeColor = FIXED_FORECOLOR;
				}
				else
				{
					//	means user-set value
					cellLabel.BackColor = USER_BACKCOLOR;
					cellLabel.ForeColor = USER_FORECOLOR;
				}

				cellLabel.Text = value.ToString();
				cellLabel.Tag = erasable;
			}
		}

		//
		//	set the Tooltip for a Label Control
		//

		public void SetToolTip( int col, int row, String possibleValues )
		{
			//	locate the particular Label Control
			Control [] lbl = this.Controls.Find( col.ToString() + row.ToString(), true );
						
			toolTip1.SetToolTip( lbl[0] as Label, possibleValues );

		}

		//
		//	start a new game
		//
		public void StartNewGame()
		{
			saveFileName = String.Empty;
			txtActivities.Text = String.Empty;
			seconds = 0;

			ClearBoard();

			GameStarted = true;
			timer1.Enabled = true;
			toolStripStatusLabel1.Text = "New game started";

			toolTip1.RemoveAll();
		}

		//
		//	Calculate the possible values for a cell
		//

		public string CalculatePossibleValues( int col, int row )
		{
			String str;

			if ( possible[col, row] == String.Empty )
				str = "123456789";
			else
				str = possible[col, row];

			//	step 1. check by column

			for ( int r = 1; r < 10; r++ )
				if ( actual[col, r] != 0 )
					//	that means there is an actual value on it
					str = str.Replace( actual[col, r].ToString(), String.Empty );

			//	step 2. check by row

			for ( int c = 1; c < 10; c++ )
				if ( actual[c, row] != 0 )
					//	that means there is an actual value on it
					str = str.Replace( actual[c, row].ToString(), String.Empty );

			//	step 3. check by minigrid

			int startC = col - ( ( col - 1 ) % 3 );
			int startR = row - ( ( row - 1 ) % 3 );

			for ( int rr=startR; rr < startR + 3; rr++ )
				for ( int cc=startC; cc < startC + 3; cc++ )
					if ( actual[cc, rr] != 0 )
						//	that means there is a actual value on it
						str = str.Replace( actual[cc, rr].ToString(), String.Empty );

			//	if possible value is an empty string then error,
			//	because of invalid move

			if ( str == String.Empty )
				throw new Exception( "Invalid Move" );

			return str;
		}

		//
		//	Calculates the possible values for all the cells
		//
		public Boolean CheckColumsAndRows()
		{
			Boolean changes = false;

			//	check all cells
			for(int row = 1; row < 10;row++)
			{
				for(int col = 1;col < 10;col++)
				{
					if(actual[col,row] == 0)
					{
						try
						{
							possible[col, row] = CalculatePossibleValues(col,row);
						}

						catch(Exception ex)
						{
							DisplayActivity("Invalid placement, please undo move", false);

							throw new Exception("Invalid Move");
						}

						//	display the possible values in the ToolTip
						SetToolTip( col, row, possible[col, row] );

						if ( possible[col, row].Length == 1 )
						{
							//	that means a number is confirmed
							SetCell( col, row, int.Parse( possible[col, row] ), 1 );

							//	number is confirmed
							actual[col, row] = int.Parse( possible[col, row] );
							DisplayActivity( "Col/Row and Minigrid Elimination", false );
							DisplayActivity( "=========================", false );
							DisplayActivity( "Inserted value " + actual[col, row] + " in"
												+ "(" + col + ", " + row + ")", false );

							//	get the UI of the application to refresh
							//		with the newly confirmed number
							Application.DoEvents();

							//	saves the move into the stack
							Moves.Push( col.ToString() + row.ToString() + possible[col, row] );

							// if user only ask for a hint, stop at this point
							changes = true;

							if ( HintMode )
								return true;

						}
					}
				}
			}

			return changes;
		}

		//
		//	Hint button
		//
		private void btnHint_Click( object sender, EventArgs e )
		{

			//	show hints one cell at a time
			HintMode = true;

			try
			{
				SolvePuzzle();
			}
			catch
			{
				MessageBox.Show(
					"Please undo your move",
					"Invalid Move",
					MessageBoxButtons.OK,
					MessageBoxIcon.Error );
			}
		}

		//
		//	Solve Puzzle button
		//
		private void btnSolvePuzzle_Click( object sender, EventArgs e )
		{

			//	solve the puzzle
			HintMode = false;

			try
			{
				SolvePuzzle();
			}
			catch
			{
				MessageBox.Show(
					"Pleas undo your move",
					"Invalid Move",
					MessageBoxButtons.OK,
					MessageBoxIcon.Error );
			}
		}

		//
		//	Steps to solve the puzzle
		//
		public bool SolvePuzzle()
		{

			bool changes;
			bool ExitLoop = false;

			try
			{
				do
				{
					//	perform Col/Row and Minigrid Elimination
					changes = CheckColumsAndRows();

					if ( ( HintMode && changes ) || IsPuzzleSolved() )
					{
						ExitLoop = true;
						break;
					}
				} while ( !changes );
			}
			catch
			{
				throw new Exception( "Invalid Move" );
			}

			if ( IsPuzzleSolved() )
			{
				timer1.Enabled = false;
				Console.Beep();
				toolStripStatusLabel1.Text = "**** Puzzle Solved ****";
				MessageBox.Show( "Puzzle Solved" );
				return true;
			}
			else
				return false;


		}

		//
		//	Steps to solve the puzzle
		//
		public bool SolvePuzzle()
		{
			bool changes;
			bool ExitLoop = false;

			int loopCounter = 0;


			//	if game is not started, return
			if ( !GameStarted )
				return false;

			try
			{
				do
				{
					//	perform Col/Row and Minigrid Elimination
					changes = CheckColumsAndRows();

					if ( ( HintMode && changes ) || IsPuzzleSolved() )
					{
						ExitLoop = true;
						break;
					}

					if ( loopCounter++ == 3 )
						return false;


				} while ( !changes );
			}
			catch
			{
				throw new Exception( "Invalid Move" );
			}

			if ( IsPuzzleSolved() )
			{
				timer1.Enabled = false;
				Console.Beep();
				toolStripStatusLabel1.Text = "**** Puzzle Solved ****";
				MessageBox.Show( "Puzzle Solved" );
				return true;
			}
			else
				return false;

		}

		//
		//	undo a move
		//
		private void undoToolStripMenuItem_Click( object sender, EventArgs e )
		{
			//	if no previous moves, then exit
			if ( Moves.Count == 0 )
				return;

			//	remove from the Moves stack and push into the RedoMoves stack
			String str = Moves.Pop();
			RedoMoves.Push( str );

			//	save the value in the array
			SetCell( int.Parse( str.Substring( 0, 1 ) ), int.Parse( str.Substring( 1, 1 ) ), 0, 1 );
			DisplayActivity( "Value " + str[2] + " removed at (" + str[0] + ", " + str[1] + ")", false );
		}

		//
		//	redo the move
		//
		private void redoToolStripMenuItem_Click( object sender, EventArgs e )
		{
			//	if RedoMove stack is empty, the exit
			if ( RedoMoves.Count == 0 )
				return;

			//	remove from the RedoMoves stack and push into the Moves stack
			String str = RedoMoves.Pop();
			Moves.Push( str );

			//	save the value in the array
			SetCell( int.Parse( str.Substring( 0, 1 ) ), int.Parse( str.Substring( 1, 1 ) ), int.Parse( str.Substring( 2, 1 ) ), 1 );
			DisplayActivity( "Value " + str[2] + " reinserted at (" + str[0] + ", " + str[1] + ")", false );
		}

		//
		//	Save the game to disk
		//
		public void SaveGameToDisk( Boolean saveAs )
		{
			//	if saveFileName is empty, means game has not been saved before
			if ( ( saveFileName == String.Empty ) || saveAs )
			{
				SaveFileDialog saveFileDialog1 = new SaveFileDialog();

				saveFileDialog1.Filter = "SDO files (*.sdo)|*.sdo|All files (*.*)|*.*";
				saveFileDialog1.FilterIndex = 1;
				saveFileDialog1.RestoreDirectory = false;

				if ( saveFileDialog1.ShowDialog() == DialogResult.OK )
				{
					//	store the filename first
					saveFileName = saveFileDialog1.FileName;
				}
				else
				{
					return;
				}
			}

			//	formulate the string representing the values to store
			StringBuilder str = new StringBuilder();

			for ( int row = 1; row < 10; row++ )
				for ( int col = 1; col < 10; col++ )
					str.Append( actual[col, row].ToString() );

			//	save the values to file
			Computer myComputer = new Computer();

			try
			{
				Boolean fileExists;

				fileExists = myComputer.FileSystem.FileExists( saveFileName );

				if ( fileExists )
					myComputer.FileSystem.DeleteFile( saveFileName );

				myComputer.FileSystem.WriteAllText( saveFileName, str.ToString(), true );

				toolStripStatusLabel1.Text = "Puzzle saved in " + saveFileName;
			}
			catch ( Exception )
			{
				MessageBox.Show( "Error saving game. Please try again." );
				throw;
			}
		}

using Microsoft.VisualBasic.Devices;

		//
		//	Save As... menu item
		//
		private void saveAsToolStripMenuItem_Click( object sender, EventArgs e )
		{
			if ( !GameStarted )
			{
				DisplayActivity( "Game not started yet.", true );
				return;
			}

			SaveGameToDisk( true );
		}

		//
		//	Save menu item
		//
		private void saveToolStripMenuItem_Click( object sender, EventArgs e )
		{
			if ( !GameStarted )
			{
				DisplayActivity( "Game not started yet.", true );
				return;
			}

			SaveGameToDisk( false );
		}

		//
		//	Open a saved game
		//
		private void openToolStripMenuItem_Click( object sender, EventArgs e )
		{
			if ( GameStarted )
			{
				var response = MessageBox.Show( "Do you want to save current game?",
												"Save current game",
												MessageBoxButtons.YesNoCancel,
												MessageBoxIcon.Question );

				if ( response == DialogResult.Yes )
					SaveGameToDisk( false );
				else if ( response == DialogResult.Cancel )
					return;

			}

			//	load the game from disk

			String fileContents;
			OpenFileDialog openFileDialog1 = new OpenFileDialog();
			Computer myComputer = new Computer();

			openFileDialog1.Filter = "SDO files (*.sdo)|*.sdo|All files (*.*)|*.*";
			openFileDialog1.FilterIndex = 1;
			openFileDialog1.RestoreDirectory = false;

			if ( openFileDialog1.ShowDialog() == DialogResult.OK )
			{
				fileContents = myComputer.FileSystem.ReadAllText( openFileDialog1.FileName );
				toolStripStatusLabel1.Text = openFileDialog1.FileName;
				saveFileName = openFileDialog1.FileName;
			}
			else
			{
				return;
			}

			StartNewGame();

			//	initialize the board

			int counter = 0;
			int value;

			for ( int row = 1; row < 10; row++ )
			{
				for ( int col = 1; col < 10; col++ )
				{
					try
					{
						value = int.Parse( fileContents[counter].ToString() );

						if ( value != 0 )
							SetCell( col, row, value, 0 );
					}
					catch ( Exception )
					{
						MessageBox.Show( "File does not contain a valid Sudoku puzzle" );

						throw;
					}

					counter++;
				}
			}

		}

		//
		//	Exit the application
		//
		private void exitToolStripMenuItem_Click( object sender, EventArgs e )
		{

			if ( GameStarted )
			{
				DialogResult reponse = MessageBox.Show( "Do you want to save current game?",
														"Save current game",
														MessageBoxButtons.YesNoCancel );

				if ( reponse == DialogResult.Yes )
					SaveGameToDisk( false );
				else if ( reponse == DialogResult.Cancel )
					return;

			}

			this.Close();
			Application.Exit();
		}

		//
		//	start a new game
		//
		private void newToolStripMenuItem_Click( object sender, EventArgs e )
		{
			if ( GameStarted )
			{
				var response = MessageBox.Show( "Do you want to save current game?",
												"Save current game",
												MessageBoxButtons.YesNoCancel,
												MessageBoxIcon.Question );

				if ( response == DialogResult.Yes )
					SaveGameToDisk( false );
				else if ( response == DialogResult.Cancel )
					return;

			}

			StartNewGame();
		}

		//
		//	Save the game to disk
		//
		public void SaveGameToDisk( Boolean saveAs )
		{
			return;
		}

		//
		//	start a new game
		//
		public void StartNewGame()
		{
			saveFileName = String.Empty;
			txtActivities.Text = String.Empty;
			seconds = 0;

			ClearBoard();

			GameStarted = true;
			timer1.Enabled = true;
			toolStripStatusLabel1.Text = "New game started";
		}

		//
		//	clear the board
		//
		public void ClearBoard()
		{
			//	initialize the stacks
			Moves = new Stack<string>();
			RedoMoves = new Stack<string>();

			//	initialize the cells in the board
			for ( int row = 1; row < 10; row++ )
				for ( int col = 1; col < 10; col++ )
					SetCell( col, row, 0, 1 );

		}

		//
		//	increment the time counter
		//
		private void timer1_Tick( object sender, EventArgs e )
		{
			toolStripStatusLabel2.Text = "Elapsed time: " + seconds + " second(s)";

			seconds += 1;
		}

		private void ToolStripButton_Click( object sender, EventArgs e )
		{
			//	ToolStripButton selectedButton = (ToolStripButton)sender;		//	ok
			ToolStripButton selectedButton = sender as ToolStripButton;

			//	uncheck all the Button controls in the ToolStrip
			toolStripButton1.Checked = false;
			toolStripButton2.Checked = false;
			toolStripButton3.Checked = false;
			toolStripButton4.Checked = false;
			toolStripButton5.Checked = false;
			toolStripButton6.Checked = false;
			toolStripButton7.Checked = false;
			toolStripButton8.Checked = false;
			toolStripButton9.Checked = false;
			toolStripButton10.Checked = false;

			//	set the selected button to "checked"
			selectedButton.Checked = true;

			//	set the appropriate number selected
			if ( selectedButton.Text == "Erase" )
				SelectedNumber = 0;
			else
				SelectedNumber = int.Parse( selectedButton.Text );

		}

		//
		//	event handler for cell click
		//
		private void Cell_Click( object sender, EventArgs e )
		{
			//	check to see if game has even started or not

			if ( !GameStarted )
			{
				DisplayActivity( "Click File->New to start a new game or File->Open to load an existing game", true );
				return;
			}

			Label cellLabel = sender as Label;

			//	if cell is not erasable then exit
			if ( cellLabel.Tag.ToString() == "0" )
			{
				DisplayActivity( "Selected cell is not empty", false );
				return;
			}

			//	determine the col and row of the selected cell
			int col = int.Parse( cellLabel.Name.Substring( 0, 1 ) );
			int row = int.Parse( cellLabel.Name.Substring( 1, 1 ) );

			//	if erasing a cell
			if ( SelectedNumber == 0 )
			{
				//	if cell is empty then no need to erase
				if ( actual[col, row] == 0 )
					return;

				//	save the value in the array
				SetCell( col, row, SelectedNumber, 1 );
				DisplayActivity( "Number erased at (" + col + ", " + row + ")", false );
			}
			else if ( cellLabel.Text == String.Empty )
			{
				//	else set a value, check if move is valid
				if ( !IsMoveValid( col, row, SelectedNumber ) )
				{
					DisplayActivity( "Invalid move at (" + col + ", " + row + ")", false );
					return;
				}

				//	save the value in the array
				SetCell( col, row, SelectedNumber, 1 );
				DisplayActivity( "Number " + SelectedNumber.ToString() + " placed at (" + col + ", " + row + ")", false );

				//	save the move into the stack
				Moves.Push( cellLabel.Name.ToString() + SelectedNumber );

				//	check if the puzzle is solved
				if ( IsPuzzleSolved() )
				{
					timer1.Enabled = false;
					Console.Beep();
					toolStripStatusLabel1.Text = "**** Puzzle is Solved ****";
				}
			}

		}

		//
		//	set a cell to a given value
		//
		public void SetCell( int col, int row, int value, int erasable )
		{
			//	locate particular Label control
			Control [] lbl = this.Controls.Find( col.ToString() + row.ToString(), true );
			Label cellLabel = lbl[0] as Label;

			//	save the value in the array
			actual[col, row] = value;

			//	set the appearance for the Label control
			if ( value == 0 )		//	erasing the cell
			{
				cellLabel.Text = String.Empty;
				cellLabel.Tag = erasable;
				cellLabel.BackColor = DEFAULT_BACKCOLOR;
			}
			else
			{
				if ( erasable == 0 )
				{
					//	means default puzzle values
					cellLabel.BackColor = FIXED_BACKCOLOR;
					cellLabel.ForeColor = FIXED_FORECOLOR;
				}
				else
				{
					//	means user-set value
					cellLabel.BackColor = USER_BACKCOLOR;
					cellLabel.ForeColor = USER_FORECOLOR;
				}

				cellLabel.Text = value.ToString();
				cellLabel.Tag = erasable;
			}
		}

		//
		//	Display a message in the Activities text box
		//
		public void DisplayActivity( String str, Boolean soundBeep )
		{
			if ( soundBeep )
				Console.Beep();

			txtActivities.Text += str + Environment.NewLine;
		}

		//	dimension of each cell in the grid
		const int CellWidth = 32;
		const int CellHeight = 32;

		//	offset from the top-left corner of the window
		const int xOffset = -20;
		const int yOffset = 25;

		//	color for empty cells
		private Color DEFAULT_BACKCOLOR = Color.White;

		//	color for original puzzle values
		private Color FIXED_FORECOLOR = Color.Blue;
		private Color FIXED_BACKCOLOR = Color.LightSteelBlue;

		//	color for user inserted values
		private Color USER_FORECOLOR = Color.Black;
		private Color USER_BACKCOLOR = Color.LightYellow;

		//	the number currently selected for insertion
		private int SelectedNumber;

		//	stacks to keep track of all the moves
		//	private Stack Moves = new Stack();				//	이 표현도 괜찮은 듯
		private Stack<string> Moves = new Stack<string>();	//	generic type?
		private Stack<string> RedoMoves = new Stack<string>();

		//	keep track of filename to save to
		private String saveFileName = String.Empty;

		//	used to represent the values in the grid
		private int [,] actual = new int[10, 10];

		//	used to keep track of elapsed time
		private int seconds = 0;

		//	has the game started?
		private Boolean GameStarted = false;

		public void DrawBoard()
		{
			//  default selected number is 1
			toolStripButton1.Checked = true;
			SelectedNumber = 1;

			//  used to store the location of the cell
			Point location = new Point();

			for ( int row = 1; row < 10; row++ )
			{
				for ( int col = 1; col < 10; col++ )
				{
					location.X = col * ( CellWidth + 1 ) + xOffset;
					location.Y = row * ( CellHeight + 1 ) + yOffset;

					Label lbl = new Label();

					lbl.Name = col.ToString() + row.ToString();
					lbl.BorderStyle = BorderStyle.None;
					lbl.Location = location;
					lbl.Width = CellWidth;
					lbl.Height = CellHeight;
					lbl.TextAlign = ContentAlignment.MiddleCenter;
					lbl.BackColor = DEFAULT_BACKCOLOR;
					lbl.Font = new Font( lbl.Font, lbl.Font.Style | FontStyle.Bold );
					lbl.Tag = "1";


					//	Add Handler
					lbl.Click += new EventHandler( Cell_Click );

					this.Controls.Add( lbl );
				}
			}
		}

		//	event handler for cell click
		private void Cell_Click( object sender, EventArgs e )
		{
			return;
		}

		private void Form1_Load( object sender, EventArgs e )
		{
			//	initialize the status bar
			toolStripStatusLabel1.Text = String.Empty;
			toolStripStatusLabel2.Text = String.Empty;

			//	draw the board
			DrawBoard();
		}

		//
		//	draw the lines outlining the minigrids
		//
		private void Form1_Paint( object sender, PaintEventArgs e )
		{
			int x1, y1, x2, y2;

			//	draw the horizontal lines
			x1 = 1 * ( CellWidth + 1 ) + xOffset - 1;
			x2 = 9 * ( CellWidth + 1 ) + xOffset + CellWidth;

			for ( int i = 1; i <= 10; i = i + 3 )
			{
				y1 = i * ( CellHeight + 1 ) + yOffset - 1;
				y2 = y1;

				e.Graphics.DrawLine( Pens.Black, x1, y1, x2, y2 );
			}

			//	draw the vertical lines
			y1 = 1 * ( CellHeight + 1 ) + yOffset - 1;
			y2 = 9 * ( CellHeight + 1 ) + yOffset + CellHeight;

			for ( int j = 1; j <= 10; j += 3 )
			{
				x1 = j * ( CellWidth + 1 ) + xOffset - 1;
				x2 = x1;

				e.Graphics.DrawLine( Pens.Black, x1, y1, x2, y2 );
			}
		}