diff --git a/ipynb/SudokuJava.ipynb b/ipynb/SudokuJava.ipynb index aa91a45..5c404eb 100644 --- a/ipynb/SudokuJava.ipynb +++ b/ipynb/SudokuJava.ipynb @@ -15,12 +15,18 @@ "|![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e0/Sudoku_Puzzle_by_L2G-20050714_standardized_layout.svg/250px-Sudoku_Puzzle_by_L2G-20050714_standardized_layout.svg.png)|![](https://upload.wikimedia.org/wikipedia/commons/thumb/1/12/Sudoku_Puzzle_by_L2G-20050714_solution_standardized_layout.svg/250px-Sudoku_Puzzle_by_L2G-20050714_solution_standardized_layout.svg.png)|\n", "\n", "\n", - "In 2006, I wrote a [Python program](http://norvig.com/sudoku.html) to solve Sudoku. Soon after that, [Peter Seibel](https://gigamonkeys.com/) invited me to publish an article in [*Code Quarterly*](https://gigamonkeys.com/code-quarterly/) magazine which would go into more detail about backtracking search and constraint propagation in general, and would feature a more efficient program. Unfortunately, the magazine [folded](https://gigamonkeys.wordpress.com/2011/10/17/end-of-the-line-for-code-quarterly/) before I could finish the article. In 2021 I [updated the Python Sudoku program](Sudoku.ipynb) to Jupyter notebook form with modern coding idioms, and now I do the same for the [more efficient Java Sudoku program](Sudoku.java). \n", + "In 2006, I wrote a [Python program](http://norvig.com/sudoku.html) designed to solve any Sudoku puzzle. As computer security expert Ben Laurie has stated, Sudoku is \"a denial of service attack on human intellect\", and I thought maybe my program would convince people they didn't need to spend excessive time playing Sudoku. \n", "\n", - "I asked Claude and Codex to help me modernize my Java, and they were very good at that. I apologize if there are remaining legacy Java idioms from decades ago. The tools did not have any suggestions for how to make the code significantly faster (although the switch to a more modern threading API did make the code a few percent faster). I guess I did a good job of writing efficient Java way back in 2007.\n", + "In 2007, [Peter Seibel](https://gigamonkeys.com/) invited me to publish an article in [*Code Quarterly*](https://gigamonkeys.com/code-quarterly/) magazine which would go into more detail about backtracking search and constraint propagation in general, and would feature a more efficient program. Unfortunately, the magazine [folded](https://gigamonkeys.wordpress.com/2011/10/17/end-of-the-line-for-code-quarterly/) before I could finish [the article](https://www.norvig.com/CQ/sudoku.html). In 2021 I [updated the Python Sudoku program](Sudoku.ipynb) to Jupyter notebook form with modern coding idioms, and now I do the same for the [more efficient Java Sudoku program](Sudoku.java). \n", + "\n", + "I asked Claude and Codex to help me update my code from Java JDK 1.6 to Java JDK 26. They were very good at that. I also asked them for suggestions to make the code faster, but they didn't have any significant ideas (although the switch to a more modern threading API did speed throughput a few percent). I guess I did a good job of writing efficient Java way back in 2007.\n", "\n", "- [**Sudoku.java**](Sudoku.java) is the Java program discussed in this notebook.\n", - "- [**Sudoku.ipynb**](Sudoku.ipynb) is the original Python notebook." + "- [**Sudoku.ipynb**](Sudoku.ipynb) is the original Python notebook.\n", + "\n", + "
\n", + "TLDR: The program solves over 400,000 puzzles per second , and over 30,000 puzzles per second on the hardest puzzles. \n", + "
" ] }, { @@ -29,7 +35,7 @@ "source": [ "# Solving a Puzzle\n", "\n", - "In the file [sudokus1.txt](sudokus1.txt) is the single puzzle shown at the top of the page, in this format (one puzzle per line):" + "In the file [sudokus1.txt](sudokus1.txt) is the single puzzle shown at the top of the page, in this format:" ] }, { @@ -164,7 +170,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's run the `java Sudoku` program on all these puzzles, and show the timing results. To get even more puzzles (more puzzles should lower timing variance), I use the `-r` option to include the reverse of each puzzle (the last square becomes the first, etc.) and `-R` to repeat puzzles." + "Let's run the `java Sudoku` program on all these puzzles, and show the timing results. To get even more puzzles (to lower timing variance), I use the `-r` option to include the reverse of each puzzle (the last square becomes the first, etc.) and `-R` to repeat puzzles." ] }, { @@ -178,9 +184,9 @@ "text": [ "Puzzles μsec KHz Threads Backtracks Name\n", "======= ====== ======= ======= ========== ====\n", - " 30000 27.5 36.392 28 330.7 sudokus_hard.txt\n", - " 983020 2.0 500.670 28 41.7 sudokus_17.txt\n", - "1000000 2.5 400.960 28 32.5 sudokus.txt\n" + " 30000 29.1 34.403 28 330.7 sudokus_hard.txt\n", + " 983020 2.0 497.578 28 41.7 sudokus_17.txt\n", + "1000000 2.5 402.050 28 32.5 sudokus.txt\n" ] } ], @@ -192,11 +198,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**Conclusion: The program solves about 35,000 puzzles per second with the hardest puzzles, and about 400,000 per second (or more) with easier puzzles.** \n", - "\n", - "This is a pretty good performance for such a simple program! One of the fastest known Sudoku solvers, [**tdoku**](https://github.com/t-dillon/tdoku), reports similar speed (but that was in 2020, so they probably used a slower computer than my 28-core 96 GB Mac Studio M3 Ultra).\n", - "\n", - "The columns of the output are:\n", + "So the program is solving 34,000 puzzles per second on the hardest puzzles, and about 400,000 to 500,000 on the other files of more average-difficulty puzzles. The columns of the output are:\n", "\n", "- `Puzzles`: the total number of puzzles solved.\n", "- `μsec`: the mean time to solve a puzzle in microseconds (millionths of a second).\n", @@ -205,8 +207,11 @@ "- `Backtracks`: the average number of times per puzzle that the search guessed wrong and had to back up.\n", "- `Name`: here the name of the file; could also be a puzzle number when -p option is on.\n", "\n", + "One of the fastest known Sudoku solvers, [**tdoku**](https://github.com/t-dillon/tdoku), reports similar speed (but that was in 2020, so they probably used a slower computer than my 28-core 96 GB Mac Studio M3 Ultra).\n", "\n", - "Note that the μsec and KHz columns are displaying **throughput**: the number of puzzles that can be solved in a given amount of time. This is different than **latency**: the time it takes to solve a single puzzle from start to end. Throughput and latency are different because there are multiple threads working in parallel. If, say, there are 25 threads working in parallel on 25 CPUs and each puzzle takes 1 second to solve, then latency would be 1 second but throughput would be 25 puzzles per second. I did some experiments, and on my machine (an M3 Ultra Mac Studio), the best performance is somewhere around 25 threads (although there is 5% to 10% variance from run to run, so I couldn't nail down an optimal number). \n", + "# Throughput versus Latency\n", + "\n", + "Note that the μsec and KHz columns are displaying **throughput**: the number of puzzles that can be solved in a given amount of time. This is different than **latency**: the time it takes to solve a single puzzle from start to end. Throughput and latency are different because there are multiple threads working in parallel. If, say, there are 28 threads working in parallel on 28 CPUs and each puzzle takes 1 second to solve, then latency would be 1 second but throughput would be 28 puzzles per second. \n", "\n", "To measure the latency, use the `-T1` option to request a single thread:" ] @@ -222,9 +227,9 @@ "text": [ "Puzzles μsec KHz Threads Backtracks Name\n", "======= ====== ======= ======= ========== ====\n", - " 3000 286.2 3.495 1 292.2 sudokus_hard.txt\n", - " 49151 70.7 14.138 1 40.2 sudokus_17.txt\n", - " 250000 67.0 14.932 1 34.2 sudokus.txt\n" + " 3000 281.9 3.547 1 292.2 sudokus_hard.txt\n", + " 49151 69.3 14.430 1 40.2 sudokus_17.txt\n", + " 250000 66.3 15.082 1 34.2 sudokus.txt\n" ] } ], @@ -259,8 +264,8 @@ "text": [ "Puzzles μsec KHz Threads Backtracks Name\n", "======= ====== ======= ======= ========== ====\n", - "1000000 2.6 378.661 28 32.5 sudokus.txt\n", - "1000000 4.2 240.693 28 107.4 sudokus.txt\n" + "1000000 2.5 395.567 28 32.5 sudokus.txt\n", + "1000000 4.2 237.418 28 107.4 sudokus.txt\n" ] } ], @@ -336,50 +341,74 @@ " \n", " \n", " count\n", - " 49528.000000\n", - " 49528.000000\n", - " 49528.000000\n", + " 49527.000000\n", + " 49527.000000\n", + " 49527.000000\n", " \n", " \n", " mean\n", - " 74.375662\n", - " 23.166825\n", - " 42.145663\n", + " 74.695403\n", + " 23.262107\n", + " 42.144939\n", " \n", " \n", " std\n", - " 151.413051\n", - " 11.061670\n", - " 187.343129\n", + " 152.543361\n", + " 11.191693\n", + " 187.344951\n", " \n", " \n", " min\n", - " 11.800000\n", - " 0.102000\n", + " 12.000000\n", + " 0.099000\n", + " 0.000000\n", + " \n", + " \n", + " 1%\n", + " 18.300000\n", + " 1.663300\n", + " 0.000000\n", + " \n", + " \n", + " 10%\n", + " 27.800000\n", + " 8.029000\n", " 0.000000\n", " \n", " \n", " 25%\n", - " 33.000000\n", - " 15.405000\n", + " 32.800000\n", + " 15.414000\n", " 1.000000\n", " \n", " \n", " 50%\n", - " 42.500000\n", - " 23.553000\n", + " 42.400000\n", + " 23.599000\n", " 5.000000\n", " \n", " \n", " 75%\n", " 64.900000\n", - " 30.303000\n", + " 30.534000\n", " 24.000000\n", " \n", " \n", + " 90%\n", + " 124.500000\n", + " 36.036000\n", + " 80.000000\n", + " \n", + " \n", + " 99%\n", + " 601.058000\n", + " 54.546000\n", + " 646.740000\n", + " \n", + " \n", " max\n", - " 9770.700000\n", - " 85.106000\n", + " 10108.800000\n", + " 83.626000\n", " 13438.000000\n", " \n", " \n", @@ -388,14 +417,18 @@ ], "text/plain": [ " μsec KHz Backtracks\n", - "count 49528.000000 49528.000000 49528.000000\n", - "mean 74.375662 23.166825 42.145663\n", - "std 151.413051 11.061670 187.343129\n", - "min 11.800000 0.102000 0.000000\n", - "25% 33.000000 15.405000 1.000000\n", - "50% 42.500000 23.553000 5.000000\n", - "75% 64.900000 30.303000 24.000000\n", - "max 9770.700000 85.106000 13438.000000" + "count 49527.000000 49527.000000 49527.000000\n", + "mean 74.695403 23.262107 42.144939\n", + "std 152.543361 11.191693 187.344951\n", + "min 12.000000 0.099000 0.000000\n", + "1% 18.300000 1.663300 0.000000\n", + "10% 27.800000 8.029000 0.000000\n", + "25% 32.800000 15.414000 1.000000\n", + "50% 42.400000 23.599000 5.000000\n", + "75% 64.900000 30.534000 24.000000\n", + "90% 124.500000 36.036000 80.000000\n", + "99% 601.058000 54.546000 646.740000\n", + "max 10108.800000 83.626000 13438.000000" ] }, "execution_count": 9, @@ -407,15 +440,16 @@ "import pandas as pd\n", "\n", "columns = 'Puzzles μsec KHz Threads Backtracks Puzzle Number'.split()\n", - "sudata = pd.read_csv('sudata.txt', sep='\\s+', names=columns).drop(columns=['Puzzles', 'Puzzle', 'Threads', 'Number'])\n", - "sudata.describe()" + "sudata = pd.read_csv('sudata.txt', sep='\\s+', usecols=(1, 2, 4))\n", + "sudata.columns = ('μsec', 'KHz', 'Backtracks')\n", + "sudata.describe(percentiles=(.01, .10, .25, .50, .75, .90, .99))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The mean latency is 74 microseconds, the median is about 42 microseconds, and the maximum is about 10 milliseconds. For number of backtracks, the mean is 42, the median is only 5, and the maximum is over 13,000. \n", + "The mean latency is 74 microseconds, the median is about 42 microseconds, and the maximum is about 10 milliseconds. For number of backtracks, the mean is 42, the median is only 5, at least 25% have zero or one backtrack, and the maximum is over 13,000. \n", "\n", "Here is a scatterplot:" ] @@ -427,7 +461,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAGwCAYAAAAOvdliAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAARQdJREFUeJzt3Xt8VNXd7/HvJCFDiMlAgskQuQWICg1eCBBAHwGJQMulrW3RgvFSi/jILd5Aj/VobQX1sQIKKlof7VFbqlV67COlBEQECYETTAURuQUIlxguYQIScpt1/oBsM7lACGHPJPN5v155vZg9a/Zee9Vmvln7t9d2GGOMAAAAYJsQf3cAAAAg2BDAAAAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGxGAAMAALBZmL870JJ4vV4dOHBAUVFRcjgc/u4OAABoAGOMjh8/roSEBIWE2DM3RQBrQgcOHFCnTp383Q0AANAI+fn56tixoy3HIoA1oaioKEmn/weMjo72c28AAEBDFBcXq1OnTtb3uB0IYE2o6rJjdHQ0AQwAgGbGzvIhivABAABsRgADAACwmV8D2GeffaYxY8YoISFBDodDf//7333eN8boySefVEJCgiIiIjRkyBB99dVXPm1KS0s1depUtW/fXpGRkRo7dqz27dvn06aoqEjp6elyuVxyuVxKT0/XsWPHfNrs3btXY8aMUWRkpNq3b69p06aprKzsYpw2AAAIcn4NYN99952uvvpqzZ8/v873n3vuOb3wwguaP3++NmzYILfbrZtuuknHjx+32mRkZGjx4sVatGiR1qxZoxMnTmj06NGqrKy02owfP165ublaunSpli5dqtzcXKWnp1vvV1ZWatSoUfruu++0Zs0aLVq0SB988IEefPDBi3fyAAAgeJkAIcksXrzYeu31eo3b7TbPPPOMte3UqVPG5XKZV1991RhjzLFjx0yrVq3MokWLrDb79+83ISEhZunSpcYYY7Zs2WIkmXXr1lltsrKyjCSzdetWY4wxS5YsMSEhIWb//v1Wm7/85S/G6XQaj8fT4HPweDxG0nl9BgAA+Jc/vr8DtgYsLy9PBQUFGj58uLXN6XRq8ODBWrt2rSQpJydH5eXlPm0SEhKUnJxstcnKypLL5VJqaqrVZsCAAXK5XD5tkpOTlZCQYLUZMWKESktLlZOTU28fS0tLVVxc7PMDAABwLgEbwAoKCiRJ8fHxPtvj4+Ot9woKChQeHq527dqdtU1cXFyt/cfFxfm0qXmcdu3aKTw83GpTl9mzZ1t1ZS6Xi0VYAQBAgwRsAKtSc00OY8w51+mo2aau9o1pU9Ojjz4qj8dj/eTn55+1XwAAAFIABzC32y1JtWagCgsLrdkqt9utsrIyFRUVnbXNt99+W2v/hw4d8mlT8zhFRUUqLy+vNTNWndPptBZdZfFVAADQUAEbwBITE+V2u5WZmWltKysr06pVqzRo0CBJUkpKilq1auXT5uDBg9q8ebPVZuDAgfJ4PFq/fr3VJjs7Wx6Px6fN5s2bdfDgQavNsmXL5HQ6lZKSclHPEwAABB+/PoroxIkT2rFjh/U6Ly9Pubm5iomJUefOnZWRkaFZs2YpKSlJSUlJmjVrltq0aaPx48dLklwul+6++249+OCDio2NVUxMjB566CH17t1baWlpkqSePXtq5MiRmjhxohYuXChJuueeezR69GhdccUVkqThw4erV69eSk9P13/913/p6NGjeuihhzRx4kRmtQAAQNOz7X7LOqxcudJIqvVzxx13GGNOL0XxxBNPGLfbbZxOp7nhhhvMpk2bfPZRUlJipkyZYmJiYkxERIQZPXq02bt3r0+bI0eOmAkTJpioqCgTFRVlJkyYYIqKinza7Nmzx4waNcpERESYmJgYM2XKFHPq1KnzOh+WoQAAoPnxx/e3wxhj/Jj/WpTi4mK5XC55PB5mzgAAaCIVlV4tWLlTG3YfVb+uMZo8tLvCQpuuisof399+vQQJAABwLgtW7tTc5dtkJH2+47AkaXpakn87dYECtggfAABAkjbsPqqqy3XmzOvmjgAGAAACWr+uMapaldNx5nVzxyVIAAAQ0CYP7S5JPjVgzR0BDAAABLSw0JBmX/NVE5cgAQAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGxGAAMAALAZAQwAAMBmBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmxHAAAAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGxGAAMAALAZAQwAAMBmBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmxHAAAAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGxGAAMAALAZAQwAAMBmBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmxHAAAAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGxGAAMAALAZAQwAAMBmBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmxHAAAAAbEYAAwAAsBkBDAAAwGYEMAAAAJsRwAAAAGwW0AGsoqJCv/nNb5SYmKiIiAh169ZNTz31lLxer9XGGKMnn3xSCQkJioiI0JAhQ/TVV1/57Ke0tFRTp05V+/btFRkZqbFjx2rfvn0+bYqKipSeni6XyyWXy6X09HQdO3bMjtMEAABBJqAD2LPPPqtXX31V8+fP19dff63nnntO//Vf/6WXXnrJavPcc8/phRde0Pz587Vhwwa53W7ddNNNOn78uNUmIyNDixcv1qJFi7RmzRqdOHFCo0ePVmVlpdVm/Pjxys3N1dKlS7V06VLl5uYqPT3d1vMFAADBwWGMMf7uRH1Gjx6t+Ph4vfHGG9a2n/3sZ2rTpo3efvttGWOUkJCgjIwMzZw5U9Lp2a74+Hg9++yzmjRpkjwejy699FK9/fbbuuWWWyRJBw4cUKdOnbRkyRKNGDFCX3/9tXr16qV169YpNTVVkrRu3ToNHDhQW7du1RVXXNGg/hYXF8vlcsnj8Sg6OrqJRwMAAFwM/vj+DugZsOuvv14rVqzQtm3bJEn//ve/tWbNGv3oRz+SJOXl5amgoEDDhw+3PuN0OjV48GCtXbtWkpSTk6Py8nKfNgkJCUpOTrbaZGVlyeVyWeFLkgYMGCCXy2W1qUtpaamKi4t9fgAAAM4lzN8dOJuZM2fK4/HoyiuvVGhoqCorK/X000/rl7/8pSSpoKBAkhQfH+/zufj4eO3Zs8dqEx4ernbt2tVqU/X5goICxcXF1Tp+XFyc1aYus2fP1m9/+9vGnyAAAAhKAT0D9te//lXvvPOO/vznP2vjxo3605/+pOeff15/+tOffNo5HA6f18aYWttqqtmmrvbn2s+jjz4qj8dj/eTn5zfktAAAQJAL6Bmwhx9+WI888ohuvfVWSVLv3r21Z88ezZ49W3fccYfcbrek0zNYHTp0sD5XWFhozYq53W6VlZWpqKjIZxassLBQgwYNstp8++23tY5/6NChWrNr1TmdTjmdzgs/UQAAEFQCegbs5MmTCgnx7WJoaKi1DEViYqLcbrcyMzOt98vKyrRq1SorXKWkpKhVq1Y+bQ4ePKjNmzdbbQYOHCiPx6P169dbbbKzs+XxeKw2AAAATSWgZ8DGjBmjp59+Wp07d9YPfvADffHFF3rhhRf0q1/9StLpy4YZGRmaNWuWkpKSlJSUpFmzZqlNmzYaP368JMnlcunuu+/Wgw8+qNjYWMXExOihhx5S7969lZaWJknq2bOnRo4cqYkTJ2rhwoWSpHvuuUejR49u8B2QAAAADRXQAeyll17S448/rvvuu0+FhYVKSEjQpEmT9L//9/+22syYMUMlJSW67777VFRUpNTUVC1btkxRUVFWmzlz5igsLEzjxo1TSUmJhg0bprfeekuhoaFWm3fffVfTpk2z7pYcO3as5s+fb9/JAgCAoBHQ64A1N6wDBgBA88M6YAAAAEGAAAYAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANiOAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYjgAEAANiMAAYAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANiOAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYjgAEAANiMAAYAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANiOAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYjgAEAANiMAAYAAGAzAhgAAIDNwvzdAQDAxVdR6dWClTu1YfdR9esao8lDuysslL/BAX8hgAFAEFiwcqfmLt8mI+nzHYclSdPTkvzbKSCI8ecPAASBDbuPypz5tznzGoD/EMAAIAj06xojx5l/O868BuA/XIIEgCAweWh3SfKpAQPgPwQwAAgCYaEh1HwBAYRLkAAAADYjgAEAANiMAAYAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANiOAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYL+AC2f/9+3XbbbYqNjVWbNm10zTXXKCcnx3rfGKMnn3xSCQkJioiI0JAhQ/TVV1/57KO0tFRTp05V+/btFRkZqbFjx2rfvn0+bYqKipSeni6XyyWXy6X09HQdO3bMjlMEAABBJqADWFFRka677jq1atVK//znP7Vlyxb94Q9/UNu2ba02zz33nF544QXNnz9fGzZskNvt1k033aTjx49bbTIyMrR48WItWrRIa9as0YkTJzR69GhVVlZabcaPH6/c3FwtXbpUS5cuVW5urtLT0+08XQAAECQcxhjj707U55FHHtHnn3+u1atX1/m+MUYJCQnKyMjQzJkzJZ2e7YqPj9ezzz6rSZMmyePx6NJLL9Xbb7+tW265RZJ04MABderUSUuWLNGIESP09ddfq1evXlq3bp1SU1MlSevWrdPAgQO1detWXXHFFQ3qb3FxsVwulzwej6Kjo5tgBAAAwMXmj+/vgJ4B++ijj9S3b1/94he/UFxcnK699lq9/vrr1vt5eXkqKCjQ8OHDrW1Op1ODBw/W2rVrJUk5OTkqLy/3aZOQkKDk5GSrTVZWllwulxW+JGnAgAFyuVxWm7qUlpaquLjY5wcAAOBcAjqA7dq1S6+88oqSkpL0r3/9S/fee6+mTZum//N//o8kqaCgQJIUHx/v87n4+HjrvYKCAoWHh6tdu3ZnbRMXF1fr+HFxcVabusyePduqGXO5XOrUqVPjTxYAAASNgA5gXq9Xffr00axZs3Tttddq0qRJmjhxol555RWfdg6Hw+e1MabWtppqtqmr/bn28+ijj8rj8Vg/+fn5DTktAAAQ5AI6gHXo0EG9evXy2dazZ0/t3btXkuR2uyWp1ixVYWGhNSvmdrtVVlamoqKis7b59ttvax3/0KFDtWbXqnM6nYqOjvb5AQAAOJeADmDXXXedvvnmG59t27ZtU5cuXSRJiYmJcrvdyszMtN4vKyvTqlWrNGjQIElSSkqKWrVq5dPm4MGD2rx5s9Vm4MCB8ng8Wr9+vdUmOztbHo/HagMAANBUwvzdgbO5//77NWjQIM2aNUvjxo3T+vXr9dprr+m1116TdPqyYUZGhmbNmqWkpCQlJSVp1qxZatOmjcaPHy9Jcrlcuvvuu/Xggw8qNjZWMTExeuihh9S7d2+lpaVJOj2rNnLkSE2cOFELFy6UJN1zzz0aPXp0g++ABAAAaKiADmD9+vXT4sWL9eijj+qpp55SYmKi5s6dqwkTJlhtZsyYoZKSEt13330qKipSamqqli1bpqioKKvNnDlzFBYWpnHjxqmkpETDhg3TW2+9pdDQUKvNu+++q2nTpll3S44dO1bz58+372QBAEDQCOh1wJob1gEDAKD5YR0wAACAIEAAAwAAsBkBDAAAwGYEMAAAAJsF9F2QANBcVFR6tWDlTm3YfVT9usZo8tDuCgvlb1wAdSOAAUATWLByp+Yu3yYj6fMdhyVJ09OS/NspAAGLP88AoAls2H1UVWv6mDOvAaA+BDAAaAL9usbIcebfjjOvAaA+XIIEgCYweWh3SfKpAQOA+hDAAKAJhIWGUPMFoMG4BAkAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANiOAAQAA2IwABgAAYLNGBTCPx6OjR2s/aPbo0aMqLi6+4E4BAAC0ZI0KYLfeeqsWLVpUa/t7772nW2+99YI7BQAA0JI1KoBlZ2dr6NChtbYPGTJE2dnZF9wpAACAlqxRAay0tFQVFRW1tpeXl6ukpOSCOwUAANCSNSqA9evXT6+99lqt7a+++qpSUlIuuFMAAAAtWVhjPvT0008rLS1N//73vzVs2DBJ0ooVK7RhwwYtW7asSTsIAADQ0jRqBuy6665TVlaWOnbsqPfee0//+Mc/1KNHD3355Zf6j//4j6buIwAAQIviMMYYf3eipSguLpbL5ZLH41F0dLS/uwMAABrAH9/fjV6IdefOnfrNb36j8ePHq7CwUJK0dOlSffXVV03WOQAAgJaoUQFs1apV6t27t7Kzs/XBBx/oxIkTkqQvv/xSTzzxRJN2EAAAoKVpVAB75JFH9Pvf/16ZmZkKDw+3tg8dOlRZWVlN1jkAAICWqFF3QW7atEl//vOfa22/9NJLdeTIkQvuFAA0tYpKrxas3KkNu4+qX9cYTR7aXWGhPA4XgH80KoC1bdtWBw8eVGJios/2L774QpdddlmTdAwAmtKClTs1d/k2GUmf7zgsSZqeluTfTgEIWo3682/8+PGaOXOmCgoK5HA45PV69fnnn+uhhx7S7bff3tR9BIALtmH3UVXd8m3OvAYAf2lUAHv66afVuXNnXXbZZTpx4oR69eqlG264QYMGDdJvfvObpu4jAFywfl1j5Djzb8eZ1wDgLxe0DtiuXbu0ceNGeb1eXXvttUpKCu7pfNYBAwIXNWAA6uOP7+8mWYi1srJSmzZtUpcuXdSuXbum6FezRAADAKD5aTYLsWZkZOiNN96QdDp8DR48WH369FGnTp306aefNmX/AAAAWpxGBbC//e1vuvrqqyVJ//jHP7Rr1y5t3bpVGRkZeuyxx5q0gwAAAC1NowLY4cOH5Xa7JUlLlizRuHHjdPnll+vuu+/Wpk2bmrSDABDMKiq9mrd8u277Y7bmLd+uikqvv7sEoAk0ah2w+Ph4bdmyRR06dNDSpUv18ssvS5JOnjyp0NDQJu0gAAQz1i8DWqZGBbC77rpL48aNU4cOHeRwOHTTTTdJkrKzs3XllVc2aQeDHXduAcGN9cuAlqlRAezJJ59U7969tXfvXv3iF7+Q0+mUdPrS5LRp05q0g8GOv36B4Nava4w+33FYRqxfBrQkjQpgTz31lPXv//7v/7b+vWPHDv3ud7/TL3/5ywvvGSTx1y8Q7CYP7S5JPrPgAJq/RgWwxYsX+7yurKxUfn6+iouL9bvf/a5JOobT+OsXCG5hoSHMegMtUKMC2BdffFFrW0VFhTIyMrRly5YL7hS+x1+/AAC0PE2yEn6VHTt26KqrrtLJkyebapfNCivhAwDQ/DSblfDrs2fPHiUmJjblLgEAAFqcRl2CfPHFF2ttKygo0JtvvqkxY8b4vM9dkQAAAL4adQmyobNcDodDu3btOu9ONVdcggQAoPnxx/d3o2bA8vLymrofAAAAQYMl1QEAAGxGAAMAALAZAQwAAMBmBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmzWrADZ79mw5HA5lZGRY24wxevLJJ5WQkKCIiAgNGTJEX331lc/nSktLNXXqVLVv316RkZEaO3as9u3b59OmqKhI6enpcrlccrlcSk9P17Fjx2w4KwAAEGyaTQDbsGGDXnvtNV111VU+25977jm98MILmj9/vjZs2CC3262bbrpJx48ft9pkZGRo8eLFWrRokdasWaMTJ05o9OjRqqystNqMHz9eubm5Wrp0qZYuXarc3Fylp6fbdn4AACCImGbg+PHjJikpyWRmZprBgweb6dOnG2OM8Xq9xu12m2eeecZqe+rUKeNyucyrr75qjDHm2LFjplWrVmbRokVWm/3795uQkBCzdOlSY4wxW7ZsMZLMunXrrDZZWVlGktm6dWuD++nxeIwk4/F4LuR0ATSx8opKMzdzm5nw+jozN3ObKa+o9HeXAAQQf3x/N4sZsMmTJ2vUqFFKS0vz2Z6Xl6eCggINHz7c2uZ0OjV48GCtXbtWkpSTk6Py8nKfNgkJCUpOTrbaZGVlyeVyKTU11WozYMAAuVwuq01dSktLVVxc7PMDIPAsWLlTc5dv05odhzV3+TYtWLnT310CEOQa9TBuOy1atEgbN27Uhg0bar1XUFAgSYqPj/fZHh8frz179lhtwsPD1a5du1ptqj5fUFCguLi4WvuPi4uz2tRl9uzZ+u1vf3t+JwTAdht2H5U5829z5jUA+FNAz4Dl5+dr+vTpeuedd9S6det62zkcDp/Xxpha22qq2aau9ufaz6OPPiqPx2P95Ofnn/WYAPyjX9cYVf0/2XHmNQD4U0DPgOXk5KiwsFApKSnWtsrKSn322WeaP3++vvnmG0mnZ7A6dOhgtSksLLRmxdxut8rKylRUVOQzC1ZYWKhBgwZZbb799ttaxz906FCt2bXqnE6nnE7nhZ0kgItu8tDukk7PfPXrGmO9BgB/CegZsGHDhmnTpk3Kzc21fvr27asJEyYoNzdX3bp1k9vtVmZmpvWZsrIyrVq1ygpXKSkpatWqlU+bgwcPavPmzVabgQMHyuPxaP369Vab7OxseTweqw2AplNR6dW85dt12x+zNW/5dlVUei/q8cJCQzQ9LUnv/DpV09OSFBYa0L/6AASBgJ4Bi4qKUnJyss+2yMhIxcbGWtszMjI0a9YsJSUlKSkpSbNmzVKbNm00fvx4SZLL5dLdd9+tBx98ULGxsYqJidFDDz2k3r17W0X9PXv21MiRIzVx4kQtXLhQknTPPfdo9OjRuuKKK2w8Y8BeFZVeLVi502dmyI5wUlUUbyR9vuOwJGl6WtJFPy4ABIqADmANMWPGDJWUlOi+++5TUVGRUlNTtWzZMkVFRVlt5syZo7CwMI0bN04lJSUaNmyY3nrrLYWGhlpt3n33XU2bNs26W3Ls2LGaP3++7ecD2MlfQYiieADBzmGMMeduhoYoLi6Wy+WSx+NRdHS0v7sDnNNtf8zWmjPBS5Ku79Fe7/w69SyfaBrzlm+3gp9DUkba5cyAAfAbf3x/N/sZMACN169rjD7fcdgKQnbdHUhRPIBgRwADWqCG1nb5KwhVFcUDQLAigAEtUENruwhCAOAf3IsNtEAUuQNAYCOAAS0QK78DQGDjEiTQAlHkDgCBjQAGtEDUdgFAYOMSJAAAgM2YAQOakL8e7QMAaF4IYEAT4hmHAICG4E9zoAmx/AMAoCEIYEATYvkH/6uo9Gre8u267Y/Zmrd8uyoqvf7uEgDUwiVIoAmx/IP/cRkYQHNAAAOaUHNZ/qEl3yzAZWAAzQEBDAhCLXmWqF/XGH2+47CMuAwMIHARwIAg1JJnibgMDKA5IIABLVh9lxpb8ixRc7kMDCC4EcCAFqy+S411zRK15LowAAg0BDCgBavvUmNds0Tzlm9vsXVhABBo+PMWuACBvubU+axL1pLrwgAg0DADBlyAQL+b8HwK0ltyXRgABBoCGHABAn3W6HwK0rl7EADsQwADLkBLmjXi7kEAsA8BDLgAzBoBABqDAAZcAGaNAACNQQADWhDW8gKA5oEABrQggX5XJgDgNP40BlqQQL8rEwBwGgEMaEHOZ+FVAID/cAkSUMupneKuTABoHghggFpO7RR3ZQJA80AAAxS4tVMtZWYOAOCLAAao8SvaX+yA1FJm5gAAvghggBpfO3WxA1KgzswBAC4MAQxQ42unLnZAaknPmgQAfI8ABlyAix2QuKsRAFomAhhaLDsK2CcP7S6v8WrxFwckSV6vUUWlV2GhIU1yfO5qBICWiQCGFsuOAvaw0BCFOEKUf/SkjKQXP9mukBCHpqclUUAPAKgX97OjxbKrgL2+41BADwCoDwEMLZZdj+Wp7zg8FggAUB8uQaLFulgF7DVruybdkFjncc51fBZZBYDgRQBDi3WxCtgbWtt1ruNTIwYAwYs/t4Hz1FS1XdSIAUDwIoChxaqo9Gre8u267Y/Zmrd8uyoqvU2y37PVdp3PMakRA4DgxSVItFgX6xLf2Wq7zueYDa1Ro1YMAFoeAhharIt1ie9stV01j/nBxn31BqeG1qhRKwYALQ8BDC2WP56jWP2YkrT36EntPXrygoJTzVC3Pu+I5i0XM2IA0IwRwNBiNeQSX1Ne3quo9MprvOoU00aSZIxRflHJ6X+r8TNwNYOk14gZMQBo5ghgaLEacomvKS/vLVi5Uy+u2GEFpQHdYrWvqOSCZ+BqBsn1eUe4exIAmjkCGIJaU9aJ1dxXiEPKSLv8gheCrRkk5y2X1u48YuulVQBA0yKAIag1ZZ1YzX31T4w9r9m0hl4OvVgr/AMA7EMAQ1BryjDT2H1VBa8PNu7T3qMnJV3YCvsAgMBHAENQa2iYqev5jws/y6s1W9WYYFS9Dq0KtV0A0LIRwBBUGnvXY81i/XW7jmjdriNNUrxfvXasupTO7Rq1PwBA4COAodmqL0xV357SuZ3kMMrZc0z9usbI6zV68ZPt5x2cahbYf32wuMmK92uuHWZx1BXLAAAtAQEMzVZ9S0hU377mzHadadMppk2jglPNAvueHaKtGbALLd6vqhV78/M8HSspt7bn7DnW6H0CAAIbAQzNVl1LSFRUevXBxn11XtIzkgqLT1mvzyc41Sywr6sGrLGq145VBUeWlwCAlo0AhmarriUkFqzcad1JWJdTFV5JUueYNvpZn44NDk51Fdg39Z2ILC8BAMEjoB8gN3v2bPXr109RUVGKi4vTT37yE33zzTc+bYwxevLJJ5WQkKCIiAgNGTJEX331lU+b0tJSTZ06Ve3bt1dkZKTGjh2rffv2+bQpKipSenq6XC6XXC6X0tPTdezYsYt9irgAk4d2V0ba5bq+R3tlpF2uyUO717qk2KldhKYP66G2Ea18tneOaaPpaUkB9QzFqpD3zq9TA65vAICmFdC/4VetWqXJkydr3bp1yszMVEVFhYYPH67vvvvOavPcc8/phRde0Pz587Vhwwa53W7ddNNNOn78uNUmIyNDixcv1qJFi7RmzRqdOHFCo0ePVmVlpdVm/Pjxys3N1dKlS7V06VLl5uYqPT3d1vPF+akrsPTrGiPHmfcdkn6e0kn333SF7rou0Wc7l/cAAP7kMMY0m1utDh06pLi4OK1atUo33HCDjDFKSEhQRkaGZs6cKen0bFd8fLyeffZZTZo0SR6PR5deeqnefvtt3XLLLZKkAwcOqFOnTlqyZIlGjBihr7/+Wr169dK6deuUmpoqSVq3bp0GDhyorVu36oorrqizP6WlpSotLbVeFxcXq1OnTvJ4PIqOjr7Io4G6NOTOyAt96DYAoGUpLi6Wy+Wy9fu7WdWAeTweSVJMzOnZi7y8PBUUFGj48OFWG6fTqcGDB2vt2rWaNGmScnJyVF5e7tMmISFBycnJWrt2rUaMGKGsrCy5XC4rfEnSgAED5HK5tHbt2noD2OzZs/Xb3/72YpwqGqm+xVDr2362JSsaEtIIdgCAxmg2AcwYowceeEDXX3+9kpOTJUkFBQWSpPj4eJ+28fHx2rNnj9UmPDxc7dq1q9Wm6vMFBQWKi4urdcy4uDirTV0effRRPfDAA9brqhkw2OdCA9DZlqyQTteZnW3/9S2FAQDA2TSbADZlyhR9+eWXWrNmTa33HA6Hz2tjTK1tNdVsU1f7c+3H6XTK6XSeq+topIaEq5oB6P2cfJ04VaGeHaL15p191Tr87P+J17cKfdWyFgtW6qwBq66lMAAAOJdmEcCmTp2qjz76SJ999pk6duxobXe73ZJOz2B16NDB2l5YWGjNirndbpWVlamoqMhnFqywsFCDBg2y2nz77be1jnvo0KFas2toevUFrZrhyus1Cglx+LSrGYD2FZVIkrJ2HdFdb/0//eWeAWc9dn2r0FcV6p8rYNW1FAYAAOcS0AHMGKOpU6dq8eLF+vTTT5WYmOjzfmJiotxutzIzM3XttddKksrKyrRq1So9++yzkqSUlBS1atVKmZmZGjdunCTp4MGD2rx5s5577jlJ0sCBA+XxeLR+/Xr1799fkpSdnS2Px2OFNDROQ2ex5izfJun0ZcB1u47o7bv71wo/i3P3K//oSZ/ZqHof46PTjws6l+prb9VVA7Zgpc4asFi7CwDQGAEdwCZPnqw///nP+r//9/8qKirKqsdyuVyKiIiQw+FQRkaGZs2apaSkJCUlJWnWrFlq06aNxo8fb7W9++679eCDDyo2NlYxMTF66KGH1Lt3b6WlpUmSevbsqZEjR2rixIlauHChJOmee+7R6NGj6y3AR8M0pEaq5qxS1q4jWrByZ63ZJUm1ZqPeuqufJOmDjftqLcDas0P9d7LUDIZv3dWvztqxcwWs+or7AQA4m4AOYK+88ookaciQIT7b33zzTd15552SpBkzZqikpET33XefioqKlJqaqmXLlikqKspqP2fOHIWFhWncuHEqKSnRsGHD9NZbbyk0NNRq8+6772ratGnW3ZJjx47V/PnzL+4JBoGG1Ej16xrjUwBf9bmqcFUVfrzGqxdX7PCZjaoKQBt2H/UJYK6IML15Z996+9XQ4nkCFgDgYmhW64AFOn+sIxLo5i3f7vN8w4y0y2sFmopKr9LfWK+sXUekM+2m3ZhUq95LUr2XMxtynOpu+2O2T+i7rnus+ifGspwEAAQh1gFDi+NTY9Wlrbxeowmvr5PXSCEOqX9irCYP7a637+6vl1bs0OLc/ZKk7LwjWpd3eras+gxVVV1W1R2KVUGpvkuF9dWg1by86TVnv9sRAICmRADDRVX9Et685ds1d8U2n4L5tTtPz3pNTzs941VVZF/9cqLR6RqvDbuPqtJrrJmyqoL90BBHtXB1+lgVlV7NW77dpzasZpCTvg9s6/OOsJwEAMA2BDDYpq41t6qHq71nwldd9h49WavIXpIVxmrOWlWv8ap+rPqCVd+u7bR25xGWkwAA2IIAhgtW12U+qXa9Vn1LRtQXrs5HVbiqqPTqpRU7tPCznfWu7VXVt+qXHKfdmKSMtMtZTgIAYAsCWJBrimcZ1nVHoVS7pqoq1PwtJ1/5ZxZMrY8ropU8JeW1tjskDegWq9AQhyq9Rut2+c5aLVi5U/M+2V7rc53aRahjuzZan3dE85ar1iXHxbn71TmmDQX4AABbEMCCXFM8y7C+pSaqb3vz8zxJslavP1cAKy2v9Hk98Ezoqh6QKiq9eumT7Vr8xQFJktdr9P/21L7E2DmmjX56bYK1hMXanUc0oFusHNX6WDULRwE+AMAOBLAg1xTPMqx5aXHv0ZNKcLX2aXOspFxzz6x2f7bV66ucqvBKOh2eftanY52zUmGhIQpxhFiF+/M+2S5XRO3/pH/Wp2Mdjyw6qWnDeihnzzGfS6AU4AMA7MB1liDXr2uMtcr8+RSfV91leNsfs+X1Gk0b1kOdY9pIOh3AqpaQqK4q3Ey6IVEDusUqLMT3QefRrWuHp84xbTQ9LaneS4I1C/s9JRWSTl/C7BzTRtOH9bDqz6rLLypRiCNE7/w6VT/r07FRYwAAQGMxAxbkGvssw5qXLjPSLlfnmDZnLaZ3SKr0Gg2fu7pWO4ckh8NR6zPnCkP1zab1vsyld36dar2ePLR7rccVVc108TxHAIDdCGBBrrGP2qnr0mVdjxSq0qldhIy+XzaiurYRrXTXdYn6W06+T+G9KyKs3gVVJ92QqIWf5Wl93ul6rn1FJ33qyvYePal5y7dbly7DQkP0sz4dfVbLrwp3PG4IAGA3AhgapeZK8lUzR+t2HfEJWVU1XF7j1bwVO+rcV3REK0nST65J0Esrd1rb7xzU1br0WHPGbd2uIz53QFY9uqhqlmvv0ZNWzVlVuGKmCwAQKAhgaJT6wkz/rjHaf+z0TNRPr03Qfw7uroWf5elPa/fU2oczLESlFV7tPXpSc5ZvU6d2ERrYLdbnEUVVM19vfp7nM+P29cFin9c5e4v0zq9TfR7KXX1tsOqzZ2/d1Y9lJgAAfkUAa0aaYs2upjpmXZft5i3frhc/2W7NSoU4QvTKqp11znx1bBehfTWWosgvKlF+UYlcEWHq27WdpLpXtJekS1qHyVNSbh2r0mt02x+zVek11vISDkkpXdr6POibZSYAAIGAANaMNMWaXRfzmHXVhdUstneGOtSnS4y2HPTUe0xPSYXmrdihEEdInY8vkqR9RSXW2mDVnw8p+a4Z5q3xHstMAAACAddhmpGmWLPrfNVcMX59Xu0i+irXdmzr87qsvEIHjvnOcrUOD9O6XUes5SLOpmrWrT4hDumdX6cqtMZyFqEhDr3z61RNT0tSzt6iWp9jmQkAgL8RwJqRxq7ZdTbV1/Oat3y7Kiq9Pu97a0w/7Tl6UhWV3jo/t363bzhbv+eYKmrsoOqyYU1RdawBVnW3o+tMkX5NVbs+27jUHKOB3WIpvgcA+B2XIJuRi3EX37kuMdaYXNK+ohK9tGKH1u8+al3aW7PjsLJ2HtaGPbVnmxrq+KnvZ8RCHfJZaqKuZ0JW79vZxqWu9yjABwD4GwGsGbkY61XVd1mzqvi+rmc2Ls7dX6u2q66V7xur0kjZeUe18LO8ei+zOnT6Tknp7OPCGl8AgEBEAAtSVQGrepCqfvmuvrsPJamw+NRF719VvVnNS6CuiFZyRbTST6+57IJmAP1xRykAAFUIYEGqZsCq/tBrqfYzFqs/57HqQdnnK9RxenarofYcPVlrqQpPSbmKS8oVEuK4oMDkjztKAQCowp/8QaqugFX9odc1C9t/1qejOrZt3eD9h4fWfq7jJc5z5/2O7SJ0XfdYDewWWyt8VWmKO0D9cUcpAABVCGBB6lx3VE4e2l3TbkxS55g26tguQlk7D+v/nUeRfVkdU11Rreu+m7G6EIdDf/pV/1pLS1TXFHeAXow7SgEAaCguQQapc91RGRYaopAQh/KPnpSR6izGP1+HTpy7dmzv0ZN66ZPtqqxZ/HVGzUuljcVzIQEA/uQwxpxHVQ7Opri4WC6XSx6PR9HR0f7uzjmdrRC9otKrG/+wqtbdjnbo1C6i3sB3fY/2eufXqTb3CADQkvnj+5sZsCD20oodmvfJdkmn1/Lyeo2mDuuhBSt36oON+5o0fDkcUkOjfvGp+lfJr3rmI3cuAgCaMwJYEFucu9/n9VtZu+tc46spRIaH6kRppfW66oHZdYluHabiag/aHlDtmY/rdh3hzkUAQLNHAIPFU1Je76rzDeUMc6hViEMnymosVVFj+qv68heXtY2wgpVD0s3XdlRIiKPWpdHb/pjNnYsAgBaBABZEqmq+1ucdUUWlVwWeCy+sr6m0wqi0jrmtWoHsjM4xbfTWXf0atChqv64x+nzHYSuoceciAKC5IoAFkeo1X4EipUvbBj8uiDsXAQAtBQEsiNSs+QoE2buONrionuc6AgBaCgIY/KrqId5rzrOonmc5AgCaM76xgsiPr+7gl+N2jmljPUvybM6nqL7qWY5rdhzW3OXbtGDlzgvpIgAAtmIGrIWrqPTqpU+268ON+/Vt8blXom9qVc+RnDy0u3UDgNdIWw545Kmx3tf5FNXzLEcAQHNGAGvhFqzcqXkrdth+3I5tI9Qlto36J8ZalwdPX148fYlx3vLtmrt8mxWiBnaLPa+ieu6IBAA0ZwSwFi5712G/HHffsRL9om8na+arZq1WXXc0nk8NF3dEAgCaMwJYC3aqrEI5e4/57fgbdh/VgpWyZrqqr15/oXc0ckckAKA5I4A1U/XdBVh9++4j36m0ou4FUO3Qr2sMtVoAANSBANZMVd0FWHNm6aVPtvul5quKK6KVXBGt9NNrLjtz+VHUagEAUAMBLMDVN9NV18zSqbIKvbpql1/6Gd06TG3bhOun11ym/xzSTQs/y9Odb25QSud2mjash3L2HKNWCwCAMwhgAa6+ma6adwFe27Gt+s9a4bdLjsWnKlR8qkIvfrJd63cftR6u/fmOw8pIu1zv/DrVL/0CACAQEcACXH01VDXvAly97VsV11hXyx+MpK8PFlP3BQDAWRDAAlx9613VvAtwzvJtfumfK6KVerqjrEcKOST17BBtzYBR9wUAQG0EsAB3rvWuTpVVKP2NbH90TZ1j2uiTBwdLkk+d2qQbErXwszzW6AIAoB4OY4w5dzM0RHFxsVwulzwej6Kjoy/KMaoX5V/bsa3+tG63bZceo1qH6Xi1Y02/MUn3D7/clmMDAHCx2PH9XRMzYM1M9aL8NTvsW+V+QGKM+nVtp5eqP/Ta8X12r+9uTQAAUBsBrJmpXpRvp9RuMcrZc8xnW/XX9d2tCQAAamOKoplJ6dzOL8etWsfLceZ1zeJ6VrwHAKDhmAFrRioqvVrnp4drVy+mr6u4vr67NQEAQG0EsGZkwcqdyt5dZOsxnaEO3Tuku1XTVd9lxXPdrQkAAL5HAGtG7LisFx7qUFnl91VmfbrE6P6brjjn584WzgAAgC9qwJqBikqv5mR+oy/3Hbvox4qPbu3zOsRRT0MAANBozIAFuIpKr9LfWK+sXUcu6nGcYSG6b0gPeY1XL67YYdVy9U+MvajHBQAgGBHAAtxLK3Zc9PAlSfcO7qbpaUmqqPQqxBFCLRcAABcRASzA/S1n70Xbd8d2EeoS00b9E2OtoEUtFwAAFx8BLMAd9JRelP0O7Bart+/uz2r1AAD4AQEswHmbcF8dosPVPS6aRwUBAOBnBLAg4JCUmhijt+7qp9bh/E8OAIC/8W0cBDLSLqeuCwCAAMI1qBpefvllJSYmqnXr1kpJSdHq1av93aXzFuUM1YDEGF3XPVb3p13OnYwAAAQYZsCq+etf/6qMjAy9/PLLuu6667Rw4UL98Ic/1JYtW9S5c2d/d69Bpg7trulpl1PfBQBAAHMYY8y5mwWH1NRU9enTR6+88oq1rWfPnvrJT36i2bNn12pfWlqq0tLv71IsLi5Wp06d5PF4FB0d3SR96vrIxw1qN/mG7rp/BMELAIDzVVxcLJfL1aTf3+fCt/UZZWVlysnJ0fDhw322Dx8+XGvXrq3zM7Nnz5bL5bJ+OnXqZEdXfYxP7agdT/9QD//oSsIXAADNBN/YZxw+fFiVlZWKj4/32R4fH6+CgoI6P/Poo4/K4/FYP/n5+XZ0VZLUPUra8fQPNeunVxO8AABoZqgBq8Hh8H36tDGm1rYqTqdTTqfTjm75eHhod00ecaXtxwUAAE2DAHZG+/btFRoaWmu2q7CwsNasmJ12PzPKb8cGAAAXB9euzggPD1dKSooyMzN9tmdmZmrQoEF+6hUAAGiJmAGr5oEHHlB6err69u2rgQMH6rXXXtPevXt17733+rtrAACgBSGAVXPLLbfoyJEjeuqpp3Tw4EElJydryZIl6tKli7+7BgAAWhDWAWtC/lhHBAAAXBjWAQMAAAgCBDAAAACbEcAAAABsRgADAACwGQEMAADAZgQwAAAAmxHAAAAAbEYAAwAAsBkr4TehqjVti4uL/dwTAADQUFXf23auTU8Aa0LHjx+XJHXq1MnPPQEAAOfr+PHjcrlcthyLRxE1Ia/XqwMHDigqKkoOh6PJ9ltcXKxOnTopPz8/6B9xxFh8j7HwxXh8j7H4HmPxPcbiezXHwhij48ePKyEhQSEh9lRnMQPWhEJCQtSxY8eLtv/o6Oig/z9NFcbie4yFL8bje4zF9xiL7zEW36s+FnbNfFWhCB8AAMBmBDAAAACbEcCaAafTqSeeeEJOp9PfXfE7xuJ7jIUvxuN7jMX3GIvvMRbfC4SxoAgfAADAZsyAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYjgDUDL7/8shITE9W6dWulpKRo9erV/u7SBZk9e7b69eunqKgoxcXF6Sc/+Ym++eYbnzbGGD355JNKSEhQRESEhgwZoq+++sqnTWlpqaZOnar27dsrMjJSY8eO1b59+3zaFBUVKT09XS6XSy6XS+np6Tp27NjFPsVGmT17thwOhzIyMqxtwTYO+/fv12233abY2Fi1adNG11xzjXJycqz3g2U8Kioq9Jvf/EaJiYmKiIhQt27d9NRTT8nr9VptWupYfPbZZxozZowSEhLkcDj097//3ed9O8977969GjNmjCIjI9W+fXtNmzZNZWVlF+O063S2sSgvL9fMmTPVu3dvRUZGKiEhQbfffrsOHDjgs49gGIuaJk2aJIfDoblz5/psD7ixMAhoixYtMq1atTKvv/662bJli5k+fbqJjIw0e/bs8XfXGm3EiBHmzTffNJs3bza5ublm1KhRpnPnzubEiRNWm2eeecZERUWZDz74wGzatMnccsstpkOHDqa4uNhqc++995rLLrvMZGZmmo0bN5qhQ4eaq6++2lRUVFhtRo4caZKTk83atWvN2rVrTXJyshk9erSt59sQ69evN127djVXXXWVmT59urU9mMbh6NGjpkuXLubOO+802dnZJi8vzyxfvtzs2LHDahMs4/H73//exMbGmv/5n/8xeXl55v333zeXXHKJmTt3rtWmpY7FkiVLzGOPPWY++OADI8ksXrzY5327zruiosIkJyeboUOHmo0bN5rMzEyTkJBgpkyZctHHoMrZxuLYsWMmLS3N/PWvfzVbt241WVlZJjU11aSkpPjsIxjGorrFixebq6++2iQkJJg5c+b4vBdoY0EAC3D9+/c39957r8+2K6+80jzyyCN+6lHTKywsNJLMqlWrjDHGeL1e43a7zTPPPGO1OXXqlHG5XObVV181xpz+5dOqVSuzaNEiq83+/ftNSEiIWbp0qTHGmC1bthhJZt26dVabrKwsI8ls3brVjlNrkOPHj5ukpCSTmZlpBg8ebAWwYBuHmTNnmuuvv77e94NpPEaNGmV+9atf+Wy7+eabzW233WaMCZ6xqPlFa+d5L1myxISEhJj9+/dbbf7yl78Yp9NpPB7PRTnfszlb6Kiyfv16I8n6Az3YxmLfvn3msssuM5s3bzZdunTxCWCBOBZcggxgZWVlysnJ0fDhw322Dx8+XGvXrvVTr5qex+ORJMXExEiS8vLyVFBQ4HPeTqdTgwcPts47JydH5eXlPm0SEhKUnJxstcnKypLL5VJqaqrVZsCAAXK5XAE1fpMnT9aoUaOUlpbmsz3YxuGjjz5S37599Ytf/EJxcXG69tpr9frrr1vvB9N4XH/99VqxYoW2bdsmSfr3v/+tNWvW6Ec/+pGk4BqL6uw876ysLCUnJyshIcFqM2LECJWWlvpcFg8kHo9HDodDbdu2lRRcY+H1epWenq6HH35YP/jBD2q9H4hjwcO4A9jhw4dVWVmp+Ph4n+3x8fEqKCjwU6+aljFGDzzwgK6//nolJydLknVudZ33nj17rDbh4eFq165drTZVny8oKFBcXFytY8bFxQXM+C1atEgbN27Uhg0bar0XTOMgSbt27dIrr7yiBx54QP/rf/0vrV+/XtOmTZPT6dTtt98eVOMxc+ZMeTweXXnllQoNDVVlZaWefvpp/fKXv5QUfP9tVLHzvAsKCmodp127dgoPDw/IsTl16pQeeeQRjR8/3nq4dDCNxbPPPquwsDBNmzatzvcDcSwIYM2Aw+HweW2MqbWtuZoyZYq+/PJLrVmzptZ7jTnvmm3qah8o45efn6/p06dr2bJlat26db3tWvo4VPF6verbt69mzZolSbr22mv11Vdf6ZVXXtHtt99utQuG8fjrX/+qd955R3/+85/1gx/8QLm5ucrIyFBCQoLuuOMOq10wjEVd7Drv5jI25eXluvXWW+X1evXyyy+fs31LG4ucnBzNmzdPGzduPO/++HMsuAQZwNq3b6/Q0NBaqbqwsLBWAm+Opk6dqo8++kgrV65Ux44dre1ut1uSznrebrdbZWVlKioqOmubb7/9ttZxDx06FBDjl5OTo8LCQqWkpCgsLExhYWFatWqVXnzxRYWFhVl9bOnjUKVDhw7q1auXz7aePXtq7969koLnvwtJevjhh/XII4/o1ltvVe/evZWenq77779fs2fPlhRcY1GdneftdrtrHaeoqEjl5eUBNTbl5eUaN26c8vLylJmZac1+ScEzFqtXr1ZhYaE6d+5s/S7ds2ePHnzwQXXt2lVSYI4FASyAhYeHKyUlRZmZmT7bMzMzNWjQID/16sIZYzRlyhR9+OGH+uSTT5SYmOjzfmJiotxut895l5WVadWqVdZ5p6SkqFWrVj5tDh48qM2bN1ttBg4cKI/Ho/Xr11ttsrOz5fF4AmL8hg0bpk2bNik3N9f66du3ryZMmKDc3Fx169YtKMahynXXXVdrOZJt27apS5cukoLnvwtJOnnypEJCfH89h4aGWstQBNNYVGfneQ8cOFCbN2/WwYMHrTbLli2T0+lUSkrKRT3PhqoKX9u3b9fy5csVGxvr836wjEV6erq+/PJLn9+lCQkJevjhh/Wvf/1LUoCOxXmV7MN2VctQvPHGG2bLli0mIyPDREZGmt27d/u7a432n//5n8blcplPP/3UHDx40Po5efKk1eaZZ54xLpfLfPjhh2bTpk3ml7/8ZZ23mnfs2NEsX77cbNy40dx444113lJ81VVXmaysLJOVlWV69+4dUMsN1FT9Lkhjgmsc1q9fb8LCwszTTz9ttm/fbt59913Tpk0b884771htgmU87rjjDnPZZZdZy1B8+OGHpn379mbGjBlWm5Y6FsePHzdffPGF+eKLL4wk88ILL5gvvvjCurPPrvOuWm5g2LBhZuPGjWb58uWmY8eOti69cLaxKC8vN2PHjjUdO3Y0ubm5Pr9LS0tLg2os6lLzLkhjAm8sCGDNwIIFC0yXLl1MeHi46dOnj7VcQ3Mlqc6fN99802rj9XrNE088Ydxut3E6neaGG24wmzZt8tlPSUmJmTJliomJiTERERFm9OjRZu/evT5tjhw5YiZMmGCioqJMVFSUmTBhgikqKrLhLBunZgALtnH4xz/+YZKTk43T6TRXXnmlee2113zeD5bxKC4uNtOnTzedO3c2rVu3Nt26dTOPPfaYzxdrSx2LlStX1vn74Y477jDG2Hvee/bsMaNGjTIREREmJibGTJkyxZw6depinr6Ps41FXl5evb9LV65cae0jGMaiLnUFsEAbC4cxxpzfnBkAAAAuBDVgAAAANiOAAQAA2IwABgAAYDMCGAAAgM0IYAAAADYjgAEAANiMAAYAAGAzAhgAAIDNCGAAglbXrl01d+5cf3dDkvTpp5/K4XDo2LFj/u4KABsQwAAEpDvvvFMOh8P6iY2N1ciRI/Xll1/a1ochQ4YoIyPDtuMBCB4EMAABa+TIkTp48KAOHjyoFStWKCwsTKNHj/Z3t3wYY1RRUeHvbgBoZghgAAKW0+mU2+2W2+3WNddco5kzZyo/P1+HDh2SJM2cOVOXX3652rRpo27duunxxx9XeXm5zz4++ugj9e3bV61bt1b79u11880313u8N998Uy6XS5mZmbrzzju1atUqzZs3z5qF2717t3Wp8F//+pf69u0rp9Op1atXa+fOnfrxj3+s+Ph4XXLJJerXr5+WL1/us//S0lLNmDFDnTp1ktPpVFJSkt544406+1JSUqJRo0ZpwIABOnr0qMrKyjRlyhR16NBBrVu3VteuXTV79uwLHGEA/hLm7w4AQEOcOHFC7777rnr06KHY2FhJUlRUlN566y0lJCRo06ZNmjhxoqKiojRjxgxJ0scff6ybb75Zjz32mN5++22VlZXp448/rnP/zz//vGbPnq1//etfGjBggPr3769t27YpOTlZTz31lCTp0ksv1e7duyVJM2bM0PPPP69u3bqpbdu22rdvn370ox/p97//vVq3bq0//elPGjNmjL755ht17txZknT77bcrKytLL774oq6++mrl5eXp8OHDtfri8Xg0evRotW7dWitWrFBkZKSef/55ffTRR3rvvffUuXNn5efnKz8/v6mHGYBdDAAEoDvuuMOEhoaayMhIExkZaSSZDh06mJycnHo/89xzz5mUlBTr9cCBA82ECRPqbd+lSxczZ84c88gjj5gOHTqYL7/80uf9wYMHm+nTp/tsW7lypZFk/v73v5/zHHr16mVeeuklY4wx33zzjZFkMjMz62xbtd+tW7eaq6++2tx8882mtLTUen/q1KnmxhtvNF6v95zHBRD4uAQJIGANHTpUubm5ys3NVXZ2toYPH64f/vCH2rNnjyTpb3/7m66//nq53W5dcsklevzxx7V3717r87m5uRo2bNhZj/GHP/xBCxcu1Jo1a9S7d+8G961v374+r7/77jvNmDFDvXr1Utu2bXXJJZdo69atVn9yc3MVGhqqwYMHn3W/aWlp6tatm9577z2Fh4db2++8807l5ubqiiuu0LRp07Rs2bIG9xVA4CGAAQhYkZGR6tGjh3r06KH+/fvrjTfe0HfffafXX39d69at06233qof/vCH+p//+R998cUXeuyxx1RWVmZ9PiIi4pzH+I//+A9VVlbqvffeO+++Vffwww/rgw8+0NNPP63Vq1crNzdXvXv3tvrTkL5I0qhRo7R69Wpt2bLFZ3ufPn2Ul5en3/3udyopKdG4ceP085///Lz6DCBwUAMGoNlwOBwKCQlRSUmJPv/8c3Xp0kWPPfaY9X7VzFiVq666SitWrNBdd91V7z779++vqVOnasSIEQoNDdXDDz9svRceHq7KysoG9W316tW688479dOf/lTS6Zq1qnoxSerdu7e8Xq9WrVqltLS0evfzzDPP6JJLLtGwYcP06aefqlevXtZ70dHRuuWWW3TLLbfo5z//uUaOHKmjR48qJiamQX0EEDgIYAACVmlpqQoKCiRJRUVFmj9/vk6cOKExY8bI4/Fo7969WrRokfr166ePP/5Yixcv9vn8E088oWHDhql79+669dZbVVFRoX/+859WkX6VgQMH6p///KdGjhypsLAw3X///ZJOL9SanZ2t3bt365JLLjlr0OnRo4c+/PBDjRkzRg6HQ48//ri8Xq/1fteuXXXHHXfoV7/6lVWEv2fPHhUWFmrcuHE++3r++edVWVmpG2+8UZ9++qmuvPJKzZkzRx06dNA111yjkJAQvf/++3K73Wrbtu2FDDEAP+ESJICAtXTpUnXo0EEdOnRQamqqNmzYoPfff19DhgzRj3/8Y91///2aMmWKrrnmGq1du1aPP/64z+eHDBmi999/Xx999JGuueYa3XjjjcrOzq7zWNddd50+/vhjPf7443rxxRclSQ899JBCQ0PVq1cvXXrppT71ZTXNmTNH7dq106BBgzRmzBiNGDFCffr08Wnzyiuv6Oc//7nuu+8+XXnllZo4caK+++67evc3btw43Xjjjdq2bZsuueQSPfvss+rbt6/69eun3bt3a8mSJQoJ4dc40Bw5jDHG350AAAAIJvzpBAAAYDMCGAAAgM0IYAAAADYjgAEAANiMAAYAAGAzAhgAAIDNCGAAAAA2I4ABAADYjAAGAABgMwIYAACAzQhgAAAANvv/zIuAb4aOdm0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -444,7 +478,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "That makes it clear that there is a strong linear relation between number of backtracks and run time (with a couple of outliers).\n", + "This plot makes it clear that there is a strong linear relation between number of backtracks and run time. (Very roughly, one microsecond per backtrack.)\n", "\n", "One weakness of a scatter plot as a visualization tool is that there can be lots of points plotted on top of each other, and you can't tell the density of such points. A histogram portrays density better (but on only one attribute at a time):" ] @@ -466,7 +500,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -524,7 +558,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Verifying Correctness\n", + "# Is the Program Correct?\n", "\n", "How do we know this program (or any program) is correct? Traditionally, there are four kinds of evidence:\n", "- A large number of example input/output pairs that give the right answer.\n", @@ -705,13 +739,14 @@ "\n", "There are a few things I didn't get a chance to explore; maybe you can:\n", "\n", - "- Would the program be even faster in Golang or C++ or Rust?\n", "- Are there more algorithmic optimizations to try?\n", + "- Would the program be even faster if translated to Golang or C++ or Rust?\n", + "- Could you use a satisfiability prover such as DPLL to solve puzzles, as [[**tdoku**](https://github.com/t-dillon/tdoku) does?\n", "- The depth-first search makes a choice to *fill* some square with a digit. What if instead the choice was to *eliminate* a digit from the square? At first glance it seems that would be slower, because more choices would be required, but would constraint propagation make it work well?\n", "- On each recursive call, the depth-first search copies the current grid into a new grid (re-using the one in `gridpool[level]`). That requires copying an array of 81 ints. Would it be faster to instead make changes directly to the current grid, and then undo the changes when failure is detected? You would need to keep track of the changes made so that they can be undone. My guess is that this would make the code more complex and not much faster (if any), but you might want to try it.\n", "- In the theory of constraint propagation, [shaving](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.175.7143&rep=rep1&type=pdf) means guessing a value for some variable, detecting a contradiction, and then keeping track of the fact that the value is not possible. But in our program, when we guess wrong we don't keep track of anything. Can the program be made faster by incorporating shaving?\n", "- Can you create an adversarial puzzle, where the program guesses wrong the maximal number of times? In other words, if you draw a tree of choices, what's a puzzle with a tree that has the solution in the bottom-right corner? How much time and how many backtracks does that puzzle take to solve?\n", - "- What [other Sudoku strategies](https://bestofsudoku.com/sudoku-strategy) can be implemented? Can you find a suite of strategies that will solve all the puzzles with no search? \n", + "- What [other Sudoku strategies](https://bestofsudoku.com/sudoku-strategy) can be implemented? Can you find a suite of strategies that will solve all the puzzles with no backtracking search? \n", "- Can you develop a system to rank the difficulty of puzzles, based on the complexity of the strategies needed to solve it?\n" ] },